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')