def reg_user():
email = request.form['email']
password = request.form['password']
md5 = hashlib.md5()
md5.update(password.encode("UTF-8"))
user = User.query.filter_by(email=email).first()
if not user:
new_user = User(email, md5.hexdigest())
try:
db.session.add(new_user)
db.session.commit()
auth_token = new_user.encode_auth_token()
if auth_token:
return Response(auth_token, True, 0).to_json()
return Response("Error generating token", False,
ErrorCodes.generateTokenError).to_json()
except (SQLAlchemyError, DBAPIError) as e:
return Response.error_json(e, ErrorCodes.internalError)
else:
return Response('User already exists', False,
ErrorCodes.userAlreadyExists).to_json()
def set_mark_null_book(book_id, token):
try:
user_id = User.decode_auth_token(token)
set_mark_book(book_id, user_id, None)
return Response.success_json()
except SQLAlchemyError as e:
return Response.error_json(e)
except ExpiredSignatureError:
return Response.expired_token_json()
except InvalidTokenError:
return Response.invalid_token_json()
def push():
resp = check_mime()
if resp.code.value:
return resp.build()
user = User.query.filter_by(id=current_identity.id).scalar()
if not user:
return Response(Code.InternalError,
error='无Token对应用户，但是Token有效，用户可能已被删除，请重新注册！').build()
user.record = str(request.json)
db.session.add(user)
db.session.commit()
return Response(Code.OK, data=f'成功更新 {user.username} 的通讯录！').build()
def submit(request, uuid, form_id):
form = get_object_or_404(Form, uuid=uuid, form_id=form_id)
resp = Response(form=form, name="John Doe", email="*****@*****.**")
# name=request.POST["name"],
# email=request.POST["email"],
resp.save()
for field in form.fields.all():
fieldresp = FormFieldResponse(
form_field=field, response=resp, content=request.POST[str(field.pk)]
)
fieldresp.save()
return redirect("submitted", form.uuid, form.form_id)
def register():
resp = check_mime()
if resp.code.value:
return resp.build()
username, password = request.json.get('username'), request.json.get(
'password')
if not all([username, password]):
return Response(Code.InvalidRequest, error='请求数据缺少用户名或密码！').build()
user = User.query.filter_by(username=username).scalar()
if user:
return Response(Code.UsernameRegistered, error='用户名已被注册！').build()
user = User(username=username, password=password)
db.session.add(user)
db.session.commit()
return Response(Code.OK, data='成功注册！').build()
def get_like_status_book(book_id, token):
try:
user_id = User.decode_auth_token(token)
user_and_book = UsersAndBooks \
.query \
.filter(UsersAndBooks.user_id == user_id, UsersAndBooks.book_id == book_id) \
.first()
data = {'mark': user_and_book.mark, 'bookID': book_id}
return jsonify(data)
except SQLAlchemyError as e:
return Response.error_json(e)
except ExpiredSignatureError:
return Response.expired_token_json()
except InvalidTokenError:
return Response.invalid_token_json()
def send_request(check, timeout):
"""Send an HTTP GET request for a check."""
start_time = datetime.utcnow()
try:
r = requests.get(check.url, timeout=timeout)
status = Status.SUCCESS if r.status_code < 400 else Status.FAILURE
description = "HTTP {code}: {msg}".format(
code=r.status_code, msg=http.client.responses[r.status_code])
except ConnectionError:
status = Status.FAILURE
description = "Error: connection failed"
except Timeout:
status = Status.FAILURE
description = "Error: request timed out"
except TooManyRedirects:
status = Status.FAILURE
description = "Error: too many redirects"
except RequestException as e:
status = Status.FAILURE
description = "Unknown error: {}".format(str(e))
finally:
elapsed_ms = int(
(datetime.utcnow() - start_time).total_seconds() * 1000)
return Response(
check_id=check.id,
start_time=start_time,
elapsed_ms=elapsed_ms,
status=status,
description=description,
)
async def test_run_project_in_codebox(docker):
project_core = ProjectToRun(
sourcecode='print("Olá mundo!")\n',
language='python',
)
responses = await run_project_in_codebox(project_core)
assert responses == Response(stdout='Olá mundo!\n', stderr='', exit_code=0)
def rate(workshop_id):
workshop = Workshop.query.filter_by(id=workshop_id).first()
timediff = datetime.utcnow() - workshop.workshop_start
if workshop is None or timediff.days > 10:
flash('Workshop survey is not available at the moment!')
return redirect(url_for('index'))
form = SurveyForm()
form.workshop_id.data = workshop_id
if form.validate_on_submit():
response = Response(workshop_id=form.workshop_id.data,
difficulty=form.difficulty.data,
assistants_score=form.assistant.data,
knowledge=form.knowledgeable.data,
objectives=form.objective.data,
timeliness=form.time.data,
venue_score=form.venue.data,
satisfaction_score=form.satisfaction.data,
comments=form.comments.data)
db.session.add(response)
db.session.commit()
return render_template('response.html')
return render_template('survey.html',
form=form,
workshop_name=workshop.workshop_name,
workshop_category=workshop.workshop_category)
async def test_run_project(client: AsyncClient) -> None:
project = ProjectToRun(
sourcecode='print("Hello World!")\n',
language='python',
title='Hello World',
description='Classic first project',
)
logger.info('project not in cache')
resp = await client.post('/projects', json=project.dict())
assert resp.status_code == 200
data = resp.json()
assert data == {
'id': '7ded54706f0aefbd641bbbe452ecb174',
'stdout': 'Hello World!\n',
'stderr': '',
'exit_code': 0
}
# second call, the project must be in cache
with patch('app.routers.projects.run_project_in_codebox',
return_value=Response(**data)) as run_project_in_codebox:
logger.info('project must be in cache')
resp = await client.post('/projects', json=project.dict())
assert resp.status_code == 200
run_project_in_codebox.assert_not_awaited()
# third call: not in cache anymore, must call run_project_in_codebox
logger.debug('sleeping...')
sleep(config.TIMEOUT + config.TTL)
logger.info('project must not be in cache anymore')
resp = await client.post('/projects', json=project.dict())
assert resp.status_code == 200
run_project_in_codebox.assert_awaited()
def set_user_genres(token, genre_id):
try:
user_id = User.decode_auth_token(token)
user_and_genre = UsersAndGenres(user_id, genre_id)
db.session.add(user_and_genre)
db.session.commit()
return Response.success_json()
except IntegrityError:
return Response("Genre already exists", False,
ErrorCodes.genreAlreadyExists).to_json()
except SQLAlchemyError as e:
return Response.error_json(e)
except ExpiredSignatureError:
return Response.expired_token_json()
except InvalidTokenError:
return Response.invalid_token_json()
def create_response():
"""
Creates a response.
"""
form = ResponseForm()
print(request.get_json())
# Get the csrf_token from the request cookie and put it into the
# form manually to validate_on_submit can be used
form['csrf_token'].data = request.cookies['csrf_token']
if form.validate_on_submit():
response = Response(node_id=form.data['node_id'],
politic_id=form.data['politic_id'],
answer=form.data['answer'])
db.session.add(response)
db.session.commit()
return response.to_dict()
return 'invalid form'
def get_user_books(token):
try:
user_id = User.decode_auth_token(token)
user = User.query.get(user_id)
user_and_book_list = user.users_and_books
books = [
BookWithMarks(book.book, book.mark) for book in user_and_book_list
]
return BookWithMarks.schema.jsonify(books, True)
except SQLAlchemyError as e:
return Response.error_json(e)
except ExpiredSignatureError:
return Response.expired_token_json()
except InvalidTokenError:
return Response.invalid_token_json()
def add_user_book(book_id, token):
try:
user_id = User.decode_auth_token(token)
users_and_books = UsersAndBooks(user_id, book_id, None)
db.session.add(users_and_books)
db.session.commit()
return Response.success_json()
except IntegrityError:
return Response("Book already exists or not found.", False,
ErrorCodes.bookAlreadyExists).to_json()
except SQLAlchemyError as e:
return Response.error_json(e)
except ExpiredSignatureError:
return Response.expired_token_json()
except InvalidTokenError:
return Response.invalid_token_json()
def login_user():
email = request.form['email']
password = request.form['password']
md5 = hashlib.md5()
md5.update(password.encode("UTF-8"))
try:
user = User.query.filter_by(email=email).first()
if user is None or not user.password == md5.hexdigest():
return Response("Invalid email or password", False,
ErrorCodes.userNotFoundError).to_json()
auth_token = user.encode_auth_token()
if auth_token:
return Response(auth_token.decode(), True, 0).to_json()
except Exception as e:
print(e)
return Response.error_json(e, ErrorCodes.internalError)
def add(vouchers_id, description, status):
respObj = Response(
vouchers_id = vouchers_id,
description = description,
status = status,
timestamp = timestampNow())
db.session.add(respObj)
db.session.commit()
def check_book_for_user(token, book_id):
try:
user_id = User.decode_auth_token(token)
user_and_book = UsersAndBooks\
.query\
.filter(UsersAndBooks.book_id == book_id, UsersAndBooks.user_id == user_id)\
.first()
if user_and_book is not None:
data = {'result': True, 'bookID': book_id}
else:
data = {'result': False, 'bookID': book_id}
return jsonify(data)
except SQLAlchemyError as e:
return Response.error_json(e)
except ExpiredSignatureError:
return Response.expired_token_json()
except InvalidTokenError:
return Response.invalid_token_json()
def average_response(study):
card_positions_x = average_card_positions_x(study)
cards_positions_y = average_card_positions_y(study)
data_values = average_response_data_values(study)
average_response = Response(
data_values=data_values, card_positions=card_positions_x + cards_positions_y
)
return average_response
def seed_responses():
res1 = Response(node_id=1,
politic_id=1,
answer='Y')
res2 = Response(node_id=1,
politic_id=2,
answer='N')
res3 = Response(node_id=6,
politic_id=2,
answer='N')
db.session.add(res1)
db.session.add(res2)
db.session.add(res3)
db.session.commit()
def response():
"""Create a response."""
return Response(
id=1,
check_id=1,
start_time=datetime.utcnow(),
elapsed_ms=50,
status=Status.SUCCESS,
description="HTTP 200: OK",
)
def get_genre_recommend_books(token, page=1, coefficient=0.25):
try:
user_id = User.decode_auth_token(token)
user = User.query.get(user_id)
user_genres = user.genres
genres_id = [genre.id for genre in user_genres]
coefficients = Coefficient \
.query \
.filter(Coefficient.genre_id.in_(genres_id), Coefficient.value > coefficient) \
.distinct(Coefficient.book_id).paginate(page, BOOKS_PER_PAGE, False).items
books = [coefficient.book for coefficient in coefficients]
return Book.schema.jsonify(books, True)
except SQLAlchemyError as e:
return Response.error_json(e)
except ExpiredSignatureError:
return Response.expired_token_json()
except InvalidTokenError:
return Response.invalid_token_json()
def add_book():
name = request.form['name']
author = request.form['author']
description = request.form['description']
url = request.form.get('url')
coef_love = request.form['coef_love']
coef_fantastic = request.form['coef_fantastic']
coef_fantasy = request.form['coef_fantasy']
coef_detective = request.form['coef_detective']
coef_adventure = request.form['coef_adventure']
coef_art = request.form['coef_art']
try:
book = Book.query.filter_by(name=name).first()
if book is None or not book.author == author:
new_book = Book(name, author, description, url)
db.session.add(new_book)
db.session.flush()
love = Coefficient(new_book.id, LOVE_ID, coef_love)
fantastic = Coefficient(new_book.id, FANTASTIC_ID, coef_fantastic)
fantasy = Coefficient(new_book.id, FANTASY_ID, coef_fantasy)
detective = Coefficient(new_book.id, DETECTIVE_ID, coef_detective)
adventure = Coefficient(new_book.id, ADVENTURE_ID, coef_adventure)
art = Coefficient(new_book.id, ART_ID, coef_art)
db.session.add(love)
db.session.add(fantastic)
db.session.add(fantasy)
db.session.add(detective)
db.session.add(adventure)
db.session.add(art)
db.session.commit()
return Response.success_json()
else:
return Response(book_already_exists_message, False,
ErrorCodes.bookAlreadyExists).to_json()
except (SQLAlchemyError, DBAPIError) as e:
return Response.error_json(e)
def delete_user_book(token, book_id):
try:
user_id = User.decode_auth_token(token)
user_and_book = UsersAndBooks\
.query\
.filter(UsersAndBooks.user_id == user_id, UsersAndBooks.book_id == book_id)\
.first()
if user_and_book is not None:
UsersAndBooks.query.filter(
UsersAndBooks.user_id == user_id,
UsersAndBooks.book_id == book_id).delete()
db.session.commit()
return Response.success_json()
else:
return Response("Book not found", False,
ErrorCodes.bookNotFound).to_json()
except SQLAlchemyError as e:
return Response.error_json(e)
except ExpiredSignatureError:
return Response.expired_token_json()
except InvalidTokenError:
return Response.invalid_token_json()
def get_user_recommend_books(token):
try:
user_id = User.decode_auth_token(token)
user = User.query.get(user_id)
user_books_id = [book.id for book in user.books]
recommend_like_books = get_recommend_books(True, user_id,
user_books_id)
recommend_dislike_books = get_recommend_books(False, user_id,
user_books_id)
recommend_books = [
book for book in recommend_like_books
if book not in recommend_dislike_books
]
return Book.schema.jsonify(recommend_books, True)
except SQLAlchemyError as e:
return Response.error_json(e)
except ExpiredSignatureError:
return Response.expired_token_json()
except InvalidTokenError:
return Response.invalid_token_json()
class RequestHandler(tornado.web.RequestHandler):
def initialize(self):
self.response = Response()
self.set_header('Access-Control-Allow-Origin', '*')
self.set_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
self.set_header('Access-Control-Allow-Headers', 'Authorization')
def options(self):
self.set_status(200)
def _authenticate(self):
token = self.request.headers[
'Access-Token'] if 'Access-Token' in self.request.headers else ''
return False if token != os.environ['API_APP_ACCESS_TOKEN'] else True
def _send_response(self):
self.write(self.response.to_json().encode())
def convert_response(cards_x, cards_y, data_values):
dv = []
cp = []
cards_x_munch = munchify(cards_x)
cards_y_munch = munchify(cards_y)
data_values_munch = munchify(data_values)
for col, cards in cards_x_munch.items():
col_num = int(col.split("_")[1])
for card in cards:
card_db = Card.query.filter_by(id=card.id).first_or_404()
card_position = CardPosition(position=col_num, card=card_db)
cp.append(card_position)
for row, cards in cards_y_munch.items():
row_num = int(row.split("_")[1])
for card in cards:
card_db = Card.query.filter_by(id=card.id).first_or_404()
card_position = CardPosition(position=row_num, card=card_db)
cp.append(card_position)
for col_row, data_values in data_values_munch.items():
col_num = int(col_row.split("_")[1])
row_num = int(col_row.split("_")[3])
for data_value in data_values:
data_value_label = DataValueLabel.query.filter_by(
id=data_value.id).first_or_404()
if data_value.value is not None:
data_value = DataValue(
column=col_num,
row=row_num,
value=data_value.value,
data_value_label=data_value_label,
)
dv.append(data_value)
return Response(data_values=dv, card_positions=cp)
def submit_response(user, form):
'''Submit Question Response to Database'''
# Get the submitted Option
optID = form.get('option')
option = Option.query.filter_by(id=optID).first()
qnID = option.qnID
# Create a Response entry
response = Response(userID=user.id,optID=option.id,qnID=option.qnID)
# Save to DB
db.session.add(response)
db.session.commit()
# Update topic / overall proficiency
qn = Question.query.filter_by(id=qnID).first()
topicID = qn.topicID if qn.topicID else 1
if topicID > 1:
update_proficiency(user, topicID)
if qn.user.admin:
update_proficiency(user)
def __init__(self, stationId, resolution, observation_type, start, end):
"""
Call the class ( FtpFileFinder ) and it's Method FtpSearch at first, so that the
connection and the paths are ready to be used.
:param stationId: string *required
:param resolution: string *required
:param observation_type: string *required
:param start: Date time *not required
:param end: Date time *not required
"""
self.stationId = stationId
self.resolution = resolution
self.observation_type = observation_type
self.start = util.deserialize_datetime(start)
self.end = util.deserialize_datetime(end)
self.path_choices = FtpFileFinder().findFile(
self.generateWalkPathByResolutionAndStationId(),
r'.*' + self.stationId + '.*', r'^Meta_Daten.*')
self.response = Response()
self.response.observation_type = self.observation_type
self.response.resolution = self.resolution
self.response.station_id = self.stationId
self.response.timeseries = []
def check_user_genres(token):
try:
user_id = User.decode_auth_token(token)
user = User.query.get(user_id)
if len(user.genres) == 0:
return Response(USER_GENRES_CHECK_RESULT_MESSAGE, False,
0).to_json()
else:
return Response(USER_GENRES_CHECK_RESULT_MESSAGE, True,
0).to_json()
except IntegrityError:
return Response("Genre already exists", False,
ErrorCodes.genreAlreadyExists).to_json()
except SQLAlchemyError as e:
return Response.error_json(e)
except ExpiredSignatureError:
return Response.expired_token_json()
except InvalidTokenError:
return Response.invalid_token_json()
def initialize(self):
self.response = Response()
self.set_header('Access-Control-Allow-Origin', '*')
self.set_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
self.set_header('Access-Control-Allow-Headers', 'Authorization')
