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