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