def post(self, topic_id):
session = Session()
roles = oidc.user_getfield('cognito:groups') if oidc.user_getfield(
'cognito:groups') else []
username = oidc.user_getfield('username')
kargs = request.get_json(silent=True)
if not kargs.get('desc'):
json_abort(400, "desc missing")
topic = session.query(Topic).get(topic_id)
if not topic:
json_abort(404)
now = datetime.datetime.now()
if topic.start_time <= now:
json_abort(403, "Voting already started. No changes allowed")
grant = session.query(RoleGrant).filter(
RoleGrant.topic_id == topic_id).filter(
RoleGrant.role.in_(roles)).all()
logger.debug("{}, {}, {}".format(topic.user, username,
topic.user != username))
if topic.user != username and 'admin' not in roles and not grant:
json_abort(403)
option = TopicOption(**kargs)
option.topic_id = topic_id
session.add(option)
session.commit()
logger.debug(option.to_dict())
session = Session()
if not oidc.is_api_request():
url = url_for('api_topic', id=topic_id)
data = {"url": url, "message": "Success. Redirecting to %s" % url}
return jsonify(data)
return jsonify(option)
def get(self, ws_id):
session = Session()
ws = session.query(Workspace).get(int(ws_id))
labeled = get_labeled(session, ws)
pages = list(session.query(Page).filter_by(workspace=ws.id))
ws_data = {
'id': ws.id,
'name': ws.name,
'pages': [
{'id': page.id,
'url': page.url,
'labeled': {
selector: label['text']
for selector, label in labeled.get(page.url, {}).items()},
} for page in pages],
}
with tempfile.NamedTemporaryFile('wb', delete=False) as tempf:
with zipfile.ZipFile(tempf, mode='w') as archive:
archive.writestr('meta.json', json.dumps(ws_data, indent=True))
for page in pages:
save_page_for_offline(archive, session, page)
try:
with open(tempf.name, 'rb') as f:
contents = f.read()
finally:
os.unlink(tempf.name)
self.set_header('Content-Disposition',
'attachment; filename="workspace_{}.zip"'.format(ws.id))
self.set_header('Content-Type', 'application/zip')
self.write(contents)
def put(self, id):
session = Session()
username = oidc.user_getfield('username')
topic = session.query(Topic).get(id)
if topic:
now = datetime.datetime.now()
if topic.start_time <= now and now <= topic.end_time:
json_abort(403)
if topic.user != username:
json_abort(403)
kargs = request.get_json(silent=True)
logger.debug(kargs)
fields = Topic.get_form_fields()
for field in fields:
if kargs.get(field):
setattr(topic, field, kargs[field])
now = datetime.datetime.now()
minimum = datetime.timedelta(minutes=5)
if kargs.get('start_time') and (parse(kargs.get('start_time'), yearfirst=True) - now) < minimum:
json_abort(400, "You can't edit a topic 5 minutes before start.")
if topic.start_time >= topic.end_time:
json_abort(400, "End time can not be less than Start time.")
session.commit()
if not oidc.is_api_request():
url = url_for('api_topic', id=int(id))
data = { "url": url, "message": "Success. Redirecting to %s" % url }
return jsonify(data)
return jsonify(topic)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--debug', action='store_true')
parser.add_argument('--echo', action='store_true')
parser.add_argument('--port', type=int, default=8000)
args = parser.parse_args()
app = Application(
[URLSpec(r'/', MainHandler, name='main'),
URLSpec(r'/workspace/', WorkspaceListHandler, name='ws_list'),
URLSpec(r'/workspace/(\d+)/', WorkspaceHandler),
URLSpec(r'/label/', LabelHandler, name='label'),
URLSpec(r'/export/(\d+)/', ExportHandler, name='ws_export'),
URLSpec(r'/proxy/(\d+)/', ProxyHandler, name='proxy'),
],
debug=args.debug,
static_prefix='/static/',
static_path=str(STATIC_ROOT),
)
engine = create_engine(
'sqlite:///{}'.format(ROOT / 'db.sqlite'), echo=args.echo)
Session.configure(bind=engine)
Base.metadata.create_all(engine)
logging.info('Listening on port {}'.format(args.port))
app.listen(args.port)
tornado.ioloop.IOLoop.current().start()
def root(session):
user = None
user_id = session.get("user_id")
if (user_id):
user = Session().query(User).filter(User.id == user_id).first()
return br.render_html(br.BaseLayout(
{"current_user": user and user.to_dict()}, [br.Home({})]),
title="Grappling Mind Mapper")
def save(self, data):
if not SAVE_TO_DB:
return
session = Session()
# if not session.query(Item).filter_by(title=data['title']).first():
obj = Item(**data)
session.add(obj)
session.commit()
def get(self):
session = Session()
records = session.query(Countries).all()
countries = [record.get_as_dict() for record in records]
response = dict(data=countries)
return response, 200
def get(self):
session = Session()
records = session.query(Countries).all()
countries = [record.get_as_dict() for record in records]
response = dict(data=countries)
return response, 200
def get(self, ws_id):
session = Session()
ws = session.query(Workspace).get(int(ws_id))
labeled = get_labeled(session, ws)
ws_data = {
'id': ws.id,
'name': ws.name,
'labels': [label.text for label in
session.query(Label).filter_by(workspace=ws.id)],
'urls': [page.url for page in
session.query(Page).filter_by(workspace=ws.id)],
'labeled': labeled,
}
self.write(ws_data)
def get(self):
session = Session()
records = session.query(Cities).all()
cities = list()
for record in records:
city = dict()
city["id"] = record.gid
city["name"] = record.name
cities.append(city)
response = dict(data=cities)
return response, 200
async def list_submissions(course_id: int,
activity_id: str,
token: str = Form(...)):
s = Session()
prof = validate_user(s, token, True)
all_submissions = s.query(Submission.content, User.lms_user) \
.join(Submission.sender) \
.filter(Submission.activity.has(course_id=course_id)) \
.filter(Submission.activity.has(course_specific_id=activity_id)) \
.all()
all_submissions = [r._asdict() for r in all_submissions]
return all_submissions
def SAP_process_table(table, fields, options, columns_dict, model):
session = Session()
df = SAP_get_table(table, fields, options)
df.rename(columns=columns_dict, inplace=True)
session.execute(model.__table__.insert(), df.to_dict(orient="records"))
session.commit()
session.close()
return df
def toggle_complete(task_id):
session = Session()
if request.method == 'POST':
task = session.query(Task).filter_by(id=task_id).all()[0]
task.is_complete = not task.is_complete
session.commit()
return redirect('/')
def Add_Stock():
res = requests.get('http://isin.twse.com.tw/isin/C_public.jsp?strMode=2')
df = pd.read_html(res.text)[0]
df = df.drop([0, 1]).reset_index() # 刪除"股票"列
df = df.drop('index', axis=1)
df = df.iloc[:946, :1] # 946列是股票9958最後一檔
df[0] = df[0].map(lambda x: x.replace(' ', ' '))
df['id'] = df[0].map(lambda x: x.split(' ')[0])
df['name'] = df[0].map(lambda x: x.split(' ')[1])
objects = list()
for _, data in df.iterrows():
objects.append(dict(id=data['id'], name=data['name']))
Session.bulk_insert_mappings(Stock, objects)
Session.commit()
def Print():
Base.metadata.create_all(engine)
session2 = Session()
# 将 ./User_Files/To_Print/ 中的文件名导入到预打印日志中
cmd = "ls -t ./User_Files/To_Print/ > ./log/ToPrint_filename"
subprocess.call(cmd, shell=True)
ToPrint = open("./log/ToPrint_filename", 'r+')
direction_option = "" # 打印方向参数
for line in ToPrint:
printed_order = session2.query(Order).filter(
Order.File_Dir == line[:-1]) # 查询当前打印订单对象
if printed_order.Print_Direction == 2:
direction_option = "-o landscape"
try:
# 开始尝试打印
print_cmd = 'lp -d {} -n {} -o fitplot {} ./User_Files/To_Print/{}'.format(
Printer_Name, printed_order.Print_Copies, direction_option,
line[:-1])
returnCode = subprocess.call(print_cmd, shell=True)
if returnCode != 0:
error = commands.getoutput(print_cmd)
raise IOError(error)
except Exception as e:
# 捕获错误，并将错误写入错误日志中
with open('./log/print_error_log', 'a') as f:
f.write(
str(datetime.datetime.now()) + " " + line[:-1] + " " +
str(e) + "\n")
else:
# 将打印成功的文件移动到 ./User_Files/Finished_Print 这个目录中
subprocess.call(
'mv ./User_Files/To_Print/{} ./User_Files/Finished_Print/'.
format(line[:-1]),
shell=True)
# 在数据库中修改打印状态为3，表示已经打印
printed_order.Print_Status = 3
session2.commit()
# session2.close()
# 在./log/print_access_log 中写入打印成功日志
with open('./log/print_access_log', 'a') as f:
f.write(
str(datetime.datetime.now()) + " " + line[:-1] + " " +
"Successfully-Added-To-Printer")
class IssueBook(QWidget):
session = Session()
def __init__(self):
super().__init__()
self.title = "Admin Panel"
self.width = 640
self.height = 400
self.top = 100
self.left = 100
self.initUI()
def initUI(self):
self.lblIssuedTo = QLabel(self)
self.lblIssuedTo.setText("Issued To")
self.lblIssuedTo.move(180, 100)
self.lblBook = QLabel(self)
self.lblBook.setText("Book")
self.lblBook.move(180, 130)
self.issuedTo = QComboBox(self)
self.issuedTo.move(220, 100)
self.populateUsers(self.issuedTo)
self.Book = QComboBox(self)
self.Book.move(220, 130)
self.populateBooks(self.Book)
self.saveBtn = QPushButton("Issue Book", self)
self.saveBtn.move(250, 200)
self.saveBtn.clicked.connect(self.saveIssue)
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.show()
def populateUsers(self, combobox):
users = self.session.query(User).filter(User.role == "Student")
for user in users:
combobox.addItem(user.username)
def populateBooks(self, combobox):
books = self.session.query(Book).all()
for book in books:
combobox.addItem(book.name)
def saveIssue(self):
issued_to = self.session.query(User).filter(
User.username == self.issuedTo.currentText()).first()
book = self.session.query(Book).filter(
Book.name == self.Book.currentText()).first()
try:
issued = Issue(issued_to.id, book.id)
self.session.add(issued)
self.session.commit()
except:
print("An error occured")
def login_submit(session):
username = bottle.request.json["username"]
password = bottle.request.json["password"]
user = Session().query(User).filter_by(username=username).first()
if (user is None):
return {
"success": False,
"error_message": "no user with username: "******"user_id"] = user.id
return {"success": True}
else:
return {"success": False, "error_message": "invalid password"}
def test_validation_should_succeed_when_all_required_fields_present(self):
session = Session(dbname, transactional=False)
obj = Sample(session)
obj['field1'] = 'something'
obj['field2'] = 'something else'
obj.save() # no exception should be raised here
obj2 = Sample(session, retrieve={'field1': 'something'})
self.assertEqual(obj.committed, obj2.committed)
def clear_complete():
session = Session()
if request.method == 'POST':
for task in session.query(Task).filter_by(is_complete=True).all():
if (task.is_complete):
session.delete(task)
session.commit()
return redirect('/')
def post(self):
session = Session()
data = json.loads(self.request.body.decode('utf8'))
if data.get('id'):
workspace = session.query(Workspace).get(data['id'])
else:
workspace = Workspace()
workspace.name = data.get('name', '')
session.add(workspace)
session.commit()
workspace.update_labels(session, data['labels'])
workspace.update_urls(session, data['urls'])
session.commit()
self.write({'id': workspace.id})
def user(session, slug):
current_user = None
current_user_id = session.get("user_id")
sa_session = Session()
if (current_user_id):
current_user = sa_session.query(User).filter(
User.id == current_user_id).first()
user_being_viewed = sa_session.query(User).filter(
func.lower(User.slug) == func.lower(slug)).first()
if (not user_being_viewed):
bottle.abort(404, "URL Not Found")
return br.render_html(br.BaseLayout(
{"current_user": current_user and current_user.to_dict()},
[br.UserPage(props)]),
title="Grappling Mind Mapper")
class EditBookUI(QWidget):
session=Session()
def __init__(self):
super().__init__()
self.title = 'Edit Book'
self.left = 30
self.top = 30
self.width = 500
self.height = 500
self.editWindow=editpopup()
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.createTable()
# Add box layout, add table to box layout and add box layout to widget
self.layout = QVBoxLayout()
self.layout.addWidget(self.tableWidget)
self.setLayout(self.layout)
# Show widget
def createTable(self):
books=self.session.query(Book).all()
print(len(books))
# Create table
self.tableWidget = QTableWidget()
self.tableWidget.setRowCount(len(books)+1)
self.tableWidget.setColumnCount(4)
self.tableWidget.setItem(0,0, QTableWidgetItem("Id"))
self.tableWidget.setItem(0,1, QTableWidgetItem("Book Name"))
self.tableWidget.setItem(0,2, QTableWidgetItem("Author"))
self.tableWidget.setItem(0,3, QTableWidgetItem("Action"))
for i in range(len(books)):
self.tableWidget.setItem(i+1,0,QTableWidgetItem(str(books[i].id)))
self.tableWidget.setItem(i+1,1,QTableWidgetItem(books[i].name))
self.tableWidget.setItem(i+1,2,QTableWidgetItem(books[i].author))
self.tableWidget.setItem(i+1,3,QTableWidgetItem("Edit"))
self.tableWidget.move(0,0)
# table selection change
self.tableWidget.doubleClicked.connect(self.on_click)
def on_click(self):
print("\n")
for currentQTableWidgetItem in self.tableWidget.selectedItems():
if(currentQTableWidgetItem.text()=="Edit"):
row=currentQTableWidgetItem.row()
item=self.tableWidget.item(row, 0)
result=self.session.query(Book).filter(Book.id==item.text()).first()
#pass the value to the edit window
self.editWindow.setValues(result.id,result.name,result.author)
self.editWindow.show()
def get(self, id):
"""Get city by ID and return as unique resource.
For example:
http://localhost:5000/api/cities/1
:param id {int}: unique id of the city to return
:return:
"""
session = Session()
city = session.query(Cities).get(id)
if city:
response = dict(data=city.get_as_dict())
else:
return "City with id={} does not exist!".format(id), HTTP_NOT_FOUND_CODE
return response, HTTP_OK_CODE
def get_labeled(session: Session, ws: Workspace) -> Dict:
labeled = {}
for element_label, page_url, label_text in (
session.query(ElementLabel, Page.url, Label.text).join(Page)
.filter(Page.workspace == ws.id)
.all()):
labeled.setdefault(page_url, {})[element_label.selector] = {
'selector': element_label.selector,
'text': label_text,
}
return labeled
def index():
session = Session()
if request.method == 'POST':
task = Task(name=request.form['name'])
if task.name != "":
session.add(task)
session.commit()
return redirect('/')
else:
tasks = session.query(Task).all()
return render_template('index.html', tasks=tasks)
def save(self, data):
if not SAVE_TO_DB:
return
session = Session()
if not session.query(Item).filter_by(title=data['title']).first():
obj = Item(**data)
session.add(obj)
session.commit()
def get(self, id=None):
session = Session()
roles = oidc.user_getfield('cognito:groups') if oidc.user_getfield(
'cognito:groups') else []
username = oidc.user_getfield('username')
if id is not None:
grant = session.query(RoleGrant).get(id)
if grant:
if 'admin' not in roles and grant.topic.user != username:
abort(403)
logger.debug(grant)
return jsonify(grant)
else:
if 'admins' in roles:
grants = session.query(RoleGrant).all()
return jsonify(grants)
grants = session.query(
RoleGrant,
Topic).filter(RoleGrant.topic_id == Topic.id).filter(
Topic.user == username).all()
grants = [id for id, _ in grants]
return jsonify(grants)
class editpopup(QWidget):
user_id = ""
session = Session()
def __init__(self):
super().__init__()
self.title = "Edit Pop Up"
self.width = 500
self.height = 500
self.top = 100
self.left = 100
self.initUI()
def initUI(self):
self.username = QLineEdit(self)
self.username.move(200, 200)
self.password = QLineEdit(self)
self.password.move(200, 240)
self.password.setEchoMode(QLineEdit.Password)
self.role = QComboBox(self)
self.role.addItem("Student")
self.role.addItem("Librarian")
self.role.addItem("Admin")
self.role.move(200, 280)
self.savechanges = QPushButton("Save changes", self)
self.savechanges.move(250, 350)
self.savechanges.clicked.connect(self.updateValues)
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
def setValues(self, user_id, user_name, user_password, user_role):
self.user_id = user_id
self.username.setText(user_name)
self.password.setText(user_password)
self.role.setCurrentText(user_role)
def updateValues(self):
result = self.session.query(User).filter(
User.id == self.user_id).first()
result.username = self.username.text()
result.password = self.password.text()
result.role = self.role.currentText()
try:
self.session.add(result)
self.session.commit()
self.close()
except:
print("Error occured while saving")
def delete(self, id):
session = Session()
username = oidc.user_getfield('username')
grant = session.query(RoleGrant).get(id)
if not grant:
json_abort(404)
if not grant.topic.user == username:
json_abort(403)
session.delete(grant)
session.commit()
logger.debug(grant)
return jsonify(grant)
def Query():
# 查询排队方式为自动排队的订单
Base.metadata.create_all(engine)
session = Session()
All_Order = session.query(Order).filter(Order.Time_Way == 1).all()
if All_Order:
for i in range(len(All_Order)):
if All_Order[i].Print_Status == 1:
# 尝试下载订单中的文件
try:
url = "http://rooins.careyou.xin/static/Upload_Files/" + All_Order[
i].File_Dir
r = requests.get(url)
if r.status_code != 200: # 判断url若不是200，则记录错误到日志
raise IOError('{} {} {}'.format(
r.status_code, r.reason, r.url))
else:
with open(
'./User_Files/To_Print/' +
All_Order[i].File_Dir, 'wb') as f:
f.write(r.content)
except Exception as e:
# 将错误写入下载错误日志
with open('./log/download_error_log', 'a') as f:
f.write(
str(datetime.datetime.now()) + " " +
All_Order[i].File_Dir + " " + str(e) + "\n")
else:
# 将下载成功写入下载成功日志
with open("./log/download_log", "a") as f:
f.write(
str(datetime.datetime.now()) + " " +
All_Order[i].File_Dir + " " + "success-download" +
"\n")
# 在数据库中做出标记，文件已下载成功
All_Order[i].Print_Status = 2
finally:
session.commit()
class Login(QWidget):
session = Session()
def __init__(self):
super().__init__()
self.title = "Admin Panel"
self.width = 640
self.height = 400
self.top = 100
self.left = 100
self.adminPanelUI = AdminPanel()
self.initUI()
def initUI(self):
self.lblusername = QLabel(self)
self.lblpassword = QLabel(self)
self.lblusername.move(200, 100)
self.lblusername.setText("USERNAME")
self.lblpassword.move(200, 140)
self.lblpassword.setText("PASSWORD")
self.username = QLineEdit(self)
self.username.move(250, 100)
self.password = QLineEdit(self)
self.password.move(250, 140)
self.password.setEchoMode(QLineEdit.Password)
self.login = QPushButton("Login", self)
self.login.move(280, 300)
self.login.clicked.connect(self.onclick)
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.show()
def onclick(self):
user = self.session.query(User).filter(
User.username == self.username.text()).first()
print("User Exists")
if (user.password == self.password.text()):
role = user.role
print(role)
if (role == "Student"):
print("It is a student")
elif (role == "Librarian"):
print("Redirect to the librarian UI")
else:
self.adminPanelUI.show()
def process_input(header=True):
csv_file = open(tmp_file, 'r', encoding='utf-8')
csv_reader = None
try:
csv_reader = list(csv.reader(csv_file, delimiter=','))
except:
print("Error in opening csv file. Please check the format/encoding!!")
quit()
line_no = 0
if header:
line_no += 1
csv_reader = csv_reader[1:]
session = Session()
all_reviews = session.query(Review).all()
reviews_set = {(review.product_id, str(review.review_text).lower())
for review in all_reviews}
reviews_in_file = set()
print("Processing input file..")
for line in csv_reader:
line_no += 1
review_text = line[0]
product_id = line[4]
search_key = (product_id, str(review_text).lower())
if search_key in reviews_set:
print("Review at line: {} is already in db!!".format(line_no))
elif search_key in reviews_in_file:
print("Review at line: {} is duplicate in file!!".format(line_no))
else:
review_ob = Review(product_id, review_text)
session.add(review_ob)
reviews_in_file.add(search_key)
print("Committing data...")
session.commit()
session.close()
try:
# Remove downloaded file
os.remove(tmp_file)
except:
pass
