def _process_restfood_account_information(userprofile,request,account_template):
password = _request_param_post(request, 'password')
mobile = _request_param_post(request, 'mobile')
office_place = _request_param_post(request, 'office_place')
office_landmark = _request_param_post(request, 'office_landmark')
office_area = _request_param_post(request, 'office_area')
office_zip = _request_param_post(request, 'office_zip')
from users.forms import AccountForm
accountform = AccountForm({'mobile':mobile,'password':password,
'home_place':userprofile.source.place,'home_landmark':userprofile.source.landmark,'home_area':userprofile.source.area,'home_zip':userprofile.source.zip,
'office_place':office_place,'office_landmark':office_landmark,'office_area':office_area,'office_zip':office_zip})
if not accountform.is_valid():
_add_errormsg(request, 'Please valid information in all the required fields')
return response(account_template,locals(),request)
password = accountform.cleaned_data.get('password')
print 'password:%s' % password
userprofile.set_password(password)
print 'password reset done'
mobile = accountform.cleaned_data.get('mobile')
userprofile.mobile = mobile
userprofile.save()
office_place = accountform.cleaned_data.get('office_place')
office_landmark = accountform.cleaned_data.get('office_landmark')
office_area = accountform.cleaned_data.get('office_area')
office_zip = accountform.cleaned_data.get('office_zip')
userprofile.set_destination_address(destination_place=office_place,destination_area=office_area,destination_landmark=office_landmark,destination_zip=office_zip)
_add_successmsg(request, 'Account Information saved Successfully')
return response(account_template,locals(),request)
def register():
try:
email = request.form['email']
name = request.form['name']
password = request.form['password']
except:
return utils.response(400, 'Missing required information')
if len(email) < 10 or '@' not in email or len(password) < 6:
return utils.response(400,
'Email is not valid or password is too short')
uid = utils.generate_numid()
password_hash = bcrypt.generate_password_hash(password)
try:
user_exists = mongo.db.users.find_one({'email': email})
except:
user_exists = None
if user_exists is not None:
return utils.response(400, 'This email address is already used')
mongo.db.users.insert_one({
'name': name,
'email': email,
'id': uid,
'password': password_hash
})
return utils.response(200, 'Success', {'id': uid})
def delete(id):
try:
delete_row('Item', id=id)
return response(True, "200 OK", 200)
except Exception as e:
return response(True, f"Internal Error. Error: {e}", 500)
def list_keys(event, context):
"""
Read post data to create a new key based on a new device
"""
# Check Authorization
requester_data = event["requestContext"]
if requester_data["authorizer"]["claims"]["email_verified"]:
identity_data = event["requestContext"]["identity"]
ip_address = identity_data["sourceIp"]
email = requester_data["authorizer"]["claims"]["email"].lower()
else:
return response(400, "Email not verified.")
print(email)
dbClient = boto3.resource('dynamodb', region_name='us-east-1')
table = dbClient.Table("CANConditioners")
db_response = table.scan()
data = db_response['Items']
while 'LastEvaluatedKey' in db_response:
db_response = table.scan(
ExclusiveStartKey=response['LastEvaluatedKey'])
data.extend(db_response['Items'])
print(data)
return response(200, data)
def post(self):
json_data, error = get_data(request)
if not error:
device_data, error = validate_json_payload(json_data, self.fields)
if not error:
error = self.validate_jetson_data(
device_data,
data_dict={
'truck_id': device_data['truck_id'],
'date_': device_data['frame_timestamp']
})
if not error:
try:
safeframe_data = self.safeframe_schema.load({
'truck_id':
device_data['truck_id'],
'frame_timestamp':
device_data['frame_timestamp'],
'frame_index':
device_data.get('frame_index', 0)
})
except marshmallow.exceptions.ValidationError as errors:
return response(400, str(errors))
safeframe = SafeFrame(**safeframe_data,
frame_image=bytes(
str(device_data['frame'])[2:-1],
'utf-8'))
error = safeframe.save()
if not error:
return response(200,
data={'safeframe_id': safeframe.id})
return error
def view_modify_snippet(request, snippet_id, snippet_slug, modify_snippet_template, snippet_profile_template):
modify = True
from quest.forms import AddSnippetForm
if request.method == 'POST':
form = AddSnippetForm(post_data(request))
existing_snippet = Snippet.objects.get(id=snippet_id)
if form.is_valid():
updated_snippet = _handle_snippet_updation(form, existing_snippet)
from quest.messages import SNIPPET_UPDATION_SUCCESSFUL
django_messages_framework.success(request, SNIPPET_UPDATION_SUCCESSFUL)
return response(request, snippet_profile_template, {'snippet': updated_snippet,
'owner': True})
return response(request, modify_snippet_template, {'form': form})
else:
snippet = Snippet.objects.get(id=snippet_id)
form_data = {'title':snippet.title,
'explanation':snippet.explanation,
'code':snippet.code,
'public':snippet.public,
'lang':snippet.lang,
'tags':" ".join([tag.name for tag in snippet.tags()])}
form = AddSnippetForm(form_data)
return response(request, modify_snippet_template, {'form':form,
'snippet': snippet,
'modify':modify})
def put(self):
"""
Update an alert to close it
"""
json_data, error = get_data(request)
if not error:
device_data, error = validate_json_payload(json_data,
[('token', True),
('alert_id', True),
('alert_end', True)])
if not error:
error = self.validate_jetson_data(device_data,
data_dict={
'alert_id':
device_data['alert_id'],
'date_':
device_data['alert_end']
})
if not error:
try:
alert = Alert.query.get(device_data['alert_id'])
except:
return response(400, 'Alert_id doesn\'t exists')
if not error:
alert.alert_end = device_data['alert_end']
alert.started = False
error = alert.save()
if not error:
return response(200, data={'id': alert.id})
return error
def post(self):
"""
Save a frame
"""
json_data, error = get_data(request)
if not error:
device_data, error = validate_json_payload(json_data, self.fields)
if not error:
error = self.validate_jetson_data(
device_data,
data_dict={
'alert_id': device_data['alert_id'],
'date_': device_data['frame_timestamp']
})
if not error:
try:
frame_data = self.frame_schema.load({
'alert_id':
device_data['alert_id'],
'frame_timestamp':
device_data['frame_timestamp'],
'frame_index':
device_data.get('frame_index', 0)
})
except marshmallow.exceptions.ValidationError as errors:
return response(400, str(errors))
frame = Frame(**frame_data,
frame_image=bytes(device_data['frame'],
'utf-8'))
error = frame.save()
if not error:
return response(200, data={'frame_id': frame.id})
return error
def view_login(request, login_template, next=''):
from users.forms import UserLoginForm
if request.method == 'POST':
data = post_data(request)
next = data.get('next') if not next else next
form = UserLoginForm(data)
if form.is_valid():
try:
userprofile = UserProfile.objects.get(user__email=form.cleaned_data.get('email'), user__is_active=True)
except UserProfile.DoesNotExist:
from users.messages import USER_LOGIN_FAILURE
messages.error(request, USER_LOGIN_FAILURE)
return response(request, login_template, {'form': form, 'next': next})
if not userprofile.check_password(form.cleaned_data.get('password')):
from users.messages import USER_LOGIN_FAILURE
messages.error(request, USER_LOGIN_FAILURE)
return response(request, login_template, {'form': form, 'next': next})
from users.messages import USER_LOGIN_SUCCESSFUL
messages.success(request, USER_LOGIN_SUCCESSFUL)
return _let_user_login(request,
userprofile.user,
email=form.cleaned_data.get('email'),
password=form.cleaned_data.get('password'),
next=next)
else:
form = UserLoginForm()
return response(request, login_template, {'form': form, 'next': next})
def view_give_answer(request, question_id, give_answer_template,
question_template):
question = get_object_or_404(Question, id=int(question_id))
if request.method == 'POST':
form = GiveAnswerForm(post_data(request))
if form.is_valid():
userprofile = loggedin_userprofile(request)
new_answer = Answer.objects.create_answer(
question=question,
description=form.cleaned_data.get('description'),
userprofile=userprofile)
new_anwer_emailer(question, new_answer)
from quest.messages import ANSWER_POSTING_SUCCESSFUL
messages.success(request, ANSWER_POSTING_SUCCESSFUL)
give_answer_form = GiveAnswerForm()
return response(request, question_template, {
'question': question,
'give_answer_form': give_answer_form
})
return response(request, question_template, {
'question': question,
'give_answer_form': form
})
return HttpResponseRedirect(redirect_to=url_reverse(
'quest.views.view_question', args=(question.id, question.slug)))
def main(event, context):
stage = os.environ['STAGE']
body = json.loads(event.get('body', {}))
if is_true(body.get('debug', '')):
configure_logging(level="DEBUG")
logging.info(f'entry_send_raw() stage:{stage}')
logging.info(f'event: {event}')
logging.info(f'context: {context}')
logging.info(f'body: {body}')
txn_s = body.get('txn', '')
sig = body.get('sig', '')
if (sig != ''):
if (verify_txn_sig(txn_s,sig) == False):
return response(409,{'msg':'Signature verification failure','txnhash':0,'cost_usd':0.0})
txn = json.loads(txn_s)
chainId = txn.get('chainId',1)
w3wsmap = w3_generic.get_w3wsock_providers()
txnhash,cost_usd,msg = new_txn(w3wsmap,txn)
logging.info(f'send_raw txnhash({txnhash}) cost_usd({cost_usd}) msg({msg}) ')
if (msg == 'success'):
return response(200,{'msg':msg,'txnhash':txnhash,'cost_usd':cost_usd})
else:
return response(401,{'msg':msg,'txnhash':0,'cost_usd':0.0})
def view_reset_my_password(request, reset_my_password_template):
if request.method == 'GET':
if request.GET.has_key('email') and request.GET.has_key('hash_key'):
email = request.GET.get('email')
userprofile = get_object_or_404(UserProfile, user__email=email)
retrieved_hash_key = request.GET.get('hash_key')
from django.contrib.auth.models import get_hexdigest
computed_hash_key = get_hexdigest('md5', '', email)
if retrieved_hash_key == computed_hash_key:
form = ResetMyPasswordForm()
return response(request, reset_my_password_template, {'form':form,
'email':email})
from users.messages import INVALID_PASSWORD_RESET_HASH_KEY
messages.error(request, INVALID_PASSWORD_RESET_HASH_KEY)
return HttpResponseRedirect(redirect_to='/')
else:
raise Http404
else:
data = post_data(request)
form = ResetMyPasswordForm(data)
if form.is_valid():
email = data.get('email')
userprofile = get_object_or_404(UserProfile, user__email=email)
password = form.cleaned_data.get('password')
userprofile.set_password(password)
from users.messages import PASSWORD_RESET_SUCCESSFULLY
messages.success(request, PASSWORD_RESET_SUCCESSFULLY)
return _let_user_login(request,
userprofile.user,
email=email,
password=password)
return response(request, reset_my_password_template, {'form':form,
'email':data.get('email')})
def view_edit_achievement(request, achievement_id, edit_achievement_template):
userprofile = loggedin_userprofile(request)
achievement = get_object_or_404(Achievement, id=int(achievement_id))
if userprofile.is_my_achievement(achievement):
achievements = list(userprofile.achievements)
for achievment_info in achievements:
if achievment_info['id'] == int(achievement_id):
achievements.remove({'title':achievement.title,
'id':int(achievement_id),
'description':achievement.description})
break
if request.method == 'GET':
form = AddAchievementForm({'title':achievement.title,
'description':achievement.description})
return response(request, edit_achievement_template, {'achievement':achievement,
'form':form,
'previous_achievements':achievements})
form = AddAchievementForm(post_data(request))
if form.is_valid():
achievement.update(title=form.cleaned_data.get('title'),
description=form.cleaned_data.get('description'),)
from users.messages import ACHIEVEMENT_UPDATED_SUCCESSFULLY
messages.success(request, ACHIEVEMENT_UPDATED_SUCCESSFULLY)
return HttpResponseRedirect(redirect_to=url_reverse('users.views.view_all_achievements'))
return response(request, edit_achievement_template, {'achievement':achievement,
'form':form,
'previous_achievements':achievements})
raise Http404
def login_user():
req = request.get_json()
login_data = {
'username': req['username'],
}
result = db.login_user(login_data)
if not result:
return response(401, "Data does not match our record.")
else:
if (hash_password(req['password'],
config['SECRET']) == result['password']):
expired_at = datetime.utcnow() + timedelta(minutes=60)
token = jwt.encode({
'user': result['username'],
'exp': expired_at
},
config['SECRET'],
algorithm="HS256")
content = {
"username": result['username'],
"token": token.decode('UTF-8'),
"expired_at": expired_at
}
return response(200, content)
return response(401, "Data does not match our record.")
def handler(event, context):
"""Update existed custom entity."""
entity = None
params = event.get("pathParameters", dict()) or dict()
uid = params.get("uid", None)
try:
entity = json.loads(event.get("body"))
except json.decoder.JSONDecodeError as e:
return bad_request("Invalid request body: {0}".format(str(e)))
try:
entity = EntitySchema().load(entity)
except ValidationError as err:
return response(400, err.messages)
if entity and uid:
try:
entity, ok = db.create_or_update(item=entity, uid=uid)
except BadRequestException as e:
return bad_request(str(e))
if ok:
# If entity updated successfully then return it in responce
try:
entity = EntitySchema().dump(entity)
except ValidationError as err:
return response(400, err.messages)
entity.update({"success": True})
return response(200, entity)
return response(404, {"status": "Not Found"})
def view_edit_question(request, question_id, question_slug, edit_question_template):
userprofile = loggedin_userprofile(request)
question = get_object_or_404(Question, id=int(question_id))
if userprofile.is_my_question(question):
asked_questions = list(userprofile.asked_questions)
for question_info in asked_questions:
if question_info['id'] == int(question_id):
asked_questions.remove({'title':question.title,
'id':int(question_id),
'slug':question_slug})
if request.method == 'GET':
question_data = {'title':question.title,
'description':question.description,
'tags':",".join([tag['name'] for tag in question.tags.values('name')])}
form = AskQuestionForm(question_data)
return response(request, edit_question_template, {'form':form,
'question':question,
'previous_questions':asked_questions})
form = AskQuestionForm(post_data(request))
if form.is_valid():
Question.objects.update_question(question,
title=form.cleaned_data.get('title'),
description=form.cleaned_data.get('description'),
tags=form.cleaned_data.get('tags'))
from quest.messages import QUESTION_UPDATED_SUCCESSFULLY
messages.success(request, QUESTION_UPDATED_SUCCESSFULLY)
return HttpResponseRedirect(redirect_to=url_reverse('quest.views.view_question', args=(question.id, question.slug)))
return response(request, edit_question_template, {'form':form,
'question':question,
'previous_questions':asked_questions})
raise Http404
def main(event, context):
stage = os.environ['STAGE']
body = json.loads(event.get('body', {}))
if is_true(body.get('debug', '')):
configure_logging(level="DEBUG")
logging.debug(f'entry_payment_google stage:{stage}')
logging.debug(f'os.environ: {os.environ}')
logging.debug(f'event: {event}')
logging.debug(f'context: {context}')
logging.debug(f'body: {body}')
#receipt = body.get('receipt', '')
#bundle_id = body.get('bundle_id', '')
account_id = body.get('account_id', '')
verify_receipt = True
# todo: add optional existing account
if os.environ['STAGE'] == 'dev':
verify_receipt = is_true(body.get('verify_receipt', 'True'))
if os.environ['STAGE'] != 'dev':
if body.get('verify_receipt', None) is not None:
return response(402, {'msg': 'invalid_dev_param'})
GOOGLE_SERVICE_ACCOUNT_KEY_FILE = get_secret(
'ORCHID_GOOGLE_SERVICE_ACCOUNT2')
logging.debug(f'{GOOGLE_SERVICE_ACCOUNT_KEY_FILE}')
GOOGLE_SERVICE_ACCOUNT_KEY = json.loads(GOOGLE_SERVICE_ACCOUNT_KEY_FILE)
purchase_token = body.get('receipt', '')
product_id = body.get('product_id', '')
bundle_id = body.get('bundle_id', 'net.orchid.Orchid')
msg, receipt_hash, total_usd = verify_(GOOGLE_SERVICE_ACCOUNT_KEY,
purchase_token, product_id,
bundle_id)
if ((account_id is None) or (account_id == '')):
account_id = receipt_hash
if (msg == "success"):
logging.debug(f'conditional writing receipt with hash: {receipt_hash}')
try:
w3_generic.dynamodb_cwrite1(os.environ['RECEIPT_TABLE_NAME'],
'receipt', receipt_hash)
except Exception as e:
logging.info(f'writing receipt exception: {str(e)} ')
return response(403, {'msg': 'Receipt already redeemed'})
w3_generic.credit_account_balance(account_id, total_usd)
return response(200, {
'msg': msg,
'account_id': account_id,
'total_usd': total_usd
})
else:
return response(402, {'msg': msg})
def post(self):
data = utils.get_json()
if 'height' not in data or 'bust' not in data or 'waist' not in data or 'hips' not in data:
return utils.response(400, "Bad request. Missing required fields")
data = {
'id': utils.gen_str_id(),
'height': data['height'],
'bust': data['bust'],
'waist': data['waist'],
'hips': data['hips'],
}
height = data['height']
bust = data['bust']
waist = data['waist']
hips = data['hips']
warnings.filterwarnings("ignore")
actress = pd.read_csv('actress_clean.csv')
df = actress[['height', 'bust', 'waist', 'hips']]
AVH_HEIGHT = actress.height.mean()
AVH_BUST = actress.bust.mean()
AVH_WAIST = actress.waist.mean()
AVH_HIPS = actress.hips.mean()
actress_np = df.to_numpy()
k_mean_3 = KMeans(n_clusters=3)
model = k_mean_3.fit(actress_np)
result = k_mean_3.labels_
df1 = actress[['id', 'height', 'bust', 'waist', 'hips']]
df2 = actress[[
'id', 'name', 'birthday', 'imgurl', 'birthplace', 'hobby',
'cup_size'
]]
lookup = df1.merge(df2, on='id', how='left')
lookup['cluster'] = result
def recommend(model,
height=AVH_HEIGHT,
bust=AVH_BUST,
waist=AVH_WAIST,
hips=AVH_HIPS):
arr = np.array([[height, bust, waist, hips]])
pred = model.predict(arr)
res = lookup[lookup['cluster'] == pred[0]].sample(10)
res = res.fillna('')
res['name_english'] = res['name'].apply(translator.translate,
lang_src='ja',
lang_tgt='en')
res['hobby'] = res['hobby'].apply(translator.translate,
lang_src='ja',
lang_tgt='en')
res['birthplace'] = res['birthplace'].apply(translator.translate,
lang_src='ja',
lang_tgt='en')
print(res)
datares = res.to_dict(orient='records')
return datares
res = recommend(model, height, bust, waist, hips)
return utils.response(200, "Success", res)
def profile(username):
user = db.find_user(username)
if user == None:
return response(200, "User not found")
res = {'name': user['name'], 'age': user['age']}
return response(200, res)
def delete_(self):
try:
db.session.delete(self)
db.session.commit()
except exc.IntegrityError as ex:
return response(409, f'Confict in Database: {ex.args[0]}')
except Exception as ex:
return response(500, f'Data base error\n{ex}')
def shared_secret(event, context):
"""
Read post data to create a new key based on a new device
"""
# Check Authorization
requester_data = event["requestContext"]
if requester_data["authorizer"]["claims"]["email_verified"]:
identity_data = event["requestContext"]["identity"]
ip_address = identity_data["sourceIp"]
email = requester_data["authorizer"]["claims"]["email"].lower()
else:
return response(400, "Email not verified.")
body = json.loads(event['body'])
try:
assert 'serial_number' in body
except AssertionError:
return response(400, "Missing required parameters.")
print(body['serial_number'])
try:
serial_number = body['serial_number']
assert len(serial_number) == 18
except:
return response(400, "Parameters are in the incorrect format.")
admin_user = True
key_dict = decrypt_device_key(serial_number, admin_user)
if key_dict is None:
return response(
400,
'There was a problem getting device keys. Is this device provisioned?'
)
server_pem_key_pass = key_dict['server_private_key'].encode('ascii')
full_password = base64.b64decode(key_dict['full_password'])
server_private_key = serialization.load_pem_private_key(
server_pem_key_pass, password=full_password, backend=default_backend())
#Serialize server private key with password from full_password
server_pem_key = server_private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.NoEncryption())
device_pub_key_bytes = base64.b64decode(key_dict['device_pub_key'])
device_bytes = b'\x04' + device_pub_key_bytes #This makes DER keys
device_pub_key = ec.EllipticCurvePublicKey.from_encoded_point(
ec.SECP256R1(), device_bytes)
shared_secret = base64.b64encode(
server_private_key.exchange(ec.ECDH(),
device_pub_key)[:16]).decode('ascii')
return response(
200, {
'server_pem_key': server_pem_key.decode('ascii'),
'shared_secret': shared_secret
})
def remove_user(username):
user = db.find_user(username)
if user == None:
return response(500, "User doesn't exist")
result = db.delete_user(username)
print(result)
return response(200, "Delete user sucessfully")
def get_usertoken_data(self, token):
token_data = decode_token(token)
if not token_data:
return None, response(400, 'Wrong token')
if not self._validate_user(token_data['username']):
return None, response(400, 'User doesn\'t exists')
return token_data, None
def save(self):
try:
db.session.add(self)
db.session.commit()
except exc.IntegrityError as ex:
return response(
409, f'Confict in Database: {ex.args[0].split(".")[4]}')
except Exception as ex:
return response(500, f'Data base error\n{ex}')
def view_messfood(request, messfood_registration_template, messfood_template):
selected_maintab = 'messfood'
if request.user.is_authenticated():
return response(messfood_template,locals(),request)
else:
from messfood.forms import MessFoodRegistrationForm,MessCreationForm
form = MessFoodRegistrationForm()
newmessform = MessCreationForm()
return response(messfood_registration_template,locals(),request)
def filter():
try:
data = request.json
rows = query('Item', **data).all()
result = ItemSchema(many=True).dump(rows)
return response(True, "200 OK", 200, result if len(result) else {})
except Exception as e:
return response(True, f'{e}', 404, {})
def webhook():
data = request.get_json()
log(data)
if data['object'] == 'page':
for entry in data['entry']:
for messaging_event in entry['messaging']:
# IDs
sender_id = messaging_event['sender']['id']
recipient_id = messaging_event['recipient']['id']
if messaging_event.has_key('postback'):
postback_event = messaging_event['postback']['payload']
if postback_event == "help":
bot.send_text_message(
sender_id,
'I can talk to you, and also search for gifs. Try typing "gif cats" ;) '
)
if messaging_event.get('message'):
# Extracting text message
if 'text' in messaging_event['message']:
messaging_text = messaging_event['message']['text']
else:
messaging_text = 'no text'
if messaging_text[:3].lower() == "gif":
if (len(messaging_text[4:]) < 2):
bot.send_text_message(
sender_id, "Enter a longer search phrase :) ")
else:
if gif_search(messaging_text[4:]) == False:
bot.send_text_message(
sender_id,
"No GIFs available for that :( ")
else:
bot.send_image_url(
sender_id, gif_search(messaging_text[4:]))
else:
if response(messaging_text) == "":
bot.send_text_message(
sender_id, response("responsetogibberish"))
elif messaging_text.lower() == "help":
bot.send_text_message(
sender_id,
'I can talk to you, and also search for gifs. Try typing "gif cats" ;) '
)
elif messaging_text.lower() == "options":
bot.send_text_message(
sender_id,
'I can talk to you, and also search for gifs. Try typing "gif cats" ;) '
)
else:
bot.send_text_message(sender_id,
response(messaging_text))
return "ok", 200
def handler(event, context):
"""Delete or deactivate entity."""
params = event.get("pathParameters", dict()) or dict()
uid = params.get("uid", None)
is_deleted = db.delete(uid)
if is_deleted:
return response(204, {})
return response(404, {"status": "Not Found"})
def update():
''' Atualiza dados da tabela de pagamentos '''
data = request.json
if not data.get('id_payment'):
return response(True, "id_payment e id_items são obrigatórios", 400)
id = data.pop('id_payment')
update_row('Item', id=id, **data)
return response(True, "200 OK", 200)
def view_homefood(request, homefood_registration_template, homefood_template):
selected_maintab = "homefood"
if request.user.is_authenticated():
googlemaps_api_key = None
if settings.MAPPING_ENABLED:
googlemaps_api_key = settings.GOOGLE_MAPS_API_KEY
return response(homefood_template, locals(), request)
else:
from homefood.forms import HomeFoodRegistrationForm
form = HomeFoodRegistrationForm()
return response(homefood_registration_template, locals(), request)
def view_restaurants(request,restaurants_registration_template,restaurants_template):
selected_maintab = 'restaurantfood'
if request.user.is_authenticated():
from restaurants.models import Restaurant
restaurants = Restaurant.premiumobjects.all().order_by('-created_on')
return response(restaurants_template,locals(),request)
else:
from restaurants.models import Restaurant
restaurants = Restaurant.premiumobjects.all().order_by('-created_on')
from restaurants.forms import RestaurantFoodRegistrationForm
form = RestaurantFoodRegistrationForm()
return response(restaurants_registration_template,locals(),request)
def put(self):
"""
Update ip and get new token
:return: {id, json web token}
"""
json_data, error = get_data(request)
if not error:
device_data, error = validate_json_payload(json_data, self.fields)
device_data['ip'] = request.remote_addr
if not error:
error = self._validate_data(
mac=device_data['mac'],
ip=device_data['ip'],
password=device_data['password'],
role_name=device_data['role']
if 'role' in device_data.keys() else None)
if not error:
device_data['password'] = hash_password(
device_data['password'])
token = gen_token(
{key: device_data[key]
for key in self.token_data})
try:
role = Role.query.filter_by(
role_name=device_data['role'] if 'role' in
device_data.keys() else 'Limited').first()
jetson = Jetson.query.filter_by(
mac=device_data['mac']).first()
account = Account.query.filter_by(
id=jetson.account_id).first()
truck = Truck.query.filter_by(
jetson_id=jetson.id).first()
except:
return response(401, 'Jetson device dosen\'t exists')
if jetson.ip != device_data['ip']:
jetson.ip = device_data['ip'] + '3'
error = jetson.save()
if error:
return response(500, 'Internal error')
if role.id != account.role_id:
account.role_id = role.id
error = account.save()
if not error:
return response(200,
data={
'id': account.id,
'truck_id': truck.id,
'token': token
})
return error
def delete():
''' Deleta dados da tabela de pagamentos '''
data = request.json
if not data.get('id_payment'):
return response(True, "id_payment obrigatório", 400)
data.update(id_parent=data.pop('id_payment'))
delete_dp_row('Payment', 'Item', **data)
return response(True, "200 OK", 200)
def view_contactus(request, contactus_template):
if request.method == 'GET':
return response(request, contactus_template, {'form':ContactUsForm()})
form = ContactUsForm(post_data(request))
if form.is_valid():
mail_admins(from_email=form.cleaned_data.get('from_email'),
from_name=form.cleaned_data.get('from_name'),
subject=form.cleaned_data.get('subject'),
message=form.cleaned_data.get('message'))
from users.messages import CONTACTED_SUCCESSFULLY
messages.success(request, CONTACTED_SUCCESSFULLY)
return HttpResponseRedirect(redirect_to='/')
return response(request, contactus_template, {'form':form})
async def ping(request):
db = Gino.init()
try:
db_status = await db.status(db.text('SELECT 1'))
logging.info(f"Database health check, response={db_status}")
return response(status=HTTPOk.status_code,
result=True,
description="Im alive!")
except Exception as error:
logging.fatal(error, exc_info=True)
return response(status=HTTPInternalServerError.status_code,
result=False,
description="Health check failed. Repair me!")
def update():
try:
data = request.json
if data.get('id'):
id = data.pop('id')
update_row('Item', id=id, **data)
return response(True, "200 OK", 200)
raise Exception('Id é obrigatório para atualização.')
except Exception as e:
return response(True, f"Bad Request. Erro: {e}", 400)
def view_save_personal_settings(request, personal_settings_template):
if request.method == 'GET':
return view_get_personal_settings(request, personal_settings_template)
userprofile = loggedin_userprofile(request)
form = PersonalSettingsForm(post_data(request))
if form.is_valid():
name = form.cleaned_data.get('name')
new_password = form.cleaned_data.get('new_password')
slug = form.cleaned_data.get('slug')
if userprofile.can_update_slug():
if slug:
if UserProfile.objects.filter(slug=slug).count():
from users.messages import WEB_RESUME_URL_ALREADY_PICKED
form._errors['slug'] = WEB_RESUME_URL_ALREADY_PICKED
else:
userprofile.update(name=name, slug=slug, password=new_password)
from users.messages import ACCOUNT_SETTINGS_SAVED
messages.success(request, ACCOUNT_SETTINGS_SAVED)
else:
from users.messages import INVALID_WEB_RESUME_URL
messages.error(request, INVALID_WEB_RESUME_URL)
else:
userprofile.update(name=name, password=new_password)
from users.messages import ACCOUNT_SETTINGS_SAVED
messages.success(request, ACCOUNT_SETTINGS_SAVED)
return response(request, personal_settings_template, {'personal_form':form})
def view_contactgroup(request, group_type, group_id, contactgroup_template):
userprofile = loggedin_userprofile(request)
if group_type == 'college':
group = get_object_or_404(College, id=int(group_id))
to = "%s Students" % group.name
redirect_url = url_reverse('users.views.view_college', args=(group_id, group.slug))
elif group_type == 'company':
group = get_object_or_404(Company, id=int(group_id))
to = "%s Employees" % group.name
redirect_url = url_reverse('users.views.view_company', args=(group_id, group.slug))
else:
raise Http404
if request.method == 'POST':
contactgroupform = ContactGroupForm(post_data(request))
if contactgroupform.is_valid():
mail_group(group_type=group_type,
group=group,
from_email=userprofile.user.email,
message=contactgroupform.cleaned_data.get('message'),
from_name=userprofile.name,
subject=contactgroupform.cleaned_data.get('subject'))
from users.messages import CONTACTED_SUCCESSFULLY
messages.success(request, CONTACTED_SUCCESSFULLY)
return HttpResponseRedirect(redirect_to=redirect_url)
contactgroupform = ContactGroupForm({'to':to})
return response(request, contactgroup_template, {'contactgroupform':contactgroupform,
'group_type':group_type,
'group_id':group_id})
def blog_view(request, template, context):
"""All blog views: contain links menu"""
# Sources
choices = Link.objects.values_list('category', flat=True).distinct()
categories = [ (c, C) for c,C in Link.CATEGORY_CHOICES if c in choices ]
sources = [ (category[-1], Link.objects.filter(category=category[0])) for category in categories ]
# Previous entries
previous = Entry.objects.all()[:16]
# Dates archive
dates = Entry.objects.values_list('timestamp', flat=True).distinct()
dates_index = list(set([ date.year for date in set(dates) ]))
for y in range(len(dates_index)):
months = list(set([ date.month for date in dates if date.year == dates_index[y] ]))
for m in range(len(months)):
days = list(set([ date.day for date in dates if date.year == dates_index[y] and date.month == months[m] ]))
months[m]= (months[m], days)
dates_index[y] = (dates_index[y], months)
# Author archive
ids = list(set(Entry.objects.values_list('author', flat=True).distinct()))
authors_index = [ User.objects.get(pk=id) for id in ids ]
context['sources'] = sources
context['previous'] = previous
context['authors'] = authors_index
context['dates'] = dates_index
return response(request, template, context)
def save_article(request, article_id=None):
article = None
if article_id:
article = get_object_or_404(Article, id=article_id, user=request.user)
form = ArticleForm(request.POST, instance=article)
if 'delete' in request.POST:
article.delete()
messages.add_message(request, messages.INFO, _(u'The article “%s” has been deleted.') % article.name)
return redirect('management:index')
else:
form = ArticleForm(request.POST)
if form.is_valid():
if article_id:
form.save()
else:
article = form.save(commit=False)
article.user = request.user
article.save()
article_id = article.id
messages.add_message(request, messages.SUCCESS, _(u'The article is saved.'))
return redirect('management:article', article_id=article_id)
return response(request, 'edit_article.html', {
'article': article,
'article_form': form,
'article_id': article_id,
'page_type': 'article',
})
def view_save_feed(request, all_feeds_template):
# FIXME:Move this entire view code to a command extension.
# Views are implicitly assumed to be called by the "browser" 'get' operation
for url_obj in Feed.objects.all():
# FIXME:Feed.objects.all() returns all feed objects. And not "url_obj"s
# So change url_obj to feed
# FIXME:And refactor the below functionality into functions. Like,
# 1)ping feed, 2)process feed response, etc...
# FIXME:Never, ever use variables like fp, file or something. Have
# a context related variable name
url = url_obj.source_url
fp = urllib.urlopen(url)
xmldoc = minidom.parse(fp)
xmlitem = xmldoc.getElementsByTagName("item")
# FIXME:xmldoc.getElementsByTagName returns objects(plural). So,
# rename the 'xmlitem' to 'feeditems'
for item in xmlitem:
title = item.getElementsByTagName("title")[0].firstChild.data
pub_date = item.getElementsByTagName("pubDate")[0].firstChild.data
page_link = item.getElementsByTagName("link")[0].firstChild.data
desc = item.getElementsByTagName("description")[0].firstChild.data
FeedEntry.objects.create_feedentry(
title=title, desc=desc, page_link=page_link, pub_date=pub_date, source=url
)
# FIXME:Try to pass only variables accessed in all_feeds_template.
# Only use locals when too many objects are to be accessed, which wont be
# the normal case anyway.
return response(request, all_feeds_template, locals())
def feed(request):
feed = News.objects.all()
template = 'home.html'
context = {
'feed': feed,
}
return response(request, template, context)
def view_validate_versions(request, validate_versions_template, enter_versions_template):
form = VersionsForm(request.POST)
if form.is_valid():
validated_versions = []
versions_info = form.cleaned_data.get('versions')
for (name, version_digits) in versions_info:
version = {}
version['name'] = name
version['version'] = version_digits
version['flag'] = _validate_version(name, version_digits)
validated_versions.append(version)
default_file_name = ''.join(('versions_',
datetime.today().strftime('%Y_%b_%d'),
'.txt'))
return response(request, validate_versions_template, {'versions':validated_versions, 'default_file_name':default_file_name})
return response(request, enter_versions_template, {'form':form})
def view_get_workinfo_settings(request, workinfo_settings_template):
userprofile = loggedin_userprofile(request)
(workplace, designation, years_of_exp) = userprofile.work_details
form = WorkInfoSettingsForm({'workplace':workplace if workplace else '',
'designation':designation,
'years_of_exp':years_of_exp})
return response(request, workinfo_settings_template, {'workinfo_form':form})
def view_orderconfirm(request,ordercofirm_template):
order_information = []
restaurant_alias = _request_param_post(request,'ralias')
from restaurants.models import Restaurant
restaurant = Restaurant.objects.get(alias=restaurant_alias)
item_ids = _request_param_post(request,'item_ids').split(',')
item_ids_quantity = _cleanquantity(item_ids)
menu_items = []
from restaurants.models import RestaurantMenuItem
foodscost = 0
vat_charges = 0
for item_id in item_ids_quantity.keys():
menuitem = RestaurantMenuItem.objects.get(id=item_id)
foodscost+=item_ids_quantity[item_id]*menuitem.cost
order_information.append({'menuitem':menuitem, 'quantity':item_ids_quantity[item_id],'netcost':item_ids_quantity[item_id]*menuitem.cost})
vat_percentage = settings.VAT_PERCENTAGE
vat_percentage_display = vat_percentage*100
foodscost = foodscost.__float__()
vat_charges = foodscost*vat_percentage
service_charge = settings.RESTAURANTFOOD_SERVICE_CHARE
total_bill = foodscost+vat_charges+service_charge
from datetime import datetime,timedelta
time_now = datetime.now()
min_time = datetime(day=datetime.today().day, month=datetime.today().month, year=datetime.today().year, hour=settings.DELIVERY_TIMINGS_START_HOUR,minute=0,second=0)
max_time = datetime(day=datetime.today().day, month=datetime.today().month, year=datetime.today().year, hour=settings.DELIVERY_TIMINGS_END_HOUR,minute=0,second=0)
hours = [1,2,3,4,5,6,7,8,9,10,11,12,13]
available_hours = []
for hour in hours:
if (time_now+timedelta(hours=hour)) <= max_time:
available_hours.append(hour)
if available_hours:
food_deliverytime = time_now+timedelta(hours=available_hours[0])
return response(ordercofirm_template,locals(),request)
def view_question(request, question_id, question_slug, question_template):
question = get_object_or_404(Question, id=int(question_id))#question_slug is for SEO
if question.is_accepting_answers():
give_answer_form = GiveAnswerForm()
else:
give_answer_form = None
return response(request, question_template, {'question':question, 'give_answer_form':give_answer_form})
def user(request, username):
"""Takes a username value"""
author = User.objects.get(username=username)
context = {
'author': author,
}
return response(request, template, context)
def view_give_answer(request, question_id, give_answer_template, question_template):
question = get_object_or_404(Question, id=int(question_id))
if request.method == 'POST':
form = GiveAnswerForm(post_data(request))
if form.is_valid():
userprofile = loggedin_userprofile(request)
new_answer = Answer.objects.create_answer(question=question,
description=form.cleaned_data.get('description'),
userprofile=userprofile)
new_anwer_emailer(question, new_answer)
from quest.messages import ANSWER_POSTING_SUCCESSFUL
messages.success(request, ANSWER_POSTING_SUCCESSFUL)
give_answer_form = GiveAnswerForm()
return response(request, question_template, {'question':question, 'give_answer_form':give_answer_form})
return response(request, question_template, {'question':question, 'give_answer_form':form})
return HttpResponseRedirect(redirect_to=url_reverse('quest.views.view_question', args=(question.id, question.slug)))
def view_photoalbum(request, photoalbum_id):
album = get_object_or_404(PicasaAlbum, id=photoalbum_id, user=request.user)
return response(request, 'photoalbum.html', {
'photoalbum': album,
'page_type': 'photoalbum',
})
def view_ordersummary(request,orderdone_template):
order_code = _request_param_get(request,'code')
from users.models import UserOrder
try:
order = UserOrder.objects.get(code=order_code)
except UserOrder.DoesNotExist:
order = None
return response(orderdone_template,locals(),request)
def view_userprofile(request, user_id, user_slug_name, userprofile_template):
userprofile = get_object_or_404(UserProfile, id=int(user_id), slug=user_slug_name)
submitted_snippets = [{'title': snippet.title,
'slug': snippet.slug,
'id': snippet.id,
'active': snippet.active} for snippet in userprofile.submitted_snippets()]
return response(request, userprofile_template, {'userprofile': userprofile,
'submitted_snippets': submitted_snippets})
def view_ask_question(request, ask_question_template):
userprofile = loggedin_userprofile(request)
asked_questions = userprofile.asked_questions
if request.method == 'GET':
form = AskQuestionForm()
return response(request, ask_question_template, {'form':form,
'asked_questions':asked_questions})
form = AskQuestionForm(post_data(request))
if form.is_valid():
question = Question.objects.create_question(title=form.cleaned_data.get('title'),
description=form.cleaned_data.get('description'),
userprofile=userprofile,
tags=form.cleaned_data.get('tags'))
messages.success(request, QUESTION_POSTING_SUCCESSFUL)
return HttpResponseRedirect(redirect_to=url_reverse('quest.views.view_question', args=(question.id, question.slug)))
return response(request, ask_question_template, {'form':form,
'asked_questions':asked_questions})
def view_close_answering(request, question_template, close_answer_template):#This would be an ajax post call
question_id = post_data(request).get('question_id')
question = get_object_or_404(Question, id=int(question_id))
userprofile = loggedin_userprofile(request)
if userprofile.id == question.owner.id:
question.close_answering()
return response(request, close_answer_template, {'give_answer_form':None})
raise Http404
def view_reset_password(request, passwordreset_template):
from users.forms import PasswordResetForm
if request.method == 'POST':
form = PasswordResetForm(post_data(request))
if not form.is_valid():
return response(passwordreset_template,locals(),request)
email = form.cleaned_data.get('email')
from users.models import UserProfile
userprofile = UserProfile.objects.get(email=email)
new_password = userprofile.reset_password()
from utils.emailer import passwordreset_mailer
passwordreset_mailer(userprofile, new_password)
from users.messages import PASSWORD_RESET_EMAIL_SUCCESS
_add_successmsg(request, PASSWORD_RESET_EMAIL_SUCCESS % email)
return response(passwordreset_template,locals(),request)
form = PasswordResetForm()
return response(passwordreset_template,locals(),request)
def view_add_achievement(request, add_achievement_template):
userprofile = loggedin_userprofile(request)
achievements = userprofile.achievements
if request.method == 'GET':
form = AddAchievementForm()
return response(request, add_achievement_template, {'form':form,
'achievements':achievements})
form = AddAchievementForm(post_data(request))
if form.is_valid():
Achievement.objects.create_achievement(userprofile,
title=form.cleaned_data.get('title'),
description=form.cleaned_data.get('description'))
from users.messages import ACHIEVEMENT_ADDED_SUCCESSFULLY
messages.success(request, ACHIEVEMENT_ADDED_SUCCESSFULLY)
return HttpResponseRedirect(url_reverse('users.views.view_all_achievements'))
return response(request, add_achievement_template, {'form':form,
'achievements':achievements})
def view_invite(request, invite_template):
if request.method == 'GET':
return response(request, invite_template, {'form':InvitationForm()})
userprofile = loggedin_userprofile(request)
form = InvitationForm(post_data(request))
if form.is_valid():
try:
invitation_emailer(from_email=userprofile.user.email,
to_emails=form.cleaned_data.get('to_emails'),
from_name=userprofile.name)
from users.messages import CONTACTED_SUCCESSFULLY
messages.success(request, CONTACTED_SUCCESSFULLY)
return HttpResponseRedirect(redirect_to='/')
except Exception:
from users.messages import CONTACTING_FAILED
messages.error(request, CONTACTING_FAILED)
return response(request, invite_template, {'form':form})
