class Track(model.Base):
album = ndb.StringProperty()
title = ndb.StringProperty()
artist = ndb.StringProperty()
origin = ndb.StringProperty()
year = ndb.StringProperty()
duration = ndb.IntegerProperty()
genre = ndb.StringProperty()
mood = ndb.StringProperty()
rating = ndb.IntegerProperty()
gdrive_id = ndb.StringProperty(default='')
website = ndb.StringProperty(default='')
stream_url = ndb.StringProperty(default='')
cover_img = ndb.StringProperty(default='')
sons_id = ndb.StringProperty()
FIELDS = {
'album': fields.String,
'title': fields.String,
'artist': fields.List(fields.String),
'albumartist': fields.String,
'originaldate': fields.String,
'composer': fields.String,
'mood': fields.List(fields.String),
'totaltracks': fields.String,
'discnumber': fields.String,
'genre': fields.String,
'rating': fields.String,
'website': fields.String,
'stream_url': fields.String,
'cover_img': fields.String,
}
@staticmethod
def genre_list():
cached = memcache.get('genre.json')
if cached is None:
with open('genre.json') as data_file:
data = json.load(data_file)
memcache.set('genre.json', data)
return data
else:
return cached
def get_duration_time(self):
if self.duration:
m, s = divmod(int(self.duration) / 1000, 60)
return "%02d:%02d" % (m, s)
else:
return None
FIELDS.update(model.Base.FIELDS)
class Issue(model.Base):
"""
Single comic issue model
"""
title = ndb.StringProperty(indexed=True, required=True)
subtitle = ndb.StringProperty(indexed=False)
serie = ndb.KeyProperty(Serie,
required=True,
default=ndb.Key('Serie', "One Shot"))
reprint = ndb.StringProperty(indexed=False)
date = ndb.DateProperty(indexed=True, default=datetime.today())
price = ndb.StringProperty(indexed=False)
image = ndb.StringProperty(indexed=False)
url = ndb.StringProperty(indexed=False, default="#")
summary = ndb.StringProperty(indexed=False, repeated=True)
logger = logging.getLogger(__name__)
FIELDS = {
'title': fields.String,
'subtitle': fields.String,
'serie': fields.Key,
'reprint': fields.String,
'date': fields.DateTime,
'price': fields.String,
'image': fields.String,
'url': fields.String,
'summary': fields.List(fields.String)
}
FIELDS.update(model.Base.FIELDS)
class Song(model.Base):
rank = ndb.IntegerProperty(default=0)
name = ndb.StringProperty(required=True)
album_key = ndb.KeyProperty(kind=model.Album, verbose_name='Album')
writer_key = ndb.KeyProperty(kind=model.Member, verbose_name='Written By')
release_date = ndb.DateProperty()
soundcloud_id = ndb.StringProperty(verbose_name='SoundCloud ID')
youtube_id = ndb.StringProperty(verbose_name='YouTube ID')
tags = ndb.StringProperty(repeated=True)
artist = ndb.StringProperty()
lyrics = ndb.TextProperty(indexed=False)
FIELDS = {
'rank': fields.Integer,
'name': fields.String,
'album_key': fields.Key,
'writer_key': fields.Key,
'release_date': fields.DateTime,
'soundcloud_id': fields.String,
'youtube_id': fields.String,
'tags': fields.List(fields.String),
'artist': fields.String,
'lyrics': fields.String,
}
FIELDS.update(model.Base.FIELDS)
class Config(model.Base, model.ConfigAuth):
analytics_id = ndb.StringProperty(default='', verbose_name='Tracking ID')
announcement_html = ndb.TextProperty(default='', verbose_name='Announcement HTML')
announcement_type = ndb.StringProperty(default='info', choices=['info', 'warning', 'success', 'danger'])
anonymous_recaptcha = ndb.BooleanProperty(default=False, verbose_name='Use reCAPTCHA in forms for unauthorized users')
brand_name = ndb.StringProperty(default=config.APPLICATION_ID)
bucket_name = ndb.StringProperty(default=config.DEFAULT_GCS_BUCKET_NAME)
check_unique_email = ndb.BooleanProperty(default=True, verbose_name='Check for uniqueness of the verified emails')
email_authentication = ndb.BooleanProperty(default=False, verbose_name='Email authentication for sign in/sign up')
feedback_email = ndb.StringProperty(default='')
flask_secret_key = ndb.StringProperty(default=util.uuid())
letsencrypt_challenge = ndb.StringProperty(default='', verbose_name=u'Let’s Encrypt Challenge')
letsencrypt_response = ndb.StringProperty(default='', verbose_name=u'Let’s Encrypt Response')
notify_on_new_user = ndb.BooleanProperty(default=True, verbose_name='Send an email notification when a user signs up')
recaptcha_private_key = ndb.StringProperty(default='', verbose_name='Private Key')
recaptcha_public_key = ndb.StringProperty(default='', verbose_name='Public Key')
salt = ndb.StringProperty(default=util.uuid())
trusted_hosts = ndb.StringProperty(repeated=True, verbose_name='Trusted Hosts')
verify_email = ndb.BooleanProperty(default=True, verbose_name='Verify user emails')
@property
def has_anonymous_recaptcha(self):
return bool(self.anonymous_recaptcha and self.has_recaptcha)
@property
def has_email_authentication(self):
return bool(self.email_authentication and self.feedback_email and self.verify_email)
@property
def has_recaptcha(self):
return bool(self.recaptcha_private_key and self.recaptcha_public_key)
@classmethod
def get_master_db(cls):
return cls.get_or_insert('master')
FIELDS = {
'analytics_id': fields.String,
'announcement_html': fields.String,
'announcement_type': fields.String,
'anonymous_recaptcha': fields.Boolean,
'brand_name': fields.String,
'bucket_name': fields.String,
'check_unique_email': fields.Boolean,
'email_authentication': fields.Boolean,
'feedback_email': fields.String,
'flask_secret_key': fields.String,
'letsencrypt_challenge': fields.String,
'letsencrypt_response': fields.String,
'notify_on_new_user': fields.Boolean,
'recaptcha_private_key': fields.String,
'recaptcha_public_key': fields.String,
'salt': fields.String,
'trusted_hosts': fields.List(fields.String),
'verify_email': fields.Boolean,
}
FIELDS.update(model.Base.FIELDS)
FIELDS.update(model.ConfigAuth.FIELDS)
class Album(model.Base):
name = ndb.StringProperty(required=True)
description = ndb.StringProperty(verbose_name='Description (Markdown)')
release_date = ndb.DateProperty(required=True)
tags = ndb.StringProperty(repeated=True)
FIELDS = {
'name': fields.String,
'description': fields.String,
'release_date': fields.DateTime,
'tags': fields.List(fields.String),
}
FIELDS.update(model.Base.FIELDS)
class User(model.Base):
name = ndb.StringProperty(required=True)
username = ndb.StringProperty(required=True)
email = ndb.StringProperty(default='')
auth_ids = ndb.StringProperty(repeated=True)
active = ndb.BooleanProperty(default=True)
admin = ndb.BooleanProperty(default=False)
permissions = ndb.StringProperty(repeated=True)
verified = ndb.BooleanProperty(default=False)
token = ndb.StringProperty(default='')
password_hash = ndb.StringProperty(default='')
def has_permission(self, perm):
return self.admin or perm in self.permissions
def has_facebook(self):
for auth_id in self.auth_ids:
if auth_id.startswith('facebook'):
return auth_id
return None
def avatar_url_size(self, size=None):
facebook_id = self.has_facebook()
if facebook_id:
return '//graph.facebook.com/%(id)s/picture%(size)s' % {
'id': facebook_id.split('_')[1],
'size': '?width=%s&height=%s' % (size, size) if size else '',
}
return '//gravatar.com/avatar/%(hash)s?d=identicon&r=x%(size)s' % {
'hash': hashlib.md5(
(self.email or self.username).encode('utf-8')).hexdigest(),
'size': '&s=%d' % size if size > 0 else '',
}
avatar_url = property(avatar_url_size)
@classmethod
def get_dbs(
cls, admin=None, active=None, verified=None, permissions=None, **kwargs
):
args = parser.parse({
'admin': wf.Bool(missing=None),
'active': wf.Bool(missing=None),
'verified': wf.Bool(missing=None),
'permissions': wf.DelimitedList(wf.Str(), delimiter=',', missing=[]),
})
return super(User, cls).get_dbs(
admin=admin or args['admin'],
active=active or args['active'],
verified=verified or args['verified'],
permissions=permissions or args['permissions'],
**kwargs
)
@classmethod
def is_username_available(cls, username, self_key=None):
if self_key is None:
return cls.get_by('username', username) is None
user_keys, _ = util.get_keys(cls.query(), username=username, limit=2)
return not user_keys or self_key in user_keys and not user_keys[1:]
@classmethod
def is_email_available(cls, email, self_key=None):
if not config.CONFIG_DB.check_unique_email:
return True
user_keys, _ = util.get_keys(
cls.query(), email=email, verified=True, limit=2,
)
return not user_keys or self_key in user_keys and not user_keys[1:]
def get_resource_dbs(self, **kwargs):
return model.Resource.get_dbs(user_key=self.key, **kwargs)
FIELDS = {
'active': fields.Boolean,
'admin': fields.Boolean,
'auth_ids': fields.List(fields.String),
'avatar_url': fields.String,
'email': fields.String,
'name': fields.String,
'permissions': fields.List(fields.String),
'username': fields.String,
'verified': fields.Boolean,
}
FIELDS.update(model.Base.FIELDS)
class User(model.Base):
name = ndb.StringProperty(required=True)
username = ndb.StringProperty(required=True)
email = ndb.StringProperty(default='')
auth_ids = ndb.StringProperty(repeated=True)
active = ndb.BooleanProperty(default=True)
admin = ndb.BooleanProperty(default=False)
permissions = ndb.StringProperty(repeated=True)
verified = ndb.BooleanProperty(default=False)
token = ndb.StringProperty(default='')
password_hash = ndb.StringProperty(default='')
# Bellow properties were added for FIRSTMastery
teams = ndb.KeyProperty(repeated=True)
achievements = ndb.KeyProperty(repeated=True)
points = ndb.IntegerProperty()
# Define a method to evaluate if user is a team admin based on team's number
def has_permission(self, perm):
return self.admin or perm in self.permissions
def avatar_url_size(self, size=None):
return '//gravatar.com/avatar/%(hash)s?d=identicon&r=x%(size)s' % {
'hash':
hashlib.md5(
(self.email or self.username).encode('utf-8')).hexdigest(),
'size':
'&s=%d' % size if size > 0 else '',
}
avatar_url = property(avatar_url_size)
def card(self):
return flask.url_for('user_card', user_id=self.key.id())
@classmethod
def get_dbs(cls,
admin=None,
active=None,
verified=None,
permissions=None,
**kwargs):
args = parser.parse({
'admin':
wf.Bool(missing=None),
'active':
wf.Bool(missing=None),
'verified':
wf.Bool(missing=None),
'permissions':
wf.DelimitedList(wf.Str(), delimiter=',', missing=[]),
})
return super(User, cls).get_dbs(admin=admin or args['admin'],
active=active or args['active'],
verified=verified or args['verified'],
permissions=permissions
or args['permissions'],
**kwargs)
@classmethod
def is_username_available(cls, username, self_key=None):
if self_key is None:
return cls.get_by('username', username) is None
user_keys, _ = util.get_keys(cls.query(), username=username, limit=2)
return not user_keys or self_key in user_keys and not user_keys[1:]
@classmethod
def is_email_available(cls, email, self_key=None):
if not config.CONFIG_DB.check_unique_email:
return True
user_keys, _ = util.get_keys(
cls.query(),
email=email,
verified=True,
limit=2,
)
return not user_keys or self_key in user_keys and not user_keys[1:]
FIELDS = {
'active': fields.Boolean,
'admin': fields.Boolean,
'auth_ids': fields.List(fields.String),
'avatar_url': fields.String,
'email': fields.String,
'name': fields.String,
'permissions': fields.List(fields.String),
'username': fields.String,
'verified': fields.Boolean,
'teams': fields.Keys,
}
FIELDS.update(model.Base.FIELDS)
class User(model.Base):
name = ndb.StringProperty(required=True, verbose_name=_('Name'))
username = ndb.StringProperty(required=True, verbose_name=_('Username'))
email = ndb.StringProperty(default='', verbose_name=_('Email'))
locale = ndb.StringProperty(default='', verbose_name=_('Language'))
auth_ids = ndb.StringProperty(repeated=True)
active = ndb.BooleanProperty(default=True, verbose_name=_('Active'))
admin = ndb.BooleanProperty(default=False, verbose_name=_('Admin'))
permissions = ndb.StringProperty(repeated=True, verbose_name=_('Permissions'))
verified = ndb.BooleanProperty(default=False, verbose_name=_('Verified'))
token = ndb.StringProperty(default='')
password_hash = ndb.StringProperty(default='')
def has_permission(self, perm):
return self.admin or perm in self.permissions
def avatar_url_size(self, size=None):
return '//gravatar.com/avatar/%(hash)s?d=identicon&r=x%(size)s' % {
'hash': hashlib.md5(
(self.email or self.username).encode('utf-8')).hexdigest(),
'size': '&s=%d' % size if size > 0 else '',
}
avatar_url = property(avatar_url_size)
@classmethod
def get_dbs(
cls, admin=None, active=None, verified=None, permissions=None, **kwargs
):
return super(User, cls).get_dbs(
admin=admin or util.param('admin', bool),
active=active or util.param('active', bool),
verified=verified or util.param('verified', bool),
permissions=permissions or util.param('permissions', list),
**kwargs
)
@classmethod
def is_username_available(cls, username, self_key=None):
if self_key is None:
return cls.get_by('username', username) is None
user_keys, _ = util.get_keys(cls.query(), username=username, limit=2)
return not user_keys or self_key in user_keys and not user_keys[1:]
@classmethod
def is_email_available(cls, email, self_key=None):
if not config.CONFIG_DB.check_unique_email:
return True
user_keys, _ = util.get_keys(
cls.query(), email=email, verified=True, limit=2,
)
return not user_keys or self_key in user_keys and not user_keys[1:]
FIELDS = {
'active': fields.Boolean,
'admin': fields.Boolean,
'auth_ids': fields.List(fields.String),
'avatar_url': fields.String,
'email': fields.String,
'locale': fields.String,
'name': fields.String,
'permissions': fields.List(fields.String),
'username': fields.String,
'verified': fields.Boolean,
}
FIELDS.update(model.Base.FIELDS)
