class PatientAssociations(db.Model):
id = db.Column(db.Integer, primary_key=True)
patientId = db.Column(
db.ForeignKey(Patient.patientId, ondelete="CASCADE"),
nullable=False,
)
healthFacilityName = db.Column(
db.ForeignKey(HealthFacility.healthFacilityName, ondelete="CASCADE"),
nullable=True,
)
userId = db.Column(db.ForeignKey(User.id, ondelete="CASCADE"), nullable=True)
# RELATIONSHIPS
patient = db.relationship(
"Patient",
backref=db.backref("associations", lazy=True, cascade="all, delete"),
)
healthFacility = db.relationship(
"HealthFacility",
backref=db.backref("associations", lazy=True, cascade="all, delete"),
)
user = db.relationship(
"User",
backref=db.backref("associations", lazy=True, cascade="all, delete"),
)
@staticmethod
def schema():
return PatientAssociationsSchema
class FollowUp(db.Model):
__tablename__ = "followup"
id = db.Column(db.Integer, primary_key=True)
followupInstructions = db.Column(db.Text)
specialInvestigations = db.Column(db.Text)
diagnosis = db.Column(db.Text)
treatment = db.Column(db.Text)
medicationPrescribed = db.Column(db.Text)
dateAssessed = db.Column(db.BigInteger, nullable=False)
followupNeeded = db.Column(db.Boolean)
# FOREIGN KEYS
readingId = db.Column(db.ForeignKey(Reading.readingId), nullable=False)
healthcareWorkerId = db.Column(db.ForeignKey(User.id), nullable=False)
# RELATIONSHIPS
reading = db.relationship(
Reading,
backref=db.backref(
"followup", lazy=True, uselist=False, cascade="all, delete-orphan"
),
)
healthcareWorker = db.relationship(User, backref=db.backref("followups", lazy=True))
@staticmethod
def schema():
return FollowUpSchema
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
firstName = db.Column(db.String(25))
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password = db.Column(db.String(128))
# FOREIGN KEYS
healthFacilityName = db.Column(
db.String(50), db.ForeignKey("healthfacility.healthFacilityName"), nullable=True
)
# RELATIONSHIPS
healthFacility = db.relationship(
"HealthFacility", backref=db.backref("users", lazy=True)
)
roleIds = db.relationship(
"Role", secondary=userRole, backref=db.backref("users", lazy=True)
)
referrals = db.relationship("Referral", backref=db.backref("users", lazy=True))
vhtList = db.relationship(
"User",
secondary=supervises,
primaryjoin=id == supervises.c.choId,
secondaryjoin=id == supervises.c.vhtId,
)
@staticmethod
def schema():
return UserSchema
def __repr__(self):
return "<User {}>".format(self.username)
class Referral(db.Model):
id = db.Column(db.Integer, primary_key=True)
dateReferred = db.Column(db.BigInteger, nullable=False)
comment = db.Column(db.Text)
actionTaken = db.Column(db.Text)
isAssessed = db.Column(db.Boolean, nullable=False, default=0)
# FOREIGN KEYS
userId = db.Column(db.Integer, db.ForeignKey("user.id"))
patientId = db.Column(db.String(50), db.ForeignKey("patient.patientId"))
readingId = db.Column(db.String(50), db.ForeignKey("reading.readingId"))
referralHealthFacilityName = db.Column(
db.String(50), db.ForeignKey("healthfacility.healthFacilityName")
)
# RELATIONSHIPS
healthFacility = db.relationship(
"HealthFacility", backref=db.backref("referrals", lazy=True)
)
reading = db.relationship(
"Reading", backref=db.backref("referral", lazy=True, uselist=False)
)
patient = db.relationship("Patient", backref=db.backref("referrals", lazy=True))
@staticmethod
def schema():
return ReferralSchema
class Referral(db.Model):
id = db.Column(db.Integer, primary_key=True)
dateReferred = db.Column(db.BigInteger, nullable=False)
comment = db.Column(db.Text)
actionTaken = db.Column(db.Text)
# FOREIGN KEYS
userId = db.Column(db.Integer, db.ForeignKey('user.id'))
patientId = db.Column(db.String(50), db.ForeignKey('patient.patientId'))
referralHealthFacilityName = db.Column(
db.String(50), db.ForeignKey('healthfacility.healthFacilityName'))
readingId = db.Column(db.String(50), db.ForeignKey('reading.readingId'))
followUpId = db.Column(db.Integer, db.ForeignKey('followup.id'))
# RELATIONSHIPS
healthFacility = db.relationship('HealthFacility',
backref=db.backref('referrals',
lazy=True))
reading = db.relationship('Reading',
backref=db.backref('referral',
lazy=True,
uselist=False))
followUp = db.relationship('FollowUp',
backref=db.backref('referral',
lazy=True,
uselist=False,
cascade="save-update"))
class Orders_Topping(db.Model):
__tablename__='orders_topping'
id = db.Column(db.Integer, primary_key=True)
order_id = db.Column(db.Integer, db.ForeignKey('orders.id'))
order = db.relationship('Order', foreign_keys=[order_id], backref=db.backref('orders_topping'), cascade='all')
topping_id = db.Column(db.Integer, db.ForeignKey('toppings.id'))
topping = db.relationship('Topping', foreign_keys=[topping_id], backref=db.backref('orders_topping'), cascade='all')
class Products(db.Model):
__tablename__ = "products"
id = db.Column(db.Integer, primary_key=True)
hid = db.Column(db.String(255), nullable=True)
productEn = db.Column(db.String(255), nullable=True)
productAr = db.Column(db.String(255), nullable=True)
imagePath = db.Column(db.String(255), nullable=True)
isActive = db.Column(db.Boolean, default=True, nullable=True)
categoryId = db.Column(db.Integer,
db.ForeignKey('categories.id'),
nullable=False)
createdAt = db.Column(db.DateTime, default=datetime.datetime.utcnow())
updatedAt = db.Column(db.DateTime, default=datetime.datetime.utcnow())
descEn = db.Column(db.String(255), nullable=True)
descAr = db.Column(db.String(255), nullable=True)
modifierId = db.Column(db.Integer,
db.ForeignKey('modifiers.id'),
nullable=True)
globalsizeId = db.Column(db.Integer,
db.ForeignKey('globalsizes.id'),
nullable=True)
taxable = db.Column(db.Boolean, default=True, nullable=True)
sizes = db.relationship("Sizes",
backref=db.backref('product_size'),
uselist=True)
prices = db.relationship("Prices",
backref=db.backref('product_prices'),
lazy='joined',
uselist=True)
class RoleData(db.Model, Serializer):
__tablename__ = 'role'
id = db.Column('role_id', db.Integer, primary_key=True)
name = db.Column('name', db.Unicode(255))
description = db.Column('description', db.Unicode(255))
timestamp = db.Column('timestamp',
db.TIMESTAMP,
server_default=db.func.current_timestamp(),
nullable=False)
permissions = db.relationship('PermissionData',
secondary=role_permission,
lazy='dynamic',
backref=db.backref('roles', lazy='dynamic'))
journey_versions = db.relationship('JourneyVersionData',
secondary=journey_version_role,
lazy='dynamic',
backref=db.backref('roles',
lazy='dynamic'))
def __init__(self, args):
for arg in args:
setattr(self, arg, args[arg])
def serialize(self):
return {
'id': self.id,
'name': self.name,
'description': self.description
}
class Users(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255), nullable=True)
last_name = db.Column(db.String(255), nullable=True)
prefix = db.Column(db.String(255), nullable=True)
group = db.Column(db.String(255), nullable=True)
username = db.Column(db.String(255), nullable=True)
password = db.Column(db.String(255), nullable=True)
mobileNumber = db.Column(db.String(255), nullable=True)
mobileNumberExtension = db.Column(db.String(255), nullable=True)
email = db.Column(db.String(255), nullable=True)
citizenId = db.Column(db.String(255), nullable=True)
status = db.Column(db.String(255), nullable=True)
groupName = db.Column(db.String(255), nullable=True)
verified = db.Column(db.Boolean(), nullable=True)
token = db.Column(db.String(255), nullable=True)
lockedOut = db.Column(db.Boolean(), nullable=True)
passwordExpired = db.Column(db.Boolean(), nullable=True)
officeNumber = db.Column(db.String(255), nullable=True)
createdAt = db.Column(db.DateTime, default=datetime.datetime.utcnow())
updatedAt = db.Column(db.DateTime, default=datetime.datetime.utcnow())
roleId = db.Column(db.Integer, db.ForeignKey('roles.id'), nullable=True)
Reset_Password_logs = db.relationship(
"Resetpasswordlogs", backref=db.backref("User_ResetPasswordLogs"))
Global_Settings = db.relationship(
"Globalsettings", backref=db.backref("User_Globalsettings"))
Login_Histories = db.relationship(
"Loginhistories", backref=db.backref("User_Loginhistories"))
class Article(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), unique=False, nullable=False)
url = db.Column(db.String(300), unique=False, nullable=False)
receiver_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
receiver = db.relationship('User',
foreign_keys=receiver_id,
backref=db.backref('received_articles',
lazy=True))
sender_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
sender = db.relationship('User',
foreign_keys=sender_id,
backref=db.backref('sent_articles', lazy=True))
def __repr__(self):
return '<Article %r>' % self.title
def serialize(self):
data = {
"id": self.id,
"title": self.title,
"url": self.url,
"sender_id": self.sender_id,
"receiver_id": self.receiver_id,
}
return json.dumps(data)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
firstName = db.Column(db.String(25))
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password = db.Column(db.String(128))
# FOREIGN KEYS
healthFacilityName = db.Column(
db.String(50),
db.ForeignKey('healthfacility.healthFacilityName'),
nullable=True)
# RELATIONSHIPS
healthFacility = db.relationship('HealthFacility',
backref=db.backref('users', lazy=True))
roleIds = db.relationship('Role',
secondary=userRole,
backref=db.backref('users', lazy=True))
referrals = db.relationship('Referral',
backref=db.backref('users', lazy=True))
vhtList = db.relationship('User',
secondary=supervises,
primaryjoin=id == supervises.c.choId,
secondaryjoin=id == supervises.c.vhtId)
def __repr__(self):
return '<User {}>'.format(self.username)
class User_Order(db.Model):
__tablename__='user_order'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', foreign_keys=[user_id], backref= db.backref('user_order'), cascade='all')
order_id = db.Column(db.Integer, db.ForeignKey('orders.id'))
order = db.relationship('Order', foreign_keys=[order_id], backref=db.backref('user_order'), cascade='all')
class Library(db.Model):
__tablename__ = "library"
id = db.Column(db.Integer, primary_key=True)
Libaray_Reference = db.Column(db.String(255), nullable=False, unique=True)
Version_id = db.Column(db.String(255), nullable=True)
Title = db.Column(db.String(255), nullable=False)
Segment = db.Column(db.String(255), nullable=False)
Section = db.Column(db.String(255), nullable=False)
Area = db.Column(db.String(255), nullable=False)
Risk = db.Column(db.String(255), nullable=False)
Review_Categorisation = db.Column(db.String(255), nullable=False)
Control_Step = db.Column(db.Boolean, default = True)
Audit_Objective = db.Column(db.String(255), nullable=False)
Document_Sort_No = db.Column(db.String(255), nullable=False)
Master_Data = db.Column(db.String(255), nullable=False)
Guidance = db.Column(db.Text(), nullable=True)
status = db.Column(db.Boolean, default = True)
Template = db.Column(db.Boolean, default = True)
Comments = db.Column(db.String(255), nullable=True)
updatedby = db.Column(db.Integer, db.ForeignKey('users.id'), nullable = True)
createdby = db.Column(db.Integer, db.ForeignKey('users.id'), nullable = False)
created_at = db.Column(db.DateTime, default = datetime.datetime.utcnow())
updated_at = db.Column(db.DateTime)
templates = db.relationship("Templates", backref=db.backref('templates'), uselist=True)
user_updated = db.relationship("Users", backref=db.backref('user_updated'), foreign_keys="[Library.updatedby]", uselist=True)
user_created = db.relationship("Users", backref=db.backref('user_created'), foreign_keys="[Library.createdby]",uselist=True)
class Reservation(Base):
id = db.Column('id', db.INTEGER, primary_key=True, unique=True)
start_time = db.Column('start_time', db.TIMESTAMP, nullable=False)
end_time = db.Column('end_time', db.TIMESTAMP, nullable=False)
user_id = db.Column('user_id', db.INTEGER, db.ForeignKey(User.id))
user = db.relationship("User", backref=db.backref("user1"))
audience_id = db.Column('audience_id', db.INTEGER,
db.ForeignKey(Audience.id))
audience = db.relationship("Audience", backref=db.backref("reservation"))
class NoteStatistic(Base):
id = db.Column(db.INTEGER, primary_key=True)
user_id = db.Column(db.INTEGER, db.ForeignKey(User.id))
user = db.relationship(User, backref=db.backref("user"))
note_id = db.Column(db.INTEGER, db.ForeignKey(Note.id))
note = db.relationship(Note, backref=db.backref("note"))
time = db.Column(db.DATETIME, default=datetime.datetime.utcnow, nullable=False)
def __str__(self):
return f"<NoteStatistic: {self.id}>"
class Note(Base):
id = db.Column(db.INTEGER, primary_key=True)
text = db.Column(db.VARCHAR(404), nullable=False)
user_id = db.Column(db.INTEGER, db.ForeignKey(User.id))
user = db.relationship(User)
tag_id = db.Column(db.INTEGER, db.ForeignKey(Tag.id))
tag = db.relationship(Tag, backref=db.backref("tag"))
co_authorship = db.relationship('User', secondary=contribs, backref=db.backref('contributors', lazy='dynamic'))
def __str__(self):
return f"<Note: {self.id}>"
class Roles(db.Model):
__tablename__ = "roles"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=True)
status = db.Column(db.String(255), nullable=True)
role_type = db.Column(db.String(255), nullable=True)
createdAt = db.Column(db.DateTime, default=datetime.datetime.utcnow())
updatedAt = db.Column(db.DateTime, default=datetime.datetime.utcnow())
User = db.relationship("Users", backref=db.backref("Role_User"))
Permission = db.relationship("Permissions",
backref=db.backref("Role_Permission"))
class Community(SAFRSBase, db.Model):
'''
description: a community of SocialNetwork
'''
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(30), unique=True, nullable=False)
type = db.Column(db.String(30), nullable=False)
rating = db.Column(db.Integer, nullable=False, default=0)
creation_date = db.Column(db.DateTime,
nullable=False,
server_default=db.func.now())
banned_table = db.Table(
'banned_users', db.metadata,
db.Column('com_id',
db.Integer,
db.ForeignKey('community.id', ondelete='CASCADE'),
primary_key=True),
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
primary_key=True))
banned_users = db.relationship(
User,
secondary=banned_table,
passive_deletes=True,
backref=db.backref("banned_com", passive_deletes=True),
primaryjoin=banned_table.c.com_id == id,
secondaryjoin=banned_table.c.user_id == User.id)
subscribe_table = db.Table(
'subscribeUsers', db.metadata,
db.Column('com_id',
db.Integer,
db.ForeignKey(id, ondelete='CASCADE'),
primary_key=True),
db.Column('user_id',
db.Integer,
db.ForeignKey(User.id, ondelete='CASCADE'),
primary_key=True))
subscribe_user = db.relationship(
User,
secondary=subscribe_table,
passive_deletes=True,
backref=db.backref("user_subscribe", passive_deletes=True),
primaryjoin=subscribe_table.c.com_id == id,
secondaryjoin=subscribe_table.c.user_id == User.id)
moderators_users = db.relationship(
User,
secondary='moderator',
passive_deletes=True,
primaryjoin=Moderator.com_id == id,
secondaryjoin=Moderator.mod_id == User.id,
backref=db.backref("users_moderators", passive_deletes=True))
class Customers(db.Model):
customer_id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(120), nullable=False)
lastname = db.Column(db.String(120), nullable=False)
date_created = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
email = db.Column(db.String(100), unique=True, nullable=False)
phone_number = db.Column(db.String(13), nullable=False)
password = db.Column(db.String(500), nullable=False)
address = db.relationship('Address',
backref=db.backref('customer', lazy=True),
cascade="all, delete-orphan")
order = db.relationship('Orders',
backref=db.backref('customer'),
lazy=True)
def __str__(self):
return '<Customer {} {}>'.format(self.firstname, self.lastname)
def save_to_db(self):
db.session.add(self)
db.session.commit()
def generate_auth_token(self):
return jwt.encode({'customer_id': self.customer_id},
app.config['SECRET_KEY'])
@staticmethod
def verify_auth_token(token):
print('calling the static method')
try:
data = jwt.decode(token, app.config['SECRET_KEY'])
except:
print('there was an error')
return
return Customers.query.get(data['customer_id'])
@classmethod
def find_by_username(cls, email):
return cls.query.filter_by(email=email).first()
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
return sha256.verify(password, hash)
class Listing(db.Model):
__tablename__ = 'listings'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey("users.id",
ondelete="cascade",
onupdate='cascade'),
nullable=False)
location_from = db.Column(db.String())
location_to = db.Column(db.String())
description = db.Column(db.String())
date = db.Column(db.DateTime)
price = db.Column(db.String)
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime,
server_default=func.now(),
onupdate=func.now())
user = db.relationship('User',
foreign_keys=[user_id],
backref="user_listings")
users_request_this_listing = db.relationship('User',
secondary=requests,
lazy='dynamic',
backref=db.backref('listings',
lazy=True))
class Business(db.Model):
__tablename__ = "company_business"
id = db.Column(db.Integer, primary_key=True)
business = db.Column(db.TEXT)
company_id = db.Column(db.Integer, db.ForeignKey('company.id'))
company = db.relationship('Company',
backref=db.backref('company', lazy='dynamic'))
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200))
created = db.Column(db.DateTime)
due = db.Column(db.Date)
completed = db.Column(db.Boolean)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref=db.backref('items', lazy='dynamic'))
def __init__(self,title):
self.title = title
self.completed = False
@staticmethod
def all():
return Item.query.all()
@staticmethod
def get(id):
return Item.query.get(id)
@staticmethod
def fields():
return {
'id': fields.Integer,
'title': fields.String,
'completed': fields.Boolean,
'uri': fields.Url('item'),
}
class Address(db.Model):
__tablename__='addresses'
id = db.Column(db.Integer, primary_key=True)
street = db.Column(db.String(255))
city = db.Column(db.String(255))
state = db.Column(db.String(255))
zip_code = db.Column(db.String(255))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now(), onupdate=func.now())
#Address to User // User can have many address
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', foreign_keys=[user_id], backref=db.backref('addresses', cascade='all'))
@classmethod
def new(cls, user_id, form):
address = cls (
user_id = user_id,
street = form['street'],
city = form['city'],
state = form['state'],
zip_code = form['zip_code'],
)
db.session.add(address)
db.session.commit()
return address.id
class Random_order(db.Model):
__tablename__ = 'random_orders'
id = db.Column(db.Integer, primary_key = True)
size = db.Column(db.String(255))
crust = db.Column(db.String(255))
topping1 = db.Column(db.String(255))
topping2 = db.Column(db.String(255))
topping3 = db.Column(db.String(255))
price = db.Column(db.Float)
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now(), onupdate=func.now())
order_id = db.Column(db.Integer, db.ForeignKey('orders.id'))
order = db.relationship('Order', foreign_keys=[order_id], backref=db.backref('orders'), cascade='all')
@classmethod
def new_pizza(cls, form):
new_pizzas = cls (
size = form['size'],
crust = form['crust'],
topping1 = form['topping1'],
topping2 = form['topping2'],
topping3 = form['topping3'],
price = form['price'],
)
db.session.add(new_pizzas)
db.session.commit()
return new_pizzas
@classmethod
def all_random_pizza(cls):
get_all_random_pizzas = cls.query.all()
return get_all_random_pizzas
class Tweet(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
content = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
server_default=func.now())
updated_at = db.Column(db.DateTime,
nullable=False,
server_default=func.now(),
onupdate=func.now())
user = db.relationship('User',
foreign_keys=[user_id],
backref=db.backref("tweets",
cascade="all, delete-orphan"))
user_likes = db.relationship('User', secondary=likes_table)
@classmethod
def validate_tweet(cls, data):
tweet_error = []
print(data['tweet'])
if len(data['tweet']) < 1:
tweet_error.append('tweeting field is blank')
if len(data['tweet']) > 255:
tweet_error.append('tweets must be less than 255 characters')
if tweet_error:
flash(tweet_error[0])
return True
else:
return False
@classmethod
def add_tweet(cls, data):
tweet = cls(content=data['tweet'], user_id=session['userid'])
db.session.add(tweet)
db.session.commit()
return tweet
@classmethod
def change_tweet(cls, data, id):
tweet = cls.query.get(id)
tweet.content = data['tweet']
db.session.commit()
@classmethod
def remove_tweet(cls, id):
id_test = cls.query.get(id)
if session['userid'] == id_test.user_id:
db.session.delete(id_test)
db.session.commit()
return id_test
@classmethod
def like(cls, id):
user = User.query.get(session['userid'])
tweet = cls.query.get(id)
tweet.user_likes.append(user)
db.session.commit()
return tweet
class Comment(db.Model):
__tablename__ = "comments"
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String(255), nullable=False)
user = db.Column(db.String(100), nullable=False)
id_post = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False)
post = db.relationship('Post', backref=db.backref('comments', lazy=True))
class Post(db.Model):
__tablename__ = "posts"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), nullable=False)
content = db.Column(db.String(512), nullable=False)
id_user = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User', backref=db.backref('posts', lazy=True))
class taskCase(db.Model):
__tablename__ = 'task_case'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
code = db.Column(db.Integer)
response = db.Column(db.TEXT)
task_id = db.Column(db.Integer, db.ForeignKey('task_plan.id'))
case_id = db.Column(db.Integer, db.ForeignKey('cases_list.id'))
task_plan = db.relationship('taskPlan',
backref=db.backref('task_case',
lazy='dynamic'))
cases_list = db.relationship('casesList',
backref=db.backref('task_case',
lazy='dynamic'))
last_update = db.Column(db.DATETIME, default=datetime.datetime.now())
is_deleted = db.Column(db.BOOLEAN, default=False)
order = db.Column(db.Integer)
case_name = db.Column(db.String(50))
class parameters(db.Model):
__tablename__ = 'parameters'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
order = db.Column(db.Integer)
req = db.Column(db.TEXT)
ast = db.Column(db.TEXT)
out_param = db.Column(db.TEXT)
last_update = db.Column(db.DATETIME, default=datetime.datetime.now())
is_deleted = db.Column(db.BOOLEAN, default=False)
case_id = db.Column(db.Integer, db.ForeignKey('cases_list.id'))
api_id = db.Column(db.Integer, db.ForeignKey('api_list.id'))
cases_list = db.relationship('casesList',
backref=db.backref('parameters',
lazy='dynamic'))
api_list = db.relationship('apiList',
backref=db.backref('parameters',
lazy='dynamic'))
class Roles(db.Model):
__tablename__ = "roles"
id = db.Column(db.Integer,primary_key=True)
role = db.Column(db.String(50),nullable=True)
status = db.Column(db.Boolean, default = True)
created_at = db.Column(db.DateTime, default = datetime.datetime.utcnow())
updated_at = db.Column(db.DateTime)
User = db.relationship("Users", backref=db.backref("Role_User"), uselist=True)
