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 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 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 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 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 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 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 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 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 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 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 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 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)
}
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 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)
}
