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)
