def refresh(): # used to fetch the new data from stations (get request) or to fetch a filtered list of destinations (post containing the filter) if request.method == 'GET': response = fetch_all_stations() print response #response = convert_in_levels(fetch_all_stations()) r = make_response(json.dumps(response, separators=(',',':'))) elif request.method == 'POST': ss = str(request.form.keys()) # takes the content of the form (multidict) and casts it to a string ss = ss.lstrip('[\'') # removes the unneeded characters at the beginning and at the end of the string ss = ss.rstrip('\']') print ss queries = json.loads(ss) # creates the dict reading the json message chosen_destinations = generate_result (queries) for i in chosen_destinations: print i print json.dumps(chosen_destinations, separators=(',',':') ) r = make_response(json.dumps(chosen_destinations, separators=(',',':') )) else: pass return r
def getData(): #id/pass cabechalho http #token query string #eu sou o servico id/pass e tenho este token para acesso #da-me um clientID token = request.args.get('token') if not token: return make_response("No token query parameter", 404) #verificar auth do server #recuperar nome do servico service = getServiceName(request.authorization.username, request.authorization.password) if not service: return make_response("failed authentication", 401) #recuperar o clientID #print service userData = getClientData(service, token) if not userData: return make_response("Client not found", 404) body = {} body["userData"] = userData return make_response(jsonify(body), 200)
def output_json(obj, code, headers=None): if type(obj) is dict: resp = make_response(dumps(obj), code) else: resp = make_response(obj, code) resp.headers.extend(headers or {}) return resp
def show_bookmark(): # Check whether current user is authenticated before saving any variables if current_user.is_authenticated: userid = current_user.user_id favhtml = "favlist_web.html" favlist = get_mysql_userfavorite(userid) if not favlist: videolist = get_db_videolist() favhtml = "favlist_notfound_web.html" response = make_response( render_template(favhtml,videolist=videolist, cdnroot=current_app.config['CDN_ROOT'])) else: response = make_response( render_template(favhtml, cdnroot=current_app.config['CDN_ROOT'], clientid=current_app.config['CLIENT_ID'], APPLICATION_NAME=current_app.config['APPLICATION_NAME'], favlist=favlist)) response.headers['Content-Type'] = 'text/html' return response else: #if the user is not authenticated, redirect it to login page #After login, redirect user back to same page return redirect(url_for('auth.login', next='/bookmark'))
def authentication_endpoint(): # parse authentication request try: auth_req = current_app.provider.parse_authentication_request(flask.request.get_data().decode('utf-8'), flask.request.headers) current_app.authn_requests[auth_req['nonce']] = auth_req.to_dict() # Check client vetting method client = current_app.provider.clients[auth_req['client_id']] if client.get('vetting_policy') == 'POST_AUTH': # Return a authn response immediately authn_response = create_authentication_response(auth_req) response_url = authn_response.request(auth_req['redirect_uri'], should_fragment_encode(auth_req)) try: headers = {'Authorization': 'Bearer {}'.format(auth_req['token'])} except KeyError: # Bearer Token needs to be supplied with the auth request for instant responses raise InvalidAuthenticationRequest('Token missing', auth_req) current_app.authn_response_queue.enqueue(deliver_response_task, response_url, headers=headers) except InvalidAuthenticationRequest as e: current_app.logger.debug('received invalid authn request', exc_info=True) error_url = e.to_error_url() if error_url: current_app.authn_response_queue.enqueue(deliver_response_task, error_url) return make_response('OK', 200) else: # deliver directly to client since we're only supporting POST return make_response('Something went wrong: {}'.format(str(e)), 400) return make_response('OK', 200)
def catch_all(path): response_info = responses.get(path) method = request.method if not response_info: status_code = 404 response = make_response(render_template('error_404.txt', path=path)) response.headers['Content-Type'] = 'text/plain' elif method not in response_info.keys(): status_code = 405 response = make_response(render_template('error_405.txt', path=path, method=method)) response.headers['Content-Type'] = 'text/plain' else: response_meta = responses[path][method] status_code = response_meta['status_code'] resp = response_meta['response'] if response_meta['response'] else {} response = make_response( json.dumps( resp, indent=2, separators=(',', ':'), sort_keys=True )) response.headers['Content-Type'] = 'application/json' return response, status_code
def login(): """ Login method Get data from login form and redirect to page """ if request.method == 'POST': if Users().login(json.loads(json.dumps(request.form, separators=(',', ':')))): session['username'] = request.form['username'] if (Users().get_permission(json.loads(json.dumps(request.form, separators=(',', ':')))['username'])[0]['id_role']) == 1: session['role'] = 1 response = make_response(redirect("/#admin")) response.set_cookie('role', "1") return response if (Users().get_permission(json.loads(json.dumps(request.form, separators=(',', ':')))['username'])[0]['id_role']) == 2: session['role'] = 2 response = make_response(redirect("/#orders")) response.set_cookie('role', "2") return response if (Users().get_permission(json.loads(json.dumps(request.form, separators=(',', ':')))['username'])[0]['id_role']) == 3: session['role'] = 3 response = make_response(redirect("/#orders")) response.set_cookie('role', "3") return response if (Users().get_permission(json.loads(json.dumps(request.form, separators=(',', ':')))['username'])[0]['id_role']) == 4: session['role'] = 4 response = make_response(redirect("/#cooker")) response.set_cookie('role', "3") return response else: #return '{"error":"login"}' return Response("danger")
def disconnect(): """Revoke current user's token and reset their session.""" # Only disconnect a connected user. credentials = session.get('credentials') if credentials is None: response = make_response(json.dumps('Current user not connected.'), 401) response.headers['Content-Type'] = 'application/json' return response # Execute HTTP GET request to revoke current token. access_token = credentials.access_token url = 'https://accounts.google.com/o/oauth2/revoke?token=%s' % access_token h = httplib2.Http() result = h.request(url, 'GET')[0] if result['status'] == '200': # Reset the user's session. del session['credentials'] response = make_response(json.dumps('Successfully disconnected.'), 200) response.headers['Content-Type'] = 'application/json' return response else: # For whatever reason, the given token was invalid. response = make_response( json.dumps('Failed to revoke token for given user.', 400)) response.headers['Content-Type'] = 'application/json' return response
def write(p="."): if request.json: if not request.json.has_key("params"): return make_response(jsonify(description='The key "params" is missing.'), 400) params = request.json["params"] if not params.has_key("path") or not params.has_key("name"): return make_response( jsonify(description='The "mkdir" operation requires the "path" and "name" parameters.'), 400 ) try: fs.mkdir(params["path"], params["name"]) except OSError: return make_response(jsonify(description="The fil exists already."), 500) else: fil = request.files["file"] if fil: if request.method == "PUT": fs.save(p, fil, True) else: fs.save(p, fil, False) return jsonify(description="ok")
def farms_api(self): if request.method == 'GET': return json.dumps(self.model.get_farms()) elif request.method == 'POST': args = self.request_data(request) make_response(self.model.create_farm(args)) else: raise("in Emily_View.farms_api, unknown method: %s" % request.method.to_string())
def removeProfile(profileID): token = request.args.get('token') if not token: return make_response("No token query parameter", 404) userID = getUserId(token) if not userID: return make_response("User not found", 404) return removeCaldavCalendar(caldavUser, caldavPassword, userID, profileID);
def farm_api(self, farm_id): if request.method == 'GET': return json.dumps(self.model.get_farm(farm_id)) elif request.method == 'PUT': args = self.request_data(request) make_response(self.model.update_farm(farm_id, args)) elif request.method == 'DELETE': make_response(self.model.delete_farm(farm_id)) else: raise("in Emily_View.farm_api, unknown method: %s" % request.method.to_string())
def removeUser(): token = request.args.get('token') if not token: return make_response("No token query parameter", 404) userID = getUserId(token) if not userID: return make_response("User not found", 404) return removeCaldavCollection(caldavUser, caldavPassword, userID);
def insertEvent(profileID): token = request.args.get('token') if not token: return make_response("No token query parameter", 404) userID = getUserId(token) if not userID: return make_response("User not found", 404) return insertCaldavEvent(caldavUser, caldavPassword, userID, profileID,request.json);
def vetting_result(): data = flask.request.get_json() qrcode = data.get('qrcode') try: qrdata = parse_opaque_data(qrcode) except InvalidOpaqueDataError as e: return make_response(str(e), 400) auth_req_data = current_app.authn_requests.pop(qrdata['nonce']) if not auth_req_data: # XXX: Short circuit vetting process for special nonce during development if qrdata['nonce'] in current_app.config.get('TEST_NONCE', []): current_app.logger.debug('Found test nonce {}'.format(qrdata['nonce'])) return development_license_check(data) # XXX: End remove later current_app.logger.debug('Received unknown nonce \'{}\''.format(qrdata['nonce'])) return make_response('Unknown nonce', 400) auth_req = AuthorizationRequest(**auth_req_data) user_id = auth_req['user_id'] try: current_app.logger.debug('Vetting data received: {}'.format(data)) # Check vetting data received parsed_data = parse_vetting_data(data) current_app.logger.debug('Vetting data parsed: {!r}'.format(parsed_data)) except ValueError as e: current_app.logger.error('Received malformed vetting data \'{}\''.format(data)) current_app.logger.error(e) return make_response('Malformed vetting data', 400) except KeyError as e: current_app.logger.error('Missing vetting data: \'{}\''.format(e)) return make_response('Missing vetting data: {}'.format(e), 400) # Save information needed for the next vetting step that uses the api try: yubico_state = current_app.yubico_states[auth_req['state']] except KeyError: yubico_state = { 'created': time(), 'state': auth_req['state'], 'client_id': auth_req['client_id'], 'user_id': user_id } else: # Yubico state already created via the api yubico_state.update({'client_id': auth_req['client_id'], 'user_id': user_id}) current_app.yubico_states[auth_req['state']] = yubico_state # Add soap license check to queue current_app.mobile_verify_service_queue.enqueue(verify_license, auth_req.to_dict(), parsed_data['front_image_data'], parsed_data['barcode_data'], parsed_data['mibi_data']) return make_response('OK', 200)
def vetting_result(ra_app): current_app.logger.info('Received vetting result from {}'.format(ra_app)) data = request.get_json() current_app.logger.debug('Data received {}'.format(data)) identity = data.get('identity') qrcode = data.get('qrcode') metadata = data.get('meta', {}) # Default to empty dict if not identity: return make_response('Missing identity', 400) try: qrdata = parse_opaque_data(qrcode) except InvalidOpaqueDataError as e: # This is by design since we want the message from this exception current_app.logger.error('Received invalid opaque data: {}'.format(e)) return make_response(str(e), 400) auth_req_data = current_app.authn_requests.pop(qrdata['nonce'], None) if auth_req_data is None: current_app.logger.error('Received unknown nonce \'%s\'', qrdata['nonce']) return make_response('Unknown nonce', 400) # Collect more metadata metadata['opaque'] = qrcode metadata['ra_app'] = ra_app # Compute credibility score from metadata metadata['score'] = compute_credibility_score(qrdata['nonce'], metadata) # Remove unneeded metadata metadata.pop('expiry_date', None) metadata.pop('ocular_validation', None) metadata.pop('document_identifier', None) # Save userinfo current_app.users[identity] = {'vetting_time': time.time(), 'identity': identity, 'metadata': metadata} # Need a minimal app config to work during tests... # TODO: Remove the minimal config app_config = { 'DB_URI': current_app.config['DB_URI'], 'REDIS_URI': current_app.config['REDIS_URI'], 'PREFERRED_URL_SCHEME': current_app.config['PREFERRED_URL_SCHEME'], } # Enqueue the delayed authn response seconds_delay = current_app.config['SELEG_AUTHN_RESPONSE_DELAY'] current_app.authn_response_delay_queue.enqueue_in(timedelta(seconds=seconds_delay), delayed_authn_response_task, auth_req_data, qrdata['token'], identity, app_config) current_app.logger.info('Vetting result from {}. Delivering authn response in {} seconds'.format( ra_app, seconds_delay)) return make_response('OK', 200)
def handler(*args, **kwargs): user = UserPrefs.get_current() if user is None: return make_response(jsonify(code="Unauthorized"), 401, {}) if user.authorized is False: return make_response(jsonify(code="Forbidden"), 403, {}) if require_admin and not user.admin: return make_response(jsonify(code="Forbidden"), 403, {}) return fn(*args, **kwargs)
def development_license_check(data): # TODO: What do we want to do here? current_app.logger.debug('Test data received: {}'.format(data)) try: parsed_data = parse_vetting_data(data) current_app.logger.debug('Test data json parsed: {!r}'.format(parsed_data)) except ValueError as e: current_app.logger.error('Received malformed json:') current_app.logger.error(e) return make_response('Malformed json data', 400) except KeyError as e: current_app.logger.error('Missing vetting data: \'{}\''.format(e)) return make_response('Missing vetting data: {}'.format(e), 400) return make_response('OK', 200)
def negotiate(graph, html_template, request): ''' Negotiate the response to return @param graph: the RDF graph containing the data to render @param html_template: the template to use for HTML responses @param headers: the request headers @param suffix: the suffix used for the query URL ''' #Â Serve HTML by default mimetype = 'text/html' logger.debug('{}'.format(len(graph))) # Use the accept header if it was provided if 'Accept' in request.headers: mimetype = parse_accept_header(request.headers['Accept']).best logger.debug("Asked for {} in content neg".format(mimetype)) # If a known suffix was asked use that instead of the accept header ext = os.path.splitext(request.base_url)[1] if ext in SUFFIX_TO_MIME: mimetype = SUFFIX_TO_MIME[ext] logger.debug("Asked for {} using {}".format(mimetype, ext)) logger.debug("Will serve {}".format(mimetype)) # Serve HTML if mimetype in ['text/html','application/xhtml_xml','*/*']: # Get data usable by the template engine data = graph_to_python(request, graph) # Render the requested template return render_template(html_template, data=data) # Serve Turtle elif mimetype in ['text/turtle', 'application/x-turtle']: logger.debug(graph.serialize(format='turtle')) response = make_response(graph.serialize(format='turtle')) response.headers['Content-Type'] = mimetype return response # Serve N-triples elif mimetype in ['application/n-triples']: response = make_response(graph.serialize(format='nt')) response.headers['Content-Type'] = mimetype return response # Serve RDF+XML :-( elif mimetype in ['application/rdf+xml']: response = make_response(graph.serialize(format='pretty-xml')) response.headers['Content-Type'] = mimetype return response
def login2(): redirectURL = request.args.get('state') code = request.args.get('code') if not redirectURL or not code: return make_response("Make sure to include state and code query parameters", 404) flow = flow_from_clientsecrets(tokenJSONPath, scope='openID https://www.googleapis.com/auth/plus.me https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email', redirect_uri='https://safeguard.192.168.8.217.xip.io:7704/loginCode') try: credentials = flow.step2_exchange(code) except: return make_response("Failed authentication @ google", 401) http = httplib2.Http() http = credentials.authorize(http) #service = build("plus", "v1", http=http) #data = service.people().get(userId='me').execute() service = build("oauth2", "v2", http=http) data = service.userinfo().get().execute() androidID = None redirectSplit = redirectURL.split("_androidid_") if len(redirectSplit) > 1: redirectURL = redirectSplit[0] androidID = redirectSplit[1] if androidID: accesstoken = registerToken("mobile", "composition", data, androidID) else: accesstoken = registerToken("composition", "composition", data, androidID) if not accesstoken: return make_response("Failed to register token", 401) if not androidID: if urlparse(redirectURL)[4]: redirectURL += '&token=' + accesstoken else: redirectURL += '?token=' + accesstoken else: redirectURL = urllib2.unquote(redirectURL) + accesstoken #criar uma entrada para composicao {clientID, retrive_code} return redirect(redirectURL, code=302)
def post(self, cobranca_id): cobranca = CobrancaModel.achar_cobranca(cobranca_id) if cobranca: cobranca.deletar_cobranca() cobrancas = returnCharge() return make_response( render_template("reportCharge.html", cobrancas=cobrancas), 201)
def do_fav_product_add(userid, productid, videoid, clicktime): datetime.strptime(clicktime, '%Y-%m-%d %H:%M:%S') #update_mysql_userfavorite(userid, productid, videoid, clicktime) response = make_response("",200) response.headers['Content-Type'] = 'application/json' return response
def delete_artist_submission(artist_id): try: a = Artist.query.get(artist_id) db.session.delete(a) db.session.commit() except: print(sys.exc_info()) flash("Something went wrong! Try again") redirect_url = url_for('show_artist', artist_id=artist_id) return make_response(jsonify({'redirect_url': redirect_url}), 500) finally: db.session.close() flash('Artist deleted successfully!') return make_response('', 204)
def read(p="."): if not os.path.exists(p): return make_response(jsonify(description="The path does not exists."), 404) if fs.is_dir(p) or "*" in p: return jsonify(content=fs.ls(p)) else: return send_from_directory(fs.split(p)[0], fs.split(p)[1])
def create(): data = document.parse(request) voicemail = formatter.dict_to_model(data) voicemail = voicemail_services.create(voicemail) result = formatter.to_api(voicemail) location = url_for('.get', voicemailid=voicemail.id) return make_response(result, 201, {'Location': location})
def new_station (): data = request.get_json() # this is the dict created from the json request sent by the station station = {} station ['station_id'] = data ['station_id'] station ['lat'] = data ['lat'] station ['lon'] = data ['lon'] # put the new station in the database insert_new_station(station) # create the response if (create_command): # allows to choose between the two possible results response = { 'state' : True, 'msg' : text_server } else: response = { 'state' : False, 'msg' : text_server, 'sleep' : 0 # the station sends a new request after 'sleep' seconds } r = make_response(json.dumps(response, separators=(',',':'))) return r # send the response to the station
def metrics(): registry = core.REGISTRY output = generate_latest(registry) response = make_response(output) response.headers['Content-Type'] = CONTENT_TYPE_LATEST return response
def put(self): # contracts try: l = lessonUpdateContract(request) except Exception as e: return make_response(jsonify(error=str(e), ), 400) # operations try: lesson = lessonUpdateOperation(l['topic_id'], l['lesson_id'], l['col'], l['value']) except ErrorWithCode as e: return make_response(jsonify(error=e.message), e.status_code) # success case return make_response(jsonify(lesson.asdict()), 200)
def create(): data = document.parse(request) line = formatter.dict_to_model(data) line = line_services.create(line) result = formatter.to_api(line) location = url_for('.get', lineid=line.id) return make_response(result, 201, {'Location': location})
def user_delete(self): """User delete RESTAPI method.""" data = request.get_json() my_id = data.get('id', None) if my_id: item = self.datamodel.get(my_id) result = self.datamodel.delete(item) if result: log.debug("user %s successfully been deleted by %s", item.username, g.user.username) return jsonify( {'msg': "Success deleted user {0}".format(item.username)}) else: return make_response(jsonify({'msg': 'delete failed'}), 500) else: return make_response(jsonify({'msg': 'user id not exists'}), 400)
def rp(): try: iss = request.args['iss'] except KeyError: link = '' else: link = iss try: uid = request.args['uid'] except KeyError: uid = '' if link or uid: if uid: args = {'user_id': uid} else: args = {} try: result = current_app.rph.begin(link, **args) except Exception as err: return make_response('Something went wrong:{}'.format(err), 400) else: return redirect(result['url'], 303) else: _providers = current_app.srv_config.rp.clients.keys() return render_template('opbyuid.html', providers=_providers)
def change_status() -> Response: ticket_id = int(request.form.get('ticketID')) new_status = request.form.get('ticketStatus') ticket = db.session.query(Ticket).get(ticket_id) ticket.state = new_status db.session.commit() return make_response("OK")
def deleteFiles(connection_id, file_id): try: filename = getFilename(connection_id, file_id) os.remove(filename) return Response(status=200) except IndexError: return make_response('File not found', 404)
def upload(): filename = None if request.method == "POST": filesize = request.cookies.get("filesize") file = request.files["file"] filename = file.filename filename_ori = filename.split('.')[0] print(f"Filesize: {filesize}") print(file) res = make_response(jsonify({"message": f"{file.filename} uploaded"}), 200) file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename)) df = pd.read_csv(os.path.join(app.config['UPLOAD_FOLDER'], filename)) plt.imshow(df) plt.savefig( os.path.join(app.config['UPLOAD_FOLDER'], '{}.jpg'.format(filename_ori))) plt.clf() return res return render_template('album.html', filename=filename)
def save_shifts(): try: i = 1 cfg = config() while i<=3: enabled = request.form.get("hasShift{idx}".format(idx = i), False) name = request.form["shift{idx}name".format(idx = i)] time = request.form["shift{idx}time".format(idx = i)] hm = time.split(':') cfg["shifts"][i-1]["enabled"].set(enabled=="on") cfg["shifts"][i-1]["name"].set(name) cfg["shifts"][i-1]["start_time_hrs"].set(hm[0]) if len(hm)>1: cfg["shifts"].items cfg["shifts"][i-1]["start_time_minutes"].set(hm[1]) else: cfg["shifts"][i-1]["start_time_minutes"].set(0) i = i +1 yml = cfg.dump(True) workdir = os.getcwd() text_file = open(workdir+'/config.yaml', "w") text_file.write(yml) text_file.close() return redirect("/settings", code=302) except Exception as e: print(e) return make_response(e, 400)
def create(): data = document.parse(request) extension = formatter.dict_to_model(data) extension = extension_services.create(extension) result = formatter.to_api(extension) location = url_for('.get', extensionid=extension.id) return make_response(result, 201, {'Location': location})
def annotate(): if not session.get('logged_in'): abort(401) errors = [] if request.method == 'GET': return render_template('annotate.html', errors=errors) elif request.method == 'POST': # Form input validation try: chrom = int(request.form['chrom']) except ValueError: errors.append('Chromosome column number must be numeric.') try: bp = int(request.form['bp']) except ValueError: errors.append('Base-pair column number must be numeric.') uploaded_file = request.files['file'] if not uploaded_file or not allowed_file(uploaded_file.filename): errors.append('Please upload a valid file ending with a .csv extension.') if errors: return render_template('annotate.html', errors=errors) # Upload file filename = secure_filename(uploaded_file.filename) saved_file = os.path.join(app.config['UPLOAD_FOLDER'], filename) uploaded_file.save(saved_file) # flash('Saved file under ' + saved_file + '\n') returncode, output, run_errors = annotate_file(saved_file, chrom, bp) if returncode != 0 or run_errors: if not run_errors: errors.append('An unknown error annotating the file has occurred.') else: for error in run_errors: errors.append(error) return render_template('annotate.html', errors=errors) else: response = make_response(output) response.headers['Content-Disposition'] = 'attachment; filename=%s' % (annotated_file_name(uploaded_file.filename),) os.remove(saved_file) return response
def login(): form = LoginForm(request.form) if request.method == 'POST' and form.validate(): user = User(form.user_id.data, form.passwd.data) keep_time = (60 * 60 * 24 if form.remember_me.data else 60 * 60) if ('admin', 'admin123') == (user.name, user.passwd) \ or user.do_authentication(): role = 'admin' time_form = TimeForm() index = get_log() data = {'data_id': index} main_page = render_template('f5log.html', user=user.name, form=time_form, action=0, index=data) sid = SID_MANAGER.add_sid(user.name, role, keep_time) response = make_response(main_page) response.set_cookie('USER', value=user.name, max_age=keep_time) response.set_cookie('SID', value=sid, max_age=keep_time) return response messages = 'Login failed, check account and password!' flash(messages) LOG.error(messages) return render_template('login.html', form=form)
def excel(): return "" import tablib type = request.args.get('type') if type == 'checked': sql = 'SELECT distinct barcode ,zcbqh,user_code ,swmc,zrbmmc,ztbz,ztbz1,ztbz2,wlwz ,ggxh,barcodelist.opdate ' \ '' \ 'FROM zczb, barcodelist WHERE zczb.zcbqh IN(SELECT mission_barcode.barcode FROM mission_barcode WHERE ' \ 'mission_barcode.missionid = 1 AND mission_barcode.msgid IS NOT NULL) AND barcodelist.barcode = zczb' \ '.zcbqh order by barcodelist.opdate desc' listdata = [] data = AdoHelper().db().query(sql) headers = ([x for x in data[0]]) for d in data: listdata.append([d[x] for x in d]) data = tablib.Dataset(*listdata, headers=headers) output = StringIO.StringIO() output.write(data.xls) response = make_response(output.getvalue()) response.headers['Content-Type'] = 'application/vnd.ms-excel' response.headers[ 'Content-Disposition'] = 'attachment; filename=list.xls' return response
def _stop_session(self, session_id): """ closes a session """ assert request.method in ('DELETE', 'GET') assert session_id in request.base_url result = self._session_handler.stop_session(session_id) return make_response(jsonify(result), 200)
def get_graph_metadata(graph_id: int): """Returns the metadata for a single graph. This is automatically generated by the datasource classes. Parameters ---------- graph_id : int Graph ID. Returns 404 if the graph ID is not found Returns ------- Dict A dictionary representing the metadata of the current graph. """ graph_obj = Graph.query.filter_by(id=graph_id).first() if not graph_obj: return make_response(jsonify({"message": "Graph not found"}), 404) response = jsonify(graph_obj.meta) response.headers.add("Access-Control-Allow-Origin", "*") return response
def _shutdown(self): for session_id in self._sessions: self._session_handler.stop_session(session_id) request.environ.get('werkzeug.server.shutdown')() res = 'shutting down...' return make_response(jsonify(res))
def decorated_view(*args, **kwargs): if current_app.login_manager._login_disabled: return func(*args, **kwargs) elif not current_user.is_authenticated: return make_response(jsonify({'msg': 'lost session, need to relogin', 'session': \ request.cookies.get(config.config.SESSION_COOKIE_NAME)}), 302) return func(*args, **kwargs)
def ckupload(): error = '' url = '' callback = request.args.get('CKEditorFuncNum') if request.method == 'POST' and 'upload' in request.files: fileobj = request.files['upload'] fname, fext = os.path.splitext(fileobj.filename) rnd_name = '%s%s' % (gen_rnd_filename(), fext) filepath = os.path.join(app.static_folder, 'upload/ckupload', rnd_name) # check file path exists or not dirname = os.path.dirname(filepath) if not os.path.exists(dirname): try: os.makedirs(dirname) except: error = 'ERROR_CREATE_DIR' elif not os.access(dirname, os.W_OK): error = 'ERROR_DIR_NOT_WRITEABLE' if not error: fileobj.save(filepath) resize_image_by_width(filepath, new_width=640) url = url_for('static', filename='%s/%s' % ('upload/ckupload', rnd_name)) else: error = 'post error' res = """ <script type="text/javascript"> window.parent.CKEDITOR.tools.callFunction(%s, '%s', '%s'); </script> """ % (callback, url, error) response = make_response(res) response.headers['Content-Type'] = 'text/html' return response
def export_move(id): move = Move.query.filter_by(id=id).first_or_404() if not move.public and move.user != current_user: return app.login_manager.unauthorized() if "format" in request.args: format = request.args.get("format").lower() else: format = "gpx" # default format_handlers = {'gpx': gpx_export.gpx_export, 'csv': csv_export.csv_export} if format not in format_handlers: flash("Export format %s not supported" % format, 'error') return redirect(url_for('move', id=id)) export_file = format_handlers[format](move) if not export_file: return redirect(url_for('move', id=id)) # app.logger.debug("Move export (format %s):\n%s" % (format, export_file)) response = make_response(export_file) date_time = move.date_time.strftime('%Y-%m-%dT%H_%M_%S') if move.location_raw: address = move.location_raw['address'] city = get_city(address) country_code = address['country_code'].upper() filename = "Move_%s_%s_%s_%s.%s" % (date_time, country_code, city, move.activity, format) else: filename = "Move_%s_%s.%s" % (date_time, move.activity, format) response.headers['Content-Disposition'] = "attachment; filename=%s" % (quote_plus(filename)) return response
def post(self): resp = make_response({"message": "Signed out"}) unset_access_cookies(resp) unset_refresh_cookies(resp) return resp
def index(): """Initialize a session for the current user, and render index.html.""" # Set the Client ID, Token State, and Application Name in the HTML while # serving it. print "Index" print "session: " + str(session) #session is a class object called <SecureCookieSession> which contains various datas if 'user_id' in session: print 'Logged in as %s' % session['user_id'] #commented this off because it only checks for google plus id #if 'gplus_id' in session: # print session['gplus_id'] else: print 'Not logged in' print "current_user.get_id(): " + str(current_user.get_id()) videolist = get_db_videolist() response = make_response( render_template('videolist_web.html', cdnroot=current_app.config['CDN_ROOT'], videolist=videolist)) response.headers['Content-Type'] = 'text/html' return response
def move_fleetmembers_to_safety(): fleet_id = int(request.form.get('fleetID')) crest_fleet = db.session.query(CrestFleet).get(fleet_id) if not crest_fleet.comp.get_eve_id() == current_user.get_eve_id(): flask.abort(403, "You are not the Fleet Comp of this fleet!") teamspeak_id = sget_active_ts_id() if teamspeak_id is None: flask.abort(500, "No TeamSpeak Server set!") teamspeak: TeamspeakDatum = db.session.query(TeamspeakDatum).get( teamspeak_id) if teamspeak.safetyChannelID is None: flask.abort(500, "No TeamSpeak Safety Channel set!") # get the safety fleet channel id member = member_info.get_fleet_members(fleet_id, crest_fleet.comp) for charID in member: char_id: int = member[charID].character_id() char = db.session.query(Character).get(char_id) if char is None: continue safety_channel_id: int = teamspeak.safetyChannelID move_to_safety_channel(char.eve_name, safety_channel_id) return make_response("OK", 200)
def delete_venue_submission(venue_id): try: v = Venue.query.get(venue_id) db.session.delete(v) db.session.commit() except: print(sys.exc_info()) flash("Something went wrong! Try again") redirect_url = url_for('show_venue', venue_id=venue_id) return make_response(jsonify({'redirect_url': redirect_url}), 500) finally: db.session.close() flash('Venue deleted successfully!') return make_response('', 204)
async def competitions_history(league_id, team_id): history_of_selected_team = [] teams_from_league = await prov.get_teams_from_league(league_id) team_info = await prov.get_teams_with_team_id(team_id) team_name = team_info[0]["team_name"] team_badge = team_info[0]["team_badge"] team_is_in_league = False # Check that both of the teams are in the same league for team in teams_from_league: if team["team_key"] == team_info[0]["team_key"]: team_is_in_league = True if team_is_in_league: for match in cache["history"]: if match["Home Name"] == team_name or match[ "Away Name"] == team_name: history_of_selected_team.append(match) return render_template("competitions.html", team_badge=team_badge, team_name=team_name, league_id=league_id, history=history_of_selected_team, history_count=len(history_of_selected_team)) else: response = make_response( redirect( url_for("competitions_make_prediction", league_id=league_id))) response.set_cookie("error", "This team is not in the league.", max_age=1) return response
def post(self): data = argumentos.parse_args() cobranca = CobrancaModel(**data) cobranca.salvar_cobranca() cobrancas = returnCharge() return make_response( render_template("reportCharge.html", cobrancas=cobrancas), 201)
async def h2h_two_teams_selected(league_id, first_team, second_team): """ Route where the user has already selected two teams """ try: first_team = await prov.get_teams_with_team_id(first_team) second_team = await prov.get_teams_with_team_id(second_team) first_team_infos = { "key": first_team[0]["team_key"], "name": first_team[0]["team_name"], "badge": first_team[0]["team_badge"], } second_team_infos = { "key": second_team[0]["team_key"], "name": second_team[0]["team_name"], "badge": second_team[0]["team_badge"], } return render_template("h2h.html", league_id=league_id, first_team=first_team_infos, second_team=second_team_infos) except Exception: response = make_response(redirect(url_for("h2h"))) response.set_cookie( "error", "We encountered a problem while data of the team you selected.", max_age=1) return response
def create(): data = document.parse(request) user = formatter.dict_to_model(data) user = user_services.create(user) result = formatter.to_api(user) location = url_for('.get', userid=user.id) return make_response(result, 201, {'Location': location})
def make_response(self): response = helpers.make_response( self.get_content(), self.status, ) response.headers.extend(self.headers) return response
def edit_cti_configuration(userid): url.check_user_exists(userid) data = document.parse(request) model = formatter.dict_to_model(data, userid) user_cti_profile_services.edit(model) return make_response('', 204)
def post(self): # contracts try: q = questionCreateContract(request) except Exception as e: return make_response(jsonify(error=str(e), ), 400) # operations try: question = questionCreateOperation(q['topic_id'], q['lesson_id'], q['description']) except ErrorWithCode as e: return make_response(jsonify(error=e.message), e.status_code) # success case return make_response(jsonify(question.asdict()), 200)
def cleanup_uploads(): """ Deletes uploaded images (input image and extra input images, if any), for each of the given keys in the data to process or list of filenames to process """ data = request.get_json()['data'] for file_name in data: # Delete the file from uploads/images file_path = os.path.join(app.config['IMAGES_DIR'], file_name) try: os.remove(file_path) except OSError as err: print('>>> [/cleanup/uploads] Error deleting file:', file_name) print('>>>', err) # Delete associated extra inputs from uploads/images/extra_inputs extra_inputs = [ file for file in os.listdir(app.config['EXTRA_IMAGES_DIR']) if file.startswith(file_name.split('.')[0] + '_') ] for extra in extra_inputs: extra_path = os.path.join(app.config['EXTRA_IMAGES_DIR'], extra) try: os.remove(extra_path) except OSError as err: print('>>> [/cleanup/uploads] Error deleting file:', extra) print('>>>', err) return make_response(jsonify('Server: Uploaded files have been deleted'), 200)
def delete(self): # contracts try: l = lessonDeleteContract(request) except Exception as e: return make_response(jsonify(error=str(e), ), 400) # operations try: lesson = lessonDeleteOperation(l['topic_id'], l['lesson_id']) except ErrorWithCode as e: return make_response(jsonify(error=e.message), e.status_code) # success case return make_response(jsonify(message='Successfully deleted lesson'), 200)
def export(direction=None, user=None, date=None): '''Export loan entries''' current_user_id = session.get('logged_in_user') our_loans = Loans(current_user_id) our_users = Users(current_user_id) # fetch loans loans = our_loans.get_loans() # fetch users from connections from us users = our_users.get_connections() # provided user? if user: # valid slug? user_id = our_users.is_connection(slug=user) if user_id: loans = our_loans.get_loans(user_id=user_id) # provided a date range? date_range = translate_date_range(date) if date_range: loans = our_loans.get_loans(date_from=date_range['low'], date_to=date_range['high']) # date ranges for the template date_ranges = get_date_ranges() # provided a direction? if direction: loans = our_loans.get_loans(direction=direction) response = make_response(render_template('admin_export_loans.html', **locals())) response.headers['Content-type'] = 'text/csv' response.headers['Content-disposition'] = 'attachment;filename=' + 'loans-' + str(today_date()) + '.csv' return response
def get(self): # contracts try: s = activityReadContract(request) except Exception as e: return make_response(jsonify(error=str(e), ), 400) # operations try: stat = activityReadOperation(s['date_start'], s['date_end'], s['student_id']) except ErrorWithCode as e: return make_response(jsonify(error=e.message), e.status_code) # success case return make_response(jsonify(stat), 200)