class Permissions(db.Model): __tablename__ = 'Permissions' id = db.Column(db.String(100), primary_key=True) isUser = db.Column(db.Boolean, default=False) isAdmin = db.Column(db.Boolean, default=False) isSales = db.Column(db.Boolean, default=False) user_id = db.Column(db.String(100), db.ForeignKey('User.id', ondelete='CASCADE')) def save_to_db(self): self.id = str(uuid.uuid4()) db.session.add(self) try: db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e) @classmethod def getPermissions(cls, permissions_id): return cls.query.filter_by(id=permissions_id).first() @classmethod def get_by_uid(cls, uid=None): return cls.query.filter_by(user_id=uid).first()
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), unique=True, nullable=False) password = db.Column(db.String(32), nullable=False) def __repr__(self): return f'<User {self.username}>' def add_user(self): db.session.add(self) db.session.commit() def remove_user(self): db.session.delete(self) db.session.commit() @staticmethod def find_by_username(value): db.create_all() return db.session.query(User).filter_by(username=value).first() @staticmethod def find_by_id(value): db.create_all() return db.session.query(User).filter_by(id=value).first()
class Admin(db.Model): __tablename__ = 'Admin' id = db.Column(db.String(100), primary_key=True) username = db.Column(db.String(80)) password = db.Column(db.String(100)) email = db.Column(db.String(100)) photoURL = db.Column(db.String()) def __init__(self, id_, username, password, email, photoURL=None): self.id = id_ self.username = username if password: self.password = generate_password_hash(password) self.email = email if photoURL: self.photoURL = photoURL else: self.photoURL = 'Some default asset' def save_to_db(self): db.session.add(self) try: db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e) @classmethod def getAdmin(cls, admin_id=None, username=None): if username is None: return cls.query.filter_by(id=admin_id).first() if admin_id is None: return cls.query.filter_by(username=username).first()
class Employee(db.Model): __tablename__ = "employee" id = db.Column(UUIDType(), db.ForeignKey(User.id), primary_key=True) user = db.relationship('User') name = db.Column(db.String(45), nullable=False) gender = db.Column(db.String(45), nullable=False) tel = db.Column(db.String(45), nullable=False) # stat = db.Column(db.Integer, nullable=False) level = db.Column(db.Integer, nullable=False) @staticmethod def new_employee(id, name, gender, tel, level=0) -> "Employee": # Test that employee id exists in user table user = User.get_by_id(id) return Employee( id=id, name=name, gender=gender, tel=tel, level=level, # stat = stat ) @staticmethod def get_by_id(id) -> "Employee": if type(id) != UUID: try: id = UUID(id) except: raise AttributeError("Invalid UUID") query = Employee.query.filter_by(id=id) if query.count() == 0: raise ValueError(f"Employee {str(id)} not found.") return query.first() @staticmethod def id_exists(id) -> bool: id = to_uuid(id) query = Employee.query.filter_by(id=id) if query.count() > 0: return True return False def json(self) -> dict: return { "id": str(self.id), "name": self.name, "gender": self.gender, "tel": self.tel, "level": self.level, }
class User(db.Model): id = db.Column(db.Integer, primary_key=True) f_name = db.Column(db.String(32), nullable=False) l_name = db.Column(db.String(32), nullable=False) email = db.Column(db.String(32), nullable=False, unique=True) password = db.Column(db.String(128), nullable=False) profile_image = db.Column(db.String(30000)) def __str__(self): return f'<User : {self.id}>'
class ProductSeller(db.Model): # Bind schema to external database __bind_key__ = 'external' # Composite key (company_id, product_name) company_id = db.Column(db.String(6), db.ForeignKey('company.id'), primary_key=True) product_name = db.Column(db.String(32), db.ForeignKey('product.name'), primary_key=True)
class Appointment(db.Model): __tablename__ = 'appointments' id = db.Column(db.Integer, primary_key=True) patient_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) doctor_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) description = db.Column(db.String(120)) doctor_notes = db.Column(db.String(120)) date = db.Column(db.Date, nullable=False) start = db.Column(db.Time, nullable=False) status = db.Column(db.Enum(AppointmentStatus), nullable=False) patient = db.relationship('User', foreign_keys=[patient_id], backref='p_appointments') doctor = db.relationship('User', foreign_keys=[doctor_id], backref='d_appointments') def __init__(self, description, date, start, status=AppointmentStatus.PENDING): self.description = description self.date = date self.start = start self.status = status def serialize(self, user_type): payload = { "id": self.id, "description": self.description, "doctor_notes": self.doctor_notes, "date": self.date.strftime("%Y-%m-%d"), "start": self.start.strftime("%H:%M"), "status": self.status.name } if user_type == UserType.DOCTOR: payload['patient'] = self.patient.serialize() elif user_type == UserType.PATIENT: payload['doctor'] = self.doctor.serialize() else: payload['patient'] = self.patient.serialize() payload['doctor'] = self.doctor.serialize() return payload
class User(db.Model, JSONStripped): __tablename__ = 'user' def __init__(self, *args, **kwargs): super(User, self).__init__(*args, **kwargs) id = \ db.Column(db.Integer, primary_key=True) login = \ db.Column(db.String(50), unique=True, nullable=False) password_hash = \ db.Column(db.String(255), nullable=False) creation_time = \ db.Column(db.DateTime, index=True, default=datetime.utcnow) st_login = \ db.Column(db.String(10), unique=True, nullable=True) course = \ db.Column(db.String(255), index=True, nullable=True) username = \ db.Column(db.String(50), index=True, nullable=False) is_public = \ db.Column(db.Boolean, default=True) score_second_lang = \ db.Column(db.Boolean, default=False) gpa = \ db.Column(db.Float, default=0) scores = \ db.relationship('UserSubject', lazy='subquery', cascade='all, delete-orphan') priorities = \ db.relationship('UserTrack', lazy='subquery', cascade='all, delete-orphan') def __repr__(self): return '<User %r>' % self.login @staticmethod def insert(**kwargs): user = User(**kwargs) db.session.add(user) db.session.commit() return user @staticmethod def get_all(**kwargs): return User.query.filter_by(**kwargs) @staticmethod def get_one(**kwargs): return User.query.filter_by(**kwargs).first()
class Item(db.Model): __tablename__ = 'items' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), unique=True, nullable=False) price = db.Column(db.Integer(), nullable=False) def __repr__(self): return f'<Item {self.name}>' @staticmethod def get_item(name): item = Item.query.filter(Item.name == name).first() return item def add_item(self): db.session.add(self) db.session.commit() @staticmethod def change_item(name, price): db.session.query(Item).filter(Item.name == name).update({'price': price}) db.session.commit() def delete_item(self): db.session.delete(self) db.session.commit() @staticmethod def get_items(): return Item.query.all() @staticmethod def delete_items(): db.session.query(Item).delete() db.session.commit()
class Track(db.Model, JSONStripped): __tablename__ = 'track' __tracks__ = [ 'Marketing', 'FM', 'Logistics', 'HR', 'IM', ] def __init__(self, *args, **kwargs): super(Track, self).__init__(*args, **kwargs) id = \ db.Column(db.Integer, primary_key=True) name = \ db.Column(db.String(30), unique=True) def __repr__(self): return '<Track %r>' % self.name @staticmethod def fill(): db.session.add_all([Track(name=name) for name in Track.__tracks__]) db.session.commit() @staticmethod def get_one(**kwargs): return Track.query.filter_by(**kwargs).first()
class Prescription(db.Model): __tablename__ = 'prescriptions' id = db.Column(db.Integer, primary_key=True) patient_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) doctor_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) drug = db.Column(db.String(50), nullable=False) dosage = db.Column(db.String(50), nullable=False) date = db.Column(db.Date, nullable=False) status = db.Column(db.Enum(PrescriptionStatus), nullable=False) patient = db.relationship('User', foreign_keys=[patient_id], backref='p_prescriptions') doctor = db.relationship('User', foreign_keys=[doctor_id], backref='d_prescriptions') def __init__(self, drug, dosage, date, status=PrescriptionStatus.ACTIVE): self.drug = drug self.date = date self.dosage = dosage self.status = status def serialize(self, user_type): payload = { "id": self.id, "drug": self.drug, "date": self.date.strftime("%Y-%m-%d"), "dosage": self.dosage, "status": self.status.name } if user_type == UserType.DOCTOR: payload['patient'] = self.patient.serialize() elif user_type == UserType.PATIENT: payload['doctor'] = self.doctor.serialize() else: payload['patient'] = self.patient.serialize() payload['doctor'] = self.doctor.serialize() return payload
class Product(db.Model): # Bind schema to external database __bind_key__ = 'external' # Composite key (name, valuation_date) name = db.Column(db.String(32), primary_key=True) valuation_date = db.Column(db.Date, primary_key=True) market_price = db.Column(db.Float, nullable=False) currency_code = db.Column(db.CHAR(3), db.ForeignKey('currency.code'))
class File(db.Model): __tablename__ = 'File' id = db.Column(db.String(100)) filename = db.Column(db.String(100), nullable=False, primary_key=True) filetype = db.Column(db.String(100), nullable=False) user_id = db.Column(db.String(100), db.ForeignKey('User.id', ondelete='CASCADE')) def save_to_db(self): self.id = str(uuid.uuid4()) db.session.add(self) try: db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e)
class CompanyStock(db.Model): # Bind schema to external database __bind_key__ = 'external' # Composite key (company_id, valuation_date) company_id = db.Column(db.String(6), db.ForeignKey('company.id'), primary_key=True) valuation_date = db.Column(db.Date, primary_key=True) stock_price = db.Column(db.Float, nullable=False) currency_code = db.Column(db.CHAR(3), db.ForeignKey('currency.code'))
class Specialization(db.Model): __tablename__ = 'specializations' id = db.Column(db.Integer, primary_key=True) spec = db.Column(db.String(50), unique=True) def __init__(self, spec): self.spec = spec def serialize(self): return {"id": self.id, "spec": self.spec}
class Edge(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) request = db.Column(db.Integer, db.ForeignKey('request.id')) visit_number = db.Column(db.Integer) src_url = db.Column(db.String(1024), nullable=False) dst_url = db.Column(db.String(1024), nullable=False) depth = db.Column(db.Integer, nullable=False) had_keyword = db.Column(db.Boolean) create_date = db.Column(db.DateTime) db.UniqueConstraint('request', 'src_url', 'dst_url', 'depth', name="_request_src_dst_uc") def as_dict(self): return {c.name: getattr(self, c.name) for c in self.__table__.columns} def __init__(self, request, visit_number, src_url, dst_url, depth, had_keyword=False): self.request = request self.visit_number = visit_number self.src_url = src_url self.dst_url = dst_url self.depth = depth self.had_keyword = had_keyword self.create_date = datetime.datetime.now() def __repr__(self): return 'Edge([request: %d] %s ----> %s)' % (self.request, self.src_url, self.dst_url)
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(120), unique=True, nullable=False) username = db.Column(db.String(120), unique=True, nullable=False) password = db.Column(db.String(200), nullable=False) first_name = db.Column(db.String(30), nullable=False) last_name = db.Column(db.String(30), nullable=False) dob = db.Column(db.Date) phone_number = db.Column(db.String(20)) created_at = db.Column(db.DateTime, server_default=func.current_timestamp()) user_type = db.Column(db.Enum(UserType), nullable=False) user_status = db.Column(db.Enum(UserStatus), nullable=False) specialization_id = db.Column(db.Integer, db.ForeignKey('specializations.id')) specialization = db.relationship('Specialization', backref='doctors') def __init__(self, email, username, first_name, last_name, dob, phone_number, user_type, user_status): self.email = email self.username = username self.first_name = first_name self.last_name = last_name self.dob = dob self.phone_number = phone_number self.user_type = user_type self.user_status = user_status def set_password(self, password): self.password = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password, password) def serialize(self): payload = { "id": self.id, "email": self.email, "username": self.username, "first_name": self.first_name, "last_name": self.last_name, "user_type": self.user_type.name, "user_status": self.user_status.name } if self.user_type == UserType.PATIENT: payload['dob'] = self.dob.strftime("%Y-%m-%d") payload['phone_number'] = self.phone_number elif self.user_type == UserType.DOCTOR: payload['dob'] = self.dob.strftime("%Y-%m-%d") payload['phone_number'] = self.phone_number payload['specialization'] = self.specialization.spec return payload
class Request(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) url = db.Column(db.String(1024), nullable=False) create_date = db.Column(db.DateTime) searchmode = db.Column(db.String(3), nullable=False) depth = db.Column(db.Integer, nullable=False) keyword = db.Column(db.String(255)) def __init__(self, url, searchmode='DFS', depth=10, keyword=None): self.url = url self.keyword = keyword self.create_date = datetime.datetime.now() if searchmode not in ['DFS', 'BFS']: raise ValueError('searchmode provided was not valid. got %s' % (searchmode)) else: self.searchmode = searchmode if int(depth) not in range(1, 11): raise ValueError('depth provided was not valid. got %s' % (depth)) else: self.depth = int(depth) def __repr__(self): return 'Request(Build me a graph for %s !)' % (self.url)
class UserSubject(db.Model, JSONStripped): __tablename__ = '$user$subject' def __init__(self, *args, **kwargs): super(UserSubject, self).__init__(*args, **kwargs) user_id = \ db.Column('user_id', db.Integer, db.ForeignKey('user.id'), primary_key=True) subject_id = \ db.Column('subject_id', db.Integer, db.ForeignKey('subject.id'), primary_key=True) mark = \ db.Column('mark', db.String(2), nullable=False) is_relevant = \ db.Column('is_relevant', db.Boolean, default=True) subject = db.relationship('Subject', lazy='subquery') def __repr__(self): return '<UserSubject %r %r>' % self.user_id % self.subject_id
class Subject(db.Model, JSONStripped): __tablename__ = 'subject' def __init__(self, *args, **kwargs): super(Subject, self).__init__(*args, **kwargs) id = \ db.Column(db.Integer, primary_key=True) name = \ db.Column(db.String(255)) term = \ db.Column(db.Integer, index=True, nullable=False) def __repr__(self): return '<Subject %r>' % self.name @staticmethod def insert(**kwargs): subject = Subject(**kwargs) db.session.add(subject) db.session.commit() return subject @staticmethod def get_all(**kwargs): return Subject.query.filter_by(**kwargs) @staticmethod def get_one(**kwargs): return Subject.query.filter_by(**kwargs).first() @staticmethod def get_or_insert(**kwargs): with db.session.no_autoflush: subject = Subject.get_one(**kwargs) return Subject.insert(**kwargs) if subject is None else subject
class User(db.Model): __tablename__ = 'User' id = db.Column(db.String(100), primary_key=True) username = db.Column(db.String(80)) password = db.Column(db.String(100)) email = db.Column(db.String(100)) photoURL = db.Column(db.String, default=_photoURL) allowed_usage = db.Column(db.Integer) ftl = db.Column(db.Boolean, default=True) created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) deleted_at = db.Column(db.DateTime, nullable=True) files = db.relationship('File', backref='uploader') badges = db.relationship('Badges', backref='creator') permissions = db.relationship('Permissions', backref=db.backref('user_permissions'), lazy='dynamic') siteAdmin = db.Column(db.Boolean, default=False) last_login_ip = db.Column(db.String, nullable=True) last_login_date = db.Column(db.DateTime, nullable=True) def __init__(self, id_, username, password, email, photoURL=None): self.id = id_ self.username = username self.allowed_usage = 200 if password: self.password = generate_password_hash(password) self.email = email if photoURL: self.photoURL = photoURL def create_site_admin(self): self.siteAdmin = True self.save_to_db() def save_to_db(self): db.session.add(self) try: db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e) def delete_user(self): db.session.delete(self) try: db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e) @classmethod def getUser(cls, user_id=None, username=None, email=None): if user_id: return cls.query.filter_by(id=user_id).first() if username: return cls.query.filter_by(username=username).first() if email: return cls.query.filter_by(email=email).first()
class Company(db.Model): # Bind schema to external database __bind_key__ = 'external' # Primary key (id) id = db.Column(db.String(6), primary_key=True) name = db.Column(db.String(32), nullable=False)
class User(Base): #, UserMixin): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True, autoincrement=True) username = db.Column(db.String(20), unique=True, nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) #image_file = db.Column(db.String(20), nullable=False, default='default.jpg') password = db.Column(db.String(60), nullable=False) registered_on = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow) confirmed = db.Column(db.Boolean) admin = db.Column(db.Boolean, nullable=False, default=False) #posts = db.relationship('Post', backref='author', lazy=True) #games = db.relationship('GameModel', backref='author', lazy=True) own_games = relationship("GameModel", back_populates="owner", foreign_keys="[GameModel.owner_id]") active_games = relationship("GameModel", back_populates="active", foreign_keys="[GameModel.active_id]") own_notes = relationship("Notes", back_populates="player", foreign_keys="[Notes.player_id]") def __init__(self, email, username, password, admin=False, confirmed=False): self.email = email self.username = username self.set_password(password) #hashed_password = generate_password_hash(password) #self.password = hashed_password self.registered_on = datetime.datetime.now() self.confirmed = confirmed self.admin = admin def check_password(self, password): return check_password_hash(self.password, password) def set_password(self, password): hashed_password = generate_password_hash(password) self.password = hashed_password def get_reset_token(self, expires_sec=86400): s = Serializer(current_app.config['SECRET_KEY'], expires_sec) return s.dumps({'user_id': self.id}, salt='reset').decode('utf-8') def get_token(self, expires_sec=2592000): #2592000sec=30days s = Serializer(current_app.config['SECRET_KEY'], expires_sec) return s.dumps({'user_id': self.id}).decode('utf-8') def get_registration_token(self, expires_sec=86400): # 86400 = 1 day s = Serializer(current_app.config['SECRET_KEY'], expires_sec) return s.dumps({ 'user_id': self.id }, salt='registration').decode('utf-8') @staticmethod def verify_token(token, salt=None): s = Serializer(current_app.config['SECRET_KEY']) """ print("try: ") stoken = s.loads(token) user_id = stoken['user_id'] """ try: user_id = s.loads(token, salt=salt)['user_id'] except: return None return Session.query(User).get(user_id) def dict(self, includeGames=False): # return the user in dict format user = {} user['username'] = self.username user['id'] = self.id return user def __repr__(self): return f"User('{self.id}', '{self.username}', '{self.email}', " \ f"'{self.password}', '{self.admin}', '{self.registered_on}'," \ f"'{self.confirmed}')"
class Badges(db.Model): __tablename__ = 'Badges' id = db.Column(db.String(100), primary_key=True) image = db.Column(db.String, nullable=False) csv = db.Column(db.String(100), nullable=False) csv_type = db.Column(db.String(100), nullable=False) ticket_types = db.Column(db.String, nullable=False) badge_size = db.Column(db.String(100), nullable=False) download_link = db.Column(db.String) image_link = db.Column(db.String) logo_image_link = db.Column(db.String) created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) deleted_at = db.Column(db.DateTime, nullable=True) badge_name = db.Column(db.String(100), default='My Badge') user_id = db.Column(db.String(100), db.ForeignKey('User.id', ondelete='CASCADE')) logo_text = db.Column(db.String) logo_color = db.Column(db.String) logo_image = db.Column(db.String) font_color_1 = db.Column(db.String(100), nullable=False) font_color_2 = db.Column(db.String(100), nullable=False) font_color_3 = db.Column(db.String(100), nullable=False) font_color_4 = db.Column(db.String(100), nullable=False) font_color_5 = db.Column(db.String(100), nullable=False) font_size_1 = db.Column(db.String) font_size_2 = db.Column(db.String) font_size_3 = db.Column(db.String) font_size_4 = db.Column(db.String) font_size_5 = db.Column(db.String) font_type_1 = db.Column(db.String(100), nullable=False) font_type_2 = db.Column(db.String(100), nullable=False) font_type_3 = db.Column(db.String(100), nullable=False) font_type_4 = db.Column(db.String(100), nullable=False) font_type_5 = db.Column(db.String(100), nullable=False) paper_size = db.Column(db.String(100), nullable=False) download_link = db.Column(db.String) def save_to_db(self): self.id = str(uuid.uuid4()) db.session.add(self) try: db.session.commit() except Exception as e: db.session.rollback() db.session.flush() print(e) def delete_from_db(self): self.deleted_at = datetime.utcnow() self.save_to_db() @classmethod def getBadge(cls, badge_id): return cls.query.filter_by(id=badge_id)
class Order(db.Model): __tablename__ = "orders" id = db.Column(UUIDType(), primary_key=True) item = db.Column(db.String(45), nullable=False) customer_id = db.Column(UUIDType(), db.ForeignKey(Customer.id), nullable=False) employee_id = db.Column(UUIDType(), db.ForeignKey(Employee.id), nullable=False) customer = db.relationship('Customer', backref=db.backref('orders', lazy=True)) employee = db.relationship('Employee', backref=db.backref('orders', lazy=True)) order_time = db.Column(db.String(45), nullable=False) star_rating = db.Column(db.Integer, nullable=True) stat = db.Column(db.Integer, nullable=False) @staticmethod def new_order(id, item, customer_id, employee_id, order_time, stat=0, star_rating=None) -> "Order": # Test that customer & employee ids are valid customer = Customer.get_by_id(customer_id) employee = Employee.get_by_id(employee_id) return Order(id=id, item=item, customer_id=customer_id, employee_id=employee_id, order_time=order_time, star_rating=star_rating, stat=stat) @staticmethod def get_by_id(id) -> "Order": id = to_uuid(id) query = Order.query.filter_by(id=id) if query.count() == 0: raise ValueError(f"Order {str(id)} not found.") return query.first() def json(self) -> dict: return { "id": str(self.id), "item": self.item, "customer": self.customer, "employee": self.employee, "order_time": self.order_time, "star_rating": self.star_rating, "stat": self.stat, } @staticmethod def get_by_participant_id(role, id) -> list: id = to_uuid(id) if role == 'customer': query = Order.query.filter_by(customer_id=id) elif role == 'employee': query = Order.query.filter_by(employee_id=id) else: raise AttributeError(f"Role {role} not valid for order {str(id)}") return query.all()
class DecisionTreeNode(db.Model): id = db.Column(db.BigInteger, primary_key=True) parent_id = db.Column(db.BigInteger) true_node_id = db.Column(db.BigInteger) false_node_id = db.Column(db.BigInteger) feature = db.Column(db.Enum(Features)) criteria = db.Column(db.Text) true_label = db.Column(db.Enum(Label)) false_label = db.Column(db.Enum(Label)) approved = db.Column(db.Boolean, nullable=False, default=False) automated = db.Column(db.Boolean, nullable=False, default=False) description = db.Column(db.String(500)) confidence = db.Column(db.Integer) last_flag_count = db.Column(db.Integer) suggested_feature = db.Column(db.String(100)) suggested_value = db.Column(db.String(100)) @property def true_node(self): return self.query.get(self.true_node_id) @property def false_node(self): return self.query.get(self.false_node_id) def calculateBuyingPartyFeature(self, item): """ Calculate the buying party feature of a given item. Args: item (Derivative): The derivative to get the feature for Returns: Boolean: The value of the feature for the given item """ return item['derivative']['buying_party'] == self.criteria def calculateSellingPartyFeature(self, item): """ Calculate the selling party feature of a given item. Args: item (Derivative): The derivative to get the feature for Returns: Boolean: The value of the feature for the given item """ return item['derivative']['selling_party'] == self.criteria def calculateAssetFeature(self, item): """ Calculate the asset party feature of a given item. Args: item (Derivative): The derivative to get the feature for Returns: Boolean: The value of the feature for the given item """ return item['derivative']['asset'] == self.criteria def calculateQuantityFeature(self, item, mean=0, standardDeviation=0): """ Calculate the quantity feature of a given item. Args: item (Derivative): The derivative to get the feature for mean (Integer): The mean to compare ``item`` to standardDeviation (Integer): The standard deviation to compare ``item`` to Returns: Boolean: The value of the feature for the given item """ result = False if self.criteria == 'less_than_mean': result = item['derivative']['quantity'] < mean elif self.criteria == 'more_than_mean': result = item['derivative']['quantity'] > mean elif self.criteria == '0_to_1_std': result = abs(mean - item['derivative']['quantity']) <= standardDeviation elif self.criteria == '1_to_2_std': deviation = abs(mean - item['derivative']['quantity']) result = standardDeviation < deviation <= 2 * standardDeviation elif self.criteria == '2_to_3_std': deviation = abs(mean - item['derivative']['quantity']) result = 2 * standardDeviation < deviation <= 3 * standardDeviation elif self.criteria == '3_to_inf_std': deviation = abs(mean - item['derivative']['quantity']) result = deviation > 3 * standardDeviation return result def calculateStrikePriceFeature(self, item, mean=0, standardDeviation=0): """ Calculate the strike price feature of a given item. Args: item (Derivative): The derivative to get the feature for mean (Integer): The mean to compare ``item`` to standardDeviation (Integer): The standard deviation to compare ``item`` to Returns: Boolean: The value of the feature for the given item """ result = False if self.criteria == 'less_than_mean': result = item['derivative']['strike_price'] < mean elif self.criteria == 'more_than_mean': result = item['derivative']['strike_price'] > mean elif self.criteria == '0_to_1_std': result = abs( mean - item['derivative']['strike_price']) <= standardDeviation elif self.criteria == '1_to_2_std': deviation = abs(mean - item['derivative']['strike_price']) result = standardDeviation < deviation <= 2 * standardDeviation elif self.criteria == '2_to_3_std': deviation = abs(mean - item['derivative']['strike_price']) result = 2 * standardDeviation < deviation <= 3 * standardDeviation elif self.criteria == '3_to_inf_std': deviation = abs(mean - item['derivative']['strike_price']) result = deviation > 3 * standardDeviation return result def split(self, data): # noqa: C901 """ Split given data on this node. Args: data (List of Derivative): The data to split Returns: (List of Derivative, List of Derivative): The split data. The first item is the data that matches this node's feature, the second item is the remaining data """ trueSplit = [] falseSplit = [] if self.feature == Features.BUYING_PARTY: trueSplit = filter(self.calculateBuyingPartyFeature, data) falseSplit = filter( lambda x: not self.calculateBuyingPartyFeature(x), data) elif self.feature == Features.SELLING_PARTY: trueSplit = filter(self.calculateSellingPartyFeature, data) falseSplit = filter( lambda x: not self.calculateSellingPartyFeature(x), data) elif self.feature == Features.SELLING_PARTY: trueSplit = filter(self.calculateSellingPartyFeature, data) falseSplit = filter( lambda x: not self.calculateSellingPartyFeature(x), data) elif self.feature == Features.ASSET: trueSplit = filter(self.calculateAssetFeature, data) falseSplit = filter(lambda x: not self.calculateAssetFeature(x), data) elif self.feature == Features.QUANTITY: mean = 0 standardDeviation = 0 if len(data) <= 2: trueSplit = data falseSplit = [] else: if 'label' in data[0]: statsData = [x for x in data if x['label'] == Label.VALID] else: statsData = data if self.criteria == 'less_than_mean' or self.criteria == 'more_than_mean': mean = statistics.mean( [x['derivative']['quantity'] for x in statsData]) else: standardDeviation = statistics.stdev( [x['derivative']['quantity'] for x in statsData]) trueSplit = filter( lambda x: self.calculateQuantityFeature( x, mean, standardDeviation), data) falseSplit = filter( lambda x: not self.calculateQuantityFeature( x, mean, standardDeviation), data) elif self.feature == Features.STRIKE_PRICE: mean = 0 standardDeviation = 0 if len(data) <= 2: trueSplit = data falseSplit = [] else: if 'label' in data[0]: statsData = [x for x in data if x['label'] == Label.VALID] else: statsData = data if self.criteria == 'less_than_mean' or self.criteria == 'more_than_mean': mean = statistics.mean( [x['derivative']['strike_price'] for x in statsData]) else: standardDeviation = statistics.stdev( [x['derivative']['strike_price'] for x in statsData]) trueSplit = filter( lambda x: self.calculateStrikePriceFeature( x, mean, standardDeviation), data) falseSplit = filter( lambda x: not self.calculateStrikePriceFeature( x, mean, standardDeviation), data) return list(trueSplit), list(falseSplit) def __str__(self): return f'<DecisionTreeNode : {self.id}, {self.feature}: {self.criteria}>'
class Derivative(db.Model): id = db.Column(db.BigInteger, primary_key=True) code = db.Column(db.String(16), nullable=False) buying_party = db.Column(db.String(6), nullable=False) selling_party = db.Column(db.String(6), nullable=False) asset = db.Column(db.String(128), nullable=False) quantity = db.Column(db.Integer, nullable=False) strike_price = db.Column(db.Float, nullable=False) notional_curr_code = db.Column(db.CHAR(3), nullable=False) date_of_trade = db.Column(db.Date, nullable=False) maturity_date = db.Column(db.Date, nullable=False) reported = db.Column(db.Boolean, nullable=False, default=False) deleted = db.Column(db.Boolean, nullable=False, default=False) @property def absolute(self): # Determine time diff between date of trade and now delta = date.today() - self.date_of_trade # The derivative is absolute if it was traded over a month ago return self.deleted or delta.days >= 30 @property def associated_actions(self): # Form query for all associated actions query = Action.query.filter_by(derivative_id=self.id) # Order actions chronologically query = query.order_by(Action.timestamp.desc()) # Return the ids of all the actions return [action.id for action in query.all()] # TODO: revisit @property def underlying_price(self): up, _ = external_management.getAssetPrice(self.asset, self.selling_party) return up # TODO: revisit @property def underlying_curr_code(self): _, ucc = external_management.getAssetPrice(self.asset, self.selling_party) return ucc # TODO: revisit @property def notional_value(self): up = self.underlying_price ucc = self.underlying_curr_code n_ex_rate = external_management.getUSDExchangeRate( self.notional_curr_code) u_ex_rate = external_management.getUSDExchangeRate(ucc) return self.quantity * up * u_ex_rate / n_ex_rate @property def notional_curr_symbol(self): return utils.getCurrencySymbol(self.notional_curr_code) @property def underlying_curr_symbol(self): return utils.getCurrencySymbol(self.underlying_curr_code) def __str__(self): return f'<Derivative : {self.id}>'
class User(db.Model): __tablename__ = 'user' id = db.Column(UUIDType(), primary_key=True) username = db.Column(db.String(80), unique=True, nullable=False) hash = db.Column(db.BINARY(32), nullable=False) salt = db.Column(db.BINARY(32), nullable=False) role = db.Column(db.String(10), nullable=False) @staticmethod def new_user(username, password, role="customer") -> 'User': if not role in roles: raise ValueError(f"Invalid role '{role}'") hash, salt = User.create_hash(password) return User(id=uuid4(), username=username, hash=hash, salt=salt, role=role) @staticmethod def new_user_with_id(uid, username, password, role="customer") -> 'User': if not role in roles: raise ValueError(f"Invalid role '{role}'") hash, salt = User.create_hash(password) return User( id=UUID(uid), username=username, hash=hash, salt=salt, role=role, ) @staticmethod def create_hash(password, salt=None) -> (bytes, bytes): if salt == None: salt = os.urandom(32) hash = hashlib.pbkdf2_hmac('sha256', password.encode('utf-8'), salt, 100000) return hash, salt @staticmethod def username_available(username) -> bool: result = User.query.filter_by(username=username).all() return len(result) == 0 def check_password(self, password) -> bool: input_hash, salt = User.create_hash(password, self.salt) return self.hash == input_hash def json(self) -> dict: return { "id": str(self.id), "username": self.username, "role": self.role } @staticmethod def get_by_id(id) -> 'User': if type(id) != UUID: try: id = UUID(id) except: raise AttributeError("Invalid UUID") query = User.query.filter_by(id=id) if query.count() == 0: raise ValueError(f"User {str(id)} not found.") return query.first() @staticmethod def get_by_username(username) -> 'User': query = User.query.filter_by(username=username) if query.count() == 0: raise ValueError(f"User '{username}' not found.") return query.first() @staticmethod def get_by_role(role) -> 'User': query = User.query.filter_by(role=role) return query.all()