def addARequest(user_id):
if request.method == 'POST':
phone_no = request.json.get('phone_no')
delivery_state = request.json.get('delivery_state')
delivery_city = request.json.get('delivery_city')
item_location_state = request.json.get('item_location_state')
item_location_city = request.json.get('item_location_city')
posted_on = request.json.get('posted_on')
deliver_before = request.json.get('deliver_before')
picture = request.json.get('picture')
offer_amount = request.json.get('offer_amount')
time_updated = request.json.get('time_updated')
item_name = request.json.get('item_name')
user = session.query(User).filter_by(id=user_id).first()
profile_image = user.picture
user_first_name = user.first_name
user_last_name = user.last_name
user_id = user_id
newRequest = Request(phone_no=phone_no,
delivery_state=delivery_state,
delivery_city=delivery_city,
item_location_state=item_location_state,
item_location_city=item_location_city,
deliver_before=deliver_before,
posted_on=posted_on,
time_updated=time_updated,
profile_image=profile_image,
user_id=user_id,
user_first_name=user.first_name,
user_last_name=user.last_name,
item_name=item_name,
offer_amount=offer_amount,
picture=picture)
session.add(newRequest)
session.commit()
payload = {}
payload['profile_image'] = user.picture
payload['id'] = newRequest.id
payload['phone_no'] = phone_no
payload['delivery_state'] = delivery_state
payload['delivery_city'] = delivery_city
payload['item_location_state'] = item_location_state
payload['item_location_city'] = item_location_city
payload['deliver_before'] = deliver_before
payload['posted_on'] = posted_on
payload['offer_amount'] = offer_amount
payload['item_name'] = item_name
payload['time_updated'] = time_updated
payload['picture'] = picture
payload['user_id'] = user_id
payload['user_first_name'] = user_first_name
payload['user_last_name'] = user.last_name
raw = {"data": payload}
request_data = json.dumps(raw)
#result = push_service.notify_single_device(registration_id = reg_id, data_message= payload)
result = push_service.notify_topic_subscribers(
topic_name=REQUEST_TOPIC, data_message=payload)
pprint(result)
return request_data
def render_request_done():
# Если данные не были отправлены
if request.method != "POST":
abort(404)
# Если данные были отправлены
form = RequestForm()
if not form.validate_on_submit():
# отправляем форму назад
return render_template('request.html', form=form)
# получаем данные
client_name = form.clientName.data
client_phone = form.clientPhone.data
client_goal = form.clientGoal.data
client_time = form.clientTime.data
time = next((t[1] for t in form.clientTime.choices if t[0] == client_time),
-1)
goal = Goal.query.filter(Goal.code == client_goal).scalar()
request_t = Request(name=client_name,
phone=client_phone,
goal=goal.goal,
time=time)
db.session.add(request_t)
db.session.commit()
# переходим на request_done
return render_template('request_done.html',
clientName=client_name,
clientPhone=client_phone,
clientGoal=request_t.goal,
clientTime=request_t.time)
def multiple_valid_request_models(multiple_valid_client_models,
multiple_valid_staff_models):
"""
A fixture for creating a multiple valid requests.
Args:
multiple_valid_client_models (list): a list of valid client models
created by a fixture.
multiple_valid_staff_models (list): a list of valid staff models
created by a fixture.
"""
requests = [
Request(
title='Improve customer care services',
description='The current customer care services are reported to '
'be abysmal with representatives dropping calls on customer or '
'being rather unpleasant.',
product_area=ProductArea.POLICIES,
target_date=datetime.utcnow(),
priority=i,
staff_id=1,
client_id=1,
).save() for i in range(12)
]
return requests
def requestsEliminator(msgBody, reqer):
text = msgBody['Body'].lower()
numOfMedia = msgBody['NumMedia']
if numOfMedia == '0' and len(text) < 10: # change latter to 150
Request(requester=reqer, message=str(msgBody), status=99).save()
return True
return False
def request_from():
""" request money from a new Mutual Aid """
user_id = request.args.get('user_id', None)
situation = request.args.get('situation', None)
identities = request.args.get('identities', None)
amount = request.args.get('amount', None)
venmo_username = request.args.get('venmo_username', None)
#Keeping this here as a note to how to get the elements of the identity
#identities_array = re.split(', |,',identities)
user = User.query.filter_by(id=user_id).first()
if user is None:
return "Could not find a mutual aid by that id", 404
request_obj = Request(situation=situation,
identities=identities,
amount=amount,
user_id=user_id,
venmo_username=venmo_username)
db.session.add(request_obj)
db.session.commit()
#return the id so the requestor can search up their 'ticket' and know their progress
return jsonify(id=request_obj.id), 200
def test_request_account_not_found(self):
request = Request()
request.username = "******"
request.save()
twitterProfile = GetTwitterProfile(request)
request = Request.objects.latest()
self.assertEqual(request.status, "User not found")
def test_get_valid_profile1(self):
request = Request()
request.username = "******"
request.save()
twitterProfile = GetTwitterProfile(request)
self.assertEqual(twitterProfile.name,
"Mauricio Morero (@maurimorero) | Twitter")
def test_get_description(self):
request = Request()
request.username = "******"
request.save()
twitterProfile = GetTwitterProfile(request)
self.assertEqual(twitterProfile.description,
"Jugador de Boca Juniors y Piola Vago frontman")
def add_request():
if request.method == 'POST':
data = request.get_json()
req1 = Request(day=data["daySelect"],
requester=data["requester"],
startTime=data["startTime"],
endTime=data["endTime"],
reason=data["reason"],
weekly=data["weekly"],
status=False)
db.session.add(req1)
db.session.commit()
print(Request.query.all())
req = Request.query.all()
newls = []
for i in range(len(req)):
newls.append({})
newls[i]["id"] = req[i].id
newls[i]["day"] = req[i].day
newls[i]["requester"] = req[i].requester
newls[i]["startTime"] = req[i].startTime
newls[i]["endTime"] = req[i].endTime
newls[i]["reason"] = req[i].reason
newls[i]["status"] = req[i].status
newls[i]["weekly"] = req[i].weekly
return json.dumps(newls)
def test_get_valid_profile2(self):
request = Request()
request.username = "******"
request.save()
twitterProfile = GetTwitterProfile(request)
self.assertEqual(twitterProfile.name,
"Diario Olé (@DiarioOle) | Twitter")
def test_create_django_response(self):
request = Request(path="/foo")
response = create_django_response(request)
self.assertEqual(response.status_code, 404,
"status code on create_django_response")
self.assertTrue("File not found" in response.content,
"content on create_django_response")
def save_request(request_data):
"""
Reorders entries for a client if priority already exists and
saves new request.
Args:
request_data (dict): request data to be saved.
"""
priority = request_data['priority']
client_id = request_data['client_id']
# Check for row with similar priority
request = Request.query.filter_by(client_id=client_id,
priority=priority).all()
# Update every duplicate we find.
while request:
# Increment priority.
priority += 1
# Check for row with the newly updated priority value.
new_request = Request.query.filter_by(client_id=client_id,
priority=priority).all()
# Update request with previous priority value.
request[0].update(priority=priority)
# Update request
request = new_request
Request(**request_data).save()
def test_request_account_suspended(self):
request = Request()
request.username = "******"
request.save()
twitterProfile = GetTwitterProfile(request)
request = Request.objects.latest()
self.assertEqual(request.status, "Account suspended")
def test_request_completed(self):
request = Request()
request.username = "******"
request.save()
twitterProfile = GetTwitterProfile(request)
request = Request.objects.latest()
self.assertEqual(request.status, "Completed")
def fetch_request(self, username):
cursor = self.conn.execute(
"""
SELECT * FROM request where status == 0 AND to_user = (?)""",
(username, ))
donations = []
consumptions = []
for row in cursor:
request_id = row[0]
from_user = row[1]
# to_user = row[2]
appointment_date = row[3]
appointment_time = row[4]
request_type = row[5]
beneficiary = row[6]
frequency = row[7]
description = row[8]
status = row[9]
create_date = row[10]
new_request = Request(from_user, username, appointment_date,
appointment_time, request_type, beneficiary,
frequency, description, status, create_date,
request_id)
if request_type == constants.REQUEST_DONATION:
donations.append(new_request)
else:
consumptions.append(new_request)
return donations, consumptions
def submit_donate_request():
if session['logged_in'] and request.method == 'POST':
from_user = session['username']
to_user = request.form['to_user']
appointment_date = request.form['date']
appointment_time = request.form['time']
request_type = constants.REQUEST_DONATION
beneficiary = request.form['beneficiary']
frequency = request.form['frequency']
description = request.form['description']
food_item_id = request.form['food_item_id']
category_id = request.form['category_id']
quantity = request.form['quantity']
weight = request.form['weight']
expiry_date = request.form['expiry_date']
new_request = Request(from_user, to_user, appointment_date,
appointment_time, request_type, beneficiary,
frequency, description,
constants.REQUEST_PENDING)
request_id = db.create_request_header(new_request)
new_request_detail = Request_Detail(request_id, food_item_id,
category_id, quantity, weight,
expiry_date)
db.create_request_detail_entry(new_request_detail)
return "succeed"
def authentication_request_get(message):
'''
This is the url that other system uses to redirect the user in order to authenticate them
'''
try:
message = JWS().verify_compact(message, keys=[public_key])
except BadSignature:
return "Signature invalid"
# todo check whether signed correctly raise BadSignature
satosa_request = Request(message)
user = database.get_user(satosa_request.userId)
if not database.request_exists(satosa_request):
database.save_request(satosa_request)
else:
return "REPLAY ATTACK"
if not user:
database.save_user(satosa_request.userId)
new_user = database.get_user(satosa_request.userId)
login_user(new_user)
return render_template('satosa_registration_index.html',
username1=satosa_request.userId,
redirect_url1=cfg['caller']['callback-url'])
if len(database.get_credentials(satosa_request.userId)) == 0:
new_user = database.get_user(satosa_request.userId)
login_user(new_user)
return render_template('satosa_registration_index.html',
username1=satosa_request.userId,
redirect_url1=cfg['caller']['callback-url'])
if cfg['host']['turn-off'] and database.is_turned_off(user.id):
database.turn_on(user.id)
login_user(user)
satosa_request = Request()
satosa_request.userId = user.id
database.make_success(satosa_request)
username = current_user.id
credentials_array = database.get_credentials(username)
return render_template("credentials.html",
credentials=credentials_array,
username1=username,
url=ORIGIN,
turn_off=cfg['host']['turn-off'],
timeout=int(
cfg['host']['turn-off-timeout-seconds']))
return render_template('satosa_index.html',
username1=satosa_request.userId,
redirect_url1=cfg['caller']['callback-url'])
def post(self):
data = request.get_json()
loggedInUser = User.query.filter_by(id=LOGGED_IN_USER).first()
req = Request(str(loggedInUser.id), str(data['driver']),
str(data['rating']))
db.session.add(req)
db.session.commit()
return
def test_get_imageURI(self):
request = Request()
request.username = "******"
request.save()
twitterProfile = GetTwitterProfile(request)
self.assertEqual(
twitterProfile.imageURI,
"https://pbs.twimg.com/profile_images/959194538182103041/q6heJEdD_400x400.jpg"
)
def api_request():
"""Send user's search request"""
request_text = request.values.get('request')
result = {
'ok': 1,
'request_id': -1
}
# create request_id in DB
try:
session_key = request.cookies.get('beaker.session.id')
# session_key = request.cookies.get('sessionid')
request_obj = Request(
request=request_text,
session=session_key
)
db.session.add(request_obj)
db.session.commit()
print("Created %s" % str(request_obj))
result['request_id'] = request_obj.id
except Exception as ex:
print(ex)
# associate all found results with this request_id
results = []
t = []
try:
t = translate(request_text)
except Exception as ex:
print("Translation failed: %s" % str(ex))
pg_conn = psycopg2.connect(
get_pg_connection_string(
app.config['DBHOST'],
app.config['DBNAME'],
app.config['DBUSER'],
app.config['DBPASS']))
cur = pg_conn.cursor()
if t and isinstance(t, str):
t = t.strip().replace('\n', ' ').replace('[1m', '').replace('[0m', '').replace('OOV', "'OOV' OR 1 = 1")
t = t.split(';')
results_count = float(len(t))
for i, r in enumerate(t):
if r:
results.append(Result(request_obj.id,
r,
results_count - float(i),
resolve_report_type(cur, r)))
for r in results:
db.session.add(r)
db.session.commit()
return jsonify(result)
def _parse_request(self, data):
request = Request()
for row in data:
request.id = row["id"]
request.nonce = row["nonce"]
request.time = row["time"]
request.userId = row["user_id"]
request.success = row["success"]
return request
def process_request(self, request):
data = {}
data['Path'] = request.path
data['Method'] = request.method
data['Meta'] = str(request.META)
req = Request(request=data)
if request.user.is_authenticated():
req.priority = 1
req.save()
return None
def index():
if request.headers.getlist("X-Forwarded-For"):
user_ip = request.headers.getlist("X-Forwarded-For")[0]
else:
user_ip = request.remote_addr
# user_ip = getrequest.remote_addr
req = Request(ip_address=user_ip)
db.session.add(req)
db.session.commit()
return render_template('home.html')
def test_login_as(self):
user = User.objects.create_user(username=TEST_USER,
password=TEST_PASS,
email=TEST_USER)
request = Request(path="/foo", login_as_user=user)
request.save()
response = create_django_response(request)
self.assertTrue(response.context["user"].is_authenticated())
def request_page():
form_request = RequestForm()
if form_request.validate_on_submit():
request_goal = int(form_request.request_goal.data)
request_client_name = form_request.request_client_name.data
request_client_tel = form_request.request_client_tel.data
request_new = Request(name=request_client_name, phone=request_client_tel, goal_id=request_goal)
db.session.add(request_new)
db.session.commit()
return redirect(url_for('search_result_page'))
return render_template('pick.html', form_request=form_request)
def add_request():
date = request.json['date']
username = request.json['username']
book_id = request.json['book_id']
new_request = Request(date, username, book_id)
db.session.add(new_request)
db.session.commit()
return jsonify(new_request)
def add_req():
if request.method == 'POST':
db.session.add(
Request(request.form["spec"], request.form["flat"],
request.form["date"], request.form["comment"]))
db.session.commit()
return redirect("/req")
else:
return render_template("add_req.html",
flats=Flat.query.all(),
specs=Specialist.query.all())
def login():
# first check if this ip should be banned
r = Request.query.filter_by(request_addr=request.remote_addr).first()
if r == None:
r = Request(request_addr=request.remote_addr)
db.session.add(r)
db.session.commit()
else:
r.attempts += 1
should_ban = True if r.attempts > 3 else False
if should_ban:
r.banned_until = datetime.now() + timedelta(hours=1)
# remove the ban after 1 hour
oneHourInSecond = 1 * 60 * 60
threading.Timer(oneHourInSecond, remove_ban,
(request.remote_addr, )).start()
db.session.add(r)
db.session.commit()
if should_ban:
abort(403)
if current_user.is_authenticated:
return render_template(url_for('index'))
form = PNOForm()
if form.validate_on_submit():
pno = form.pno.data
user = User.get_by_pno(pno)
# user has registered before
if user is not None:
session['pno'] = pno
return redirect(url_for('login4'))
# no such user ever existed
else:
user = User(pno)
db.session.add(user)
db.session.commit()
# generate random for verification code
# not doing anything for now, reserved for future probably
rand = randint(1000, 9999)
flash('this is your verification code: {}'.format(rand))
session['pno'] = pno
session['verif_code'] = rand
return redirect(url_for('login2'))
return render_template('index.html')
return render_template('login.html', form=form)
def request_post(post_id):
"""Update a post if the current user is the author."""
db_session = current_app.config["db_session"]
post = db_session.query(Referral).filter(Referral.id_ == post_id).first()
user = db_session.query(User).filter(User.id_ == session.get("user_id")).first()
if post is None:
abort(404)
if user.id_ == post.user_id:
abort(405)
req = Request(user.id_, post_id)
db_session.add(req)
db_session.commit()
return redirect(url_for('post.view', id=post.id_))
def accept_request():
accepted_data = request.json
new_request = Request(district=accepted_data.get('district'),
street=accepted_data.get('street'),
volunteer=accepted_data.get('volunteer'),
address=accepted_data.get('address'),
name=accepted_data.get('name'),
surname=accepted_data.get('surname'),
phone=accepted_data.get('phone'),
text=accepted_data.get('text'))
db.session.add(new_request)
db.session.commit()
return jsonify({'status': 'success'}), 201, {
"Location": f"/helpme/{new_request.id}"
}
