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
