class Racer(db.Model): __tablename__ = 'racers' id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True) name = db.Column(db.String(255), nullable=False) city = db.Column(db.String(255)) state = db.Column(db.String(255)) points = db.Column(db.Integer) cars = db.relationship('Car', secondary=CarRacer, back_populates='racers') sponsors = db.relationship('Sponsor', secondary=RacerSponsor, backref='racers') laps = db.relationship('BestLap', backref='racer') created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow(), nullable=False) updated_date = db.Column(db.DateTime, nullable=True) #Picture def __init__(self, email, name, city, state, points): self.email = email self.name = name self.city = city self.state = state self.points = points self.created_date = datetime.datetime.now() def __repr__(self): return '<Racer {0}>'.format(self.name)
class Document(db.Model): """ Document upload by user to extract skill """ __tablename__ = "documents" id = db.Column(db.Integer, primary_key=True, autoincrement=True) content_type = db.Column(db.String(255), nullable=False) title = db.Column(db.String(1000), nullable=False) created_on = db.Column(db.DateTime, nullable=False) created_by = db.Column(db.Integer, nullable=True) # User.id filename = db.Column(db.String(1000), nullable=True) path = db.Column(db.String(1255), nullable=True) def __init__(self, content_type, title, created_by, filename, path): self.content_type = content_type self.title = title self.created_on = datetime.datetime.now() self.created_by = created_by self.filename = filename self.path = path def get_id(self): return self.id def __repr__(self): return "<Document {0}>".format(self.title) def set_content(self, content): self.content = content def get_content(self): return self.content
class Expert(db.Model): __tablename__ = 'expert' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False) nickname = db.Column(db.String(255), unique=True, nullable=False) active = db.Column(db.Boolean, default=True) # def __init__(self, name, created_by): # self.name = name # self.created_by = created_by # # def save(self): # db.session.add(self) # db.session.commit() # # @staticmethod # def get_all(user_id): # return Expert.query.filter_by(created_by=user_id) # # def delete(self): # db.session.delete(self) # db.session.commit() # # def __repr__(self): # return "<ExpertList: {}>".format(self.name) def toDict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class Product(db.Model): __tablename__ = "products" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False) permalink = db.Column(db.String(255), nullable=False) date_created_gmt = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) description = db.Column(db.String(255), nullable=False) price = db.Column(db.Float, nullable=False) weight = db.Column(db.Float, nullable=False) def __init__(self, name, permalink, description, price, weight): self.name = name self.permalink = permalink self.description = description self.price = price self.weight = weight def get_id(self): return self.id def __repr__(self): return "<Product {0}>".format(self.name)
class Projects(db.Model): __tablename__ = 'projects' id = db.Column(db.Integer, primary_key=True, autoincrement=True) proj_id = db.Column(db.String(10), nullable=False) proj_name = db.Column(db.String(255), nullable=False) proj_desc = db.Column(db.String(9999), nullable=False) proj_status = db.Column(db.String(25), nullable=False) created_by = db.Column(db.Integer, nullable=False) modified_by = db.Column(db.Integer, nullable=True) created_date = db.Column(db.DateTime, nullable=False) modified_date = db.Column(db.DateTime, nullable=True) actions = db.relationship('Assessment', backref='projects', lazy=True) def __init__(self, proj_id, proj_name, proj_desc, proj_status, created_by): self.proj_id = proj_id self.proj_name = proj_name self.proj_desc = proj_desc self.proj_status = proj_status self.created_by = created_by self.created_date = datetime.datetime.now() def __repr__(self): return '<Projects %r>' % (self.proj_name) def to_dict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class Song(db.Model): __tablename__ = "songs" created_at = db.Column(db.DateTime, default=datetime.datetime.now) id = db.Column(db.Integer, primary_key=True, autoincrement=True) title = db.Column(db.String(255), nullable=False) artist = db.Column(db.String(255), nullable=False) album = db.Column(db.String(255), nullable=False) song_url = db.Column(db.String(255), nullable=False) # artist_id = Column(Integer, ForeignKey(Artist.id), primary_key=True) # artist = relationship('Artist', foreign_keys='Song.artist_id') # # album_id = Column(Integer, ForeignKey(Album.id), primary_key=True) # album = relationship('Album', foreign_keys='Song.album_id') def __init__(self, title, artist, album, song=None, song_url=None): self.created_at = datetime.datetime.now() self.title = title self.artist = artist self.album = album self.song_url = "songs/%s.mp3" % str( uuid.uuid4()) if song else song_url if song: song.save(os.path.join(app.static_folder, self.song_url)) def response(self): return
class Students(db.Model): __tablename__ = "students" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(250)) last_name = db.Column(db.String(250)) age = db.Column(db.Integer) email = db.Column(db.String(250)) def __init__(self, *args, **kwargs): self.name = kwargs['name'] self.last_name = kwargs['last_name'] self.age = kwargs['age'] self.email = kwargs['email'] @property def serializer(self): return { 'name': self.name, 'last_name': self.last_name, 'age': self.age, 'email': self.email } def __str__(self): return f'{self.name} {self.last_name}'
class Course(db.Model): __tablename__ = 'courses' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), unique=True, nullable=False) description = db.Column(db.Text(), nullable=False) subject = db.Column(db.String(255), nullable=False) start_date = db.Column(db.DateTime, nullable=False) end_date = db.Column(db.DateTime, nullable=False) active = db.Column(db.Boolean, nullable=False, default=True) teacher_id = db.Column(db.Integer, db.ForeignKey('teachers.id'), nullable=False) teacher = db.relationship('Teacher', backref='courses') students = db.relationship('Student', secondary=course_student_association_table, backref='courses') def __init__(self, name, description, subject, start_date, end_date, teacher_id): self.name = name self.description = description self.subject = subject self.start_date = start_date self.end_date = end_date self.teacher_id = teacher_id def __repr__(self): return '<Class {0}>'.format(self.name)
class UserPost(db.Model): """ User Post Model for storing posts made by users """ __tablename__ = "user_posts" id = db.Column(db.Integer, primary_key=True, autoincrement=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) title = db.Column(db.String(255), unique=False, nullable=False) body = db.Column(db.String(2000), nullable=True) link = db.Column(db.String(1000), nullable=True) image = db.Column(db.String(1000), nullable=True) created_on = db.Column(db.DateTime, nullable=False, index=True) visibility = db.Column(db.Boolean, nullable=False, default=True) delete_flag = db.Column(db.Boolean, nullable=False, default=False) def __init__(self, title="Empty Post Title", body="empty post body", link="", image="", visibility=True, delete_flag=False, user_id=None, **kwargs): self.user_id = user_id self.title = title self.body = body self.link = link self.image = image self.created_on = datetime.datetime.now() self.visibility = visibility self.delete_flag = delete_flag
class User(db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) def __init__(self, email, password, admin=False): self.email = email self.password = bcrypt.generate_password_hash( password, app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8') self.registered_on = datetime.datetime.now() self.admin = admin def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def get_id(self): return self.id def __repr__(self): return '<User {0}>'.format(self.email)
class SARResponse(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) sarattachment = db.relationship('sar_attachment', lazy='dynamic', cascade='all,delete', backref=db.backref('sarresponse', lazy='joined')) sar_id = db.Column(db.Integer, db.ForeignKey('sar.id'), nullable=False) fromUser = db.Column(db.String(255)) toUser = db.Column(db.String(255)) responseText = db.Column(db.String(255)) user_id = db.Column(db.Integer) user_name = db.Column(db.String(255)) def __init__(self, data, sar_id=None): self.fromUser = data['fromUser'] self.toUser = data['toUser'] self.responseText = data['responseText'] # self.user_name = data['user_name'] # self.user_id = data['user_id'] self.sar_id = sar_id # def to_dict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class Attachments(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) fileName = db.Column(db.String(255)) documentLink = db.Column(db.String(500)) answer_id = db.Column(db.Integer, db.ForeignKey('answer.id'), nullable=False)
class Secuencia(db.Model): __tablename__ = 'secuencias' id = db.Column(db.Integer, primary_key=True, autoincrement=True) customer_id = db.Column(db.Integer, db.ForeignKey('customers.id'), nullable=False) radar_id = db.Column(db.Integer, db.ForeignKey('radares.id'), nullable=False) # ID de radar web_path = db.Column(db.String(255), unique=True, nullable=False) fs_path = db.Column(db.String(255), unique=True, nullable=False) vel_max = db.Column(db.Integer, nullable=False) vel = db.Column(db.Integer, nullable=False) secuencia = db.Column(db.String(255), unique=True, nullable=False) registered_on = db.Column(db.DateTime, nullable=False) processed = db.Column(db.Boolean, nullable=False, default=False) reprocess = db.Column(db.Boolean, nullable=False, default=False) def __init__(self, customer_id,radar_id,web_path,fs_path,vel_max,vel,secuencia,registered_on,processed=False,reprocess=False): self.customer_id = customer_id self.radar_id = radar_id self.web_path = web_path self.fs_path = fs_path self.vel_max = vel_max self.vel = vel self.secuencia = secuencia self.registered_on = registered_on # datetime.datetime.now() self.processed = processed self.reprocess = reprocess def get_id(self): return self.id def __repr__(self): return '<Secuencia {0}>'.format(self.web_path)
class Section(db.Model): __tablename__ = 'section' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False) owner_id = db.Column(db.Integer, nullable=False) parentSectionId = db.Column(db.Integer, nullable=True) assessment_id = db.Column(db.Integer, db.ForeignKey('assessment.id'), nullable=False) created_date = db.Column(db.DateTime, nullable=False) modified_date = db.Column(db.DateTime, nullable=True) status = db.Column(db.String(255), nullable=True) quesRelation = db.relationship('Question', backref='section', lazy=True) sectionsdpi = db.relationship('DpiAudit', backref='section', lazy=True) def __init__(self, name, owner_id, parentSectionId, assessment_id): self.name = name self.owner_id = owner_id self.parentSectionId = parentSectionId self.assessment_id = assessment_id self.created_date = datetime.datetime.now() def __repr__(self): return '<Section %r>' % (self.name) def to_dict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class Attachments(db.Model): __tablename__ = 'attachments' id = db.Column(db.Integer, primary_key=True, autoincrement=True) fileName = db.Column(db.String(255), nullable=False) documentLink = db.Column(db.String(255), nullable=False) question_id = db.Column(db.Integer, db.ForeignKey('question.id'), nullable=False) created_date = db.Column(db.DateTime, nullable=False) modified_date = db.Column(db.DateTime, nullable=True) def __init__(self, fileName, documentLink, question_id): self.fileName = fileName self.documentLink = documentLink self.question_id = question_id self.created_date = datetime.datetime.now() def __repr__(self): return '<Attachments %r>' % (self.fileName) def to_dict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class DpiAudit(db.Model): __tablename__ = 'Dpiaudit' id = db.Column(db.Integer, primary_key=True, autoincrement=True) question_id = db.Column(db.Integer, db.ForeignKey('question.id'), nullable=False) section_id = db.Column(db.Integer, db.ForeignKey('section.id'), nullable=False) description = db.Column(db.String(255), nullable=False) owner_id = db.Column(db.String(255), nullable=False) created_date = db.Column(db.DateTime, nullable=False) modified_date = db.Column(db.DateTime, nullable=True) def __init__(self, question_id, section_id, owner_id, description): self.question_id = question_id self.section_id = section_id self.owner_id = owner_id self.description = description self.created_date = datetime.datetime.now() def __repr__(self): return '<Action %r>' % (self.owner_id) def to_dict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class Entry(db.Model): """ Entry model for storing selected user text """ __tablename__ = 'entries' id = db.Column(db.Integer, primary_key=True, autoincrement=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) text = db.Column(db.Text, nullable=False) created_on = db.Column(db.DateTime, nullable=False) keywords = db.Column(db.String(500), nullable=True) url = db.Column(db.String(500), nullable=False) title = db.Column(db.String(500), nullable=False) def __init__(self, user_id, text, url, title, created_on=None, keywords=None): self.user_id = user_id self.text = text self.url = url self.title = title self.created_on = datetime.datetime.now( ) if not created_on else created_on self.keywords = keywords
class Answer(db.Model): __tablename__ = 'answer' id = db.Column(db.Integer, primary_key=True, autoincrement=True) question_id = db.Column(db.Integer, db.ForeignKey('question.id'), nullable=False) section_id = db.Column(db.Integer, db.ForeignKey('section.id'), nullable=False) answer_sel = db.Column(db.String(255), nullable=True) comments = db.Column(db.String(255), nullable=False) created_date = db.Column(db.DateTime, nullable=False) modified_date = db.Column(db.DateTime, nullable=True) # attachment = db.relationship('Attachments', backref='answer', lazy=True) def __init__(self, question_id, section_id, answer_sel, comments): self.question_id = question_id self.section_id = section_id self.answer_sel = answer_sel self.comments = comments self.created_date = datetime.datetime.now() def __repr__(self): return '<Answer %r>' % (self.comments) def to_dict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class User(db.Model): """ User Model for storing user related details """ __tablename__ = "user_auth" id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(100), unique=True, nullable=False) password = db.Column(db.String(200), nullable=False) user_role = db.Column(db.String(100), nullable=False) verified = db.Column(db.String(100), nullable=True) created_on = db.Column(db.DateTime, nullable=False) modified_on = db.Column(db.DateTime, nullable=False) def __init__(self, email, password, user_role): self.email = email self.password = bcrypt.generate_password_hash( password, app.config.get('BCRYPT_LOG_ROUNDS')).decode() self.created_on = datetime.datetime.now() self.modified_on = datetime.datetime.now() self.user_role = user_role self.verified = 'NotVerified' def encode_auth_token(self, user_email): """ Generates the Auth Token :return: string """ try: payload = { 'exp': datetime.datetime.utcnow() + datetime.timedelta(days=1, seconds=0), 'iat': datetime.datetime.utcnow(), 'sub': user_email } return jwt.encode(payload, app.config.get('SECRET_KEY'), algorithm='HS256') except Exception as e: return e @staticmethod def decode_auth_token(auth_token): """ Validates the auth token :param auth_token: :return: integer|string """ try: payload = jwt.decode(auth_token, app.config.get('SECRET_KEY')) is_blacklisted_token = BlacklistToken.check_blacklist(auth_token) if is_blacklisted_token: return 'Token blacklisted. Please log in again.' else: return str(payload['sub']) except jwt.ExpiredSignatureError: return 'Signature expired. Please log in again.' except jwt.InvalidTokenError: return 'Invalid token. Please log in again.'
class Radar(db.Model): __tablename__ = 'radares' id = db.Column(db.Integer, primary_key=True, autoincrement=True) customer_id = db.Column(db.Integer, db.ForeignKey('customers.id'), nullable=False) pub_id = db.Column(db.String(50), unique=True, nullable=False) # ID de radar para Evial/barrio configuration = db.Column(db.String(2048), unique=False, nullable=True) registered_on = db.Column(db.DateTime, nullable=False) online = db.Column(db.Boolean, nullable=False, default=False) conn_port = db.Column(db.String(3), unique=False, nullable=True) def __init__(self, customer_id,pub_id,configuration,registered_on,online,conn_port='000'): self.customer_id = customer_id self.pub_id = pub_id self.configuration = configuration self.registered_on = registered_on # datetime.datetime.now() self.online = online self.conn_port = conn_port def get_id(self): return self.id def __repr__(self): return '<Radar {0}>'.format(self.pub_id)
class User(db.Model): """ User Model for storing user related details """ __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(1000), nullable=False) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) entries = db.relationship('Entry', backref='user', lazy='dynamic') def __init__(self, name, email, password, admin=False): self.name = name self.email = email self.password = bcrypt.generate_password_hash( password, app.config.get('BCRYPT_LOG_ROUNDS')).decode() self.registered_on = datetime.datetime.now() self.admin = admin def encode_auth_token(self, user_id): """ Generates the Auth Token :return: string """ try: days, hours, seconds = app.config.get('TOKEN_EXPIRATION') payload = { 'exp': datetime.datetime.utcnow() + datetime.timedelta(days=days, hours=hours, seconds=seconds), 'iat': datetime.datetime.utcnow(), 'sub': user_id } return jwt.encode(payload, app.config.get('SECRET_KEY'), algorithm='HS256') except Exception as e: return e @staticmethod def decode_auth_token(auth_token): """ Validates the auth token :param auth_token: :return: integer|string """ try: payload = jwt.decode(auth_token, app.config.get('SECRET_KEY')) is_blacklisted_token = BlacklistToken.check_blacklist(auth_token) if is_blacklisted_token: return 'Token blacklisted. Please log in again.' else: return payload['sub'] except jwt.ExpiredSignatureError: return 'Signature expired. Please log in again.' except jwt.InvalidTokenError: return 'Invalid token. Please log in again.'
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) projects = db.relationship('Project', backref='users', lazy=True) def __init__(self, email, password, admin=False): self.email = email self.password = bcrypt.generate_password_hash( password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8') self.admin = admin def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def get_id(self): return self.id def __repr__(self): return '<User {0}>'.format(self.email)
class User(db.Model): """ User Model for storing user related details """ __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) def __init__(self, email, password, admin=False): self.email = email self.password = bcrypt.generate_password_hash( password, app.config.get('BCRYPT_LOG_ROUNDS') ).decode() self.registered_on = datetime.datetime.now() self.admin = admin def encode_auth_token(self, user_id): """ Generates the Auth Token :return: string """ try: payload = { 'exp': datetime.datetime.utcnow() + datetime.timedelta(days=0, seconds=5), 'iat': datetime.datetime.utcnow(), 'sub': user_id } return jwt.encode( payload, app.config.get('SECRET_KEY'), algorithm='HS256' ) except Exception as e: return e @staticmethod def decode_auth_token(auth_token): """ Decodes the auth token :param auth_token: :return: integer|string """ try: payload = jwt.decode(auth_token, app.config.get('SECRET_KEY')) return payload['sub'] except jwt.ExpiredSignatureError: return 'Signature expired. Please log in again.' except jwt.InvalidTokenError: return 'Invalid token. Please log in again.' @app.route("/users/index") def users_index(): users = db.session.query(User).all() user_list = [] for i in users: user_list.append(i.email) return str(user_list)
class ActionNote(db.Model): __tablename__ = 'action_note' id = db.Column(db.Integer, primary_key=True, autoincrement=True) question_id = db.Column(db.Integer, db.ForeignKey('question.id'), nullable=False) owner_id = db.Column(db.Integer, nullable=False) type = db.Column(db.String(255), nullable=False) notes = db.Column(db.String(999), nullable=False) created_date = db.Column(db.DateTime, nullable=False) modified_date = db.Column(db.DateTime, nullable=True) def __init__(self, data): self.question_id = data['question_id'] self.owner_id = data['owner_id'] self.type = data['type'] self.notes = data['notes'] self.created_date = datetime.datetime.now() def __repr__(self): return '<ActionNote %r>' % (self.owner_id) def to_dict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class LoanApplication(db.Model): """Model for storing the loan applications of the users.""" __tablename__ = 'loan_applications' STATES = [ (u'pending', u'Pending'), (u'approved', u'Approved'), (u'denied', u'Denied'), ] id = db.Column(db.Integer, primary_key=True, autoincrement=True) creator_id = db.Column(db.Integer, db.ForeignKey('users.id')) creator = relationship("User", back_populates="loan_applications") business_name = db.Column(db.String(255), nullable=False) tax_id = db.Column(db.String(20), nullable=False) requested_amount = db.Column(db.Numeric(12, 4), nullable=False) application_status = db.Column(ChoiceType(STATES), nullable=False) requested_on = db.Column(db.DateTime, nullable=False) loan = relationship("Loan", uselist=False, back_populates="loan_application") def __init__(self, creator_id, business_name, requested_amount, tax_id, application_status): self.creator_id = creator_id self.business_name = business_name self.requested_amount = requested_amount self.tax_id = tax_id self.application_status = application_status self.requested_on = datetime.datetime.now() def __repr__(self): return f"{self.business_name}, {self.requested_amount}, {self.application_status}"
class User(db.Model): """ User Model for storing user related details """ __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) def __init__(self, email, password, admin=False): self.email = email self.password = bcrypt.generate_password_hash( password, app.config.get('BCRYPT_LOG_ROUNDS')).decode() self.registered_on = datetime.datetime.now() self.admin = admin def encode_auth_token(self, user_id): """ Generates the Auth Token :return: string """ try: # exp: expiration date of the token # iat: time the token is generated # sub: subject of the token (user that it identifies) payload = { 'exp': datetime.datetime.utcnow() + datetime.timedelta(days=0, seconds=60), 'iat': datetime.datetime.utcnow(), 'sub': user_id } return jwt.encode(payload, app.config.get('SECRET_KEY'), algorithm='HS256') except Exception as e: return e @staticmethod # static because it doesn't relate to the classes instance def decode_auth_token(auth_token): """ Validates the auth token :param auth_token: :return: integer|string """ try: payload = jwt.decode(auth_token, app.config.get('SECRET_KEY')) is_blacklisted_token = BlacklistToken.check_blacklist(auth_token) if is_blacklisted_token: return 'Token blacklisted. Please login again.' else: return payload['sub'] except jwt.ExpiredSignatureError: return 'Signature expired. Please login again.' except jwt.InvalidTokenError: return 'Invalid token. Please login again.'
class RSAPair(db.Model): """ RSAPair model for database mapping to create RSAPair table which store RSA Key Pairs generated for each of login session """ __tablename__ = 'rsa_key' id = db.Column(db.Integer, primary_key=True, autoincrement=True) public_modulus = db.Column(db.String(), nullable=False) public_exponent = db.Column(db.Integer, nullable=False) private_exponent = db.Column(db.String(), nullable=False) def __init__(self, public_modulus, public_exponent, private_exponent): """ RSAPair Model Constructor :params: :modulus: public modulus :exponent: public exponent :key_mod: private modulus :returns: void """ self.public_modulus = public_modulus self.public_exponent = public_exponent self.private_exponent = private_exponent @staticmethod def is_existed(key): """ Check if provided key is existed :params: :key: list or RSA instance of the key :returns: True or False """ if isinstance(key, str): rsa_key = RSAPair.query.filter_by(public_modulus=key).first() elif isinstance(key, list): rsa_key = RSAPair.query.filter_by(public_modulus=key[0]).first() else: rsa_key = RSAPair.query.filter_by( public_modulus=str(key.n)).first() return True if rsa_key else False @staticmethod def get_RSA_by_public(public_key): """ Get stored RSAPair from the public key :params: :public_key: the corresponding public key :returns: :RSAPair: """ if isinstance(public_key, list): return RSAPair.query.filter_by( public_modulus=public_key[0]).first() elif isinstance(public_key, str): return RSAPair.query.filter_by(public_modulus=public_key).first() elif isinstance(public_key, int): return RSAPair.query.filter_by( public_modulus=str(public_key)).first() else: return RSAPair.query.filter_by( public_modulus=str(public_key.n)).first()
class User(db.Model): """ Defines a user database with associated login information. This is an SQL table. """ # Define the table name, this is the SQLite table name. __tablename__ = "users" # Define the column names and their types in this SQL table. user_id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) def __init__(self, email, password, admin=False): """ Calling a new instance of this class runs this __init__ function. This is how a new user is created. """ # Assign the values to the class instance, this populates # the SQL row entries. self.email = email # TODO: Comment this, explain what is happening here and # what is actually saved in the row. self.password = bcrypt.generate_password_hash( password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8') # Save what time the user was created. self.registered_on = datetime.datetime.now() # Set the administrator boolean value. self.admin = admin def is_authenticated(self): """ TODO: Populated this function. """ return True def is_active(self): return False def is_anonymous(self): return False def get_id(self): return self.user_id def __repr__(self): """Return a string representation of the user, wrapped in an HTML User tag.""" return '<User {0}>'.format(self.email)
class AdditionalInformation(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) type = db.Column(db.String(255)) requester = db.Column(db.String(255)) responder = db.Column(db.String(255)) request_date = db.Column(db.DateTime, default=datetime.datetime.now()) action_id = db.Column(db.Integer, db.ForeignKey('action.id'), nullable=False)
class Sar(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) assignedTo = db.Column(db.Integer, db.ForeignKey(Users.id), nullable=False) otherInfo = db.Column(db.String(255)) sarDescription = db.Column(db.String(255)) externalUser = db.Column(db.String(255)) representative = db.Column(db.String(255)) user_confirmed = db.Column(db.String(255)) rep_confirmed = db.Column(db.String(255)) priority = db.Column(db.String(255)) completionTime = db.Column(db.DateTime) #completionTime = db.Column(db.String(255)) status = db.Column(db.String(255)) ticketinfo = db.relationship('TicketInfo', lazy='dynamic', backref=db.backref('sar', lazy='joined')) ticket = db.relationship('Ticket', lazy='dynamic', cascade='all,delete', innerjoin=True, primaryjoin="Sar.id == Ticket.sar_id", backref=db.backref('sar', lazy='joined')) sar_response = db.relationship('SARResponse', lazy='dynamic', cascade='all,delete', backref=db.backref('sar', lazy='joined')) user_id = db.Column(db.Integer, db.ForeignKey(Users.id), nullable=False) creation_time = db.Column(db.DateTime, nullable=False) modification_time = db.Column(db.DateTime, default=datetime.datetime.now()) created_by = db.Column(db.String(255)) modified_by = db.Column(db.String(255)) isEscalated = db.Column(db.Boolean) assigned_user = db.relationship('Users', foreign_keys='Sar.assignedTo') created_user = db.relationship('Users', foreign_keys='Sar.user_id') def __init__(self, data, user_id=None): self.assignedTo = data['assignedTo'] self.otherInfo = data['otherInfo'] self.sarDescription = data['sarDescription'] self.externalUser = data['externalUser'] self.representative = data['representative'] self.completionTime = datetime.datetime.now() self.status = data['status'] self.creation_time = datetime.datetime.now() # self.modification_time = data["modification_time"] self.created_by = data["created_by"] self.modified_by = data["modified_by"] self.isEscalated = data['isEscalated'] self.priority = data['priority'] self.user_id = data['user_id'] def to_dict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }