class StoreModel(db.Model):
__tablename__ = 'stores'
id_ = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
# back reference
items = db.relationship('ItemModel', lazy = 'dynamic')
def __init__(self,name):
self.name = name
def json(self):
return {'name':self.name, 'items':[x.json() for x in self.items.all()]}
@classmethod
def get_by_name(cls,name):
return cls.query.filter_by(name=name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(100), nullable=False)
# for returning the string representation of user object
def __repr__(self):
return f"User(id = {id}, username = {username}, password = {password})"
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
return sha256.verify(password, hash)
class Post(db.Model):
"""Represents Proected posts."""
__tablename__ = 'posts'
id = db.Column(db.String(45), primary_key=True)
title = db.Column(db.String(255))
text = db.Column(db.Text())
publish_date = db.Column(db.DateTime)
# Set the foreign key for Post
user_id = db.Column(db.String(45), db.ForeignKey('users.id'))
comments = db.relationship('Comment', backref='posts', lazy='dynamic')
# many to many: posts <==> tags
tags = db.relationship(
'Tag',
#会告知 SQLAlchemy 该 many to many 的关联保存在 posts_tags 表中
secondary=posts_tags,
#声明表之间的关系是双向，帮助手册 help(db.backref)。
# 需要注意的是：在 one to many 中的 backref 是一个普通的对象，
# 而在 many to many 中的 backref 是一个 List 对象
backref=db.backref('posts', lazy='dynamic'))
def __init__(self, title):
self.title = title
def __repr__(self):
return "<Model Post `{}`>".format(self.title)
class finalTask_file(db.Model):
__tablename__ = 'final_task_file'
id = db.Column(db.Integer, primary_key=True, unique=True)
final_task_id = db.Column(db.Integer,
ForeignKey("final_task.id"),
nullable=False)
file_path = db.Column(db.String(255), nullable=False)
def save(self):
try:
sess.add(self)
sess.commit()
new_final_task_path = {
'id': self.id,
'final_task_id': self.final_task_id,
'file_path': self.file_path,
}
ret = {
'status': 200,
'message': 'New Final Task File Saved',
'results': new_final_task_path
}
return ret
except Exception as e:
sess.rollback()
ret = {
'status': 200,
'message': e.args,
}
return ret
finally:
sess.close()
class finalTask_lecturer(db.Model):
__tablename__ = 'final_task_lecturer'
id = db.Column(db.Integer, primary_key=True, unique=True)
final_task_id = db.Column(db.Integer,
ForeignKey("final_task.id"),
nullable=False)
lecturer_nip = db.Column(db.String(255), nullable=False)
lecturer_position = db.Column(db.String(255), nullable=False)
def save(self):
try:
sess.add(self)
sess.commit()
new_final_task_lecturer = {
'id': self.id,
'final_task_id': self.final_task_id,
'lecturer_nip': self.lecturer_nip,
'lecturer_position': self.lecturer_position,
}
ret = {
'status': 200,
'message': 'New Final Task Lecturer Registered',
'results': "Sukses"
}
return ret
except Exception as e:
sess.rollback()
ret = {
'status': 200,
'message': e.args,
}
return ret
finally:
sess.close()
class ItemModel(db.Model):
__tablename__ = 'items'
id_ = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
price = db.Column(db.Float(precision=2))
store_id = db.Column(db.Integer, db.ForeignKey('stores.id_'))
store = db.relationship('StoreModel')
def __init__(self, name, price, store_id):
self.name = name
self.price = price
self.store_id = store_id
def json(self):
return {
'name': self.name,
'price': self.price,
'store_id': self.store_id
}
@classmethod
def get_by_name(cls, name):
return cls.query.filter_by(name=name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class Message(db.Model):
"""
Saving messages from guest(buyers) to seller in our database
"""
id = db.Column(db.Integer, primary_key=True)
gar_name = db.Column(db.Text, nullable=False)
msg = db.Column(db.Text, nullable=False)
receiver_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
class UserModel(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
fName = db.Column(db.String(100), nullable=False)
lName = db.Column(db.String(100), nullable=True)
email = db.Column(db.String(100), unique=True, nullable=False)
# for returning the string representation of user object
def __repr__(self):
return f"User(id = {id}, fName = {fName}, lName = {lName}, email = {email})"
class tbl_toDoList(db.Model):
__tablename__ = 'tbl_toDoList'
todo_id = db.Column(db.Integer, primary_key=True)
todo_text = db.Column(db.String(50))
is_complete = db.Column(db.Boolean)
user_id = db.Column(db.Integer)
def __init__(self, todo_text, is_complete, user_id):
self.todo_text = todo_text
self.is_complete = is_complete
self.user_id = user_id
class Tag(db.Model):
"""Represents Proected tags."""
__tablename__ = 'tags'
id = db.Column(db.String(45), primary_key=True)
name = db.Column(db.String(255))
def __init__(self, name):
self.name = name
def __repr__(self):
return "<Model Tag `{}`>".format(self.name)
class Category(db.Model):
__tablename__ = 'category_tb'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(20), unique=True)
content = db.Column(db.String(100))
def __init__(self, title, content):
self.title = title
self.content = content
def __repr__(self):
return '<Category %r>' % self.title
class RevokedTokenModel(db.Model):
__tablename__ = 'revoked_tokens'
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(150))
def add(self):
db.session.add(self)
db.session.commit()
@classmethod
def is_jti_blacklisted(cls, jti):
query = cls.query.filter_by(jti=jti).first()
return bool(query)
class Comment(db.Model):
"""Represents Proected comments."""
__tablename__ = 'comments'
id = db.Column(db.String(45), primary_key=True)
name = db.Column(db.String(255))
text = db.Column(db.Text())
date = db.Column(db.DateTime())
post_id = db.Column(db.String(45), db.ForeignKey('posts.id'))
def __init__(self, name):
self.name = name
def __repr__(self):
return '<Model Comment `{}`>'.format(self.name)
class journalCorrespondingAuthor(db.Model):
__tablename__ = 'journal_corr_author'
id = db.Column(db.Integer, unique=False, primary_key=True)
journal_id = db.Column(db.Integer, ForeignKey('journal.id'), unique=False)
names = db.Column(db.String(255), unique=False)
def save(self):
try:
sess.add(self)
sess.commit()
return True
except Exception as e:
sess.rollback()
return e
finally:
sess.close()
class User(db.Model):
__tablename__ = 'users'
username = db.Column(db.String(80), primary_key=True)
email = db.Column(db.String(120), unique=True, nullable=False)
def json(self):
return{'username': self.username, 'email': self.email}
@staticmethod
def get_all_users():
return [User.json(user) for user in User.query.all()]
@staticmethod
def get_user(_username):
query = User.query.filter_by(username=_username).first()
return query
@staticmethod
def add_user(_username, _email):
new_user = User(username=_username, email=_email)
db.session.add(new_user)
db.session.commit()
@staticmethod
def update_email(_username, _email):
user_to_update = User.query.filter_by(username=_username).first()
user_to_update.email = _email
db.session.commit()
@staticmethod
def delete_user(_username):
is_successful = User.query.filter_by(username=_username).delete()
db.session.commit()
return bool(is_successful)
@staticmethod
def add_user_td():
User.add_user("darth", "*****@*****.**")
User.add_user("superman", "*****@*****.**")
User.add_user("thor", "*****@*****.**")
def __repr__(self):
user_object = {
'username': self.username,
'email': self.email
}
return json.dumps(user_object)
class tbl_user(db.Model):
__tablename__ = 'tbl_user'
user_id = db.Column(db.Integer, primary_key=True)
user_name = db.Column(db.String(40))
user_email = db.Column(db.String(40))
user_password = db.Column(db.String(255))
def __init__(self, user_name, user_email, user_password):
self.user_name = user_name
self.user_email = user_email
self.user_password = user_password
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return unicode(self.user_id)
def __repr__(self):
return '<User %r>' % (self.user_name)
# Class method which finds user from DB by username
@classmethod
def find_user_by_username(cls, user_name):
return cls.query.filter_by(user_name=user_name).first()
# Class method which finds user from DB by id
@classmethod
def find_user_by_id(cls, user_id):
return cls.query.filter_by(user_id=user_id).first()
# Method to save user to DB
def save_to_db(self):
db.session.add(self)
db.session.commit()
# Method to remove user from DB
def remove_from_db(self):
db.session.delete(self)
db.session.commit()
class Location(db.Model):
__tablename__ = 'locations'
id = db.Column(db.Integer, primary_key=True)
state = db.Column(db.String(80), unique=True, nullable=False)
capital = db.Column(db.String(120), unique=True, nullable=False)
def json(self):
return {'state': self.state, 'capital': self.capital}
@staticmethod
def get_all_locations():
return [Location.json(location) for location in Location.query.all()]
@staticmethod
def get_location(_state):
query = Location.query.filter_by(state=_state).first()
return query
@staticmethod
def add_location(_state, _capital):
new_location = Location(state=_state, capital=_capital)
db.session.add(new_location)
db.session.commit()
@staticmethod
def update_capital(_state, _capital):
location_to_update = Location.query.filter_by(state=_state).first()
location_to_update.capital = _capital
db.session.commit()
@staticmethod
def delete_location(_state):
is_successful = Location.query.filter_by(state=_state).delete()
db.session.commit()
return bool(is_successful)
@staticmethod
def add_location_td():
Location.add_location("mn", "st paul")
Location.add_location("ca", "sacramento")
Location.add_location("ny", "albany")
def __repr__(self):
location_object = {'state': self.state, 'capital': self.capital}
return json.dumps(location_object)
class research(db.Model):
id = db.Column(db.Integer, unique=True, primary_key=True)
lecturer_nip = db.Column(db.String(255), ForeignKey("lecturer.nip"), unique=False)
year = db.Column(db.String(255), unique=False)
title = db.Column(db.String(255), unique=False)
investor = db.Column(db.String(255), unique=False)
amount = db.Column(db.String(255), unique=False)
position = db.Column(db.String(255), unique=False)
term = db.Column(db.String(255), unique=False)
filepath = db.Column(db.String(255), unique=False)
def save(self):
try:
check_research = sess.query(research).filter(research.lecturer_nip == self.lecturer_nip). \
filter(research.title == self.title).first()
if check_research is None:
sess.add(self)
sess.commit()
files = research_file(research_id=self.id, filepath=self.filepath)
new_research = {
'id': self.id,
'lecturer_nip': self.lecturer_nip,
'title': self.title,
'investor': self.investor,
'amount': self.amount,
'position': self.position,
'year': self.year,
'term': self.term,
}
ret = {
'status': 200,
'message': 'New Research Registered',
'results': [new_research, files.save()]
}
else:
ret = {
'status': 200,
'message': 'Your research already registered before, please try again another research!'
}
return ret
except Exception as e:
sess.rollback()
ret = {
'status': 200,
'message': e.args
}
return ret
finally:
sess.close()
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.String(45), primary_key=True)
username = db.Column(db.String(255))
password = db.Column(db.String(255))
#会在 SQLAlchemy 中创建一个虚拟的列，该列会与 Post.user_id (db.ForeignKey) 建立联系。这一切都交由 SQLAlchemy 自身管理
posts = db.relationship(
'Post',
#用于指定表之间的双向关系，如果在一对多的关系中建立双向的关系，这样的话在对方看来这就是一个多对一的关系
backref='users',
#指定 SQLAlchemy 加载关联对象的方式，lazy=subquery: 会在加载 Post 对象后，将与 Post 相关联的对象全部加载
lazy='dynamic')
def __init__(self, id, username, password):
self.id = id
self.username = username
self.password = password
def __repr__(self):
return '<Model User `{}`>'.format(self.username)
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20))
password = db.Column(db.String(20))
def __init__(self, username, password):
self.username = username
self.password = password
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_id(cls, id_):
return cls.query.filter_by(id=id).first()
class User(db.Model):
"""Model for users"""
__tablename__ = 'users'
username = db.Column(db.String(80), primary_key=True)
email = db.Column(db.String(120), unique=True, nullable=False)
def json(self):
"""Returns a data dictionary"""
return {'username': self.username, 'email': self.email}
@staticmethod
def get_all_users():
"""Gets all users"""
return [User.json(user) for user in User.query.all()]
@staticmethod
def get_user(_username):
"""Gets a single user"""
query = User.query.filter_by(username=_username).first()
return query
@staticmethod
def add_user(_username, _email):
"""Function adds a user to a db table."""
new_user = User(username=_username, email=_email)
db.session.add(new_user)
db.session.commit()
@staticmethod
def add_user_td():
"""Adds test users to the database"""
User.add_user("darth", "*****@*****.**")
User.add_user("superman", "*****@*****.**")
User.add_user("thor", "*****@*****.**")
def __repr__(self):
"""Printable representation of our Model"""
user_object = {'username': self.username, 'email': self.email}
return json.dumps(user_object)
class Garment(db.Model):
"""
Saving clothes posted by users with login credentials into our database
"""
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(10), nullable=False)
gender = db.Column(db.String(5), nullable=False)
size = db.Column(db.String(5), nullable=False)
price = db.Column(db.INTEGER, nullable=False)
des = db.Column(db.Text, nullable=False)
pic = db.Column(db.String(2000), nullable=False, default='default.jpg')
#db.Column(ARRAY(db.Text), nullable=False, default=db.cast(array([], type_=db.Text), ARRAY(db.Text)))
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Garment('{self.title}', '{self.date_posted}')"
class research_file(db.Model):
id = db.Column(db.Integer, unique=True, primary_key=True)
research_id = db.Column(db.String(255), ForeignKey("research.id"), unique=False)
filepath = db.Column(db.String(255), unique=False)
def save(self):
try:
sess.add(self)
sess.commit()
res = {
'research_id': self.research_id,
'filepath': self.filepath
}
return res
except Exception as e:
sess.rollback()
res = {
'status': 200,
'message': e.args
}
return res
finally:
sess.close()
class experience(db.Model):
id = db.Column(db.Integer, unique=True, primary_key=True)
lecturer_nip = db.Column(db.String(255),
ForeignKey("lecturer.nip"),
unique=False)
job_name = db.Column(db.String(255), unique=False)
job_type = db.Column(db.String(255), unique=False)
year = db.Column(db.String(255), unique=False)
term = db.Column(db.Integer, unique=False)
filepath = db.Column(db.String(255), unique=False)
def save(self):
try:
check_experience = sess.query(experience).filter(experience.lecturer_nip == self.lecturer_nip).\
filter(experience.job_name == self.job_name).first()
if check_experience is None:
sess.add(self)
sess.commit()
new_experience = {
'id': self.id,
'lecturer_nip': self.lecturer_nip,
'job_name': self.job_name,
'job_type': self.job_type,
'year': self.year,
'term': self.term,
'filepath': self.filepath
}
ret = {
'status': 200,
'message': 'New Experience Registered',
'results': new_experience
}
else:
ret = {
'status':
200,
'message':
'Your experience already registered before, please try again another experience!'
}
return ret
except Exception as e:
sess.rollback()
ret = {
'status': 200,
'message': e.args,
}
return ret
finally:
sess.close()
class patent(db.Model):
id = db.Column(db.Integer, unique=True, primary_key=True)
lecturer_nip = db.Column(db.String(255),
ForeignKey('lecturer.nip'),
unique=False)
title = db.Column(db.String(255), unique=True)
status = db.Column(db.String(255), unique=False)
publisher = db.Column(db.String(255), unique=False)
year = db.Column(db.String(5), unique=False)
filepath = db.Column(db.String(255), unique=False)
def save(self):
try:
check_patent = sess.query(patent).filter(patent.lecturer_nip == self.lecturer_nip). \
filter(patent.title == self.title).first()
if check_patent is None:
sess.add(self)
sess.commit()
new_patent = {
'id': self.id,
'lecturer_nip': self.lecturer_nip,
'title': self.title,
'status': self.status,
'year': self.year,
'publisher': self.publisher,
'filepath': self.filepath
}
ret = {
'status': 200,
'message': 'New Patent Registered',
'results': new_patent
}
else:
ret = {
'status':
200,
'message':
'Your patent already registered before, please try again another patent!'
}
return ret
except Exception as e:
sess.rollback()
ret = {'status': 200, 'message': e.args}
return ret
finally:
sess.close()
class finalTask(db.Model):
__tablename__ = 'final_task'
id = db.Column(db.Integer, primary_key=True, unique=True)
student_name = db.Column(db.String(255), nullable=False)
student_nim = db.Column(db.String(255), nullable=False)
student_type = db.Column(db.String(255), nullable=False)
title = db.Column(db.String(255), nullable=False)
starting_date = db.Column(db.Date, nullable=False)
graduation_date = db.Column(db.Date, nullable=False)
def save(self):
try:
sess.add(self)
sess.commit()
new_final_task = {
'id': self.id,
'student_name': self.student_name,
'student_nim': self.student_nim,
'student_type': self.student_type,
'title': self.title,
'starting_date': self.starting_date,
'graduation_date': self.graduation_date
}
ret = {
'status': 200,
'message': 'New Final Task Registered',
'results': new_final_task
}
return ret
except Exception as e:
sess.rollback()
ret = {
'status': 200,
'message': e.args,
}
return ret
finally:
sess.close()
class User(db.Model, UserMixin):
"""
Saving new users data into our database
"""
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
firstname = db.Column(db.String(20), nullable=False)
lastname = db.Column(db.String(20), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
garments = db.relationship('Garment', backref='seller', lazy=True)
messages = db.relationship('Message', backref='sender', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}')"
def set_password(self, secret):
self.password = generate_password_hash(secret)
def check_password(self, secret):
return check_password_hash(self.password, secret)
class admin(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), unique=True, nullable=False)
role = db.Column(db.Integer, unique=True, nullable=False)
auth_id = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
def save(self):
try:
check_user = sess.query(admin).filter(admin.auth_id == self.auth_id).first()
if check_user is not None:
ret = {
'status': 200,
'message': "Auth_ID already registered, try again another Auth_ID"
}
return ret
sess.add(self)
sess.commit()
new_admin = {
'id': self.id,
'auth_id': self.auth_id,
'name': self.name,
'role': self.role,
'email': self.email
}
ret = {
'status': 200,
'message': 'Admin Registered',
'results': new_admin
}
return ret
except Exception as e:
sess.rollback()
ret = {
'status': 200,
'message': e.args,
}
return ret
finally:
sess.close()
def edit(self, auth_id, request):
try:
selected_admin = sess.query(admin).filter(admin.auth_id == auth_id).first()
if selected_admin is not None:
data = {}
for k in request.keys():
param = k
if param == "password":
data[k] = bcrypt.hashpw(request[param].encode('utf-8'), bcrypt.gensalt())
else:
data[k] = request[param]
check = sess.query(admin).filter(admin.auth_id == auth_id).update(data, synchronize_session=False)
sess.commit()
if check == 1:
ret = {
'status': 200,
'message': 'Data updated!'
}
else:
ret = {
'status': 500,
'message': "Something's wrong with our server. Please try again later!"
}
return ret
else:
ret = {
'status': False,
'message': "Auth_ID is not registered"
}
return ret
except Exception as e:
sess.rollback()
ret = {
'status': 200,
'message': e.args,
}
return ret
finally:
sess.close()
def delete(self, auth_id):
try:
selected_admin = sess.query(admin).filter(admin.auth_id == auth_id).first()
if selected_admin is not None:
sess.delete(selected_admin)
sess.commit()
ret = {
'status': 200,
'message': 'Data deleted!'
}
return ret
else:
ret = {
'status': 200,
'message': "Auth_ID is not registered"
}
return ret
except Exception as e:
sess.rollback()
ret = {
'status': 200,
'message': e.args,
}
return ret
finally:
sess.close()
class User(db.Model):
__tablename__ = 'tb_user'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), unique=True)
age = db.Column(db.Integer)
class journal(db.Model):
id = db.Column(db.Integer, unique=True, primary_key=True)
title = db.Column(db.String(255), unique=True)
lecturer_nip = db.Column(db.String(255),
ForeignKey('lecturer.nip'),
unique=False)
year = db.Column(db.String(5), unique=False)
number = db.Column(db.String(255), unique=False)
issue = db.Column(db.Integer, unique=False, nullable=True)
total_page = db.Column(db.Integer, unique=False, nullable=True)
type = db.Column(db.String(255), unique=False)
doi = db.Column(db.String(255), unique=False, nullable=True)
link = db.Column(db.String(255), unique=False)
filepath = db.Column(db.String(255), unique=False)
names = db.Column(db.String(255), unique=False, nullable=True)
def save(self):
global saveJourCorr
try:
check_journal = sess.query(journal).filter(journal.lecturer_nip == self.lecturer_nip). \
filter(journal.title == self.title).first()
if check_journal is None:
sess.add(self)
sess.commit()
new_journal = {
'lecturer_nip': self.lecturer_nip,
'title': self.title,
'issue': self.issue,
'year': self.year,
'number': self.number,
'total_page': self.total_page,
'type': self.type,
'doi': self.doi,
'link': self.link,
'filepath': self.filepath,
'names': self.names
}
# savejourCorr = True
# for name in self.names:
# if saveJourCorr:
# saveJourCorr = journalCorrespondingAuthor(journal_id=self.id, names=name).save()
# else:
# return {'status': 200,
# 'message': 'something went wrong when we try to save corresponding author!'}
if self.names:
names = self.names.split(",")
for name in names:
journalCorrespondingAuthor(journal_id=self.id,
names=name).save()
# else:
# return {'status': 200, 'message': 'no corresponding author'}
ret = {
'status': 200,
'message': 'New Journal Registered',
'results': new_journal
}
else:
ret = {
'status':
200,
'message':
'Your journal already registered before, please try again another journal!'
}
return ret
except Exception as e:
sess.rollback()
ret = {'status': 200, 'message': e.args}
return ret
finally:
sess.close()
