class Invoices(db.Model):
__tablename__ = 'invoices'
invoices_id = db.Column(db.Integer, primary_key=True)
net = db.Column(db.Integer, default=0)
tax = db.Column(db.Integer, default=0)
sum = db.Column(db.Integer, default=0)
customer_id = db.Column(db.Integer,
db.ForeignKey('customers.customers_id'),
nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
payment_date = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
quantities = db.relationship('Quantities', backref='invoice', lazy=True)
class People(db.Model):
id = db.Column(db.Integer, primary_key=True)
age = db.Column(db.Integer)
gender = db.Column(db.Integer)
likes = db.Column(db.String(120))
dislikes = db.Column(db.String(120))
profession = db.Column(db.String(120))
birthday = db.Column(db.DateTime)
location = db.Column(db.String(120))
def __init__(self, title, text, pub_date=None, slug=None):
self.title = title
self.text = text
self.slug = (slug or title).replace(' ', '_')
self.pub_date = (pub_date or datetime.utcnow())
def __repr__(self):
return self.title
class Post(db.Model):
__tablename__ = "t_post"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
post_time = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
poster_id = db.Column(db.Text())
poster_name = db.Column(db.Text())
post_contents = db.Column(db.Text())
parent_post_id = db.Column(db.Integer)
ke_id = db.Column(db.Integer, db.ForeignKey('m_thread.id'))
password = db.Column(db.Text())
is_delete = db.Column(db.Integer)
def __init__(self, post_time, poster_id, poster_name, post_contents,
parent_post_id, ke_id, password, is_delete):
self.post_time = post_time
self.poster_id = poster_id
self.poster_name = poster_name
self.post_contents = post_contents
self.parent_post_id = parent_post_id
self.ke_id = ke_id
self.password = password
self.is_delete = is_delete
class Orders(db.Model):
__tablename__ = 'orders'
orders_id = db.Column(db.Integer, primary_key=True)
net = db.Column(db.Integer, default=0)
sum = db.Column(db.Integer, default=0)
supplier_id = db.Column(db.Integer,
db.ForeignKey('suppliers.suppliers_id'),
nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
quantities = db.relationship('Quantities', backref='order', lazy=True)
sent = db.Column(db.Boolean, default=False)
class PDB(db.Model):
# __tablename__ = 'pdb'
id = db.Column(db.Integer, primary_key=True)
pdb_id = db.Column(db.String(64), unique=True)
in_bindingdb_validation_set = db.Column(db.Boolean)
#ligand column may not be necessary
ligand = db.Column(db.String(64))
expressed_in_ecoli = db.Column(db.Boolean)
expression_system = db.Column(db.String(64))
#SEQRES sequence
sequence = db.Column(db.String(1024), unique=True)
method = db.Column(db.String(64), unique=True)
uniprot_id = db.Column(db.Integer, db.ForeignKey('uniprot.id'))
# uniprot_acc = db.Column(db.String(64), db.ForeignKey('uniprot.acc'))
hets = db.relationship("HET", backref='pdb', lazy='dynamic')
# def __init__(self, pdb_id, present_in_BindingDB_validation_set):
# self.pdb_id = pdb_id
# self.present_in_BindingDB_validation_set = present_in_BindingDB_validation_set
def __repr__(self):
return "<PDB %r>" % self.pdb_id
class Milestone(db.Model):
"""
Startup milestones
"""
__tablename__ = "milestone"
id = db.Column(Integer, primary_key=True)
name = db.Column(db.String)
year = db.Column(db.Integer)
month = db.Column(db.Integer)
day = db.Column(db.Integer)
url = db.Column(db.String)
class Energy(db.Model):
building = db.Column(db.String, primary_key=True)
year = db.Column(db.Integer, primary_key=True)
month = db.Column(db.Integer, primary_key=True)
quantity = db.Column(db.Integer, unique=False)
consumption_price = db.Column(db.Float, unique=False)
transmission_price = db.Column(db.Float, unique=False)
def __repr__(self):
return '{} Energy {}.{} quantity={}'.format('School' if self.building == 'SCH' else 'Workshop',
self.year, self.month, self.quantity)
class ExchangeMetadata(db.Model):
id = db.Column(db.Integer(), primary_key=True)
giver_id = db.Column(db.String(8), db.ForeignKey('user.login'))
receiver_id = db.Column(db.String(8), db.ForeignKey('user.login'))
date_execution = db.Column(db.DateTime(), default=None)
date_conf_giver = db.Column(db.DateTime(), default=None)
date_conf_receiver = db.Column(db.DateTime(), default=None)
date_cancelled = db.Column(db.DateTime(), default=None)
canceller = db.Column(db.String(8), default=None)
date_creation = db.Column(db.DateTime())
data = db.relationship("ExchangeData", backref="exchange")
giver = db.relationship("User", foreign_keys="ExchangeMetadata.giver_id")
receiver = db.relationship("User",
foreign_keys="ExchangeMetadata.receiver_id")
def __init__(self, giver):
self.giver_id = giver
self.date_creation = datetime.datetime.now()
def __repr__(self):
return '<EchangeMetadata %r>' % self.id
class UserInfo(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(10))
sex = db.Column(db.String(2))
english = db.Column(db.Float)
math = db.Column(db.Float)
chinese = db.Column(db.Float)
def __repr__(self):
return '<UserInfo %r>' % self.id
class Device(db.Model):
id = db.Column(db.Integer, primary_key=True)
mac_address = db.Column(db.String(MAC_ADDR_LEN), unique=True)
last_seen = db.Column(db.Integer)
label = db.Column(db.String(NAME_MAX_LENGTH))
location = db.Column(db.String(LOCATION_MAX_LENGTH))
registered = db.Column(db.Integer)
def __init__(self, mac_addr, last_seen_time):
self.mac_address = mac_addr
self.last_seen = last_seen_time
class FirewallRule(db.Model):
"""
An access control list object
"""
__tablename__ = 'rules'
id = db.Column(db.Integer, primary_key=True)
action = db.Column(db.String)
where = db.Column(db.String)
to = db.Column(db.String)
protocol = db.Column(db.String)
port = db.Column(db.String)
class Registry(db.Model):
__tablename__ = 'XM_REGISTRY'
REGISTRY_ID = db.Column(db.String(128), primary_key=True)
REGISTRY_URL = db.Column(db.String(128), nullable=False)
REGISTRY_PORT = db.Column(db.Integer, nullable=False)
REGISTRY_USERNAME = db.Column(db.String(128), nullable=False)
REGISTRY_PASSWORD = db.Column(db.String(128), nullable=False)
CREATION_DATE = db.Column(db.Date, default=_get_date)
def __repr__(self):
return '<Registry (%s, %s) >' % (self.REGISTRY_ID, self.REGISTRY_URL)
class Paragraph(db.Model):
__table_args__ = ({"mysql_charset": "utf8mb4"})
id = db.Column(db.Integer, primary_key=True)
book_id = db.Column(db.Integer)
offset = db.Column(db.Integer)
content = db.Column(db.Text)
content_type = db.Column(db.Integer)
chapter = db.Column(db.Integer)
section = db.Column(db.Integer)
subsection = db.Column(db.Integer)
position = db.Column(db.Integer)
def __init__(self, book_id, offset, content, content_type, chapter, section, subsection, position):
self.book_id = book_id
self.offset = offset
self.content = content
self.content_type = content_type
self.chapter = chapter
self.section = section
self.subsection = subsection
self.position = position
def __repr__(self):
return '<Paragraph %r>' % self.id
def to_dict(self):
return {
"text": self.content,
"audioTimeFrame": self.offset,
"type": self.content_type,
"index": self.get_index(),
"position": self.position
}
def get_index(self):
if self.subsection != 0:
return "%d-%d-%d" % (self.chapter, self.section, self.subsection)
else:
return "%d-%d" % (self.chapter, self.section)
class VerificationCode(db.Model):
eth_address = db.Column(db.Numeric(precision=50, scale=0),
primary_key=True)
phone = db.Column(db.String(20), index=True)
code = db.Column(db.String(10))
expires_at = db.Column(db.DateTime(timezone=True))
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True),
server_default=func.now(),
onupdate=func.now())
class Lift(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
osm_id = db.Column(db.BigInteger, unique=True)
ski_area = db.relationship('SkiArea')
ski_area_id = db.Column(db.Integer, db.ForeignKey('ski_area.id'))
type = db.Column(db.Text)
path = db.Column(Geometry())
occupancy = db.Column(db.Integer)
@hybrid_property
def geojson(self):
return json.loads(
db.session.scalar(geoalchemy2.functions.ST_AsGeoJSON(self.path)))
class Collection(db.Model):
id = db.Column(db.Integer(), primary_key=True)
login_user = db.Column(db.String(8),
db.ForeignKey('user.login'),
index=True)
ecocup = db.Column(db.Integer(), db.ForeignKey('ecocup.id'), index=True)
in_collection = db.Column(db.Integer())
accepte_echange = db.Column(db.Integer())
souhaite = db.Column(db.Integer())
date_mise_a_jour = db.Column(db.DateTime(),
default=datetime.datetime.utcnow())
def __repr__(self):
return '<Collection %r %r>' % (self.id, self.nom_ecocup,
self.in_collection, self.login_user)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime(), default=datetime.datetime.now)
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def __str__(self):
return self.email
class Datastore(db.Model):
"""
A datastore object
"""
__tablename__ = 'datastores'
id = db.Column(db.Integer, primary_key=True) # id
name = db.Column(db.String) # identification name
username = db.Column(db.String) # username
password = db.Column(db.String) # password
host = db.Column(db.String) # host IP address or hostname
type = db.Column(db.String) # only supported type at the moment: smb
arguments = db.Column(db.String) # unsupported
def __str__(self):
return self.name
class Users(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(80), nullable=False)
last_name = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(120), nullable=False)
phone = db.Column(db.Integer, nullable=False)
admin = db.Column(db.Boolean)
articles_id = db.Column(db.Integer, db.ForeignKey('articles.id'))
article = db.relationship('Articles',
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return '<Post %r>' % self.firstname
class Event(db.Model, Thing):
inLanguage = db.Column('inLanguage', db.String(1024))
startDate = db.Column('startDate', db.DateTime)
endDate = db.Column('endDate', db.DateTime)
doorTime = db.Column('doorTime', db.DateTime)
attendee_id = db.Column('attendee_id', db.String(1024),
ForeignKey('person.guid'))
organizer_id = db.Column('organizer_id', db.String(1024),
ForeignKey('person.guid'))
offers_id = db.Column('offers_id', db.String(1024),
ForeignKey('offer.guid'))
eventStatus_id = db.Column('eventStatus_id', db.String(1024),
ForeignKey('eventstatustype.guid'))
attendee = db.relationship('Person', secondary='EventAttendees')
organizer = db.relationship('Person', secondary='EventOrganizers')
offers = db.relationship('Offer', secondary='EventOffers')
eventStatus = db.relationship('EventStatusType')
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String, unique=True, nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
firstname = db.Column(db.String(80), nullable=False)
lastname = db.Column(db.String(80), nullable=False)
password = db.Column(db.String(300), nullable=False)
active = db.Column(db.Boolean(), nullable=False)
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
submissions = db.relationship('Submission', backref='user', lazy='dynamic')
def __repr__(self):
return self.username
def __unicode__(self):
return self.username
class VCModel(db.Model):
__tablename__ = "vc"
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime, default=datetime.datetime.now())
name = db.Column(db.String)
crunchbase_url = db.Column(db.String)
angellist_url = db.Column(db.String)
image_url = db.Column(db.String)
score = db.Column(db.Float)
startup_data_user_id = db.Column(db.Integer,
db.ForeignKey('startup_data.id'))
def as_dict(self):
return {
'id': self.id,
'name': self.name,
'crunchbase_url': self.crunchbase_url,
'score': self.score
}
class QuestionData(db.Model):
""" Feedback-form question-data for all experiments """
q_id = db.Column(db.Integer, primary_key=True)
gfg_id = db.Column(db.String(32), nullable=False)
session_id = db.Column(db.Integer, db.ForeignKey('session.session_id'))
exp_name = db.Column(db.String(32), nullable=False)
rating = db.Column(db.String(32))
difficulty = db.Column(db.String(32))
distraction = db.Column(db.String(32)) #informative
#extrahelp = db.Column(db.String) #added new
openended = db.Column(db.Text())
def __repr__(self):
pass
def add_json_data(self, json_event):
""" Parse and add backbone.js json data for a questionnaire """
self.rating = json_event['rating']
if json_event['difficulty'] == "Not difficult":
json_event['difficulty'] = "1"
elif json_event['difficulty'] == "Somewhat difficult":
json_event['difficulty'] = "5"
elif json_event['difficulty'] == "Very difficult":
json_event['difficulty'] = "10"
elif json_event['difficulty'] == "Not rated":
json_event['difficulty'] = "0"
self.difficulty = json_event['difficulty']
if json_event['distraction'] == "No distraction":
json_event['distraction'] = "1"
elif json_event['distraction'] == "Some distractions":
json_event['distraction'] = "5"
elif json_event['distraction'] == "Frequent interruptions":
json_event['distraction'] = "10"
elif json_event['distraction'] == "Not rated":
json_event['distraction'] = "0"
self.distraction = json_event['distraction']
#self.extrahelp = json_event['extrahelp']
self.openended = clean_db_string(json_event['openended'])
current_app.logger.info("%s added to QuestionData for session id %s " %
(self.q_id, self.session_id))
class Interest(db.Model):
__tablename__ = 'interest'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
company_name = db.Column(db.String(255))
email = db.Column(db.String(255))
website = db.Column(db.String(255))
note = db.Column(db.Text())
def __str__(self):
return '%s' % (self.email)
class HET(db.Model):
# __tablename__ = 'het'
id = db.Column(db.Integer, primary_key=True)
# component identifier is 3 letter code according to PDB Chemical Components Dictionary
component_identifier = db.Column(db.String(64), unique=True)
full_name = db.Column(db.String(64), unique=True)
smiles = db.Column(db.String(256), unique=True)
inchi = db.Column(db.String(256), unique=True)
pdb_table_id = db.Column(db.Integer, db.ForeignKey('PDB.id'))
def __repr__(self):
return "<HET %r>" % self.component_identifier
class Event(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
start_date = db.Column(db.DateTime, nullable=False)
end_date = db.Column(db.DateTime, nullable=False)
location = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(1000), nullable=False)
color = db.Column(db.String(20), nullable=False)
is_public = db.Column(db.Integer)
def __init__(self, name, start_date, end_date, location, description,
color):
self.name = name
self.start_date = start_date
self.end_date = end_date
self.location = location
self.description = description
self.color = color
self.date_posted = datetime.date.today()
class GoogleAnalyticsVisitors(db.Model):
"""
Google Analytics Site Visitor Metrics
"""
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String)
profile_id = db.Column(db.Integer)
date = db.Column(db.DateTime)
visitors = db.Column(db.Integer)
new_visits = db.Column(db.Integer)
percent_new_visits = db.Column(db.Integer)
def __init__(self,
username=None,
profile_id=None,
date=None,
visitors=None,
new_visits=None,
percent_new_visits=None):
self.username = username
self.profile_id = profile_id
self.date = date
self.visitors = visitors
self.new_visits = new_visits
self.percent_new_visits = percent_new_visits
def as_dict(self):
return {
'id': self.id,
'username': self.username,
'profile_id': self.profile_id,
'date': time.mktime(datetime.datetime.timetuple(self.date)) * 1000,
'visitors': self.visitors,
'new_visits': self.new_visits,
'percent_new_visits': self.percent_new_visits
}
def as_count(self, all_visitors=True):
if all_visitors:
return [
time.mktime(datetime.datetime.timetuple(self.date)) * 1000,
self.visitors
]
else:
return [
time.mktime(datetime.datetime.timetuple(self.date)) * 1000,
self.new_visits
]
class WufooTextareaSentiment(db.Model):
id = db.Column(db.Integer, primary_key=True)
survey_id = db.Column(db.Integer, db.ForeignKey('wufoo_survey.id'))
created = db.Column(db.DateTime, default=datetime.datetime.now())
score = db.Column(db.Float(15), default=0.0)
sentiment_type = db.Column(db.String)
text = db.Column(db.Text)
def __init__(self, score, sentiment_type, text):
self.score = score
self.sentiment_type = sentiment_type
self.text = text
class ConversionWorkflow(Workflow):
__tablename__ = "conversion_workflows"
subscription_id = db.Column(db.Integer,
db.ForeignKey("subscriptions.id"),
nullable=False)
def get_subscription(self):
return Subscription.get_by_id(self.subscription_id)
@classmethod
def get_subscriptions_to_send_final_notice(cls):
return ConversionWorkflow.query.join(Subscription).filter(Subscription.id == ConversionWorkflow.id). \
filter(Subscription.end_date <= cls.days_later(0)). \
filter(ConversionWorkflow.status > ConversionWorkflowStatus.sent_final_notice). \
filter(Subscription.type != SubscriptionTypes.free). \
filter(Subscription.status == SubscriptionStatuses.active). \
all()
@classmethod
def get_subscriptions_to_send_one_week_notice(cls):
return ConversionWorkflow.query.join(Subscription).filter(Subscription.id == ConversionWorkflow.id). \
filter(Subscription.end_date <= cls.days_later(7)). \
filter(ConversionWorkflow.status > ConversionWorkflowStatus.sent_one_week_notice). \
filter(Subscription.type != SubscriptionTypes.free). \
filter(Subscription.status == SubscriptionStatuses.active). \
all()
@classmethod
def get_subscriptions_to_send_two_week_notice(cls):
return ConversionWorkflow.query.join(Subscription).filter(Subscription.id == ConversionWorkflow.id). \
filter(Subscription.end_date <= cls.days_later(14)). \
filter(ConversionWorkflow.status > ConversionWorkflowStatus.sent_two_week_notice). \
filter(Subscription.type != SubscriptionTypes.free). \
filter(Subscription.status == SubscriptionStatuses.active). \
all()
@classmethod
def get_subscriptions_to_send_four_week_notice(cls):
return ConversionWorkflow.query.join(Subscription).filter(Subscription.id == ConversionWorkflow.id). \
filter(Subscription.end_date <= cls.days_later(28)). \
filter(ConversionWorkflow.status > ConversionWorkflowStatus.sent_four_week_notice). \
filter(Subscription.type != SubscriptionTypes.free). \
filter(Subscription.status == SubscriptionStatuses.active). \
all()
class Facility(db.Model):
__tablename__ = 'facilities'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
type = db.Column(db.String(10), nullable=False)
ward_id = db.Column(db.String(2), nullable=False)
image_url = db.Column(db.Text, nullable=True)
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now())
def __init__(self, name, type, ward_id, image_url):
self.name = name
self.type = type
self.ward_id = ward_id
self.image_url = image_url
