class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return '<User %r>' % self.username
class Messages(db.Model):
__tablename__ = 'tr_messages'
id = db.Column(db.Integer, primary_key=True)
event_id = db.Column(db.Integer)
email_subject = db.Column(db.String(200))
email_content = db.Column(db.String(500))
timestamp = db.Column(db.DateTime())
class LDAPConnection(db.Model):
__tablename__ = 'ldap_connections'
id = db.Column(db.Integer, primary_key=True)
ldap_id = db.Column(db.String(50), unique=True, nullable=False)
url = db.Column(db.String(2000), unique=False, nullable=False)
port = db.Column(db.Integer, unique=False, nullable=False)
use_ssl = db.Column(db.Boolean, unique=False, nullable=False)
user_dn = db.Column(db.String(200), unique=False, nullable=False)
bind_dn = db.Column(db.String(200), unique=False, nullable=False)
bind_credential = db.Column(db.String(200), unique=False, nullable=False)
account_type = db.Column(db.Enum(LDAPAccountTypes), unique=False, nullable=False)
create_time = db.Column(db.DateTime, nullable=False)
last_update_time = db.Column(db.DateTime, default=datetime.datetime.utcnow, nullable=False)
@property
def serialize(self):
return {
'ldap_id': self.ldap_id,
'url': self.url,
'port': self.port,
'user_dn': self.user_dn,
'bind_dn': self.bind_dn,
'use_ssl': self.use_ssl,
'bind_credential': self.bind_credential,
'account_type': self.account_type.serialize,
"create_time": self.create_time,
"last_update_time": self.last_update_time,
}
class Preference(db.Model):
id = db.Column(db.Integer, primary_key=True)
group_id = db.Column(db.Integer, db.ForeignKey('group.id'), nullable=False)
first_preference = db.Column(db.String(500), index=True)
second_preference = db.Column(db.String(500), index=True)
third_preference = db.Column(db.String(500), index=True)
match_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
last_updated_time = db.Column(db.DateTime,
index=True,
default=datetime.utcnow)
#this is the many side, so uselist=False
match = db.relationship("User",
backref=db.backref("match_preferences",
lazy='dynamic'),
foreign_keys=[match_id],
uselist=False)
user = db.relationship("User",
backref=db.backref("user_preferences",
lazy='dynamic'),
foreign_keys=[user_id],
uselist=False)
def __repr__(self):
return '<Preference {}, {}>'.format(self.group_id, self.user_id)
class User(db.Model):
"""
User model used for storing name and email of the user
"""
id = db.Column(db.Text(length=36),
default=lambda: str(uuid.uuid4()),
primary_key=True)
email = db.Column(db.String(120), index=True)
name = db.Column(db.String(255))
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow)
__tablename__ = 'user'
def __repr__(self):
return 'User {}'.format(self.name)
def to_dict(self):
"""
"""
data = {
'id': self.id,
'email': self.email,
'name': self.name,
'created_at': self.created_at.strftime('%Y-%m-%dT%H:%M:%S.%fZ'),
'updated_at': self.updated_at.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
}
return data
class Site(db.Model):
__tablename__ = 'site'
site_id = db.Column(db.String, primary_key=True)
primary = db.Column(db.Boolean, nullable=False, default=False)
# only needs to be set if primary=True
base_url = db.Column(db.String, nullable=True, unique=True)
tenant_base_url_template = db.Column(db.String, nullable=True, unique=True)
site_admin_tenant_id = db.Column(db.String, nullable=False)
services = db.Column(ARRAY(db.String), unique=False, nullable=False)
create_time = db.Column(db.DateTime, nullable=False)
last_update_time = db.Column(db.DateTime, default=datetime.datetime.utcnow, nullable=False)
created_by = db.Column(db.String(120), unique=False, nullable=False)
last_updated_by = db.Column(db.String(120), unique=False, nullable=False)
def __repr__(self):
return f'{self.site_id}'
@property
def serialize(self):
return {
"site_id": self.site_id,
"primary": self.primary,
"base_url": self.base_url,
"tenant_base_url_template": self.tenant_base_url_template,
"site_admin_tenant_id": self.site_admin_tenant_id,
"services": self.services,
"create_time": str(self.create_time),
"created_by": self.created_by,
"last_update_time": str(self.last_update_time),
"last_updated_by": self.last_updated_by
}
class Application(db.Model):
name = db.Column(db.String(120), unique=True, nullable=False, primary_key=True)
fields = db.Column(db.String(255), unique=False, nullable=True, default='[]', server_default='[]')
s3_buckets = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return '<Application %r>' % self.name
class Mapping(db.Model):
id = db.Column(db.String(120), unique=True, nullable=False, primary_key=True)
app_name = db.Column(db.String(120), db.ForeignKey('application.name'), nullable=False)
app = db.relationship('Application', foreign_keys=app_name)
image_url = db.Column(db.String(500), nullable=True)
fields = db.Column(db.String(500), nullable=True)
def __repr__(self):
return '<Mapping %r>' % self.id
class Tweet(db.Model):
id = db.Column(db.Integer, primary_key = True)
date_created = db.Column(db.DateTime)
date_updated = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
username = db.Column(db.String(32), db.ForeignKey('user.username'))
body = db.Column(db.String(140))
def __repr__(self):
return '<Tweet %r>' % (self.body)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
date_created = db.Column(db.DateTime)
date_updated = db.Column(db.DateTime)
username = db.Column(db.String(64), unique=True)
user_sid = db.Column(db.String(16), unique=True)
hashed_token = db.Column(db.String(16), unique=True)
def __repr__(self):
return '<User %r>' % (self.username)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
def __init__(self, username, email):
self.username = username
self.email = email
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True, nullable=False)
def to_dict(self):
d = {'id': self.id, 'name': self.name}
return d
class GroupMember(db.Model):
id = db.Column(db.Integer, primary_key=True)
group_id = db.Column(db.Integer, db.ForeignKey('group.id'), nullable=False)
member_email = db.Column(db.String(120), index=True, nullable=False)
def __repr__(self):
return '<GroupMember {}, {}>'.format(self.group_id, self.member_email)
@staticmethod
def signup_status(member_email):
user = User.query.filter_by(email=member_email).first()
if user:
return True
else:
return False
@staticmethod
def group_signup_status(group_id, member_email):
user = User.query.filter_by(email=member_email).first()
if user:
preferences = user.user_preferences.filter_by(
group_id=group_id).first()
if preferences:
return True
return False
class ActivityLog(db.Model):
TYPES = [
('create', 'Create'),
('update', 'Update'),
('delete', 'Delete'),
]
id = db.Column(db.Text(length=36),
default=lambda: str(uuid.uuid4()),
primary_key=True)
action = db.Column(ChoiceType(TYPES))
user_id = db.Column(db.String(255), db.ForeignKey('user.id'))
attributes = db.Column(JSONType)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow)
__tablename__ = 'ActivityLog'
def __repr__(self):
return 'User id {}'.format(self.user_id)
def to_dict(self):
data = {
"id": self.id,
"user_id": self.user_id,
"action": self.action.code,
"attributes": self.attributes,
'created_at': self.created_at.strftime('%Y-%m-%dT%H:%M:%S.%fZ'),
'updated_at': self.updated_at.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
}
return data
class Group(db.Model):
id = db.Column(db.Integer, primary_key=True)
groupname = db.Column(db.String(120),
index=True,
unique=True,
nullable=False)
rsvp_close_date = db.Column(db.Date, index=True, nullable=False)
reveal_date = db.Column(db.Date, index=True, nullable=False)
budget = db.Column(db.Float, index=True)
host_join = db.Column(db.Boolean, index=True)
last_updated_time = db.Column(db.DateTime,
index=True,
default=datetime.utcnow)
host_id = db.Column(db.Integer, db.ForeignKey('user.id'))
preferences = db.relationship('Preference',
backref='group',
lazy='dynamic')
members = db.relationship('GroupMember', backref='group', lazy='dynamic')
def __repr__(self):
return '<Group {}>'.format(self.groupname)
def get_all_member_emails(self):
current_members = self.members.all()
current_emails = []
for member in current_members:
current_emails.append(member.member_email)
if self.host_join:
current_members.append(self.host.email)
return current_emails
def get_all_signup_member_emails(self):
current_members = self.members.all()
current_emails = []
for member in current_members:
if GroupMember.group_signup_status(self.id, member.member_email):
current_emails.append(member.member_email)
if self.host_join and GroupMember.group_signup_status(
self.id, self.host.email):
current_members.append(self.host.email)
return current_emails
def if_match_set(self):
current_preferences = self.preferences.all()
match_set = True
for current_preference in current_preferences:
if not current_preference.match:
match_set = False
break
return match_set
@staticmethod
def check_group_member(group_name, email):
current_group = Group.query.filter_by(groupname=group_name).first()
current_emails = current_group.get_all_member_emails()
if email in current_emails:
return True
else:
return False
class TitleRegisterData(db.Model): # type: ignore
title_number = db.Column(db.String(10), primary_key=True)
register_data = db.Column(JSON)
geometry_data = db.Column(JSON)
official_copy_data = db.Column(JSON)
is_deleted = db.Column(db.Boolean, default=False, nullable=False)
last_modified = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now(), nullable=False)
lr_uprns = db.Column(ARRAY(db.String), default=[], nullable=True)
class TenantHistory(db.Model):
__tablename__ = 'tenants_history'
id = db.Column(db.Integer, primary_key=True)
tenant_id = db.Column(db.String(50), db.ForeignKey('tenants.tenant_id'), nullable=False)
update_time = db.Column(db.DateTime, default=datetime.datetime.utcnow, nullable=False)
updated_by = db.Column(db.String(120), unique=False, nullable=False)
updates_as_json = db.Column(db.String(10000), unique=False, nullable=False)
@property
def serialize(self):
d = {
'tenant_id': self.tenant_id,
'update_time': str(self.update_time),
'updated_by': self.updated_by,
'updates': json.loads(self.updates_as_json)
}
return d
class User(UserMixin, db.Model):
y = db.Column(db.String(256), primary_key=True)
def __init__(self, y):
self.y = y
def save_to_db(self):
db.session.add(self)
db.session.commit()
class TenantOwner(db.Model):
__tablename__ = 'tenantOwners'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True, nullable=False)
name = db.Column(db.String(80), unique=False, nullable=False)
institution = db.Column(db.String(80), unique=False, nullable=False)
create_time = db.Column(db.DateTime, nullable=False)
last_update_time = db.Column(db.DateTime, default=datetime.datetime.utcnow, nullable=False)
def __repr__(self):
return f'{self.email}, {self.institution}'
@property
def serialize(self):
return {
"email": self.email,
"name": self.name,
"institution": self.institution,
"create_time": self.create_time,
"last_update_time": self.last_update_time,
}
class UserSearchAndResults(db.Model): # type: ignore
"""
Store details of user view (for audit purposes) and update after payment (for reconciliation).
"""
# As several users may be searching at the same time, we need a compound primary key.
# Note that WebSeal prevents a user from being logged in from multiple places concurrently.
search_datetime = db.Column(db.DateTime(), nullable=False, primary_key=True)
user_id = db.Column(db.String(20), nullable=False, primary_key=True)
title_number = db.Column(db.String(20), nullable=False)
search_type = db.Column(db.String(20), nullable=False)
purchase_type = db.Column(db.String(20), nullable=False)
amount = db.Column(db.String(10), nullable=False)
cart_id = db.Column(db.String(30), nullable=True)
# Post-payment items: these (or the like) are also held in the 'transaction_data' DB.
# TODO: Ideally they should be fetched from there instead, via the 'search_datetime' key.
lro_trans_ref = db.Column(db.String(30), nullable=True) # Reconciliation: 'transId' from Worldpay.
viewed_datetime = db.Column(db.DateTime(), nullable=True) # If null, user has yet to view the results.
valid = db.Column(db.Boolean, default=False)
def __init__(self,
search_datetime,
user_id,
title_number,
search_type,
purchase_type,
amount,
cart_id,
lro_trans_ref,
viewed_datetime,
valid
):
self.search_datetime = search_datetime
self.user_id = user_id
self.title_number = title_number
self.search_type = search_type
self.purchase_type = purchase_type
self.amount = amount
self.cart_id = cart_id
self.lro_trans_ref = lro_trans_ref
self.viewed_datetime = viewed_datetime
self.valid = valid
# This is for serialisation purposes; it returns the arguments used and their values as a dict.
# Note that __dict__ only works well in this case if no other local variables are defined.
# "marshmallow" may be an alternative: https://marshmallow.readthedocs.org/en/latest.
def get_dict(self):
return self.__dict__
def id(self):
return '<lro_trans_ref {}>'.format(self.lro_trans_ref)
class Operator(db.Model):
name = db.Column(db.String(80), unique=True, nullable=False, primary_key=True)
backend = db.Column(db.String(80), nullable=False)
type = db.Column(db.String(80), nullable=False)
input = db.Column(db.String(80), nullable=False)
output = db.Column(db.String(80), nullable=False)
dimension = db.Column(db.Integer, nullable=False)
metric_type = db.Column(db.String(120), nullable=False)
endpoint = db.Column(db.String(120), nullable=False)
def __repr__(self):
return '<name %r>' % self.name
class Pipeline(db.Model):
name = db.Column(db.String(120), unique=True, nullable=False, primary_key=True)
description = db.Column(db.String(240), unique=False, nullable=True)
processors = db.Column(db.String(240), unique=False, nullable=False)
encoder = db.Column(db.String(240), unique=False, nullable=False)
input = db.Column(db.String(120), unique=False, nullable=False)
output = db.Column(db.String(120), unique=False, nullable=False)
dimension = db.Column(db.Integer, unique=False, nullable=False)
index_file_size = db.Column(db.Integer, unique=False, nullable=False)
metric_type = db.Column(db.String(120), unique=False, nullable=False)
def __repr__(self):
return '<Pipeline %r>' % self.name
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(250), nullable=False)
sender_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
recipient_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
is_palindrome = db.Column(db.Boolean, nullable=False)
def to_dict(self):
d = {
'id': self.id,
'body': self.body,
'sender_id': self.sender_id,
'recipient_id': self.recipient_id,
'is_palindrome': self.is_palindrome
}
return d
class Operator(db.Model):
name = db.Column(db.String(80),
unique=True,
nullable=False,
primary_key=True)
addr = db.Column(db.String(80), nullable=False)
author = db.Column(db.String(80), nullable=False)
version = db.Column(db.String(80), nullable=False)
type = db.Column(db.String(80), nullable=False)
description = db.Column(db.String(300), nullable=False)
def __repr__(self):
return '<name %r>' % self.name
class Storage(db.Model):
name = db.Column(db.String(120), unique=True, nullable=False, primary_key=True)
milvus_addr = db.Column(db.String(120), unique=False, nullable=False)
milvus_port = db.Column(db.Integer, unique=False, nullable=False)
milvus_table_name = db.Column(db.String(120), unique=False, nullable=False)
milvus_dimension = db.Column(db.Integer, unique=False, nullable=False)
milvus_index_file_size = db.Column(db.Integer, unique=False, nullable=False)
milvus_metric_type = db.Column(db.String(120), unique=False, nullable=False)
s3_addr = db.Column(db.String(120), unique=False, nullable=False)
s3_port = db.Column(db.Integer, unique=False, nullable=False)
s3_token = db.Column(db.String(120), unique=False, nullable=False)
def __repr__(self):
return '<Storage %r>' % self.name
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64),
index=True,
unique=True,
nullable=False)
email = db.Column(db.String(120), index=True, unique=True, nullable=False)
password_hash = db.Column(db.String(200))
firstname = db.Column(db.String(64), index=True, nullable=False)
lastname = db.Column(db.String(64), index=True, nullable=False)
nickname = db.Column(db.String(64), index=True)
last_updated_time = db.Column(db.DateTime,
index=True,
default=datetime.utcnow)
host_groups = db.relationship('Group', backref='host', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
def get_full_name(self):
return self.firstname + ' ' + self.lastname
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{
'reset_password': self.id,
'exp': time() + expires_in
},
app.config['SECRET_KEY'],
algorithm='HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
user_id = jwt.decode(token,
app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except:
return None
return User.query.get(user_id)
class Validation(db.Model): # type: ignore
""" Store of price etc., for anti-fraud purposes """
__tablename__ = 'validation'
price = db.Column(db.Integer, nullable=False, default=300, primary_key=True)
product = db.Column(db.String(20), default="drvSummary") # purchase_type
class UprnMapping(db.Model): # type: ignore
uprn = db.Column(db.String(20), primary_key=True)
lr_uprn = db.Column(db.String(20), nullable=False)
class Subject(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), unique=True, nullable=False)
homework = db.relationship('Homework', backref='subject', lazy=True)
books = db.relationship('Books', backref='subject', lazy=True)
schedule = db.relationship('Schedule', backref='subject', lazy=True)
class Emails(db.Model):
__tablename__ = 'tm_emails'
id = db.Column(db.String(30), primary_key=True)
email = db.Column(db.String(190))
first_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
