def __init__(self, user):
self.memberHome = QtWidgets.QMainWindow()
self.ui = Ui_memberMainWindow()
self.ui.setupUi(self.memberHome)
self.ui.logoutButton.clicked.connect(self.logout)
self.confirm = confirmView.ConfirmView()
self.error = errorView.ErrorView()
self.notification = notificationView.NotificationView()
self.userController = UserController()
self.bookController = BookController()
self.loanController = LoanController()
self.loanController.update_fines()
self.ui.searchButton.clicked.connect(self.search_books)
self.ui.waitingListButton.clicked.connect(self.add_to_waiting_list)
self.ui.checkoutButton.clicked.connect(self.checkout_book)
self.ui.cancelSelected.clicked.connect(self.cancel_waiting)
self.ui.returnBookButton.clicked.connect(self.return_operation)
self.ui.payFineButton.clicked.connect(self.payment_operation)
self.ui.resetButton.clicked.connect(self.reset_book_filters)
self.ui.waitingListWidget.cellDoubleClicked.connect(self.show_book_info_waiting)
self.ui.viewBookWidget.cellDoubleClicked.connect(self.show_book_info_view)
self.ui.searchBookWidget.cellDoubleClicked.connect(self.show_book_info_search)
self.currentUser = user
self.payment = paymentView.PaymentView(0)
self.prepare_scene()
self.current_book_queries = ["", "", ""]
self.update_lists()
self.update_scene()
self.set_button_effects()
self.book_info = None
self.check_notifications()
def post(self):
data = request.get_json()["credentials"]
email = data["email"]
password = data["password"]
userController = UserController()
# validate that user email doesn't already exist
if (userController.findByEmail(email) != None):
return {"error": f"User {email} already exists"}
try:
message = userController.registration(email, password)
access_token = create_access_token(identity=email)
refresh_token = create_refresh_token(identity=email)
return {
"message": message,
"user": email,
"access_token": access_token,
"refresh_token": refresh_token
}
except:
return {"error": "Something went wrong"}
def user_page(self, nickname_or_id):
assert len(nickname_or_id) > 0
u = UserController.get_user_by_nick_or_id(nickname_or_id)
if u == None:
return render_template('404.html')
user_page_data = UserController.get_user_page_data(u)
return render_template('user_page.html', **user_page_data)
def post(self):
data = parser.parse_args()
userController = UserController()
user = userController.findByUsername(data["username"])
history = userController.getUserBalanceHistory(user.getUserId)
return history
def start(self):
self.user_controller = UserController()
self.user_controller.show_options()
user = self.user_controller.get_user_logged()
self.task_controller = TaskController()
self.task_controller.set_user(user)
self.task_controller.show_menu()
def __init__(self):
self.userRegisterFormScreen = QtWidgets.QDialog()
self.ui = Ui_userRegisterForm()
self.userController = UserController()
self.ui.setupUi(self.userRegisterFormScreen)
self.ui.registerButton.clicked.connect(self.register_user)
self.ui.cancelButton.clicked.connect(self.terminate)
self.error = errorView.ErrorView()
self.currentUser = None
self.type = 0 # 0 for create user 1 for update user
def __init__(self):
self.login = QtWidgets.QDialog()
self.ui = Ui_Login()
self.ui.setupUi(self.login)
self.ui.loginButton.clicked.connect(self.user_login)
self.ui.searchButton.clicked.connect(self.guest_search)
self.userController = UserController()
self.error = errorView.ErrorView()
self.ui.loginButton.released.connect(self.released_color_change)
self.ui.loginButton.pressed.connect(self.pressed_color_change)
self.ui.searchButton.released.connect(self.released_color_change)
self.ui.searchButton.pressed.connect(self.pressed_color_change)
class App():
def __init__(self):
self.start()
def start(self):
self.user_controller = UserController()
self.user_controller.show_options()
user = self.user_controller.get_user_logged()
self.task_controller = TaskController()
self.task_controller.set_user(user)
self.task_controller.show_menu()
def post(self):
data = parser.parse_args()
userController = UserController()
if (userController.findByUsername(data["username"]) != None):
return {"message": f"User {data['username']} already exists"}
try:
userController.registration(data["username"],
data["password"]) #, data["email"])
access_token = create_access_token(identity=data["username"])
refresh_token = create_refresh_token(identity=data["username"])
return {
"message": "User successfully created",
"access_token": access_token,
"refresh_token": refresh_token
}
except:
return {"message": "Something went wrong"}
def post(self):
data = parser.parse_args()
userController = UserController()
try:
if (userController.findByUsername(data["username"])) == None:
return {"message": f"User {data.username} doesn't exist"}
if userController.login(data["username"],
data["password"]) == True:
access_token = create_access_token(identity=data["username"])
refresh_token = create_refresh_token(identity=data["username"])
return {
"message": f"Logged in as {data['username']}",
"access_token": access_token,
"refresh_token": refresh_token
}
else:
return {"message": "Username or password is incorrect."}
except:
return {"message": "Something went wrong, please try again"}
def __init__(self, user):
self.userRegisterScreen = userRegisterFormView.UserRegisterFormView()
self.bookRegisterScreen = bookRegisterFormView.BookRegisterFormView()
self.librarianHome = QtWidgets.QMainWindow()
self.ui = Ui_libraryMainWindow()
self.ui.setupUi(self.librarianHome)
self.ui.logoutButton.clicked.connect(self.logout)
self.ui.userResetButton.clicked.connect(self.reset_user_filters)
self.ui.bookResetButton.clicked.connect(self.reset_book_filters)
self.ui.userDeleteButton.clicked.connect(self.delete_selected_user)
self.ui.userCreateButton.clicked.connect(self.register_user_form)
self.ui.userUpdateButton.clicked.connect(self.update_user_form)
self.ui.userSearchButton.clicked.connect(self.search_users)
self.ui.bookSearchButton.clicked.connect(self.search_books)
self.ui.bookDeleteButton.clicked.connect(self.delete_selected_book)
self.ui.bookCreateButton.clicked.connect(self.register_book_form)
self.ui.bookUpdateButton.clicked.connect(self.update_book_form)
self.ui.userTableWidget.cellDoubleClicked.connect(
self.update_user_form)
self.ui.bookTableWidget.cellDoubleClicked.connect(
self.update_book_form)
self.currentUser = user
self.confirm = confirmView.ConfirmView()
self.error = errorView.ErrorView()
self.userController = UserController()
self.bookController = BookController()
self.loanController = LoanController()
self.customize_scene()
self.current_user_queries = ["", "", ""]
self.current_book_queries = ["", "", ""]
self.set_button_effects()
self.book_ids = []
self.user_ids = []
self.list_users()
self.list_books()
from six.moves.urllib.request import urlopen
from jose import jwt
import urllib.parse
# Controllers
from controllers.UserController import UserController
from controllers.ErrorController import ErrorController
# Set up Flask/Tornado
app = Flask(__name__)
app.debug = True
CORS(app)
limiter = Limiter(app)
# Set up controllers
user_controller = UserController(app)
error_controller = ErrorController(app)
# Read configuration file
config = configparser.ConfigParser()
config.read('config.ini')
environment = config['server']['environment']
if environment is None or environment == '':
environment = 'production'
# Auth0 config
auth0_domain = config['auth0']['domain']
auth0_audience = config['auth0']['audience']
auth0_algorithms = [config['auth0']['algorithms']]
# Get config variables
import os
from flask import Flask, request
from controllers.UserController import UserController
from service.UserService import UserService
from dataAccessLayer.UserQueries import UserQueries
userQueries = UserQueries()
userService = UserService(userQueries)
userCtrl = UserController(userService)
from controllers.PostController import PostController
from service.PostService import PostService
from dataAccessLayer.PostsQueries import PostsQueries
from dataAccessLayer.CommentsQueries import CommentsQueries
postQueries = PostsQueries()
commentsQueries = CommentsQueries()
postService = PostService(postQueries, commentsQueries)
postCtrl = PostController(postService)
def create_app():
app = Flask(__name__)
app.config.from_object('config.ProductionConfig')
#app.config.from_envvar('APP_CONFIG')
#app.config.from_pyfile('config.py')
return app
app = create_app()
class MemberHomeView(Ui_memberMainWindow):
def __init__(self, user):
self.memberHome = QtWidgets.QMainWindow()
self.ui = Ui_memberMainWindow()
self.ui.setupUi(self.memberHome)
self.ui.logoutButton.clicked.connect(self.logout)
self.confirm = confirmView.ConfirmView()
self.error = errorView.ErrorView()
self.notification = notificationView.NotificationView()
self.userController = UserController()
self.bookController = BookController()
self.loanController = LoanController()
self.loanController.update_fines()
self.ui.searchButton.clicked.connect(self.search_books)
self.ui.waitingListButton.clicked.connect(self.add_to_waiting_list)
self.ui.checkoutButton.clicked.connect(self.checkout_book)
self.ui.cancelSelected.clicked.connect(self.cancel_waiting)
self.ui.returnBookButton.clicked.connect(self.return_operation)
self.ui.payFineButton.clicked.connect(self.payment_operation)
self.ui.resetButton.clicked.connect(self.reset_book_filters)
self.ui.waitingListWidget.cellDoubleClicked.connect(self.show_book_info_waiting)
self.ui.viewBookWidget.cellDoubleClicked.connect(self.show_book_info_view)
self.ui.searchBookWidget.cellDoubleClicked.connect(self.show_book_info_search)
self.currentUser = user
self.payment = paymentView.PaymentView(0)
self.prepare_scene()
self.current_book_queries = ["", "", ""]
self.update_lists()
self.update_scene()
self.set_button_effects()
self.book_info = None
self.check_notifications()
def prepare_scene(self):
self.ui.greetingLabel.setText("Hi, " + str(self.currentUser.name) + " " + str(self.currentUser.surname))
self.ui.dateLabel.setText(datetime.datetime.now().strftime("%Y-%m-%d"))
self.ui.searchBookWidget.setColumnCount(4)
self.ui.viewBookWidget.setColumnCount(4)
self.ui.waitingListWidget.setColumnCount(4)
self.ui.searchBookWidget.setHorizontalHeaderLabels(["Title", "Author", "Year", "User ID"])
self.ui.viewBookWidget.setHorizontalHeaderLabels(["Title", "Author", "Return Date", "User ID"])
self.ui.waitingListWidget.setHorizontalHeaderLabels(["Title", "Author", "Published Year", "User ID"])
def update_scene(self):
self.currentUser = self.userController.get_user_by_id(self.currentUser.id)
self.ui.lastBookLabel.setText("Last Loaned Book : " + self.currentUser.lastLoanedBook)
self.ui.fineLabel.setText("Current Fine Amount : ₺" + str(self.currentUser.currentFine))
self.ui.totalBooksLabel.setText("Total Loaned Books : " + str(self.currentUser.totalLoanedBooks))
def logout(self):
import views.LoginView as LoginView
self.memberHome.hide()
self.ui = LoginView.LoginView()
self.ui.show()
def show(self):
self.memberHome.show()
def reset_book_filters(self):
self.current_book_queries = ["", "", ""]
self.update_lists()
def payment_operation(self):
self.payment = paymentView.PaymentView(self.currentUser.currentFine)
self.payment.paymentPrompt.exec_()
if self.payment.paymentFlag:
self.loanController.reset_user_loans(self.currentUser.id)
self.currentUser.currentFine = 0
self.currentUser.formerFine = 0
self.userController.update_member_attributes(self.currentUser)
self.loanController.update_fines()
self.update_scene()
def show_book_info_view(self):
selected_row = self.ui.viewBookWidget.currentRow()
if selected_row > -1:
selected_book_id = self.ui.viewBookWidget.item(selected_row, 3).text()
selected_book = self.bookController.get_book_by_id(str(selected_book_id))
self.book_info = bookInfoView.BookInfoView(selected_book)
self.book_info.update_scene()
self.book_info.show()
def show_book_info_search(self):
selected_row = self.ui.searchBookWidget.currentRow()
if selected_row > -1:
selected_book_id = self.ui.searchBookWidget.item(selected_row, 3).text()
selected_book = self.bookController.get_book_by_id(selected_book_id)
self.book_info = bookInfoView.BookInfoView(selected_book)
self.book_info.update_scene()
self.book_info.show()
def show_book_info_waiting(self):
selected_row = self.ui.waitingListWidget.currentRow()
if selected_row > -1:
selected_book_id = self.ui.waitingListWidget.item(selected_row, 3).text()
selected_book = self.bookController.get_book_by_id(str(selected_book_id))
self.book_info = bookInfoView.BookInfoView(selected_book)
self.book_info.update_scene()
self.book_info.show()
def list_books(self):
query_result = self.bookController.search_books(self.current_book_queries[0], self.current_book_queries[1],
self.current_book_queries[2])
i = 0
current_row_count = query_result.count()
self.ui.searchBookWidget.setRowCount(current_row_count)
for record in query_result:
self.ui.searchBookWidget.setItem(i, 0, QtWidgets.QTableWidgetItem(record["title"]))
self.ui.searchBookWidget.setItem(i, 1, QtWidgets.QTableWidgetItem(record["author"]))
self.ui.searchBookWidget.setItem(i, 2, QtWidgets.QTableWidgetItem(record["year"]))
self.ui.searchBookWidget.setItem(i, 3, QtWidgets.QTableWidgetItem(str(record["_id"])))
if record["isAvailable"] is False:
self.ui.searchBookWidget.item(i, 0).setBackground(QtGui.QColor(255, 68, 68))
self.ui.searchBookWidget.item(i, 1).setBackground(QtGui.QColor(255, 68, 68))
self.ui.searchBookWidget.item(i, 2).setBackground(QtGui.QColor(255, 68, 68))
i = i + 1
self.show()
def search_books(self):
search_title = self.ui.titleLineEdit.text()
search_author = self.ui.authorLineEdit.text()
search_year = self.ui.yearLineEdit.text()
self.current_book_queries = [search_title, search_author, search_year]
self.update_lists()
def checkout_book(self):
selected_row = self.ui.searchBookWidget.currentRow()
if selected_row > -1:
selected_book_id = self.ui.searchBookWidget.item(selected_row, 3).text()
selected_book = self.bookController.get_book_by_id(str(selected_book_id))
if selected_book.isAvailable is False:
self.error.set_error_text("You can't checkout an unavailable book.")
self.error.errorScreen.exec_()
else:
indicator = self.loanController.checkout_book(self.currentUser, selected_book)
if indicator == 0:
self.error.set_error_text("You cannot checkout with existing fines.")
self.error.errorScreen.exec_()
elif indicator == 1:
self.error.set_error_text("You cannot borrow more than 4 books.")
self.error.errorScreen.exec_()
elif indicator == 2:
self.notification.set_notif_text("\""+selected_book.title+"\" is added to your books.")
self.notification.notificationScreen.exec_()
self.update_lists()
self.update_scene()
def add_to_waiting_list(self):
selected_row = self.ui.searchBookWidget.currentRow()
if selected_row > -1:
selected_book_id = self.ui.searchBookWidget.item(selected_row, 3).text()
selected_book = self.bookController.get_book_by_id(str(selected_book_id))
if selected_book.isAvailable is True:
self.error.set_error_text("You can't add an available book to your waiting list.")
self.error.errorScreen.exec_()
elif selected_book.id in self.currentUser.loanedBooks:
self.error.set_error_text("You already loaned this book.")
self.error.errorScreen.exec_()
elif selected_book.isAvailable is False:
if str(selected_book.id) not in self.currentUser.waitingBooks:
self.currentUser.waitingBooks.append(str(selected_book.id))
if str(self.currentUser.id) not in selected_book.waitingList:
selected_book.waitingList.append(str(self.currentUser.id))
self.userController.update_member_attributes(self.currentUser)
self.bookController.update_book_attributes(selected_book)
self.update_lists()
def update_lists(self):
self.list_user_waiting_list()
self.list_books()
self.list_loaned_books()
def check_notifications(self):
for book in self.currentUser.waitingBooks:
if self.bookController.get_book_by_id(book).isAvailable:
self.notification.set_notif_text("\"" + self.bookController.get_book_by_id(book).title + "\"" +
" is available to rent.")
self.notification.show()
def list_user_waiting_list(self):
i = 0
current_row_count = len(self.currentUser.waitingBooks)
self.ui.waitingListWidget.setRowCount(current_row_count)
for record in self.currentUser.waitingBooks:
waited_book = self.bookController.get_book_by_id(record)
self.ui.waitingListWidget.setItem(i, 0, QtWidgets.QTableWidgetItem(waited_book.title))
self.ui.waitingListWidget.setItem(i, 1, QtWidgets.QTableWidgetItem(waited_book.author))
self.ui.waitingListWidget.setItem(i, 2, QtWidgets.QTableWidgetItem(waited_book.publishedYear))
self.ui.waitingListWidget.setItem(i, 3, QtWidgets.QTableWidgetItem(str(waited_book.id)))
if waited_book.isAvailable is False:
self.ui.waitingListWidget.item(i, 0).setBackground(QtGui.QColor(255, 68, 68))
self.ui.waitingListWidget.item(i, 1).setBackground(QtGui.QColor(255, 68, 68))
self.ui.waitingListWidget.item(i, 2).setBackground(QtGui.QColor(255, 68, 68))
i = i + 1
self.show()
def list_loaned_books(self):
i = 0
current_row_count = len(self.currentUser.loanedBooks)
self.ui.viewBookWidget.setRowCount(current_row_count)
for record in self.currentUser.loanedBooks:
loaned_book = self.bookController.get_book_by_id(record)
return_date = self.loanController.get_loan_record(loaned_book.id)["returnDate"]
self.ui.viewBookWidget.setItem(i, 0, QtWidgets.QTableWidgetItem(loaned_book.title))
self.ui.viewBookWidget.setItem(i, 1, QtWidgets.QTableWidgetItem(loaned_book.author))
self.ui.viewBookWidget.setItem(i, 2, QtWidgets.QTableWidgetItem(return_date.strftime("%d %b %Y")))
self.ui.viewBookWidget.setItem(i, 3, QtWidgets.QTableWidgetItem(str(loaned_book.id)))
if datetime.datetime.now() > return_date:
self.ui.viewBookWidget.item(i, 0).setBackground(QtGui.QColor(206,190,190))
self.ui.viewBookWidget.item(i, 1).setBackground(QtGui.QColor(206,190,190))
self.ui.viewBookWidget.item(i, 2).setBackground(QtGui.QColor(206,190,190))
i = i + 1
self.show()
def cancel_waiting(self):
selected_row = self.ui.waitingListWidget.currentRow()
if selected_row > -1:
selected_book_id = self.ui.waitingListWidget.item(selected_row, 3).text()
selected_book = self.bookController.get_book_by_id(str(selected_book_id))
self.confirm.confirm_flag = 0
self.confirm.set_confirm_text("Are you sure you want to cancel waiting for this book?")
self.confirm.confirmScreen.exec_()
if self.confirm.confirm_flag is 1:
self.currentUser.waitingBooks.remove(str(selected_book.id))
selected_book.waitingList.remove(str(self.currentUser.id))
self.userController.update_member_attributes(self.currentUser)
self.bookController.update_book_attributes(selected_book)
self.update_lists()
def return_operation(self):
selected_row = self.ui.viewBookWidget.currentRow()
if selected_row > -1:
selected_book_id = self.ui.viewBookWidget.item(selected_row, 3).text()
selected_book = self.bookController.get_book_by_id(str(selected_book_id))
self.confirm.confirm_flag = 0
self.confirm.set_confirm_text("Are you sure you want to return this book?")
self.confirm.confirmScreen.exec_()
if self.confirm.confirm_flag is 1:
self.loanController.return_book(self.currentUser, selected_book)
self.update_lists()
self.update_scene()
def set_button_effects(self):
self.ui.returnBookButton.released.connect(self.released_color_change)
self.ui.returnBookButton.pressed.connect(self.pressed_color_change)
self.ui.searchButton.released.connect(self.released_color_change)
self.ui.searchButton.pressed.connect(self.pressed_color_change)
self.ui.cancelSelected.released.connect(self.released_color_change)
self.ui.cancelSelected.pressed.connect(self.pressed_color_change)
self.ui.checkoutButton.released.connect(self.released_color_change)
self.ui.checkoutButton.pressed.connect(self.pressed_color_change)
self.ui.logoutButton.released.connect(self.released_color_change)
self.ui.logoutButton.pressed.connect(self.pressed_color_change)
self.ui.waitingListButton.released.connect(self.released_color_change)
self.ui.waitingListButton.pressed.connect(self.pressed_color_change)
self.ui.payFineButton.released.connect(self.released_color_change)
self.ui.payFineButton.pressed.connect(self.pressed_color_change)
self.ui.resetButton.released.connect(self.released_color_change)
self.ui.resetButton.pressed.connect(self.pressed_color_change)
def released_color_change(self):
if self.memberHome.sender().text() == 'Add To Waiting List':
self.memberHome.sender().setStyleSheet("QPushButton {\n"
"color: white;\n"
"background-color: QLinearGradient( x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #dd7a23, stop: 0.1 #e87919, stop: 0.49 #ce650a, stop: 0.5 #c45d03, stop: 1 #d16304);\n"
"font-size: 20px;\n"
"border-radius:10px;\n"
"}")
else:
self.memberHome.sender().setStyleSheet("QPushButton {\n"
"color: white;\n"
"background-color: QLinearGradient( x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #dd7a23, stop: 0.1 #e87919, stop: 0.49 #ce650a, stop: 0.5 #c45d03, stop: 1 #d16304);\n"
"font-size: 30px;\n"
"border-radius:10px;\n"
"}")
def pressed_color_change(self):
if self.memberHome.sender().text() == 'Add To Waiting List':
self.memberHome.sender().setStyleSheet("QPushButton {\n"
"color: white;\n"
"background-color: red;\n"
"font-size: 20px;\n"
"border-radius:10px;\n"
"}")
else:
self.memberHome.sender().setStyleSheet("QPushButton {\n"
"color: white;\n"
"background-color:red;\n"
"font-size: 30px;\n"
"border-radius:10px;\n"
"}")
from flask import Flask, render_template, request, redirect, url_for, json
from controllers.EPSController import EPSController
from controllers.UserController import UserController
from controllers.ExhibitionController import ExhibitionController
from controllers.ExhibitorController import ExhibitorController
from controllers.RegistrationController import RegistrationController
import Helper as hp
import os
app = Flask(__name__)
app.secret_key = os.urandom(24)
global con, cur, ic, uc, xc, ec, rc
con, cur = hp.connectDB()
ic = EPSController.getInstance(con, cur)
uc = UserController.getInstance(con, cur)
xc = ExhibitionController.getInstance(con, cur)
ec = ExhibitorController.getInstance(con, cur)
rc = RegistrationController.getInstance(con, cur)
@app.route('/')
def index():
return ic.cIndex()
@app.route('/search/')
def search():
return xc.cSearch('ongoing')
class LibrarianHomeView(Ui_libraryMainWindow):
def __init__(self, user):
self.userRegisterScreen = userRegisterFormView.UserRegisterFormView()
self.bookRegisterScreen = bookRegisterFormView.BookRegisterFormView()
self.librarianHome = QtWidgets.QMainWindow()
self.ui = Ui_libraryMainWindow()
self.ui.setupUi(self.librarianHome)
self.ui.logoutButton.clicked.connect(self.logout)
self.ui.userResetButton.clicked.connect(self.reset_user_filters)
self.ui.bookResetButton.clicked.connect(self.reset_book_filters)
self.ui.userDeleteButton.clicked.connect(self.delete_selected_user)
self.ui.userCreateButton.clicked.connect(self.register_user_form)
self.ui.userUpdateButton.clicked.connect(self.update_user_form)
self.ui.userSearchButton.clicked.connect(self.search_users)
self.ui.bookSearchButton.clicked.connect(self.search_books)
self.ui.bookDeleteButton.clicked.connect(self.delete_selected_book)
self.ui.bookCreateButton.clicked.connect(self.register_book_form)
self.ui.bookUpdateButton.clicked.connect(self.update_book_form)
self.ui.userTableWidget.cellDoubleClicked.connect(
self.update_user_form)
self.ui.bookTableWidget.cellDoubleClicked.connect(
self.update_book_form)
self.currentUser = user
self.confirm = confirmView.ConfirmView()
self.error = errorView.ErrorView()
self.userController = UserController()
self.bookController = BookController()
self.loanController = LoanController()
self.customize_scene()
self.current_user_queries = ["", "", ""]
self.current_book_queries = ["", "", ""]
self.set_button_effects()
self.book_ids = []
self.user_ids = []
self.list_users()
self.list_books()
def customize_scene(self):
self.ui.greetingLabel.setText("Hi, " + str(self.currentUser.name) +
" " + str(self.currentUser.surname))
self.ui.dateLabel.setText(datetime.datetime.now().strftime("%Y-%m-%d"))
self.ui.userTableWidget.setColumnCount(4)
self.ui.bookTableWidget.setColumnCount(4)
self.ui.userTableWidget.setHorizontalHeaderLabels(
["Name", "Surname", "Username", "User ID"])
self.ui.bookTableWidget.setHorizontalHeaderLabels(
["Title", "Author", "Published Year", "Book ID"])
def reset_user_filters(self):
self.current_user_queries = ["", "", ""]
self.list_users()
def reset_book_filters(self):
self.current_book_queries = ["", "", ""]
self.list_books()
def delete_selected_user(self):
selected_row = self.ui.userTableWidget.currentRow()
if selected_row > -1:
selected_user_id = self.ui.userTableWidget.item(selected_row,
3).text()
self.confirm.confirm_flag = 0
self.confirm.confirmScreen.exec_()
if self.confirm.confirm_flag is 1:
self.userController.delete_one_user(str(selected_user_id))
self.loanController.delete_user_from_loans(
str(selected_user_id))
self.bookController.delete_from_all_waiting_lists(
str(selected_user_id))
self.list_users()
def delete_selected_book(self):
selected_row = self.ui.bookTableWidget.currentRow()
if selected_row > -1:
selected_book_id = self.ui.bookTableWidget.item(selected_row,
3).text()
self.confirm.confirm_flag = 0
self.confirm.confirmScreen.exec_()
if self.confirm.confirm_flag is 1:
self.bookController.delete_one_book_by_id(
str(selected_book_id))
self.userController.delete_from_all_owned_books(
str(selected_book_id))
self.userController.delete_from_all_waiting_lists(
str(selected_book_id))
self.loanController.delete_book_from_loans(
str(selected_book_id))
self.list_books()
def list_users(self):
query_result = self.userController.search_users(
self.current_user_queries[0], self.current_user_queries[1],
self.current_user_queries[2])
i = 0
current_row_count = query_result.count()
self.ui.userTableWidget.setRowCount(current_row_count)
for record in query_result:
self.ui.userTableWidget.setItem(
i, 0, QtWidgets.QTableWidgetItem(record["name"]))
self.ui.userTableWidget.setItem(
i, 1, QtWidgets.QTableWidgetItem(record["surname"]))
self.ui.userTableWidget.setItem(
i, 2, QtWidgets.QTableWidgetItem(record["username"]))
self.ui.userTableWidget.setItem(
i, 3, QtWidgets.QTableWidgetItem(str(record["_id"])))
i = i + 1
self.show()
def list_books(self):
query_result = self.bookController.search_books(
self.current_book_queries[0], self.current_book_queries[1],
self.current_book_queries[2])
i = 0
current_row_count = query_result.count()
self.ui.bookTableWidget.setRowCount(current_row_count)
for record in query_result:
self.ui.bookTableWidget.setItem(
i, 0, QtWidgets.QTableWidgetItem(record["title"]))
self.ui.bookTableWidget.setItem(
i, 1, QtWidgets.QTableWidgetItem(record["author"]))
self.ui.bookTableWidget.setItem(
i, 2, QtWidgets.QTableWidgetItem(record["year"]))
self.ui.bookTableWidget.setItem(
i, 3, QtWidgets.QTableWidgetItem(str(record["_id"])))
if record["isAvailable"] is False:
self.ui.bookTableWidget.item(i, 0).setBackground(
QtGui.QColor(255, 68, 68))
self.ui.bookTableWidget.item(i, 1).setBackground(
QtGui.QColor(255, 68, 68))
self.ui.bookTableWidget.item(i, 2).setBackground(
QtGui.QColor(255, 68, 68))
i = i + 1
self.show()
def logout(self):
import views.LoginView as LoginView
self.librarianHome.hide()
self.ui = LoginView.LoginView()
self.ui.show()
def show(self):
self.librarianHome.show()
def update_user_form(self):
selected_row = self.ui.userTableWidget.currentRow()
if selected_row > -1:
selected_user_id = self.ui.userTableWidget.item(selected_row,
3).text()
self.userRegisterScreen.type = 1
self.userRegisterScreen.currentUser = self.userController.get_user_by_id(
str(selected_user_id))
self.userRegisterScreen.prepare_update(
self.userRegisterScreen.currentUser)
self.userRegisterScreen.userRegisterFormScreen.exec_()
self.list_users()
def update_book_form(self):
selected_row = self.ui.bookTableWidget.currentRow()
if selected_row > -1:
selected_book_id = self.ui.bookTableWidget.item(selected_row,
3).text()
self.bookRegisterScreen.type = 1
self.bookRegisterScreen.currentBook = self.bookController.get_book_by_id(
str(selected_book_id))
self.bookRegisterScreen.prepare_update(
self.bookRegisterScreen.currentBook)
self.bookRegisterScreen.bookRegisterFormScreen.exec_()
self.list_books()
def register_user_form(self):
self.userRegisterScreen.type = 0
self.userRegisterScreen.clear_forms()
self.userRegisterScreen.userRegisterFormScreen.exec_()
self.list_users()
def register_book_form(self):
self.bookRegisterScreen.type = 0
self.bookRegisterScreen.clear_forms()
self.bookRegisterScreen.bookRegisterFormScreen.exec_()
self.list_books()
def search_users(self):
search_username = self.ui.usernameLineEdit.text()
search_name = self.ui.nameLineEdit.text()
search_surname = self.ui.surnameLineEdit.text()
self.current_user_queries = [
search_username, search_name, search_surname
]
self.list_users()
def search_books(self):
search_title = self.ui.titleLineEdit.text()
search_author = self.ui.authorLineEdit.text()
search_year = self.ui.yearLineEdit.text()
self.current_book_queries = [search_title, search_author, search_year]
self.list_books()
def released_color_change(self):
self.librarianHome.sender().setStyleSheet(
"QPushButton {\n"
"color: white;\n"
"background-color: QLinearGradient( x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #dd7a23, stop: 0.1 #e87919, stop: 0.49 #ce650a, stop: 0.5 #c45d03, stop: 1 #d16304);\n"
"font-size: 30px;\n"
"border-radius:10px;\n"
"}")
def pressed_color_change(self):
self.librarianHome.sender().setStyleSheet("QPushButton {\n"
"color: white;\n"
"background-color: red;\n"
"font-size: 30px;\n"
"border-radius:10px;\n"
"}")
def set_button_effects(self):
self.ui.logoutButton.released.connect(self.released_color_change)
self.ui.logoutButton.pressed.connect(self.pressed_color_change)
self.ui.userSearchButton.released.connect(self.released_color_change)
self.ui.userSearchButton.pressed.connect(self.pressed_color_change)
self.ui.userCreateButton.released.connect(self.released_color_change)
self.ui.userCreateButton.pressed.connect(self.pressed_color_change)
self.ui.userDeleteButton.released.connect(self.released_color_change)
self.ui.userDeleteButton.pressed.connect(self.pressed_color_change)
self.ui.userUpdateButton.released.connect(self.released_color_change)
self.ui.userUpdateButton.pressed.connect(self.pressed_color_change)
self.ui.bookSearchButton.released.connect(self.released_color_change)
self.ui.bookSearchButton.pressed.connect(self.pressed_color_change)
self.ui.bookDeleteButton.released.connect(self.released_color_change)
self.ui.bookDeleteButton.pressed.connect(self.pressed_color_change)
self.ui.bookCreateButton.released.connect(self.released_color_change)
self.ui.bookCreateButton.pressed.connect(self.pressed_color_change)
self.ui.bookResetButton.released.connect(self.released_color_change)
self.ui.bookResetButton.pressed.connect(self.pressed_color_change)
self.ui.bookUpdateButton.released.connect(self.released_color_change)
self.ui.bookUpdateButton.pressed.connect(self.pressed_color_change)
self.ui.userResetButton.released.connect(self.released_color_change)
self.ui.userResetButton.pressed.connect(self.pressed_color_change)
class UserRegisterFormView(Ui_userRegisterForm):
def __init__(self):
self.userRegisterFormScreen = QtWidgets.QDialog()
self.ui = Ui_userRegisterForm()
self.userController = UserController()
self.ui.setupUi(self.userRegisterFormScreen)
self.ui.registerButton.clicked.connect(self.register_user)
self.ui.cancelButton.clicked.connect(self.terminate)
self.error = errorView.ErrorView()
self.currentUser = None
self.type = 0 # 0 for create user 1 for update user
def show(self):
self.userRegisterFormScreen.show()
def terminate(self):
self.userRegisterFormScreen.hide()
def clear_forms(self):
self.ui.usernameLineEdit.setText("")
self.ui.passwordLineEdit.setText("")
self.ui.nameLineEdit.setText("")
self.ui.surnameLineEdit.setText("")
self.ui.emailLineEdit.setText("")
def prepare_update(self, user):
self.ui.usernameLineEdit.setText(user.username)
self.ui.passwordLineEdit.setText(user.password)
self.ui.nameLineEdit.setText(user.name)
self.ui.surnameLineEdit.setText(user.surname)
self.ui.emailLineEdit.setText(user.email_address)
def register_user(self):
username = self.ui.usernameLineEdit.text()
password = self.ui.passwordLineEdit.text()
name = self.ui.nameLineEdit.text()
surname = self.ui.surnameLineEdit.text()
email = self.ui.emailLineEdit.text()
validation_flag = 0
error_flag = 0
if self.type is 0:
for field in [username, password, name, surname, email]:
if len(field) == 0:
validation_flag = 1
if validation_flag is 0:
if self.userController.add_new_member(username, password, name, surname, email) is None:
self.error.set_error_text("Username already exists!")
error_flag = 1
self.error.errorScreen.exec_()
else:
self.error.set_error_text("Please fill the blank fields.")
self.error.errorScreen.exec_()
elif self.type is 1:
for field in [username, password, name, surname, email]:
if len(field) == 0:
validation_flag = 1
if validation_flag is 0:
self.userController.update_member([username, password, email, name, surname], self.currentUser)
else:
self.error.set_error_text("Please fill the blank fields.")
self.error.errorScreen.exec_()
if error_flag is 0:
self.userRegisterFormScreen.hide()
self.clear_forms()
def set_button_effects(self):
self.ui.registerButton.released.connect(self.released_color_change)
self.ui.registerButton.pressed.connect(self.pressed_color_change)
self.ui.cancelButton.released.connect(self.released_color_change)
self.ui.cancelButton.pressed.connect(self.pressed_color_change)
def released_color_change(self):
self.userRegisterFormScreen.sender().setStyleSheet("QPushButton {\n"
"color: white;\n"
"background-color: QLinearGradient( x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #dd7a23, stop: 0.1 #e87919, stop: 0.49 #ce650a, stop: 0.5 #c45d03, stop: 1 #d16304);\n"
"font-size: 30px;\n"
"border-radius:10px;\n"
"}")
def pressed_color_change(self):
self.userRegisterFormScreen.sender().setStyleSheet("QPushButton {\n"
"color: white;\n"
"background-color: red;\n"
"font-size: 30px;\n"
"border-radius:10px;\n"
"}")
class LoginView(Ui_Login):
def __init__(self):
self.login = QtWidgets.QDialog()
self.ui = Ui_Login()
self.ui.setupUi(self.login)
self.ui.loginButton.clicked.connect(self.user_login)
self.ui.searchButton.clicked.connect(self.guest_search)
self.userController = UserController()
self.error = errorView.ErrorView()
self.ui.loginButton.released.connect(self.released_color_change)
self.ui.loginButton.pressed.connect(self.pressed_color_change)
self.ui.searchButton.released.connect(self.released_color_change)
self.ui.searchButton.pressed.connect(self.pressed_color_change)
def show(self):
loan_controller = LoanController()
loan_controller.update_fines()
self.login.show()
def clear_login_forms(self):
self.ui.usernameText.setText("")
self.ui.passText.setText("")
def get_login_info(self):
return self.ui.usernameText.text(), self.ui.passText.text()
def guest_search(self):
self.login.hide()
self.ui = guestWindowView.GuestWindowView()
self.ui.show()
def user_login(self):
user, password = self.get_login_info()
if self.userController.authorization(user, password):
current_user = self.userController.get_user_by_username(user)
if current_user.type is "member":
self.login.hide()
self.ui = memberHomeView.MemberHomeView(current_user)
elif current_user.type is "librarian":
self.login.hide()
self.ui = librarianHomeView.LibrarianHomeView(current_user)
self.ui.show()
else:
self.error.set_error_text("Wrong username or password")
self.error.show()
self.clear_login_forms()
def released_color_change(self):
self.login.sender().setStyleSheet("QPushButton {\n"
"color: white;\n"
"background-color: QLinearGradient( x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #dd7a23, stop: 0.1 #e87919, stop: 0.49 #ce650a, stop: 0.5 #c45d03, stop: 1 #d16304);\n"
"font-size: 30px;\n"
"border-radius:10px;\n"
"}")
def pressed_color_change(self):
self.login.sender().setStyleSheet("QPushButton {\n"
"color: white;\n"
"background-color: red;\n"
"font-size: 30px;\n"
"border-radius:10px;\n"
"}")
def login():
from controllers.UserController import UserController
return UserController.login()
def post(self):
data = parser.parse_args()
userController = UserController()
user_info = userController.findByUsername(data["username"])
return user_info.__dict__
from flask import Flask, session, redirect, url_for, render_template, request, jsonify
import os, string, random, simplejson
from datetime import timedelta
from controllers.UserController import UserController
from controllers.AccountController import AccountController
app = Flask(__name__)
app.config.from_object(os.environ['APP_SETTING'])
app.permanent_session_lifetime = timedelta(seconds=86400)
user = UserController()
account = AccountController()
## home page
@app.route('/')
def index():
try:
if session['logged_in'] == True:
return redirect(url_for('viewAccounts'))
except KeyError:
return render_template('index.html')
## dashboard
@app.route('/dashboard/<account_id>', methods=['GET'])
def dashboard(account_id):
try:
if session['logged_in'] == True:
meta_data = account.getAccountData(session['username'], account_id)
if not meta_data:
return render_template('dashboard.html', error="This account is not associated with this user!")
def __init__(self):
self.client = DbClient.Instance()
self.userController = UserController()
self.bookController = BookController()
class LoanController:
def __init__(self):
self.client = DbClient.Instance()
self.userController = UserController()
self.bookController = BookController()
def checkout_book(self, user, book):
if user.currentFine is not 0:
return 0
elif len(user.loanedBooks) >= 4:
return 1
else:
user.loanedBooks.append(book.id)
if book.id in user.waitingBooks:
user.waitingBooks.remove(str(book.id))
book.isAvailable = False
user.totalLoanedBooks = user.totalLoanedBooks + 1
user.lastLoanedBook = book.title
self.userController.update_member_attributes(user)
self.bookController.update_book_attributes(book)
new_loan = Loan(str(user.id), str(book.id))
self.client.add_loan_record(new_loan)
return 2
def return_book(self, user, book):
loan_info = self.get_loan_record(str(book.id))
existing_loan = Loan(str(loan_info["user_id"]),
str(loan_info["book_id"]))
existing_loan.startDate = loan_info["startDate"]
existing_loan.returnDate = loan_info["returnDate"]
existing_loan.check_status()
self.update_loan_attributes(existing_loan)
user.loanedBooks.remove(str(book.id))
book.isAvailable = True
user.formerFine = user.formerFine + existing_loan.currentFine
self.client.delete_loan_record(str(book.id))
self.bookController.update_book_attributes(book)
self.userController.update_member_attributes(user)
self.update_fines()
self.available_notification(book)
def available_notification(self, returned_book):
mail_client = MailClient()
for waiting_user_id in returned_book.waitingList:
waiting_user = self.userController.get_user_by_id(
str(waiting_user_id))
_thread.start_new_thread(
mail_client.send_email,
(waiting_user.username, waiting_user.email_address,
returned_book.title))
# mail_client.send_email(waiting_user.username,waiting_user.email_address,returned_book.title)
def get_loan_record(self, book_id):
return self.client.find_loan_record(str(book_id))
def instantiate_loan(self, loan_info):
existing_loan = Loan(str(loan_info["user_id"]),
str(loan_info["book_id"]))
existing_loan.startDate = loan_info["startDate"]
existing_loan.returnDate = loan_info["returnDate"]
return existing_loan
def update_fines(self):
self.reset_fines()
loans = self.client.db.loans.find({})
for loan in loans:
existing_loan = self.instantiate_loan(loan)
existing_loan.check_status()
self.update_loan_attributes(existing_loan)
existing_user = self.userController.get_user_by_id(
str(existing_loan.user_id))
existing_user.currentFine = existing_user.currentFine + existing_loan.currentFine
self.userController.update_member_attributes(existing_user)
def reset_fines(self):
current_users = self.client.search_user_db("", "", "")
for person in current_users:
user_op = self.userController.get_user_by_id(str(person["_id"]))
user_op.currentFine = user_op.formerFine
self.userController.update_member_attributes(user_op)
def delete_user_from_loans(self, user_id):
loans = self.client.db.loans.find({})
for loan in loans:
if loan["user_id"] == user_id:
op_book = self.bookController.get_book_by_id(
str(loan["book_id"]))
op_book.isAvailable = True
self.bookController.update_book_attributes(op_book)
self.client.delete_loan_record(str(loan["book_id"]))
def delete_book_from_loans(self, book_id):
loans = self.client.db.loans.find({})
for loan in loans:
if loan["book_id"] == book_id:
self.client.delete_loan_record(str(loan["book_id"]))
def update_loan_attributes(self, loan):
self.client.update_loan_attributes_db(loan)
def reset_user_loans(self, user_id):
loans = self.client.db.loans.find({})
for loan_info in loans:
if loan_info["user_id"] == user_id and loan_info["status"] == 1:
updated_loan = self.instantiate_loan(loan_info)
updated_loan.startDate = datetime.datetime.now(
) - datetime.timedelta(days=40)
updated_loan.check_status()
self.update_loan_attributes(updated_loan)
def check_if_token_in_blacklist(decrypted_token):
jti = decrypted_token["jti"]
return UserController.tokenIsBlacklisted(jti)
def register():
from controllers.UserController import UserController
return UserController.createAccount()
