def impression(): if len(request.args) == 5 and "sdk" in request.args and "user" in request.args: if saveImpression(request.args['user'],request.args['sdk']): return app.make_response(rv = jsonify(200)) else: return errors.bad_request("could not save impression") elif len(request.args) != 5 or not "sdk" in request.args or not "user" in request.args: return errors.bad_request("insufficient args")
def get_user_records(): if get_jwt_identity()['is_admin'] == 'admin': results = User().get_users() if results is not None: return make_response(jsonify(results = results), 200) else: return bad_request('There was an error in the retrieval of database records! Please try again.') else: return bad_request('Unauthorised!')
def getMaterialAmounts(): """ Retrieve material amounts for calculations """ if request.method == 'GET': layout_id = request.args.get('layout_id') layout = dbSession.query(Layout).filter( Layout.layout_id == layout_id).one() if layout is None: return bad_request('Layout does not exist') return jsonify(getMaterialAmount(layout)) return bad_request('Request is not a GET request')
def get_past_content(): platform = request.args.get('platform') search_string = request.args.get('search_string') current_platforms = ['All', 'Facebook', 'Twitter', 'Instagram', 'LinkedIn', 'User'] if platform is None or search_string is None: return bad_request('Invalid input!') elif platform not in current_platforms: return bad_request('Platform is not supported!') else: results = Link().get_past_content(platform, search_string) return make_response(jsonify(results = results), 200)
def view_past_records(): current_user = get_username_jwt() if current_user: try: startPage = int(request.args.get('start')) except: return bad_request("Error, invalid parameters!") past_submissions = Link.get_user_past_records(username = current_user, start = startPage) return make_response(jsonify(logged_in_as = current_user, past_submissions = past_submissions, page = startPage), 200) else: return bad_request('Please login to view this module!')
def ban_user(): current_user = get_jwt_identity() data = request.get_json() allowed_types = ['ban', 'unban'] if data['modifyTypes'] in allowed_types: user_to_ban = User().modify_user(username = current_user['username'], target_user = data['targetUser'], modify_type = data['modifyType']) if user_to_ban is not None: ban_unban = 'banned' if user_to_ban.is_banned is True else 'unbanned' return make_response(jsonify(results = f'{user_to_ban.username} is {ban_unban}!'), 201) # CRUD else: return bad_request('Invalid user!') else: return bad_request('Invalid parameters!')
def login(): data = request.get_json() if 'username' not in data or 'password' not in data: return bad_request('Username or password missing.') user, token = User.verify_identity(username = data['username'],password = data['password']) if user and token is not None: response = jsonify(message = f'Welcome {user.username}', token = token) response.status_code = 200 return response else: return bad_request('Username or password wrong.')
def delete_user_records(): user_records = request.get_json() if 'id' not in user_records: return bad_request('Please provide an ID!') if get_jwt_identity()['is_admin'] == 'admin': user_to_delete = User.delete_user_records(id = user_records['id']) if User.get_user(id = user_records['id']) is None: response = make_response(jsonify(message = "Success!"), 201) return response else: return bad_request('Invalid user!') else: return bad_request('Insufficient privileges')
def evaluate_link(): results = None url = request.get_json() try: url = str(url.get('search')).strip() if not url: # If the URL in the search parameter is blank return bad_request('Please enter a URL!') else: # We otherwise call the function to scrape the URLs results = scraper(url) except: #If the search parameter is not found, we throw an error return bad_request('Please check your parameters!') if results["is_valid"] is not True: return bad_request(results["text"]) # JWT based user details, we simply assign a default if user is not logged in # for this endpoint. current_user = get_username_jwt() if get_username_jwt() else 'Guest' if 'platform' in results and results["is_valid"]: # Check if the key is created by the scraper function # Only load models from disks if it not loaded to keep our overheads minimal. # The search in the locals and globals function ensure that the models are # only initialised once in the entire session if 'sentiment' in locals() or 'sentiment' in globals(): pass else: sentiment, log_model = load_models() # Commence analysis try: # Remove noise, and tokenize our text _text = remove_noise(word_tokenize(results['text'])) # Pull sentiment results using the model results['sentiment_result'] = sentiment.classify(dict([token, True] for token in _text)) _fraud_result = log_model.predict([results['text']]) # This is a binary classification model, but there is a predict_proba function through scikit # learn which permits us to get get the numerical probability of the fake or real news results['fraud_probab'] = max(log_model.predict_proba([results['text']])[0]) results['fraud_result'] = 'Fake' if _fraud_result[0] == 'fake' else 'Real' # We then use these results of the scraper and commit it into the DB added_link = Link.add_link(url = url, platform = results['platform'], text = results['text'],\ sentiment = results['sentiment_result'], fraud = results['fraud_result'],\ fraud_probability = results['fraud_probab'], username = current_user) return make_response(jsonify(results = results['text'], url = url, sentiment = results['sentiment_result'],\ fraud = results['fraud_result'], fraud_probability = results['fraud_probab'], \ id = added_link.id ), 200) except Exception as e: return bad_request(f'There has been an error evaluating your link, please validate your links again. Error: {e}')
def create_user(): data = request.get_json() if 'username' not in data or 'email' not in data or 'password' not in data: return bad_request('Must include username, email and password fields.') if User.query.filter_by(username=data['username']).first(): return bad_request('Username has already been taken.') if User.query.filter_by(email=data['email']).first(): return bad_request('Email has been previously registered.') if User.check_email(data['email']) is not None: User.add_user(username = data['username'], email = data['email'], password = data['password']) response = make_response(jsonify(message = "User registered!"), 201) return response else: return bad_request('Invalid email!')
def register(): data = request.get_json() or {} if len(data.keys()) == 0: return bad_request('no data provided') if User.query.filter_by(username=data['username']).first(): return bad_request('please use a different username') if User.query.filter_by(email=data['email']).first(): return bad_request('please use a different email') user = User() user.from_dict(data, new_user=True) db.session.add(user) db.session.commit() response = jsonify(user.to_dict()) response.status_code = 201 return response
def GetAd(): try: if len(request.args) == 5 and 'sdk' in request.args and "user" in request.args: req = sendRequest() if req:# XML in a VAST format in a json format if saveAdReqs(request.args['user'],request.args['sdk']): return app.make_response(rv = req) elif not req: return errors.error_response(412,"No XML VAST Retrived") elif len(request.args) != 5 or not "user" in request.args or not "sdk" in request.args: return errors.bad_request("wrong input in request or missing") except Exception as e: return errors.bad_request(str(e))
def edit_hat(username): hat = Hat.query.filter_by(username=username).first() if hat is None: return not_found() if g.current_user not in hat.users: logger.info( '{} попытался отредактировать {}, но не входит в список носителей шляпы' .format(g.current_user, hat)) return unauthorized() try: hat.display_name = request.json['display_name'] if request.json.get('add_user', '') is not '': u = User.query.filter_by(username=request.json['add_user']).first() if u is not None: hat.users.append(user) hat.about_me = request.json['about_me'] db_session.add(hat) db_session.commit() logger.info('{u} обновил шляпу {h}: {d}, {a}, {us}'.format( u=g.current_user, d=hat.display_name, a=hat.about_me, us=hat.users, h=hat)) except Exception as exc: logging.warn('Не получилось отредактировать шляпу {}: {}'.format( hat, exc)) return bad_request() return jsonify(hat=hat_schema.dump(hat))
def getStatusList(): """ Returns the list of statuses """ if request.method == "GET": statuses = dbSession.query(Status).all() if len(statuses) == 0: return bad_request("No statuses were found") return jsonify(statuses)
def update_user(username): user = Users.query.filter_by(username=username).first_or_404() data = request.get_json() or {} if 'username' in data and data['username'] != user.username and \ Users.query.filter_by(username=data['username']).first(): return errors.bad_request('please use a different username') if 'email' in data and data['email'] != user.email and \ Users.query.filter_by(email=data['email']).first(): return errors.bad_request('please use a different email address') for field in ['username', 'email', 'address']: if field in data: setattr(user, field, data[field]) if 'password_hash' in data: user.set_password(data['password_hash']) db.session.commit() return user_schema.jsonify(user)
def give_feedback(): current_user = get_username_jwt() if current_user is None: return bad_request('Please login to provide your feedback!') data = request.get_json() allowed_feedbacks = ['Neutral', 'Great', 'Poor'] if 'id' not in data or 'feedback_string' not in data: return bad_request('Feedback ID or feedback is missing.') elif data['feedback_string'] not in allowed_feedbacks: return bad_request('Invalid feedback!') else: feedback = Link().add_feedback(username = current_user, feedback_string = data['feedback_string'], id = data['id']) if feedback is None: return bad_request('Invalid feedback ID to feedback!') else: # Return 201 since CRUD is done return make_response(jsonify(message = f'Thank you for your feedback. {feedback.url} has been rated.'), 201)
def update_user_records(): new_records = request.get_json() if 'id' not in new_records: return bad_request('Please select an intended receipent!') elif 'email' not in new_records or 'is_admin' not in new_records: return bad_request('Please choose a field to update!') else: user_to_update = User.update_user_records(id = new_records['id'], email = new_records['email'], is_admin = new_records['is_admin']) user_privilege = get_jwt_identity()['is_admin'] if user_to_update is not None and user_privilege == 'admin': response = make_response(jsonify(message = "Success!"), 201) return response elif user_privilege != 'admin': return bad_request('Insufficient privileges!') else: return bad_request('Invalid user to target!')
def delete_subscription(username): u = g.current_user delu = Hat.query.filter_by(username=username).first() if delu is None: return bad_request('Нет такой шляпы') u.reader_feed.writer_feeds.remove(delu.writer_feed) db_session.add(u) db_session.commit() return jsonify(ok=True)
def create_user(): data = request.get_json() or {} if 'name' not in data or 'password' not in data: return bad_request('must include username and password fields') if User.query.filter_by(name=data['name']).first(): return bad_request('please use a different username') user = User(data["name"]) user.set_password(data["password"]) db.session.add(user) db.session.commit() response = jsonify(user.to_dict()) response.status_code = 201 response.headers['Location'] = url_for('get_user', id=user.id) return response
def post(self): data = request.get_json() or {} if 'username' not in data or 'email' not in data or 'password_hash' not in data: return errors.bad_request('must include username, email and password fields') if Users.query.filter_by(username=data['username']).first(): return errors.bad_request('please use a different username') if Users.query.filter_by(email=data['email']).first(): return errors.bad_request('please use a different email address') user = Users() for field in ['username', 'email', 'user_address']: if field in data: setattr(user, field, data[field]) if 'password_hash' in data: user.set_password(data['password_hash']) db.session.add(user) db.session.commit() response = user_schema.jsonify(user) response.status_code = 201 response.headers['Location'] = url_for('api.usersget', username=user.username) return response
def register(): try: registration = registration_schema.load(request.json) except ValidationError as exc: logger.info('Не получилось зарегистрироваться {}'.format(exc)) return bad_request('Не хватает полей') u = create_user(registration) token = u.get_token() db_session.add(token) db_session.commit() return jsonify(user=user_schema.dump(u), token=token_schema.dump(token))
def gen_invites(): u = g.current_user if u.can_have_more_invites(): invite = Invite() invite.generate_code() g.current_user.invites.append(invite) db_session.add(invite) db_session.commit() return jsonify(invite=invite_schema.dump(invite)) return bad_request('UNREDEEMED')
def get_records(): try: startPage = int(request.args.get('start')) return make_response(jsonify(results = Link.get_past_records(start = startPage), page = startPage),200) except: # We throw an error for when the parameters or results are invalid. Now, we can also create custom messages for # many other scenarios, but at a brevity point of view, we've decided to create a global catch-all instead. # For example, it is possible to check if the json input string comprises of the start parameter, # or if the Link module returns no results. However, since this is a fairly simplistic read operation, # defensive programming is not imperative (no pun intended) in this case. # We can always refer to our logfile if needed. return bad_request('Parameters are invalid!')
def update_user(user_id): user = User.query.get_or_404(user_id) data = request.get_json() or {} if 'name' in data and data['name'] != user.name and \ User.query.filter_by(name=data['name']).first(): return bad_request('please use a different username') user.name = data["name"] user.set_password(data["password"]) db.session.commit() return jsonify(user.to_dict())
def get_results(): results = Link.get_summarised_records() try: return make_response(jsonify(results = results), 200) except: # Note that since there has not been any errors with such a simple function, # we just maintain a global catch-all. And, in the unlikely event that there # should was an error, we will then go to our logfile and identify the error. # Checking for none for the function is illogical as it is essentially a # fetch, which well, fetches all of the records, and records can be empty. # The same concept is applied across all functions that involves a simple # get function. return bad_request('There has been an error, please try again')
def update_book_api(user_id, book_id): user = User.query.get_or_404(user_id) book = Book.query.get_or_404(book_id) data = request.get_json() or {} required_fields = ("name", "author", "pages_number") for field in required_fields: if field not in data.keys(): return bad_request("Must contain {} field".format(field)) book.name = data["name"] book.author = data["author"] book.pages_number = data["pages_number"] db.session.commit() return jsonify(book.to_dict())
def create_post(): p = new_post_schema.load(request.json) hat = Hat.query.filter_by(username=request.json['username']).first() if hat is None: hat = g.current_user.hats[0] if not hat.is_wearable_by(g.current_user): logger.info('Пользователь {} пытался запостить со шляпой {}'.format( g.current_user, hat)) return unauthorized('Не твоя шляпа') if p is not None: p.author = hat p.user = g.current_user p.writer_feed = hat.writer_feed db_session.add(p) db_session.commit() logger.info('Created post {}'.format(p)) notify_readers.delay(p.writer_feed.id, p.id) return jsonify(post=post_schema.dump(p)) return bad_request('Не тот формат')
def add_book_api(user_id): user = User.query.get_or_404(user_id) data = request.get_json() or {} required_fields = ("name", "author", "pages_number") for field in required_fields: if field not in data.keys(): return bad_request("Must contain {} field".format(field)) book = Book(data["name"], data["author"], data["pages_number"], user_id) db.session.add(book) db.session.commit() response = jsonify(book.to_dict()) response.status_code = 201 response.headers['Location'] = url_for('get_book_api', user_id=user_id, book_id=book.id) return response
def get_token(): try: p = pass_auth_schema.load(request.json) except ValidationError as exc: return bad_request() u = User.query.filter_by(username=p['username']).first() if u is None: return unauthorized('Не получилось залогиниться') if u.check_password(p['password']): token = u.get_token() token.expire_in_2_weeks() db_session.add(token) db_session.add(u) db_session.commit() return jsonify(token=token_schema.dump(token), username=u.username, user=user_schema.dump(u)) return unauthorized('Не получилось залогиниться')
def getAccountingSummary(): """ Returns a list of accounting related calculations """ if request.method == 'POST': year_filter = request.values.get('year') quotes = dbSession.query(Quote).filter( Project.company_name == current_user.company_name).filter( Project.status_name == 'Paid').filter( Project.finalize == True).filter( Quote.project_id == Project.project_id) # Filter Quotes by year if 0 is not given if year_filter != '0' and year_filter is not None: year_filter = int(year_filter) quotes = quotes.filter( extract('year', Project.end_date) == year_filter) quotes = quotes.order_by(Project.end_date).all() send = {"data": quotes} if len(quotes) == 0: return bad_request('no quotes were found') return jsonify(send) pass