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