class SuggestionModel(db.Model): __tablename__ = 'suggestion' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80)) news_title = db.Column(db.Text()) news_link = db.Column(db.Text()) value = db.Column(db.String(30)) def __init__(self, username, news_title, news_link, value): self.username = username self.news_title = news_title self.news_link = news_link self.value = value def json(self): return { 'username': self.username, 'news_title': self.news_title, 'news_link': self.news_link, 'value': self.value } @classmethod def find_by_title(cls, title): return cls.query.filter_by(news_title=title).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class WidgetPage(db.Model): __tablename__ = 'widget_page' id = db.Column('Id', db.BIGINT, primary_key=True) candidate_source_id = db.Column('CandidateSourceId', db.Integer, db.ForeignKey('candidate_source.Id')) # unique_key = db.Column('UniqueKey', db.String(255)) email_source = db.Column('EmailSource', db.String(255)) page_views = db.Column('PageViews', db.Integer) reply_address = db.Column('ReplyAddress', db.String(255)) request_email_html = db.Column('RequestEmailHtml', db.Text()) request_email_subject = db.Column('RequestEmailSubject', db.String(255)) request_email_text = db.Column('RequestEmailText', db.Text()) sign_ups = db.Column('SignUps', db.Integer) simple_hash = db.Column('SimpleHash', db.String(8)) updated_time = db.Column('UpdatedTime', db.DateTime) url = db.Column('Url', db.String(500)) user_id = db.Column('UserId', db.BIGINT, db.ForeignKey('user.Id')) widget_name = db.Column('WidgetName', db.String(63)) welcome_email_text = db.Column('WelcomeEmailText', db.Text()) welcome_email_html = db.Column('WelcomeEmailHtml', db.Text()) welcome_email_subject = db.Column('WelcomeEmailSubject', db.String(255)) @classmethod def get_by_simple_hash(cls, simple_hash): return cls.query.filter(cls.simple_hash == simple_hash).first() def __repr__(self): return "<WidgetPage (id = {})>".format(self.id)
class CountryModel(db.Model): __tablename__ = 'countries' name = db.Column(db.String(50), primary_key=True) date = db.Column(db.Text(50), primary_key=True) cases = db.Column(db.Integer) deaths = db.Column(db.Integer) recoveries = db.Column(db.Integer) def __init__(self, name, date, cases, deaths, recoveries): self.name = name self.date = date self.cases = cases self.deaths = deaths self.recoveries = recoveries def json(self): return { 'name': self.name, 'date': self.date, 'cases': self.cases, 'deaths': self.deaths, 'recoveries': self.recoveries } @classmethod def find_by_country(cls, name): return cls.query.filter_by(name=name).order_by(desc(cls.date)).first()
class BaseCampaign(db.Model): __tablename__ = 'base_campaign' id = db.Column('id', db.Integer, primary_key=True) user_id = db.Column('UserId', db.BIGINT, db.ForeignKey('user.Id', ondelete='CASCADE')) name = db.Column('name', db.String(127), nullable=False) description = db.Column('description', db.Text(65535)) added_datetime = db.Column('added_datetime', db.DateTime, default=datetime.utcnow) # Relationships base_campaign_events = relationship('BaseCampaignEvent', lazy='dynamic', cascade='all, delete-orphan', passive_deletes=True) email_campaigns = relationship('EmailCampaign', lazy='dynamic', cascade='all, delete-orphan', passive_deletes=True, backref='base_campaign') @classmethod @contract def search_by_id_in_domain(cls, base_campaign_id, domain_id): """ This returns all base campaigns for given name in given domain. :param positive base_campaign_id: Id of base campaign :param positive domain_id: Id of domain """ from user import User # This has to be here to avoid circular import return cls.query.filter_by(id=base_campaign_id).join(User).filter( User.domain_id == domain_id).first()
class SponsorListModels(db.Model): __tablename__ = 'sponsors_table' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(30), nullable=False) image = db.Column(db.Text()) def __init__(self, name, image='NONE'): self.name = name self.image = image def sponspor_json(self): return {'name': self.name, 'image': self.image} @classmethod def find_all(cls): return cls.query.all() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class Application(db.Model): __tablename__ = 'applications' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(256)) email = db.Column(db.String(128)) newbie = db.Column(db.Boolean) data = db.Column(db.Text()) state = db.Column(db.String(10), default="tbd") def to_dict(self): final_json = dict() final_json['id'] = self.id final_json['name'] = self.name final_json['email'] = self.email final_json['newbie'] = self.newbie final_json['state'] = self.state partial_data = json.loads(self.data) final_json.update(partial_data) return final_json @staticmethod def getByID(id): app = Application.query.filter_by(id=id).first() return app
class ItemModel(db.Model): __tablename__ = 'items' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), nullable=False) price = db.Column(db.Float(precision=2), nullable=False) description = db.Column(db.Text(), nullable=False) image = db.Column(db.String(256), unique=True) def __init__(self, name, price, description, image): self.name = name self.price = price self.description = description self.image = image @classmethod def find_by_id(cls, item_id): return cls.query.filter_by(id=item_id).first() @classmethod def get_all_items(cls): return cls.query.all() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class SourceServiceModel(db.Model): __tablename__ = "source_service" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) description = db.Column(db.Text()) service_id = db.Column(db.Integer, db.ForeignKey("service.id"), nullable=False) # def json(self) -> SourceServiceJSON: # return { # "id": self.id, # "name": self.name, # "description": self.description, # } @classmethod def get_all(cls) -> List["SourceServiceModel"]: return cls.query.all() @classmethod def get_by_service_id(cls, service_id) -> List["SourceServiceModel"]: return cls.query.filter_by(service_id=service_id).all() def save_to_db(self) -> None: db.session.add(self) db.session.commit()
class UserProfile(TimestampMixin, db.Model): id = db.Column(db.Integer, primary_key=True) photoFsRef = db.Column(db.Text()) coverPhotoFsRef = db.Column(db.Text()) tagline = db.Column(db.Text()) short_bio = db.Column(db.Text(), nullable=False) country = db.Column(db.String(30)) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) def __repr__(self): return '<User %r>' % self.user def save(self): db.session.add(self) db.session.commit()
class Alarm(db.Model): __tablename__ = 'alarms' id = db.Column(db.Integer, primary_key=True) subject = db.Column(db.String(64)) alarm_text = db.Column(db.Text()) task_id = db.Column(db.Integer, db.ForeignKey('tasks.id')) task = db.relationship('Task') def __init__(self, subject, log, task_id): self.subject = subject self.alarm_text = log self.task_id = task_id def __str__(self): return self.subject + '\n' + self.alarm_text def json(self): return {'id' : self.id, 'subject' : self.subject, 'alarm_text' : self.alarm_text} def find_by_id(cls, id): return Alarm.query.filter_by(id=id).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit() def find_all(cls): return Alarm.query.all()
class User(db.Model): __tablename__ = "user" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.Text(), nullable=False, unique=True) posts = db.relationship("Post", back_populates="user") likes = db.relationship("Like", back_populates="user")
class Post(db.Model): __tablename__ = "post" id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False) text = db.Column(db.Text(), nullable=False) user = db.relationship("User", back_populates="posts") likes = db.relationship("Like", back_populates="post")
class Ingredients(TimestampMixin, db.Model): id = db.Column(db.Integer, primary_key=True) dish_id = db.Column(db.Integer, db.ForeignKey('dish.id'), nullable=False) amount = db.Column(db.Float(5)) unit = db.Column(db.String(20)) grocery_item_id = db.Column(db.Integer) ingredient_name = db.Column( db.String(200)) # for will be converted to just id after migration additional_note = db.Column(db.Text(), nullable=True) main_dish = db.Column( db.Integer) # for tracking, can be deleted after migration step_order = db.Column(db.Integer) status = db.Column(db.Integer) def save(self): db.session.add(self) db.session.commit() def update(self, data): for key, item in data.items(): setattr(self, key, item) db.session.commit() @classmethod def find_by_id(self, ingr_id): return self.query.get(ingr_id) @classmethod def find_last_step(self, dish_id): try: query = (db.session.query().with_entities('step_order').filter( Ingredients.dish_id == dish_id).order_by( Ingredients.step_order.desc()).first()) return query except Exception as e: logging.debug( f"[err] Ingredients.find_last_step({dish_id}) => {e}") return None @classmethod def find_all_by_dish_id(self, dishid): try: query = (db.session.query(Ingredients).filter( Ingredients.dish_id == dishid).filter( Ingredients.status == 1).all()) return query except Exception as e: logging.debug( f"[err] Ingredients.find_all_by_dish_id({dishid}) => {e}") return None @classmethod def find_all_active(self, ingr_id): return self.query.filter(id=ingr_id, status=1)
class Blog(db.Model): __tablename__ = 'blog' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(200)) poem = db.Column(db.Text()) key = db.Column(db.String(100)) def __init__(self, title, poem, key): self.title = title self.poem = poem self.key = key
class CaseModel(db.Model): __tablename__ = 'cases' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(30)) description = db.Column(db.Text(256)) start_time = db.Column(db.DateTime, default=datetime.datetime.now()) end_time = db.Column(db.DateTime) history = db.relationship('CaseHistoryModel', cascade="all,delete") status_id = db.Column(db.Integer, db.ForeignKey('statuses.id')) status = db.relationship('StatusModel') user_id = db.Column(db.Integer, db.ForeignKey('users.id')) def __init__(self, name, description, end_time, user_id): self.name = name self.description = description self.end_time = end_time self.user_id = user_id self.status = StatusModel.query.filter_by(name='New').first() def json(self): return { 'name': self.name, 'description': self.description, 'start_time': str(self.start_time.strftime('%H:%M:%S %d.%m.%Y')), 'end_time': str(self.end_time.strftime('%H:%M:%S %d.%m.%Y')), 'status': self.status.name, 'user_id': self.user_id } def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit() @classmethod def find_by_name_and_user_id(cls, name, user_id): return cls.query.filter_by(name=name, user_id=user_id).first() @classmethod def find_by_id(cls, _id): return cls.query.filter_by(id=_id).first() @classmethod def find_all_by_user_id(cls, user_id, status="%%", end_time="%%"): return cls.query.filter((CaseModel.user_id == user_id) & (CaseModel.status_id.like(status)) & (CaseModel.end_time.like(end_time))).all()
class Post(db.Model): __tablename__= 'posts' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(255), index=True, nullable=False) body = db.Column(db.Text(length=10000), index=True, nullable=False) price = db.Column(db.Integer, nullable=False) category_id = db.Column(db.Integer, db.ForeignKey('categories.id')) email = db.Column(db.String(255), nullable=False) token = db.Column(db.String(255), nullable=False) images = db.relationship('Image', backref='post') def update(self, *args, **kwargs): try: self.title = kwargs['title'] self.body = kwargs['body'] self.price = kwargs['price'] self.email = kwargs['email'] db.session.add(self) db.session.commit() except: db.session.rollback() def delete(self): try: db.session.delete(self) for image in self.images: db.session.delete(image) db.session.commit() except: db.session.rollback() @classmethod def create(cls, *args, **kwargs): try: post = Post(**kwargs) db.session.add(post) db.session.commit() except: db.session.rollback() return post @classmethod def querydb(cls, query): query = '%{0}%'.format(query) return db.session.query(cls).filter(cls.title.ilike(query))
class MaidPlanModel(db.Model): __tablename__ = "maidplans" id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(80)) summary = db.Column(db.String(240)) description = db.Column(db.Text()) plan_creation_date = db.Column(db.DateTime, default=datetime.now()) plan_update_date = db.Column(db.DateTime, default=None) deleted = db.Column(db.Boolean) schedule = db.relationship('MaidPlanSchedule', secondary="maidplanscheduleplan", backref='maidplans', lazy='dynamic') def __init__(self, title, summary, description, deleted): self.title = title self.summary = summary self.description = description self.deleted = deleted def json(self): return { "id": self.id, "title": self.title, "summary": self.summary, "description": self.description, "deleted": self.deleted, "schedule": [schedule.json for schedule in self.schedule.all()] } @classmethod def find_by_id(cls, id): return cls.query.filter_by(id=id).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class PrepInstruction(TimestampMixin, db.Model): id = db.Column(db.Integer, primary_key=True) dish_id = db.Column(db.Integer, db.ForeignKey('dish.id'), nullable=False) main_dish = db.Column(db.Integer) description = db.Column(db.Text()) step_order = db.Column(db.Integer) status = db.Column(db.Integer, default="1") def __repr__(self): return '<Instruction %r>' % self.id def save(self): db.session.add(self) db.session.commit() def update(self, data): for key, item in data.items(): setattr(self, key, item) db.session.commit() @classmethod def find_by_id(self, id): try: return self.query.get(id) except Exception as e: logging.debug(f"[err] PrepInstruction.find_by_id({id}) => {e}") return None @classmethod def find_last_step(self, dish_id): try: query = (db.session.query().with_entities('step_order').filter( PrepInstruction.dish_id == dish_id).order_by( PrepInstruction.step_order.desc()).first()) return query except Exception as e: logging.debug( f"[err] PrepInstruction.find_last_step({dish_id}) => {e}") return None
class ServiceModel(db.Model): __tablename__ = "service" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) description = db.Column(db.Text()) status = db.Column(db.String(30)) image = db.Column(db.String()) sources = db.relationship("SourceServiceModel", backref="service") @classmethod def get_all(cls) -> List["ServiceModel"]: return cls.query.all() def save_to_db(self) -> None: db.session.add(self) db.session.commit() def delete_from_db(self) -> None: db.session.delete(self) db.session.commit()
class Post(db.Model): __tablename__='posts' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(255), index=True, nullable=False) body = db.Column(db.Text(length=10000), index=True, nullable=False) price = db.Column(db.Integer, nullable=False) category_id = db.Column(db.Integer, db.ForeignKey('categories.id')) email = db.Column(db.String(255), nullable=False) token = db.Column(db.String(255), nullable=False) filename = db.Column(db.String(255)) def update(self, *args, **kwargs): try: self.title = kwargs['title'] self.body = kwargs['body'] self.price = kwargs['price'] self.email = kwargs['email'] db.session.add(self) db.session.commit() except: db.session.rollback() @classmethod def create(cls, *args, **kwargs): try: # title = kwargs['title'] # body = kwargs['body'] # category_id = kwargs['category_id'] # email = kwargs['email'] # price = kwargs['price'] # token = kwargs['token'] # post = Post(title=title, body=body, category_id=category_id, email=email, price=price, token=token) post = Post(**kwargs) db.session.add(post) db.session.commit() except: db.session.rollback() return post
class UserSettingsModel(db.Model): __tablename__ = "user_settings" id = db.Column(db.Integer, primary_key=True) notifications = db.Column(db.Boolean(), default=bool(True)) public = db.Column(db.Boolean(), default=bool(True)) language = db.Column(db.Text(), default=str('English')) user_id = db.Column(db.String(50), db.ForeignKey( "users.id"), nullable=False) user = db.relationship("UserModel") @classmethod def find_by_user(cls, user_id) -> "UserSettingsModel": return cls.query.filter_by(user_id=user_id).first() def save_to_db(self) -> None: db.session.add(self) db.session.commit() def delete_from_db(self) -> None: db.session.delete(self) db.session.commit()
class HiddenFileModel(db.Model): __tablename__ = "hiddenfiles" id = db.Column(db.Integer, primary_key=True) email = db.Column(db.ForeignKey('users.email'), nullable=False) submitUUID = db.Column(db.CHAR(36), nullable=False) # upload froms submitName = db.Column(db.String(80), nullable=False) modelDesc = db.Column(db.Text()) huggingfaceOrganizationName = db.Column(db.String(80)) huggingfaceRepoName = db.Column(db.String(80)) huggingfaceCommonHash = db.Column(db.String(80)) paramShared = db.Column(db.String(80)) task = db.Column(db.Enum(Task), nullable=False) # others state = db.Column(db.Enum(Status), nullable=False, default=Status.UPLOADED) stateInfo = db.Column(db.String(80)) aoeTimeUpload = db.Column(db.DateTime, nullable=False) dateUpload = db.Column(db.DateTime, default=db.func.current_timestamp()) showOnLeaderboard = db.Column(db.Enum(Show), nullable=False, default=Show.NO) scores = db.relationship("HiddenScoreModel", backref="hiddenfiles") @classmethod def find_by_email(cls, email: str) -> "HiddenFileModel": return cls.query.filter_by(email=email) @classmethod def find_by_submitID(cls, submitUUID: str) -> "HiddenFileModel": return cls.query.filter_by(submitUUID=submitUUID).first() @classmethod def find_by_submitID_task_and_modity_score(cls, submitUUID: str, task: str, score) -> None: submission = cls.query.filter_by(submitUUID=submitUUID).first() setattr(submission.scores[0], task, float(score)) db.session.commit() @classmethod def reset_same_task_show_attribute(cls, email: str, task: enum.Enum) -> None: submissions = cls.query.filter_by(email=email, task=task).all() for submission in submissions: submission.showOnLeaderboard = Show.NO db.session.commit() @classmethod def set_show_attribute_by_submitID(cls, submitUUID) -> None: submission = cls.query.filter_by(submitUUID=submitUUID).first() submission.showOnLeaderboard = Show.YES db.session.commit() @classmethod def unset_show_attribute_by_submitID(cls, submitUUID) -> None: submission = cls.query.filter_by(submitUUID=submitUUID).first() submission.showOnLeaderboard = Show.NO db.session.commit() @classmethod def find_all(cls) -> List["HiddenFileModel"]: return cls.query.all() @classmethod def find_show_on_leaderboard(cls) -> List["HiddenFileModel"]: return cls.query.filter_by(showOnLeaderboard=Show.YES).all() @classmethod def get_upload_count_by_mail(cls, email: str) -> int: return cls.query.filter_by(email=email).count() @classmethod def get_interval_upload_count_by_mail(cls, email: str, AOEtime: datetime.datetime) -> int: return cls.query.filter_by(email=email).filter(cls.aoeTimeUpload >= AOEtime).count() def save_to_db(self) -> None: db.session.add(self) db.session.commit() def delete_from_db(self) -> None: db.session.delete(self) db.session.commit()
class EmailCampaign(db.Model): __tablename__ = 'email_campaign' id = db.Column('Id', db.Integer, primary_key=True) user_id = db.Column('UserId', db.BIGINT, db.ForeignKey('user.Id', ondelete='CASCADE')) base_campaign_id = db.Column( 'BaseCampaignId', db.BIGINT, db.ForeignKey('base_campaign.id', ondelete='CASCADE')) name = db.Column('Name', db.String(127), nullable=False) type = db.Column('Type', db.String(63)) is_hidden = db.Column('IsHidden', db.Boolean, default=False) subject = db.Column('emailSubject', db.String(127)) description = db.Column('Description', db.Text(65535)) _from = db.Column('emailFrom', db.String(127)) reply_to = db.Column('emailReplyTo', db.String(127)) is_email_open_tracking = db.Column('isEmailOpenTracking', db.Boolean, default=True) is_track_html_clicks = db.Column('isTrackHtmlClicks', db.Boolean, default=True) is_track_text_clicks = db.Column('isTrackTextClicks', db.Boolean, default=True) # body_html and body_text are deferred fields because they could be huge. Should really be stored in S3. body_html = db.deferred(db.Column('EmailBodyHtml', LONGTEXT), group='email_body') body_text = db.deferred(db.Column('EmailBodyText', LONGTEXT), group='email_body') is_personalized_to_field = db.Column('isPersonalizedToField', db.Boolean, default=False) frequency_id = db.Column('frequencyId', db.Integer, db.ForeignKey('frequency.id')) start_datetime = db.Column('SendTime', db.DateTime) end_datetime = db.Column('StopTime', db.DateTime) scheduler_task_id = db.Column('SchedulerTaskIds', db.String(255)) custom_html = db.Column('CustomHtml', LONGTEXT) custom_url_params_json = db.Column('CustomUrlParamsJson', db.String(512)) is_subscription = db.Column('isSubscription', db.Boolean, default=False) added_datetime = db.Column('addedTime', db.DateTime, default=datetime.utcnow) email_client_id = db.Column('EmailClientId', db.Integer, db.ForeignKey('email_client.id')) email_client_credentials_id = db.Column( 'EmailClientCredentialsId', db.Integer, db.ForeignKey('email_client_credentials.id')) # Relationships blasts = relationship('EmailCampaignBlast', lazy='dynamic', cascade='all, delete-orphan', passive_deletes=True, backref='campaign') sends = relationship('EmailCampaignSend', cascade='all, delete-orphan', passive_deletes=True, lazy='dynamic', backref='campaign') smartlists = relationship('EmailCampaignSmartlist', cascade='all, delete-orphan', passive_deletes=True, backref='campaign') def to_dict(self, include_fields=None): """ This returns required fields when an email-campaign object is requested. :param list[str] | None include_fields: List of fields to include, or None for all. :rtype: dict[str, T] """ from smartlist import Smartlist smart_lists = Smartlist.query.join(EmailCampaignSmartlist).filter( EmailCampaignSmartlist.campaign_id == self.id).all() talent_pipelines = [{ "id": smart_list.talent_pipeline.id, "name": smart_list.talent_pipeline.name } for smart_list in smart_lists if smart_list.talent_pipeline] talent_pipelines = [ dict(tupleized) for tupleized in set( tuple(item.items()) for item in talent_pipelines) ] return_dict = { "id": self.id, "user_id": self.user_id, "name": self.name, "frequency": self.frequency.name if self.frequency else None, "subject": self.subject, "description": self.description, "from": self._from, "reply_to": self.reply_to, "start_datetime": DatetimeUtils.utc_isoformat(self.start_datetime) if self.start_datetime else None, "end_datetime": DatetimeUtils.utc_isoformat(self.end_datetime) if self.end_datetime else None, "added_datetime": DatetimeUtils.utc_isoformat(self.added_datetime) if self.added_datetime else None, # Conditionally include body_text and body_html because they are deferred fields "body_html": self.body_html if (include_fields and 'body_html' in include_fields) else None, "body_text": self.body_text if (include_fields and 'body_text' in include_fields) else None, "is_hidden": self.is_hidden, "talent_pipelines": talent_pipelines, "list_ids": [smart_list.id for smart_list in smart_lists], "scheduler_task_id": self.scheduler_task_id, "email_client_credentials_id": self.email_client_credentials_id, "base_campaign_id": self.base_campaign_id } # Only include the fields that are supposed to be included if include_fields: return { key: return_dict[key] for key in include_fields if key in return_dict } return return_dict def get_id(self): return unicode(self.id) @classmethod def get_by_domain_id(cls, domain_id, page_number=None): """ This methods returns list of email campaigns in a user's domain :param long|int domain_id: Domain Id :param None|long|int page_number: Page number for pagination purpose :rtype: list|flask_sqlalchemy.BaseQuery """ assert domain_id, 'domain_id not given' from user import User # This has to be here to avoid circular import common_query = cls.query.join(User).filter(User.domain_id == domain_id, cls.is_hidden == 0) if page_number is None: return common_query return get_paginated_objects(common_query, page_number) @classmethod def search_by_id_in_domain(cls, email_campaign_id, domain_id): """ This searches email-campaign by email_campaign_id in user's domain. It raises 404 error if campaign is not found in database. It raises 403 error if camapign does not belong to user's domian. :type email_campaign_id: int|long :type domain_id: int|long :rtype: EmailCampaign|None """ email_campaign = cls.get_by_id(email_campaign_id) if not email_campaign: raise ResourceNotFound( "Email campaign with id: %s does not exist" % email_campaign_id, error_code=EMAIL_CAMPAIGN_NOT_FOUND[1]) if not email_campaign.user.domain_id == domain_id: raise ForbiddenError(EMAIL_CAMPAIGN_FORBIDDEN[0], error_code=EMAIL_CAMPAIGN_FORBIDDEN[1]) return email_campaign @classmethod @contract def get_by_domain_id_and_filter_by_name(cls, domain_id, search_keyword, sort_by, sort_type, is_hidden, user_id=None): """ This filters records of database table EmailCampaign for given criteria. By default it returns all the campaigns in user's domain. If we provide user_id it will only return campaigns belonging to give user_id. :param positive domain_id: Id of domain :param string search_keyword: String with which we want to filter the records. e.g. filter campaigns containing word "Python" :param string sort_by: String by which we want to sort the records. e.g. Sort by Name OR Description etc :param string sort_type: String either "ASC" or "DESC" :param int is_hidden: Indicator to return archived or unarchived campaigns :param positive|None user_id: Id of user """ assert domain_id, 'domain_id not given' from user import User # This has to be here to avoid circular import if sort_by == 'name': sort_by_object = EmailCampaign.name else: sort_by_object = EmailCampaign.added_datetime if sort_type == 'ASC': sort_by_object = sort_by_object.asc() else: sort_by_object = sort_by_object.desc() is_hidden = True if is_hidden else False if user_id: assert str(user_id).isdigit() and int( user_id) > 0, 'positive user_id expected, given: {}'.format( user_id) sub_query = cls.query.filter_by(user_id=user_id) else: sub_query = cls.query.join(User).filter( User.domain_id == domain_id) return sub_query.filter( cls.name.ilike('%' + search_keyword + '%'), cls.is_hidden == is_hidden).order_by(sort_by_object) @classmethod @contract def get_by_user_id(cls, user_id, page_number=None): """ Returns EmailCampaigns against a User Id :param positive user_id: User Id :param positive|None page_number: Page number for returning limited number of records :rtype: list """ query_object = cls.query.filter(cls.user_id == user_id, cls.is_hidden == 0) if page_number is None: return query_object.all() return get_paginated_objects(query_object, page_number) @classmethod @contract def get_by_domain_id_and_name(cls, domain_id, name): """ Gets EmailCampaign against campaign name :param positive domain_id: User's domain Id :param string name: :rtype: list """ from user import User return cls.query.join(User).filter(cls.name == name, User.domain_id == domain_id, cls.is_hidden == 0).all() def __repr__(self): return "<EmailCampaign(name=' %r')>" % self.name @classmethod @contract def email_campaigns_in_user_group(cls, user_id): """ Gets EmailCampaigns in user's group against User Id :param positive user_id: User Id :rtype: list """ from user import User user = User.query.filter(User.id == user_id).first() if user: if user.user_group_id: return cls.query.join(User).filter( User.user_group_id == user.user_group_id, cls.is_hidden == 0).all() raise NotFoundError @classmethod @contract def email_campaigns_in_talent_pool(cls, user_id, scope, talentpool_names=None, page_number=None): """ Returns EmailCampaigns in talent pool :param positive|None page_number: Page number for returning limited number of records :param int scope: Number which determines weather user asking about all domain campaigns or only his campaigns :param positive user_id: User Id :param list|None talentpool_names: list of Talentpool names or None :rtype: list """ from smartlist import SmartlistCandidate # To avoid circular dependency this has to be here from user import User # To avoid circular dependency this has to be here smartlist_ids = SmartlistCandidate.get_smartlist_ids_in_talent_pools( user_id, talentpool_names) email_campaign_ids = EmailCampaignSmartlist.query.with_entities(EmailCampaignSmartlist.campaign_id).\ filter(EmailCampaignSmartlist.smartlist_id.in_(smartlist_ids)).all() email_campaign_ids = [ email_campaign_id[0] for email_campaign_id in email_campaign_ids ] scope_dependant_filter = cls.query.join(User).filter(cls.id.in_(email_campaign_ids), cls.is_hidden == 0, cls.user_id == user_id)\ if scope == OWNED else cls.query.filter(cls.id.in_(email_campaign_ids), cls.is_hidden == 0) if page_number is None: return scope_dependant_filter.all() return get_paginated_objects(scope_dependant_filter, page_number)
class CommentModel(db.Model): __tablename__ = 'comments' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(255)) content = db.Column(db.Text()) created_at = db.Column(db.DateTime()) updated_at = db.Column(db.DateTime()) course_id = db.Column(db.Integer, db.ForeignKey('courses.id')) course = db.relationship('CourseModel', backref=db.backref('comments', cascade='all, delete-orphan', lazy='dynamic')) author_id = db.Column(db.Integer, db.ForeignKey('users.id')) author = db.relationship('UserModel', backref=db.backref('comments', cascade='all, delete-orphan', lazy='dynamic')) def __init__(self, title, content, course_id, author_id): self.title = title self.content = content self.add_course(course_id) self.add_author(author_id) self.created_at = datetime.utcnow() self.updated_at = datetime.utcnow() def add_course(self, course_id): course = CourseModel.query.filter_by(id=course_id).first() self.course = course def add_author(self, author_id): author = UserModel.query.filter_by(id=author_id).first() self.author = author def save(self): db.session.add(self) db.session.commit() def update(self, **kwargs): self.title = kwargs['title'] self.content = kwargs['content'] self.updated_at = datetime.now() db.session.commit() def delete(self): db.session.delete(self) db.session.commit() def json(self): return { "id": self.id, "title": self.title, "content": self.content, "created_at": self.created_at.strftime('%Y-%m-%dT%H:%M:%S'), "updated_at": self.updated_at.strftime('%Y-%m-%dT%H:%M:%S'), "course": { "id": self.course.id, "title": self.course.title }, "author": { "id": self.author.id, "username": self.author.username } } @classmethod def find_by_id(cls, comment_id): return cls.query.filter_by(id=comment_id).first() @classmethod def find_by_course(cls, course_id): return cls.query.filter_by(course_id=course_id).all()
class BookModel(db.Model): """SQLAlchemy Book Model""" # We assign the correct table __tablename__ = 'books' # Table columns bookId = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(300)) publisher = db.Column(db.String(150)) published_date = db.Column(db.String(15)) description = db.Column(db.Text()) isbn10 = db.Column(db.String(20)) isbn13 = db.Column(db.String(20)) booktype = db.Column(db.String(30)) language = db.Column(db.String(30)) thumbnail = db.Column(db.String(200)) page_count = db.Column(db.Integer) md5 = db.Column(db.String(32)) url_info = db.Column(db.String(200)) dl_link1 = db.Column(db.String(200)) dl_link2 = db.Column(db.String(200)) chosen_url = db.Column(db.String(200)) filepath = db.Column(db.String(200)) # Foreign key a book belongs to a category and an author categoryId = db.Column('categoryId', db.Integer, db.ForeignKey('categories.categoryId')) authorId = db.Column('authorId', db.Integer, db.ForeignKey('authors.authorId')) # We reference the parents category = db.relationship('CategoryModel', cascade="save-update") author = db.relationship('AuthorModel', cascade="save-update") # A book might many portfolio book relations portfolios_books = db.relationship("PortfolioBookModel", cascade="save-update, merge, delete") def __init__(self, title, authorId, categoryId, publisher, published_date, description, isbn10, isbn13, booktype, language, thumbnail, page_count, md5, url_info, dl_link1, dl_link2, chosen_url, filepath): """[summary] Arguments: title {string} -- title of the book authorId {int} -- id of the author of the book categoryId {int} -- id of the category of the book publisher {string} -- name of the publisher of the book published_date {string} -- publishing date description {string} -- description of the book isbn10 {string} -- isbn10 of the book isbn13 {string} -- isbn13 of the book booktype {string} -- type of the book (extension) language {string} -- Language of the book thumbnail {string} -- Url of the book's thumbnail page_count {int} -- Page count of the book md5 {string} -- libgen.io identifier url_info {string} -- google book api book info url dl_link1 {string} -- download link 1 dl_link2 {string} -- download link 2 chosen_url {string} -- Chosen url for the download (Whether dl_link1 or dl_link2) filepath {string} -- file path where the book is digitally contained """ # Instance variables self.title = title self.authorId = authorId self.categoryId = categoryId self.publisher = publisher self.published_date = published_date self.description = description self.isbn10 = isbn10 self.isbn13 = isbn13 self.booktype = booktype self.language = language self.thumbnail = thumbnail self.page_count = page_count self.md5 = md5 self.url_info = url_info self.dl_link1 = dl_link1 self.dl_link2 = dl_link2 self.filepath = filepath self.chosen_url = chosen_url def json(self): """Return a JSON data of the instance variables""" return { 'bookId': self.bookId, 'title': self.title, 'authorId': self.authorId, 'categoryId': self.categoryId, 'publisher': self.publisher, 'published_date': self.published_date, 'description': self.description, 'isbn10': self.isbn10, 'isbn13': self.isbn13, 'booktype': self.booktype, 'language': self.language, 'thumbnail': self.thumbnail, 'page_count': self.page_count, 'md5': self.md5, 'url_info': self.url_info, 'dl_link1': self.dl_link1, 'dl_link2': self.dl_link2, 'filepath': self.filepath, 'chosen_url': self.chosen_url } # Important methods used to retrieve data through SQL Alchemy @classmethod def find_by_title(cls, title): """Retrieve the book provided its title""" return cls.query.filter_by(title=title).first() @classmethod def find_by_id(cls, bookId): """Retrieve the book provided its bookId""" return cls.query.filter_by(bookId=bookId).first() @classmethod def find_by_author_id(cls, authorId): """Retrieve the book provided its authorId""" return cls.query.filter_by(authorId=authorId).all() @classmethod def find_by_category_id(cls, categoryId): """Retrieve the book provided its categoryId""" return cls.query.filter_by(categoryId=categoryId).all() def save_to_db(self): """Methods used to push and commit to the database""" db.session.add(self) db.session.commit() def delete_from_db(self): """Methods used to delete and commit to the database""" db.session.delete(self) db.session.commit()
class FileModel(db.Model): __tablename__ = "files" id = db.Column(db.Integer, primary_key=True) email = db.Column(db.ForeignKey('users.email'), nullable=False) submitUUID = db.Column(db.CHAR(36), nullable=False) # upload froms submitName = db.Column(db.String(80), nullable=False) modelURL = db.Column(db.String(264)) modelDesc = db.Column(db.Text()) stride = db.Column(db.Text()) inputFormat = db.Column(db.Text()) corpus = db.Column(db.Text()) paramDesc = db.Column(db.Text()) paramShared = db.Column(db.String(80)) fineTunedParam = db.Column(db.String(80)) taskSpecParam = db.Column(db.String(80)) task = db.Column(db.Enum(Task), nullable=False) # others state = db.Column(db.Enum(Status), nullable=False, default=Status.UPLOADED) stateInfo = db.Column(db.String(80)) filePath = db.Column(db.String(264), nullable=False) aoeTimeUpload = db.Column(db.DateTime, nullable=False) dateUpload = db.Column(db.DateTime, default=db.func.current_timestamp()) showOnLeaderboard = db.Column(db.Enum(Show), nullable=False, default=Show.NO) # profiling macs = db.Column(BIGINT(unsigned=True)) macsShort = db.Column(BIGINT(unsigned=True)) macsMedium = db.Column(BIGINT(unsigned=True)) macsLong = db.Column(BIGINT(unsigned=True)) macsLonger = db.Column(BIGINT(unsigned=True)) scores = db.relationship("ScoreModel", backref="files") @classmethod def find_by_email(cls, email: str) -> "FileModel": return cls.query.filter_by(email=email) @classmethod def find_by_submitID(cls, submitUUID: str) -> "FileModel": return cls.query.filter_by(submitUUID=submitUUID).first() @classmethod def reset_same_task_show_attribute(cls, email: str, task: enum.Enum) -> None: submissions = cls.query.filter_by(email=email, task=task).all() for submission in submissions: submission.showOnLeaderboard = Show.NO db.session.commit() @classmethod def set_show_attribute_by_submitID(cls, submitUUID) -> None: submission = cls.query.filter_by(submitUUID=submitUUID).first() submission.showOnLeaderboard = Show.YES db.session.commit() @classmethod def unset_show_attribute_by_submitID(cls, submitUUID) -> None: submission = cls.query.filter_by(submitUUID=submitUUID).first() submission.showOnLeaderboard = Show.NO db.session.commit() @classmethod def find_all(cls) -> List["FileModel"]: return cls.query.all() @classmethod def find_show_on_leaderboard(cls) -> List["FileModel"]: return cls.query.filter_by(showOnLeaderboard=Show.YES).all() @classmethod def get_upload_count_by_mail(cls, email: str) -> int: return cls.query.filter_by(email=email).count() @classmethod def get_interval_upload_count_by_mail(cls, email: str, AOEtime: datetime.datetime) -> int: return cls.query.filter_by(email=email).filter(cls.aoeTimeUpload >= AOEtime).count() def save_to_db(self) -> None: db.session.add(self) db.session.commit() def delete_from_db(self) -> None: db.session.delete(self) db.session.commit()
class BnbModel(db.Model): __tablename__ = "bnblistings" id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(80)) summary = db.Column(db.String(240)) content = db.Column(db.Text()) thumbnail = db.Column(db.String(80)) active = db.Column(db.Boolean, default=False) archived = db.Column(db.Boolean, default=False) deleted = db.Column(db.Boolean, default=False) bedrooms = db.Column(db.Integer) bathrooms = db.Column(db.Integer) street_address_1 = db.Column(db.String(80)) street_address_2 = db.Column(db.String(80)) city = db.Column(db.String(80)) state = db.Column(db.String(80)) zip_code = db.Column(db.String(20)) square_footage = db.Column(db.String(20)) def __init__(self, title: str, summary: str, content: str, thumbnail: str, active: bool, archived: bool, deleted: bool, bedrooms: int, bathrooms: int, street_address_1: str, street_address_2: str, city: str, state: str, zip_code: str, square_footage: str): self.square_footage = square_footage self.zip_code = zip_code self.state = state self.city = city self.street_address_2 = street_address_2 self.street_address_1 = street_address_1 self.bathrooms = bathrooms self.bedrooms = bedrooms self.deleted = deleted self.archived = archived self.active = active self.thumbnail = thumbnail self.content = content self.summary = summary self.title = title def json(self): return { "id": self.id, "title": self.title, "summary": self.summary, "content": self.content, "thumbnail": self.thumbnail, "active": self.active, "archived": self.archived, "deleted": self.deleted, "bedrooms": self.bedrooms, "bathrooms": self.bathrooms, "street_address_1": self.street_address_1, "street_address_2": self.street_address_2, "city": self.city, "state": self.state, "zip_code": self.zip_code, "square_footage": self.square_footage, } @classmethod def find_by_id(cls, _id): return cls.query.filter_by(id=_id).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()
class NewsArticleModel(db.Model): __tablename__ = 'articles' id = db.Column(db.Integer, primary_key=True) date = db.Column(db.Date()) title = db.Column(db.String()) description = db.Column(db.String()) text = db.Column(db.Text()) def __init__(self, date, title, description, text): self.date = date self.title = title self.description = description self.text = text def json(self): return { 'id': self.id, 'date': self.date.strftime("%d-%m-%Y"), 'title': self.title, 'description': self.description, 'text': self.text, } @classmethod def find_by_title(cls, title): return cls.query.filter_by(title=title).first() @classmethod def find_by_id(cls, _id): return cls.query.filter_by(id=_id).first() @classmethod def find_by_date(cls, date): return cls.query.filter_by(date=date).all() @classmethod def find_by_date_and_title(cls, date, title): return cls.query.filter_by(date=date, title=title).first() @classmethod def get_all_sorted_by_date(cls): return cls.query.order_by(cls.date.desc()).all() @classmethod def get_all_sorted_by_title(cls): return cls.query.order_by(cls.title).all() @classmethod def get_all_sorted_by_date_and_title(cls): return cls.query.order_by(cls.date.desc(), cls.title).all() @classmethod def delete_from_db_by_date(cls, date): bukl_delete_q = cls.__table__.delete().where(cls.date == date) db.session.execute(bukl_delete_q) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit() def save_to_db(self): db.session.add(self) db.session.commit()