class TimelineActivityTypeModel(db.Model):
__tablename__ = 'timeline_activity_types'
__table_args__ = {"schema": "mgn"}
timeline_activity_type_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(10), nullable=False)
description = db.Column(db.String(100), nullable=False)
created = db.Column(db.DateTime, nullable=False)
@property
def id(self):
return self.timeline_activity_type_id
def __init__(self, name=None, description=None):
self.name = name,
self.description = description,
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
return {
'timeline_activity_type_id': self.timeline_activity_type_id,
'name': self.name,
'description': self.description,
'created': str(self.created)
}
class UserFollowersModel(db.Model):
__tablename__ = 'user_followers'
__table_args__ = {"schema": "mgn"}
user_follower_id = db.Column(db.Integer, primary_key=True)
follower = db.Column(db.Integer, db.ForeignKey(MasterUserModel.master_user_id), nullable=False)
following = db.Column(db.Integer, db.ForeignKey(MasterUserModel.master_user_id), nullable=False)
is_blocked = db.Column(db.SmallInteger, nullable=False)
created = db.Column(db.DateTime, nullable=True)
follower_user = db.relationship('MasterUserModel', foreign_keys=[follower],
backref=db.backref('follower_user', lazy='dynamic'))
following_user = db.relationship('MasterUserModel', foreign_keys=[following],
backref=db.backref('following_user', lazy='dynamic'))
@property
def id(self):
return self.user_follower_id
def __init__(self, follower=None, following=None):
self.follower = follower
self.following = following
self.is_blocked = FALSE
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
return {
'id': self.user_follower_id,
'follower': self.follower_user.serialize,
'following': self.following_user.serialize,
'blocked': self.is_blocked,
'created': str(self.created)
}
class MasterLanguageModel(db.Model):
__tablename__ = 'master_language'
__table_args__ = {"schema": "mgn"}
master_language_id = db.Column(db.Integer, primary_key=True)
language_name = db.Column(db.String(50), nullable=False)
language_description = db.Column(db.String(100), nullable=False)
is_active = db.Column(db.SmallInteger, nullable=False)
created = db.Column(db.DateTime, nullable=True)
@property
def id(self):
return self.master_language_id
def __init__(self,
language_name=None,
language_description=None,
is_active=None):
self.language_name = language_name
self.language_description = language_description
self.is_active = is_active
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
return {
'language_id': self.master_language_id,
'language_name': self.language_name,
'language_description': self.language_description,
'is_active': self.is_active,
'created': str(self.created)
}
class MGNUserTypeModel(db.Model):
__tablename__ = 'mgn_user_type'
__table_args__ = {"schema": "mgn"}
mgn_user_type_id = db.Column(db.BigInteger, primary_key=True)
user_type = db.Column(db.String(10), unique=True, nullable=False)
user_type_desc = db.Column(db.String(30), nullable=False)
created = db.Column(db.DateTime, nullable=False)
def __init__(self, user_type=None, user_type_desc=None):
self.user_type = user_type
self.user_type_desc = user_type_desc
self.created = datetime.datetime.utcnow()
@property
def id(self):
return self.mgn_user_type_id
@property
def serialize(self):
return {
'user_type_id': self.mgn_user_type_id,
'user_type': self.user_type,
'user_type_desc': self.user_type_desc,
'created': str(self.created)
}
class MGNAuthTypeModel(db.Model):
__tablename__ = 'auth_type'
__table_args__ = {"schema": "mgn"}
auth_type_id = db.Column(db.BigInteger, primary_key=True)
auth_name = db.Column(db.String(45), unique=True, nullable=False)
auth_desc = db.Column(db.String(100), nullable=False)
created = db.Column(db.DateTime, nullable=False)
def __init__(self, auth_name=None, auth_desc=None):
self.auth_name = auth_name
self.auth_desc = auth_desc
self.created = datetime.datetime.utcnow()
@property
def id(self):
return self.auth_type_id
@property
def serialize(self):
return {
'auth_type_id': self.auth_type_id,
'auth_name': self.auth_name,
'auth_desc': self.auth_desc,
'created': str(self.created)
}
class UserNotificationsModel(db.Model):
__tablename__ = 'user_notifications'
__table_args__ = {"schema": "mgn"}
user_notification_id = db.Column(db.Integer, primary_key=True)
master_user_id = db.Column(db.Integer,
db.ForeignKey(MasterUserModel.master_user_id),
nullable=False)
notifications = db.Column(JSONB, nullable=False)
notification_user = db.relationship('MasterUserModel',
backref=db.backref('notification_user',
lazy='dynamic'))
@property
def id(self):
return self.user_notification_id
def __init__(self, master_user_id=None, notifications=None):
self.master_user_id = master_user_id
self.notifications = notifications
@property
def serialize(self):
return {
'id': self.user_notification_id,
'user': self.notification_user.serialize,
'notifications': self.notifications
}
class UserMessageStatusModel(db.Model):
__tablename__ = 'user_message_status'
__table_args__ = {"schema": "mgn"}
user_message_status_id = db.Column(db.Integer, primary_key=True)
master_user_id = db.Column(db.Integer,
db.ForeignKey(MasterUserModel.master_user_id),
nullable=False)
user_message_thread_id = db.Column(
db.Integer,
db.ForeignKey(UserMessageThreadsModel.user_message_thread_id),
nullable=False)
user_message_id = db.Column(db.Integer,
db.ForeignKey(
UserMessageModel.user_message_id),
nullable=False)
is_deleted = db.Column(db.SmallInteger, nullable=True)
delete_timestamp = db.Column(db.DateTime, nullable=True)
is_read = db.Column(db.SmallInteger, nullable=True)
read_timestamp = db.Column(db.DateTime, nullable=True)
created = db.Column(db.DateTime, nullable=False)
archive = db.Column(db.SmallInteger, nullable=True)
message_thread = db.relationship('UserMessageThreadsModel',
backref=db.backref('message_thread',
lazy='dynamic'))
message_status_master_user = db.relationship(
'MasterUserModel',
backref=db.backref('message_status_master_user', lazy='dynamic'))
user_message = db.relationship('UserMessageModel',
backref=db.backref('user_message',
lazy='dynamic'))
@property
def id(self):
return self.user_message_status_id
def __init__(self,
master_user_id=None,
user_message_thread_id=None,
user_message_id=None,
last_message_timestamp=None):
self.master_user_id = master_user_id
self.user_message_thread_id = user_message_thread_id
self.user_message_id = user_message_id
self.is_read = FALSE
self.is_deleted = FALSE
self.archive = FALSE
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
return {
'message': self.user_message.serialize,
'is_deleted': self.is_deleted,
'delete_timestamp': str(self.delete_timestamp),
'is_read': self.is_read,
'read_timestamp': str(self.read_timestamp),
'created': self.created
}
class UserMessageThreadsModel(db.Model):
__tablename__ = 'user_message_threads'
__table_args__ = {"schema": "mgn"}
user_message_thread_id = db.Column(db.Integer, primary_key=True)
thread_creator_master_user_id = db.Column(
db.Integer,
db.ForeignKey(MasterUserModel.master_user_id),
nullable=False)
last_user_message_id = db.Column(db.Integer,
db.ForeignKey(
UserMessageModel.user_message_id),
nullable=True)
created = db.Column(db.DateTime, nullable=False)
last_user_message = db.relationship('UserMessageModel',
backref=db.backref('last_user_message',
lazy='dynamic'))
message_thread_creator = db.relationship('MasterUserModel',
backref=db.backref(
'message_thread_creator',
lazy='dynamic'))
@property
def id(self):
return self.user_message_thread_id
def __init__(self, thread_creator_master_user_id=None):
self.thread_creator_master_user_id = thread_creator_master_user_id
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
if self.last_user_message is not None:
return {
'message_thread_creator':
self.message_thread_creator.serialize,
'last_user_message': self.last_user_message.serialize,
'created': str(self.created),
'id': self.user_message_thread_id
}
else:
return {
'message_thread_creator':
self.message_thread_creator.serialize,
'last_user_message': self.last_user_message,
'created': str(self.created),
'id': self.user_message_thread_id
}
class MasterUserSettingModel(db.Model):
__tablename__ = 'master_user_setting'
__table_args__ = {"schema": "mgn"}
master_user_setting_id = db.Column(db.BigInteger, primary_key=True)
master_user_id = db.Column(db.BigInteger,
db.ForeignKey(MasterUserModel.master_user_id))
master_language_id = db.Column(
db.Integer, db.ForeignKey(MasterLanguageModel.master_language_id))
timezone_id = db.Column(db.Integer,
db.ForeignKey(MasterTimezoneModel.timezone_id))
master_currency_id = db.Column(
db.Integer, db.ForeignKey(MasterCurrencyModel.master_currency_id))
master_user = db.relationship('MasterUserModel',
backref=db.backref('user', lazy='dynamic'))
master_timezone = db.relationship('MasterTimezoneModel',
backref=db.backref('timezone',
lazy='dynamic'))
master_language = db.relationship('MasterLanguageModel',
backref=db.backref('language',
lazy='dynamic'))
master_currency = db.relationship('MasterCurrencyModel',
backref=db.backref('currency',
lazy='dynamic'))
@property
def id(self):
return self.master_user_setting_id
def __init__(self,
master_user_id=None,
master_language_id=None,
timezone_id=None,
master_currency_id=None):
self.master_user_id = master_user_id
self.master_language_id = master_language_id
self.timezone_id = timezone_id
self.master_currency_id = master_currency_id
@property
def serialize(self):
return {
'id': self.master_user_setting_id,
'user': self.master_user.serialize,
'language': self.master_language.serialize,
'timezone': self.master_timezone.serialize,
'currency': self.master_currency.serialize
}
class UserProfileModel(db.Model):
__tablename__ = 'user_profile'
__table_args__ = {"schema": "mgn"}
user_profile_id = db.Column(db.Integer, primary_key=True)
profile_banner_image = db.Column(db.String(200), nullable=True)
dob = db.Column(db.Date, nullable=True)
master_gender_id = db.Column(db.SmallInteger,
db.ForeignKey(
MasterGenderModel.master_gender_id),
nullable=False)
master_user_id = db.Column(db.Integer,
db.ForeignKey(MasterUserModel.master_user_id),
nullable=False)
master_gender = db.relationship('MasterGenderModel',
backref=db.backref('master_gender',
lazy='dynamic'))
master_user = db.relationship('MasterUserModel',
backref=db.backref('master_user',
lazy='dynamic'))
@property
def id(self):
return self.user_profile_id
def __init__(self,
profile_pic=None,
profile_banner_image=None,
dob=None,
master_gender_id=None,
master_user_id=None):
self.profile_banner_image = profile_banner_image
self.dob = dob
self.master_gender_id = master_gender_id
self.master_user_id = master_user_id
@property
def serialize(self):
return {
'profile_banner_image': self.profile_banner_image,
'dob': str(self.dob),
'gender': self.master_gender.serialize,
'user': self.master_user.serialize
}
class MasterGenderModel(db.Model):
__tablename__ = 'master_gender'
__table_args__ = {"schema": "mgn"}
master_gender_id = db.Column(db.SmallInteger, primary_key=True)
gender = db.Column(db.String(10), unique=True)
@property
def id(self):
return self.master_gender_id
def __init__(self, gender=None):
self.gender = gender
@property
def serialize(self):
return {
'master_gender_id': self.master_gender_id,
'gender': self.gender
}
class CommentThreadsModel(db.Model):
__tablename__ = 'comment_threads'
__table_args__ = {"schema": "mgn"}
comment_thread_id = db.Column(db.Integer, primary_key=True)
created = db.Column(db.DateTime, nullable=True)
@property
def id(self):
return self.comment_thread_id
def __init__(self):
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
return {
'comment_thread_id': self.comment_thread_id,
'created': str(self.created)
}
class CommentsModel(db.Model):
__tablename__ = 'comments'
__table_args__ = {"schema": "mgn"}
comment_id = db.Column(db.Integer, primary_key=True, nullable=False)
comment_thread_id = db.Column(db.Integer, db.ForeignKey(CommentThreadsModel.comment_thread_id), nullable=False)
comment_reply_thread_id = db.Column(db.Integer, db.ForeignKey(CommentThreadsModel.comment_thread_id), nullable=True)
master_user_id = db.Column(db.Integer, db.ForeignKey(MasterUserModel.master_user_id), nullable=False)
comment = db.Column(db.String(200), nullable=False)
created = db.Column(db.DateTime, nullable=False)
comment_master_user = db.relationship('MasterUserModel', backref=db.backref('comment_master_user', lazy='dynamic'))
@property
def id(self):
return self.comment_id
def __init__(self, master_user_id=None, comment_thread_id=None, comment_reply_thread_id=None, comment=None):
self.master_user_id = master_user_id
self.comment_thread_id = comment_thread_id
self.comment_reply_thread_id = comment_reply_thread_id
self.comment = comment
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
return {
'user': self.comment_master_user.serialize,
'comment': self.comment,
'reply_thread': self.comment_reply_thread_id,
'created': str(self.created)
}
class User(db.Model):
__tablename__ = 'test'
__table_args__ = {"schema": "test"}
id = db.Column(db.BigInteger, primary_key=True)
name = db.Column(db.String(45), unique=True)
desc = db.Column(db.String(100))
updated = db.Column(db.DateTime, nullable=True)
def __init__(self, id=None, name=None, desc=None, updated=None):
self.id = id
self.desc = desc
self.name = name
self.updated = updated
@property
def serialize(self):
return {
'id': self.id,
'name': self.name,
'desc': self.desc,
'updated': str(self.updated)
}
class UserConnectionsModel(db.Model):
__tablename__ = 'user_connections'
__table_args__ = {"schema": "mgn"}
user_connection_id = db.Column(db.Integer, primary_key=True)
connected_from_id = db.Column(db.Integer, db.ForeignKey(MasterUserModel.master_user_id), nullable=False)
connected_to_id = db.Column(db.Integer, db.ForeignKey(MasterUserModel.master_user_id), nullable=False)
user_message_thread_id = db.Column(db.Integer, db.ForeignKey(
UserMessageThreadParticipantsModel.user_message_thread_id), nullable=True)
is_accepted = db.Column(db.SmallInteger, nullable=False)
is_blocked = db.Column(db.SmallInteger, nullable=False)
is_ignored = db.Column(db.SmallInteger, nullable=False)
created = db.Column(db.DateTime, nullable=False)
master_user_from = db.relationship('MasterUserModel', foreign_keys=[connected_from_id],
backref=db.backref('master_user_from', lazy='dynamic'))
master_user_to = db.relationship('MasterUserModel', foreign_keys=[connected_to_id],
backref=db.backref('master_user_to', lazy='dynamic'))
connection_message_thread = db.relationship('UserMessageThreadParticipantsModel',
backref=db.backref('connection_message_thread', lazy='dynamic'))
@property
def id(self):
return self.user_connection_id
def __init__(self, connected_from_id=None, connected_to_id=None):
self.connected_from_id = connected_from_id
self.connected_to_id = connected_to_id
self.is_accepted = FALSE
self.is_blocked = FALSE
self.is_ignored = FALSE
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
return {
'connection': self.master_user_to.serialize,
'message_thread': self.user_message_thread_id,
'accepted': self.is_accepted,
'blocked': self.is_blocked,
'ignored': self.is_ignored,
'created': str(self.created)
}
class UserMessageModel(db.Model):
__tablename__ = 'user_messages'
__table_args__ = {"schema": "mgn"}
user_message_id = db.Column(db.Integer, primary_key=True)
sent_from_master_user_id = db.Column(db.Integer,
db.ForeignKey(
MasterUserModel.master_user_id),
nullable=False)
"""Thread foreign key removed because of compile exception"""
user_message_thread_id = db.Column(db.Integer, nullable=False)
message_text = db.Column(db.String(400), nullable=False)
has_attachment = db.Column(db.SmallInteger, nullable=False)
attachment_url = db.Column(db.String(200), nullable=False)
created = db.Column(db.DateTime, nullable=False)
sent_from_master_user = db.relationship('MasterUserModel',
backref=db.backref(
'sent_from_master_user',
lazy='dynamic'))
@property
def id(self):
return self.user_message_id
def __init__(self,
sent_from_master_user_id=None,
user_message_thread_id=None,
message_text=None,
has_attachment=FALSE,
attachment_url=None):
self.sent_from_master_user_id = sent_from_master_user_id
self.user_message_thread_id = user_message_thread_id
self.message_text = message_text
self.has_attachment = has_attachment
self.attachment_url = attachment_url
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
return {
'id': self.user_message_id,
'sent_from_master_user': self.sent_from_master_user.serialize,
'message_text': self.message_text,
'has_attachment': self.has_attachment,
'attachment_url': self.attachment_url,
'created': str(self.created)
}
class MasterCurrencyModel(db.Model):
__tablename__ = 'master_currency'
__table_args__ = {"schema": "mgn"}
master_currency_id = db.Column(db.Integer, primary_key=True)
currency_code = db.Column(db.String(10), unique=True, nullable=False)
currency_name = db.Column(db.String(50), nullable=False)
currency_symbol = db.Column(db.String(30), nullable=False)
currency_description = db.Column(db.String(100), nullable=False)
is_active = db.Column(db.SmallInteger, nullable=False)
created = db.Column(db.DateTime, nullable=True)
@property
def id(self):
return self.master_currency_id
def __init__(self,
currency_code=None,
currency_name=None,
currency_symbol=None,
currency_description=None,
is_active=None):
self.currency_code = currency_code
self.currency_name = currency_name
self.currency_symbol = currency_symbol
self.currency_description = currency_description
self.is_active = is_active
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
return {
'currency_id': self.master_currency_id,
'currency_code': self.currency_code,
'currency_name': self.currency_name,
'currency_symbol': self.currency_symbol,
'currency_description': self.currency_description,
'is_active': self.is_active,
'created': str(self.created)
}
class MasterTimezoneModel(db.Model):
__tablename__ = 'master_timezone'
__table_args__ = {"schema": "mgn"}
timezone_id = db.Column(db.Integer, primary_key=True)
timezone_code = db.Column(db.String(10), unique=True, nullable=False)
timezone_description = db.Column(db.String(50), nullable=False)
timezone_offset = db.Column(db.String(10), nullable=False)
timezone_offset_dst = db.Column(db.String(10), nullable=False)
is_active = db.Column(db.SmallInteger, nullable=False)
created = db.Column(db.DateTime, nullable=True)
@property
def id(self):
return self.timezone_id
def __init__(self,
timezone_code=None,
timezone_description=None,
timezone_offset=None,
timezone_offset_dst=None,
is_active=None):
self.timezone_code = timezone_code
self.timezone_description = timezone_description
self.timezone_offset = timezone_offset
self.timezone_offset_dst = timezone_offset_dst
self.is_active = is_active
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
return {
'timezone_id': self.timezone_id,
'timezone_code': self.timezone_code,
'timezone_description': self.timezone_description,
'timezone_offset': self.timezone_offset,
'timezone_offset_dst': self.timezone_offset_dst,
'is_active': self.is_active,
'created': str(self.created)
}
class MgnCountriesModel(db.Model):
__tablename__ = 'mgn_countries'
__table_args__ = {"schema": "mgn"}
country_id = db.Column(db.SmallInteger, primary_key=True)
short_name = db.Column(db.String(3), unique=True)
full_name = db.Column(db.String(50))
isd_code = db.Column(db.String(10))
states = db.Column(JSONB)
cities = db.Column(JSONB)
is_active = db.Column(db.SmallInteger, nullable=True)
def __init__(self, country_id=None, short_name=None, full_name=None, isd_code=None, states=None, cities=None,
is_active=None):
self.country_id = country_id
self.short_name = short_name
self.full_name = full_name
self.isd_code = isd_code
self.states = states
self.cities = cities
self.is_active = is_active
@property
def id(self):
return self.country_id
@property
def serialize(self):
return {
'country_id': self.country_id,
'short_name': self.short_name,
'full_name': self.full_name,
'isd_code': self.isd_code,
'states': self.states,
'cities': self.cities,
'is_active': self.is_active
}
class LikesModel(db.Model):
__tablename__ = 'likes'
__table_args__ = {"schema": "mgn"}
like_id = db.Column(db.Integer, primary_key=True, nullable=False)
master_user_id = db.Column(db.Integer,
db.ForeignKey(MasterUserModel.master_user_id),
nullable=False)
like_thread_id = db.Column(db.Integer,
db.ForeignKey(LikeThreadsModel.like_thread_id),
nullable=False)
post_id = db.Column(db.Integer,
db.ForeignKey(PostsModel.user_post_id),
nullable=True)
blog_id = db.Column(db.Integer,
db.ForeignKey(BlogsModel.user_blog_id),
nullable=True)
share_id = db.Column(db.Integer,
db.ForeignKey(SharesModel.share_id),
nullable=True)
created = db.Column(db.DateTime, nullable=False)
liked_master_user = db.relationship('MasterUserModel',
backref=db.backref('liked_master_user',
lazy='dynamic'))
liked_thread = db.relationship('LikeThreadsModel',
backref=db.backref('liked_thread',
lazy='dynamic'))
liked_post = db.relationship('PostsModel',
backref=db.backref('liked_post',
lazy='dynamic'))
liked_blog = db.relationship('BlogsModel',
backref=db.backref('liked_blog',
lazy='dynamic'))
liked_share = db.relationship('SharesModel',
backref=db.backref('liked_share',
lazy='dynamic'))
@property
def id(self):
return self.like_id
def __init__(self,
master_user_id=None,
like_thread_id=None,
post_id=None,
blog_id=None,
share_id=None):
self.master_user_id = master_user_id
self.like_thread_id = like_thread_id
self.post_id = post_id
self.blog_id = blog_id
self.share_id = share_id
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
return {
'like_id': self.like_id,
'liked_master_user': self.liked_master_user.serialize,
'liked_thread': self.liked_thread.serialize,
'liked_post': self.liked_post.serialize,
'liked_blog': self.liked_blog.serialize,
'liked_share': self.liked_share.serialize,
'created': str(self.created)
}
class PostsModel(db.Model):
__tablename__ = 'user_posts'
__table_args__ = {"schema": "mgn"}
user_post_id = db.Column(db.Integer, primary_key=True, nullable=False)
post_text = db.Column(db.String(200), nullable=False)
has_attachment = db.Column(db.SmallInteger, nullable=False)
attachment_url = db.Column(db.String(200), nullable=False)
comment_thread_id = db.Column(db.Integer,
db.ForeignKey(
CommentThreadsModel.comment_thread_id),
nullable=False)
like_thread_id = db.Column(db.Integer,
db.ForeignKey(LikeThreadsModel.like_thread_id),
nullable=False)
created_by_master_user_id = db.Column(db.Integer,
db.ForeignKey(
MasterUserModel.master_user_id),
nullable=False)
like_count = db.Column(db.SmallInteger, nullable=True)
comment_count = db.Column(db.SmallInteger, nullable=True)
share_count = db.Column(db.SmallInteger, nullable=True)
created = db.Column(db.DateTime, nullable=False)
post_master_user = db.relationship('MasterUserModel',
backref=db.backref('post_master_user',
lazy='dynamic'))
@property
def id(self):
return self.post_id
def __init__(self,
created_by_master_user_id=None,
post_text=None,
has_attachment=None,
attachment_url=None,
comment_thread_id=None,
like_thread_id=None):
self.created_by_master_user_id = created_by_master_user_id
self.post_text = post_text
self.has_attachment = has_attachment
self.attachment_url = attachment_url
self.comment_thread_id = comment_thread_id
self.like_thread_id = like_thread_id
self.like_count = 0
self.comment_count = 0
self.share_count = 0
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
return {
'post_id': self.user_post_id,
'user': self.post_master_user.serialize,
'post': self.post_text,
'attachment_url': self.attachment_url,
'comment_thread_id': self.comment_thread_id,
'like_thread_id': self.like_thread_id,
'like_count': self.like_count,
'comment_count': self.comment_count,
'share_count': self.share_count,
'created': str(self.created)
}
class MasterUserModel(db.Model):
__tablename__ = 'master_user'
__table_args__ = {"schema": "mgn"}
master_user_id = db.Column(db.BigInteger, primary_key=True)
first_name = db.Column(db.String(45), nullable=False)
last_name = db.Column(db.String(45), nullable=False)
full_name = db.Column(db.String(100), nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
profile_pic = db.Column(db.String(100), nullable=True)
is_email_confirmed = db.Column(db.String(100))
username = db.Column(db.String(30), unique=True, nullable=False)
password = db.Column(db.String(100), nullable=True)
is_active = db.Column(db.String(100), nullable=False)
is_deleted = db.Column(db.String(100), nullable=False)
is_blocked = db.Column(db.String(100), nullable=False)
created = db.Column(db.DateTime, nullable=False)
updated = db.Column(db.DateTime, nullable=False)
auth_type_id = db.Column(db.Integer, nullable=False)
mgn_user_type_id = db.Column(db.Integer, nullable=False)
social_id = db.Column(db.String(100), nullable=True)
def __init__(self,
first_name=None,
last_name=None,
email=None,
password=None,
username=None,
auth_type_id=None,
mgn_user_type_id=None,
profile_pic=None,
social_id=None):
self.first_name = first_name
self.last_name = last_name
self.full_name = first_name + " " + last_name
self.email = email
self.is_email_confirmed = FALSE
self.username = username
self.password = password
self.is_active = FALSE
self.is_deleted = FALSE
self.is_blocked = FALSE
self.updated = datetime.datetime.utcnow()
self.created = datetime.datetime.utcnow()
self.auth_type_id = auth_type_id
self.mgn_user_type_id = mgn_user_type_id
self.profile_pic = profile_pic
self.social_id = social_id
@property
def id(self):
return self.master_user_id
@property
def serialize(self):
return {
'id': self.master_user_id,
'first_name': self.first_name,
'last_name': self.last_name,
'full_name': self.full_name,
'email': self.email,
'profile_pic': self.profile_pic,
'social_id': self.social_id,
'username': self.username,
'created': str(self.created)
}
class UserMessageThreadParticipantsModel(db.Model):
__tablename__ = 'user_message_thread_participants'
__table_args__ = {"schema": "mgn"}
user_message_thread_participants_id = db.Column(db.Integer, primary_key=True)
master_user_id = db.Column(db.Integer, db.ForeignKey(MasterUserModel.master_user_id), nullable=False)
user_message_thread_id = db.Column(db.Integer, db.ForeignKey(UserMessageThreadsModel.user_message_thread_id),
nullable=False)
is_deleted = db.Column(db.SmallInteger, nullable=True)
delete_timestamp = db.Column(db.DateTime, nullable=True)
is_spam = db.Column(db.SmallInteger, nullable=True)
spam_timestamp = db.Column(db.DateTime, nullable=True)
has_left_group = db.Column(db.SmallInteger, nullable=True)
has_left_group_timestamp = db.Column(db.DateTime, nullable=True)
is_muted = db.Column(db.SmallInteger, nullable=True)
is_muted_timestamp = db.Column(db.DateTime, nullable=True)
is_read = db.Column(db.SmallInteger, nullable=True)
last_read_timestamp = db.Column(db.DateTime, nullable=True)
unread_message_count = db.Column(db.SmallInteger, nullable=True)
last_message_timestamp = db.Column(db.DateTime, nullable=True)
archive = db.Column(db.SmallInteger, nullable=True)
participants_message_thread = db.relationship('UserMessageThreadsModel',
backref=db.backref('participants_message_thread', lazy='dynamic'))
message_thread_master_user = db.relationship('MasterUserModel',
backref=db.backref('message_thread_master_user', lazy='dynamic'))
@property
def id(self):
return self.user_message_thread_participants_id
def __init__(self, master_user_id=None, user_message_thread_id=None):
self.master_user_id = master_user_id
self.user_message_thread_id = user_message_thread_id
self.is_deleted = FALSE
self.is_spam = FALSE
self.is_muted = FALSE
self.is_read = FALSE
self.has_left_group = FALSE
self.archive = FALSE
self.unread_message_count = 0
@staticmethod
def get_participants(thread_id=None, master_user_id=None):
data = UserMessageThreadParticipantsModel.query.filter(
and_(
UserMessageThreadParticipantsModel.user_message_thread_id == thread_id,
UserMessageThreadParticipantsModel.master_user_id != master_user_id
)
)
result = [i.serialize_participants for i in data.all()]
return json.dumps(result)
@property
def serialize(self):
return {
'message_thread_master_user': self.message_thread_master_user.serialize,
'message_thread': self.participants_message_thread.serialize,
'is_deleted': self.is_deleted,
'delete_timestamp': str(self.delete_timestamp),
'is_spam': self.is_spam,
'spam_timestamp': str(self.spam_timestamp),
'has_left_group': self.has_left_group,
'has_left_group_timestamp': str(self.has_left_group_timestamp),
'is_muted': self.is_muted,
'is_muted_timestamp': str(self.is_muted_timestamp),
'is_read': self.is_read,
'last_read_timestamp': str(self.last_read_timestamp),
'unread_message_count': self.unread_message_count,
'last_message_timestamp': self.last_message_timestamp,
'participants': str(self.get_participants(self.user_message_thread_id, self.master_user_id))
}
@property
def serialize_participants(self):
return self.message_thread_master_user.serialize
class UserAccessDetailsModel(db.Model):
__tablename__ = 'user_access_details'
__table_args__ = {"schema": "mgn"}
user_access_details_id = db.Column(db.Integer, primary_key=True)
master_user_id = db.Column(db.Integer, db.ForeignKey(MasterUserModel.master_user_id), nullable=False)
access_history = db.Column(JSONB, nullable=True)
latitude = db.Column(db.Float, nullable=True)
longitude = db.Column(db.Float, nullable=True)
city = db.Column(db.String(50), nullable=True)
state = db.Column(db.String(50), nullable=True)
zipcode = db.Column(db.String(15), nullable=True)
country_code = db.Column(db.String(5), nullable=True)
browser = db.Column(db.String(100), nullable=True)
device = db.Column(db.String(100), nullable=True)
request_string = db.Column(db.String(150), nullable=True)
platform = db.Column(db.String(50), nullable=True)
updated = db.Column(db.DateTime, nullable=False)
master_user = db.relationship('MasterUserModel', backref=db.backref('access_user', lazy='dynamic'))
@property
def id(self):
return self.user_profile_id
def __init__(self, master_user_id=None, access_history=None, latitude=None, longitude=None,
city=None, state=None, zipcode=None, country_code=None, browser=None, device=None,request_string=None,
platform=None):
self.master_user_id = master_user_id
self.access_history = access_history
self.latitude = latitude
self.longitude = longitude
self.city = city
self.state = state
self.zipcode = zipcode
self.country_code = country_code
self.browser = browser
self.device = device
self.request_string = request_string
self.platform = platform
self.updated = datetime.datetime.now()
@property
def serialize(self):
return {
'user': self.master_user.serialize,
'access_history': self.access_history,
'latitude': self.latitude,
'longitude': self.longitude,
'city': self.city,
'state': self.state,
'zipcode': self.zipcode,
'country_code': self.country_code,
'browser': self.browser,
'device': self.device,
'request_string': self.request_string,
'platform': self.platform,
'updated': str(self.updated)
}
class TimelineModel(db.Model):
__tablename__ = 'timeline'
__table_args__ = {"schema": "mgn"}
timeline_id = db.Column(db.Integer, primary_key=True, nullable=False)
master_user_id = db.Column(db.Integer, db.ForeignKey(MasterUserModel.master_user_id), nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey(PostsModel.user_post_id), nullable=True)
blog_id = db.Column(db.Integer, db.ForeignKey(BlogsModel.user_blog_id), nullable=True)
share_id = db.Column(db.Integer, db.ForeignKey(SharesModel.share_id), nullable=True)
comment_id = db.Column(db.Integer, db.ForeignKey(CommentsModel.comment_id), nullable=False)
like_id = db.Column(db.Integer, db.ForeignKey(LikesModel.like_id), nullable=False)
timeline_activity_type_id = db.Column(db.Integer,
db.ForeignKey(TimelineActivityTypeModel.timeline_activity_type_id),
nullable=False)
created = db.Column(db.DateTime, nullable=False)
timeline_user = db.relationship('MasterUserModel', backref=db.backref('timeline_user', lazy='dynamic'))
timeline_post = db.relationship('PostsModel', backref=db.backref('timeline_post', lazy='dynamic'))
timeline_blog = db.relationship('BlogsModel', backref=db.backref('timeline_blog', lazy='dynamic'))
timeline_comment = db.relationship('CommentsModel', backref=db.backref('timeline_comment', lazy='dynamic'))
timeline_like = db.relationship('LikesModel', backref=db.backref('timeline_like', lazy='dynamic'))
timeline_share = db.relationship('SharesModel', backref=db.backref('timeline_share', lazy='dynamic'))
timeline_activity = db.relationship('TimelineActivityTypeModel',
backref=db.backref('timeline_activity', lazy='dynamic'))
@property
def id(self):
return self.timeline_id
def __init__(self, master_user_id=None, post_id=None, blog_id=None, share_id=None, comment_id=None,
like_id=None, timeline_activity_type_id=None):
self.master_user_id = master_user_id
self.post_id = post_id
self.blog_id = blog_id
self.share_id = share_id
self.comment_id = comment_id
self.timeline_activity_type_id = timeline_activity_type_id
self.like_id = like_id
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
if self.timelined_post is not None:
return {
'timeline_id': self.timeline_id,
'timelinetimeline_activity_type_id': self.timeline_activity_type_id,
'user': self.timelined_master_user.serialize,
'timelined_post': self.timelined_post.serialize,
'created': str(self.created)
}
elif self.timelined_blog is not None:
return {
'timeline_id': self.timeline_id,
'timelinetimeline_activity_type_id': self.timeline_activity_type_id,
'user': self.timelined_master_user.serialize,
'timelined_blog': self.timelined_blog.serialize,
'created': str(self.created)
}
elif self.timeline_share is not None:
return {
'timeline_id': self.timeline_id,
'timelinetimeline_activity_type_id': self.timeline_activity_type_id,
'user': self.timelined_master_user.serialize,
'timeline_share': self.timeline_share.serialize,
'created': str(self.created)
}
elif self.timeline_comment is not None:
return {
'timeline_id': self.timeline_id,
'timelinetimeline_activity_type_id': self.timeline_activity_type_id,
'user': self.timelined_master_user.serialize,
'timeline_comment': self.timeline_comment.serialize,
'created': str(self.created)
}
elif self.timeline_like is not None:
return {
'timeline_id': self.timeline_id,
'timelinetimeline_activity_type_id': self.timeline_activity_type_id,
'user': self.timelined_master_user.serialize,
'timeline_like': self.timeline_like.serialize,
'created': str(self.created)
}
class BlogsModel(db.Model):
__tablename__ = 'user_blogs'
__table_args__ = {"schema": "mgn"}
user_blog_id = db.Column(db.Integer, primary_key=True, nullable=False)
blogger_master_user_id = db.Column(db.Integer,
db.ForeignKey(
MasterUserModel.master_user_id),
nullable=False)
blog_name = db.Column(db.String(200), nullable=False)
blog_subject = db.Column(db.String(100), nullable=False)
blog_body = db.Column(db.String, nullable=False)
comment_thread_id = db.Column(db.Integer,
db.ForeignKey(
CommentThreadsModel.comment_thread_id),
nullable=False)
like_thread_id = db.Column(db.Integer,
db.ForeignKey(LikeThreadsModel.like_thread_id),
nullable=False)
visit_count = db.Column(db.SmallInteger, nullable=False)
like_count = db.Column(db.SmallInteger, nullable=False)
comment_count = db.Column(db.SmallInteger, nullable=False)
share_count = db.Column(db.SmallInteger, nullable=False)
tags = db.Column(JSONB, nullable=False)
updated = db.Column(db.DateTime, nullable=False)
created = db.Column(db.DateTime, nullable=False)
blog_master_user = db.relationship('MasterUserModel',
backref=db.backref('blog_master_user',
lazy='dynamic'))
@property
def id(self):
return self.blog_id
def __init__(self,
master_user_id=None,
blog_name=None,
blog_subject=None,
blog_body=None,
comment_thread_id=None,
like_thread_id=None,
tags=None):
self.blogger_master_user_id = master_user_id
self.blog_name = blog_name
self.blog_subject = blog_subject
self.blog_body = blog_body
self.comment_thread_id = comment_thread_id
self.like_thread_id = like_thread_id
self.tags = tags
self.visit_count = 0
self.like_count = 0
self.comment_count = 0
self.share_count = 0
self.updated = datetime.datetime.utcnow()
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
return {
'user': self.blog_master_user.serialize,
'url': url_for("blogs_services.get", blog_name=self.blog_name),
'blog_id': self.user_blog_id,
'blog_subject': self.blog_subject,
'blog_body': self.blog_body,
'comment_thread_id': self.comment_thread_id,
'like_thread_id': self.like_thread_id,
'tags': self.tags,
'visit_count': self.visit_count,
'like_count': self.like_count,
'comment_count': self.comment_count,
'share_count': self.share_count,
'updated': str(self.updated),
'created': str(self.created)
}
class SharesModel(db.Model):
__tablename__ = 'shares'
__table_args__ = {"schema": "mgn"}
share_id = db.Column(db.Integer, primary_key=True, nullable=False)
master_user_id = db.Column(db.Integer, db.ForeignKey(MasterUserModel.master_user_id), nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey(PostsModel.user_post_id), nullable=True)
blog_id = db.Column(db.Integer, db.ForeignKey(BlogsModel.user_blog_id), nullable=True)
url = db.Column(db.String(200), nullable=True)
comment_thread_id = db.Column(db.Integer, db.ForeignKey(CommentThreadsModel.comment_thread_id), nullable=False)
like_thread_id = db.Column(db.Integer, db.ForeignKey(LikeThreadsModel.like_thread_id), nullable=False)
like_count = db.Column(db.SmallInteger, nullable=True)
comment_count = db.Column(db.SmallInteger, nullable=True)
share_count = db.Column(db.SmallInteger, nullable=True)
created = db.Column(db.DateTime, nullable=False)
shared_master_user = db.relationship('MasterUserModel', backref=db.backref('share_master_user', lazy='dynamic'))
shared_post = db.relationship('PostsModel', backref=db.backref('shared_post', lazy='dynamic'))
shared_blog = db.relationship('BlogsModel', backref=db.backref('shared_blog', lazy='dynamic'))
@property
def id(self):
return self.share_id
def __init__(self, master_user_id=None, post_id=None, blog_id=None, url=None, comment_thread_id=None,
like_thread_id=None):
self.master_user_id = master_user_id
self.post_id = post_id
self.blog_id = blog_id
self.url = url
self.comment_thread_id = comment_thread_id
self.like_thread_id = like_thread_id
self.like_count = 0
self.comment_count = 0
self.share_count = 0
self.created = datetime.datetime.utcnow()
@property
def serialize(self):
if self.shared_post is not None:
return {
'share_id': self.share_id,
'share_type': 'post',
'user': self.shared_master_user.serialize,
'shared_post': self.shared_post.serialize,
'comment_thread_id': self.comment_thread_id,
'like_thread_id': self.like_thread_id,
'like_count': self.like_count,
'comment_count': self.comment_count,
'share_count': self.share_count,
'created': str(self.created)
}
elif self.shared_blog is not None:
return {
'share_id': self.share_id,
'share_type': 'blog',
'user': self.shared_master_user.serialize,
'shared_blog': self.shared_blog.serialize,
'comment_thread_id': self.comment_thread_id,
'like_thread_id': self.like_thread_id,
'like_count': self.like_count,
'comment_count': self.comment_count,
'share_count': self.share_count,
'created': str(self.created)
}
elif self.url is not None:
return {
'share_id': self.share_id,
'share_type': 'url',
'user': self.shared_master_user.serialize,
'shared_url': self.url,
'comment_thread_id': self.comment_thread_id,
'like_thread_id': self.like_thread_id,
'like_count': self.like_count,
'comment_count': self.comment_count,
'share_count': self.share_count,
'created': str(self.created)
}
