def block_descriptions(request):
"""See :class:`bgpranking.api.get_block_descriptions`"""
asn = request.get('asn')
block = request.get('block')
if asn is None or block is None:
return json.dumps([])
return json.dumps(bgpranking.get_block_descriptions(asn, block))
def asn_description(request):
"""See :class:`bgpranking.api.get_asn_descs`"""
asn = request.get('asn')
if asn is None:
return json.dumps({})
return json.dumps(bgpranking.get_asn_descs(asn,
request.get('date'), request.get('sources')))
def aggregate_history(request):
ip = request.get('ip')
if ip is None:
return json.dumps({})
return json.dumps([(line[0], line[1], line[2], line[3])
for line in ipasn.aggregate_history(ip, request.get('days_limit') or 30)
if line is not None])
def all_ranks_single_asn(request):
"""See :class:`bgpranking.api.get_all_ranks_single_asn`"""
asn = request.get('asn')
if asn is None:
return json.dumps({})
dates_sources = __default_dates_sources(request)
return json.dumps(bgpranking.get_all_ranks_single_asn(asn,
dates_sources, request.get('with_details_sources')))
def ips_description(request):
"""See :class:`bgpranking.api.get_ips_descs`"""
asn = request.get('asn')
block = request.get('block')
if asn is None or block is None:
return json.dumps({})
return json.dumps(bgpranking.get_ips_descs(asn, block,
request.get('date'), request.get('sources')))
def create_user():
username = request.get('username')
password = request.get('password')
email = request.get('email')
user = User(email = email, password = password, username = username)
db.session.add(user)
db.session.commit()
return make_response('user created')
def opcua_init(request):
client = Client(
request.get('url', 'opc.tcp://localhost:4841'),
timeout=request.get('timeout', 10)
)
client.set_security_string(request.get('security', ''))
client.connect()
return client
def cached_top_asns(request):
"""See :class:`bgpranking.api.cache_get_top_asns`"""
cached_dates = bgpranking.cache_get_dates()
date = request.get('date')
if date is None or date in cached_dates:
return json.dumps(bgpranking.cache_get_top_asns(
request.get('source'), date, request.get('limit'),
request.get('with_sources')),
cls=SetEncoder)
return json.dumps({})
def create_task():
# print "I am %s and my daddy is %s" % (whoami(),whosmydaddy())
current_user_id = session['user_id']
task_content = request.form['task_content']
deadline = request.get('deadline',None)
priority = request.get('priority',0)
parent_tasklist_id = request['parent_tasklist_id']
new_task = Task(parent_tasklist_id,current_user_id,task_content,deadline,priority)
db.session.add(new_task)
return 'true'
def cached_daily_rank(request):
"""See :class:`bgpranking.api.cache_get_daily_rank`"""
asn = request.get('asn')
if asn is None:
return json.dumps({})
cached_dates = bgpranking.cache_get_dates()
date = request.get('date')
if date is None or date in cached_dates:
return json.dumps(bgpranking.cache_get_daily_rank(asn,
request.get('sources'), date))
return json.dumps({})
def cached_position(request):
"""See :class:`bgpranking.api.cache_get_position`"""
asn = request.get('asn')
if asn is None:
return json.dumps({})
cached_dates = bgpranking.cache_get_dates()
date = request.get('date')
if date is None or date in cached_dates:
return json.dumps(bgpranking.cache_get_position(asn, date=date),
cls=SetEncoder)
return json.dumps({})
def search(request):
if request.get('value'):
hash_value = SHA.new(request.get('value')).hexdigest()
else:
hash_value = request.get('hash_value')
if hash_value is None:
return json.dumps({})
r = StrictRedis(unix_socket_path=redis_socket)
known_uuids = r.smembers(hash_value)
to_return = {'known': (len(known_uuids) != 0)}
if not request.get('quiet'):
to_return['uuids'] = known_uuids
return to_return
def update_user():
username = request.get('username')
password = request.get('password')
email = request.get('email')
pincode = request.get('pincode')
first_name = request.get('first_name')
last_name = request.get('last_name')
phone = request.get('phone')
address = request.get('address')
zip_code = request.get('zip_code')
country = request.get('country')
user = db.session.query(User).filter(User.username == username).first()
if user.verify_password(password) :
if any(email) :
user.email = email
if any(username) :
user.username = username
if any(password) :
user.password = password
if any(pincode) :
user.pincode = pincode
if any(first_name) :
user.first_name = first_name
if any(last_name) :
user.last_name = last_name
if any(phone) :
user.phone = phone
if any(address) :
user.address = address
if any(zip_code) :
user.zip_code = zip_code
if any(country) :
user.country = country
return make_response('user updated')
else:
abort(401)
def webhook():
res = request.get_json(silent=True)
event = checkEvent(res).get_event()
menu = menusFB(url_send,os.environ['TOKEN'],res,usuarios_faltantes)
req_backend = reqsbackend()
validate_obj = validate(url_send,os.environ['TOKEN'],res)
print res
print event
if event is 'postback':
print event
postback_obj = postback(res,menu,validate_obj)
postback_obj.derivar_postback()
elif event is 'message':
if menu.guardar_y_solicitar_dato():
menu.pedirDato()
if menu.contieneTexto('menu'):
menu.menu_principal()
elif event is 'optin':
if not req_backend.existeUser(res['sender']['id']):
url = url_user_datos.replace('<USER_ID>', res['sender']['id']) + os.environ['TOKEN']
datos_user = request.get(url)
datos_user['user_fb'] = res['sender']['id']
req_backend.crearUser(datos_user)
else:
print "error event"
return "asd"
def setrange():
"""
User chose a date range with the bootstrap daterange
widget.
"""
app.logger.debug("Entering setrange")
flask.flash("Setrange gave us '{}'".format(request.form.get('daterange')))
daterange = request.form.get('daterange')
flask.session['daterange'] = daterange
daterange_parts = daterange.split()
flask.session['begin_date'] = interpret_date(daterange_parts[0])
flask.session['end_date'] = interpret_date(daterange_parts[2])
#begin time maybe?
#end time maybe?
start_time = request.form.get('start_time')
#covert the time to local, so use interpret function
flask.session['start_time']=interpret_time(start_time)
end_time = request.get('end_time')
flask.session['end_time']=interpret_time(end_time)
#re-formatting the debug message, with start time and end time
app.logger.debug("Setrange parsed {} - {} dates as {} - {}".format(
daterange_parts[0], daterange_parts[1],
flask.session['begin_date'], flask.session['end_date']))
#end date and end time on debug
app.logger.debug("Setrange parsed time as {}-{}".format(
flask.session['start_time'],flask.session['end_time']))
return flask.redirect(flask.url_for("choose"))
def getCurrentWeather(zipCode, date=datetime.today()):
url = buildUSZipUrl(zipCode, 'weather')
weatherResponse = request.get(url)
if weatherResponse.status_code == 200:
return weatherResponse.content
else:
return jsonify("Error while collecting weather report")
def getForecastForZip(zipCode, forecastDays):
url = buildUSZipUrl(zipCode)
weatherResponse = request.get(url)
if weatherResponse.status_code == 200:
return weatherResponse.content
else:
return jsonify("Error while collecting weather report")
def make_admin():
user = User.all().filter("email", request.get("email")).get()
if user:
user.is_admin = True
user.put()
return make_response("User with email %s is now admin" % user.email)
def searchDataFrames(self, request, from_get=False):
"""
DataFrame Search Function
"""
# enforce project level access control by enforcing restrictions on keyspaces
check_ks = request.get('keyspaceIds', None)
if check_ks is None or (len(check_ks) == 1 and check_ks[0] == unicode('mask-keys')):
raise BadRequestException("keyspaceIds required when searching dataframes")
# get proto, validates
jreq = util.fromJson(json.dumps(request), fs.SearchDataFramesRequest)
# handle masks, ommitting contents from endpoint
mask_contents = {"contents": 0}
mask_keys = None
# handle filters
filters = {}
if len(jreq.dataframe_ids) > 0:
filters['_id'] = util.getMongoFieldFilter(jreq.dataframe_ids, ObjectId, from_get=from_get)
if len(jreq.keyspace_ids) > 0:
# grab keys mask
keyspace_ids = jreq.keyspace_ids
if from_get:
keyspace_ids = jreq.keyspace_ids[0].split(',')
mask_keys = util.setMask(keyspace_ids, unicode('mask-keys'), 'keys')
# process keyspace ids
if len(keyspace_ids) > 0:
filters.setdefault('$or',[]).append({'major': util.getMongoFieldFilter(keyspace_ids, ObjectId, from_get=from_get)})
filters['$or'].append({'minor': util.getMongoFieldFilter(keyspace_ids, ObjectId, from_get=from_get)})
if len(jreq.unit_ids) > 0:
filters.setdefault('$and', []).append({'units': util.getMongoFieldFilter(jreq.unit_ids, ObjectId, from_get=from_get)})
result = self.db.dataframe.find(filters, mask_contents)
# make proto
_protoresp = fs.SearchDataFramesResponse(dataframes=[])
for r in result:
kmaj_name, kmaj_keys = util.getKeySpaceInfo(self.db, r['major'], mask_keys)
kmin_name, kmin_keys = util.getKeySpaceInfo(self.db, r['minor'], mask_keys)
dataframe = fs.DataFrame(id=str(r['_id']), \
major=fs.Dimension(keyspace_id=str(r['major']), keys=kmaj_keys), \
minor=fs.Dimension(keyspace_id=str(r['minor']), keys=kmin_keys), \
units=[], contents=[])
for unit in r['units']:
_unit = self.db.units.find_one({'_id':unit})
dataframe.units.extend([fs.Unit(name=_unit['name'], \
description=_unit['description'], \
id=str(_unit['_id']))])
_protoresp.dataframes.extend([dataframe])
return util.toFlaskJson(_protoresp)
def url_endpoint():
url = request.args.get('url')
if pass_connection('data'):
# Generate request to the URL, serve back to user
req = request.get(url, stream = True)
return Response(stream_with_context(req.iter_content()),
content_type = req.headers['content-type'])
else:
return generate_503()
def subscribe():
error = None
print "sub"
print "sub1"
username = request.form["myname"]
print username
db = dynamodb_date()
user_data = db.get_user(username)
print user_data.get("address")
notification = sns()
print 'subscribe new'
print user_data
#db.update(user)
if request.get('sbs') =='0':
notification.subscribe1(user_data["email"])
elif request.get('sbs') =='1':
notification.subscribe1_phone(user_data["phone"])
return render_template('subscribe.html', user=user_data, error =error )
def isValid(request):
for field, fieldType in Validator.fields:
typeVal = fieldType.value
validator = getattr(Validator, "isValid" + typeVal,
lambda _: (False,
typeVal + " validator not found."))
valid, err = validator(request.get(field))
if not valid:
return False, err
return True, "Valid request."
def thumbnails():
if request.method == 'POST' :
url =request.form['url']
r = request.get(url)
if r.status_code==200:
images=image_dem(url)
return render_template('view.html',images=images)
return render_template('view.html')
else:
return render_template('form.html')
def view(cls, request, *args, **kwargs):
config = get_json_file('config.json')
module_name = request.get('module_name')
sub_module_name = request.get('sub_module_name')
module_config = config.get('modules').get(module_name)
module_children = module_config.get('children')
sub_module_confg = module_children.get(sub_module_name)
try:
middleware = import_module("middleware.module_" +
sub_module_confg.get('module'))
except ImportError:
abort(404)
data = middleware.main(app, sub_module_confg.get('data', {}))
return cls(properties=data)
def return_directions():
"""Display directions to a specific park."""
route = session.get('origin')
routing = session.get('routing')
coords = request.get('coords')
# print request.form
# Use json.loads to read the string
results = get_directions(route, routing)
return jsonify(results)
def opcua_write(request):
global_error = False
commands_ok = False
commands_ko = False
try:
client = opcua_init(request)
commands_ok, commands_ko = do_write(
client,
request.get('commands', []),
)
except Exception, error:
global_error = error.message
def login():
username = request.get('username')
password = request.get('password')
Rfid = request.get('Rfid')
pincode = request.get('pincode')
if any(username) and any(password) :
user = db.session.query(User).filter(User.username == username).first()
if user.verify_password(password) :
return make_response('true')
else :
abort(401)
elif any(Rfid) and any(pincode):
user = db.session.query(User).filter(User.Rfid == Rfid).first()
if user.verify_pincode(pincode) :
return make_response('true')
else :
abort(401)
else :
abort(400)
def create(self, request):
if 'environment' in request:
environment = request['environment']
else:
environment = ''
project = Project.query.get(request['project'])
host = Host.query.get(request['host'])
instance = VagrantInstance(None, request['path'], request['name'],
environment)
instance.git_reference = request.get('gitReference')
instance.archive_url = request.get('archive_url')
instance.project = project
instance.host = host
db.session.add(instance)
db.session.commit()
if instance.git_reference:
instance.clone()
elif instance.archive_url:
instance.extract()
return instance
def getIdResults(ingredient_id):
def dict_factory(cursor, row):
d = {}
for idx, col in enumerate(cursor.description):
d[col[0]] = row[idx]
return d
#First checking in databse
conn = sqlite3.connect('../../ingredients.db', detect_types=sqlite3.PARSE_COLNAMES)
conn.row_factory = dict_factory
c = conn.cursor()
query = 'SELECT * from ingredients where id=(?);'
c.execute(query, (int(ingredient_id),))
query_result = c.fetchone()
#if database doesn't have the id
print(str(ingredient_id).zfill(5))
if query_result is None:
string_id = str(ingredient_id).zfill(5)
url = "http://api.nal.usda.gov/ndb/reports/?ndbno="+string_id+"&type=f&format=json&api_key=DEMO_KEY"
url_results = request.get(url).json()
#to make sure we don't get bad outputs
if 'errors' in url_results:
reponse ={'response': 'ingredient', 'error': 'Invalid key'}
response = {
'response' : 'ingredient',
'id' : url_results['report']['food']['ndbno'],
'name': url_results['report']['food']['name'],
'group_name': url_results['report']['food']['fg'],
'nutrients': []
}
for nutrient in url_results['report']['food']['nutrients']:
response['nutrients'].append({'name': nutrient['name'] ,'value':nutrient['value']})
return response
response = {
'response': 'ingredient',
'id': query_result['id'],
'name': query_result['name'],
'group_name': query_result['group_name'],
'nutrients': []
}
for key in query_result.keys():
if key is not ('name' or 'id' or 'group_name'):
if query_result[key] is not None:
response['nutrients'].append({'name':key,'value':query_result[key]})
return response
def get_post_comments(id):
post = Post.query.get_or_404(id)
page = request.get('page', 1, type=int)
pagination = post.comments.order_by(Comment.timestamp.asc()).paginate(page,
per_page=current_app.config['BOOK_COMMENTS_PER_PAGE'], error_out=False)
comments = pagination.items
prev = None
if pagination.has_prev:
prev = url_for('api.get_post_comments', page=page-1, _external=True)
next = None
if pagination.has_next:
next = url_for('api.get_post_comments', page=page+1, _external=True)
return jsonify({'comments': [comment.to_json() for comment in comments],
'prev': prev,
'next': next,
'count': pagination.total
})
def inbound_sms():
if request.is_json:
message = request.get(json())
else:
message = dict(request.form) or dict(request.args)
num = message['msisdn']
text = message['text'].lower()
map = {
"hi": add,
"cancel": remove,
"status": status,
"help": help
}
action = map.get(text)
if action:
action(num)
else:
send(num, "Could not understand. Please try again")
return ('', 204)
def kakao():
""" kakao 로그인 API
"""
db = None
try:
token = request.headers['Authorization']
nickname = request.get_json(silent=True).get('nickname', None)
if not token:
return jsonify(message="TOKEN_DOES_NOT_EXIST"), 400
data = request.get('https://kapi.kakao.com/v2/user/me', headers={'Authorization':f'Bearer {token}'})
kakao_id = data.json()['kakao_id']
db = db_connector()
if db is None:
return jsonify(message="DATABASE_INIT_ERROR"), 500
kakao_user = model_dao.search_kakao_user(db, kakao_id)
# 가입된 계정인 경우 로그인 진행
if kakao_user:
token = jwt.encode(kakao_user, SECRET_KEY, ALGORITHM)
return Jsonify(token=token.decode('utf-8'), nickname=nickname), 200
# 가입되어있지 않은 계정인 경우 회원가입 진행
elif kakao_user is None:
db.begin()
social_id = model_dao.insert_kakao_user(db, kakao_id)
if nickname:
kakao_user = model_dao.insert_kakao_into_user(db, social_id, nickname)
token = jwt.encode(kakao_user, SECRET_KEY, ALGORITHM)
return Jsonify(token=token.decode('utf-8'), nickname=nickname), 200
# 닉네임 입력하지 않은 경우 에러처리
elif nickname is None:
return jsonify(message="DATA_ERROR"), 400
db.commit()
except Exception as e:
db.rollback()
return jsonify(message=f"{e}"), 500
finally:
if db:
db.close()
def get(self):
"""Handle a GET request."""
project = request.get('project')
if access.has_access():
# User is an internal user of ClusterFuzz (eg: ClusterFuzz developer).
# Show all projects in the list, since this allows user to pick another
# project as needed.
projects_list = data_handler.get_all_project_names()
# Filter fuzzers and job list if a project is provided.
fuzzers_list = (
data_handler.get_all_fuzzer_names_including_children(
include_parents=True, project=project))
jobs_list = data_handler.get_all_job_type_names(project=project)
else:
# User is an external user of ClusterFuzz (eg: non-Chrome dev who
# submitted a fuzzer or someone with a project in OSS-Fuzz).
user_email = helpers.get_user_email()
# TODO(aarya): Filter fuzzer and job if |project| is provided.
fuzzers_list = sorted(
external_users.allowed_fuzzers_for_user(user_email,
include_from_jobs=True,
include_parents=True))
if not fuzzers_list:
# User doesn't actually have access to any fuzzers.
raise helpers.AccessDeniedException(
"You don't have access to any fuzzers.")
jobs_list = sorted(
external_users.allowed_jobs_for_user(user_email))
projects_list = sorted(
{data_handler.get_project_name(job)
for job in jobs_list})
result = {
'projects': projects_list,
'fuzzers': fuzzers_list,
'jobs': jobs_list,
}
return self.render_json(result)
def resolve_conflicts(self):
neighbours = self.nodes
new_chain = None
max_length = len(self.chain)
for node in neighbours:
response = request.get(f'http://{node}/chain')
if response.status_code == 200:
length = response.json()['length']
chain = response.json()['chain']
if length > max_length and self.valid_chain(chain):
max_length = length
new_chain = chain
if new_chain:
self.chain = new_chain
return True
return False
def event_search():
print("HI")
print("HI")
print("HI")
print("HI")
print("HI")
print("HI")
search_term = request.get('search_term')
import pdb; pdb.set_trace()
search_term = '"%s"' % search_term.replace('"', '')
search_term = search_term.encode('unicode-escape')
event_search_index = search.Index(EVENT_SEARCH_INDEX)
results = event_search_index.search(search_term)
logging.debug('search results are "{}"'.format(results))
events = [ndb.Key(urlsafe=r.doc_id).get() for r in results]
events = [e for e in events if e is not None]
return("HI")
def register_nodes():
res = api.add('conn')
h = res['Hash']
def find():
os.system("ipfs dht findprovs " + h + "> peers")
t1 = threading.Thread(target=find)
t1.start()
time.sleep(10)
lis = []
with open("peers", "r") as f:
_ = f.readline()
for line in f:
line.rstrip("\n")
li = api.dht_findpeer(line[:-1])
li = li['Responses'][0]['Addrs']
for ele in li:
if ele.split("/")[1] == "ip4":
a = ele.split("/")[2]
try:
response = request.get(f'http://{a}:5000/chain',
timeout=1)
if response.status_code == 200:
if a != "127.0.0.1":
lis.append(a)
except:
print("", end="")
for i in lis:
i = "http://" + i + ":5000"
nodes = lis
if nodes is None:
return "Error: Please supply a valid list of nodes", 400
for node in nodes:
blockchain.register_node(node)
response = {
'message': 'New nodes have been added',
'total_nodes': list(blockchain.nodes),
}
return jsonify(response), 201
def payment():
invoice = request.get('invoice')
amount = request.form.get('amount')
customer = stripe.Customer.create(
email=request.form['stripeEmail'],
source=request.form['stripeToken'],
)
charge = stripe.Charge.create(
customer=customer.id,
description='Myshop',
amount=amount,
currency='usd',
)
orders = CustomerOrder.query.filter_by(
customer_id=current_user.id,
invoice=invoice).order_by(CustomerOrder.id.desc()).first()
orders.status = 'Paid'
db.session.commit()
return redirect(url_for('thanks'))
def get_user_posts(id):
user = User.query.get_or_404(id)
page = request.get('page', 1, type=int)
pagination = user.posts.order_by(Post.timestamp.desc()).paginate(page)
posts = pagination.items
prev = None
if pagination.has_prev:
prev = url_for('api.get_user_posts', page=page - 1, _external=True)
next = None
if pagination.has_next:
next = url_for('api.get_user_posts', page=page + 1, _external=True)
posts = Post.query.filter(author_id=id).all()
return jsonify({
'posts': [post.to_json() for post in posts],
'prev': prev,
'next': next,
'count': pagination.total
})
def get_result():
"""Get the result for the crash stats page."""
params = dict(request.iterparams())
page = helpers.cast(request.get('page') or 1, int, "'page' is not an int.")
group_by = params.get('group', 'platform')
params['group'] = group_by
sort_by = params.get('sort', 'total_count')
params['sort'] = sort_by
params['number'] = params.get('number', 'count')
# Conditions for individual records.
query = crash_stats.Query()
query.group_by = group_by
query.sort_by = sort_by
crash_access.add_scope(query, params, 'security_flag', 'job_type',
'fuzzer_name')
filters.add(query, params, FILTERS)
# Conditions after grouping.
group_query = crash_stats.Query()
filters.add(group_query, params, GROUP_FILTERS)
try:
total_count, rows = crash_stats.get(
query=query,
group_query=group_query,
offset=(page - 1) * PAGE_SIZE,
limit=PAGE_SIZE)
except ValueError:
raise helpers.EarlyExitException('Invalid filters', 400)
attach_testcases(rows)
helpers.log('CrashStats', helpers.VIEW_OPERATION)
result = {
'totalPages': (total_count // PAGE_SIZE) + 1,
'page': page,
'pageSize': PAGE_SIZE,
'items': rows,
'totalCount': total_count
}
return result, params
def consensus():
global blockchain
longestchain = None
currentlength = len(blockchain.chain)
for peer in peers:
response = request.get('{}chain'.format(peer))
length = response.json()['length']
chain = response.json()['chain']
if length > currentlength and blockchain.chain_validity(chain):
currentlength = length
longestchain = chain
if longestchain:
blockchain = longestchain
return True
return False
def a():
if request.method == 'POST':
url = request.form.get('url', '')
if url == '':
return '500'
hash_ = uhash(url)
content = request.get(url)
try:
title = content.content.split('<title>')[1].split('</title>')[0]
except:
title = ''
#content
new_url_info = Pool(time=datetime.datetime.now(),
uid=hash_,
url=url,
title=title,
content='')
new_url_info.save()
return LINK_SITE % (
DOMAIN + 'r?uid=' + hash_,
DOMAIN + 'r?uid=' + hash_,
)
else:
url = request.args.get('url', '')
if url == '':
return '500'
hash_ = uhash(url)
respon = requests.get(url)
try:
title = respon.content.split('<title>')[1].split('</title>')[0]
except:
title = ''
#content
new_url_info = Pool(time=datetime.datetime.now(),
uid=hash_,
url=url,
title=title,
content='')
new_url_info.save()
return LINK_SITE % (
DOMAIN + 'r?uid=' + hash_,
DOMAIN + 'r?uid=' + hash_,
)
def validate_get(Authorization=None): # noqa: E501
"""validate_get
# noqa: E501
:param Authorization: an authorization header token
:type Authorization: str
:rtype: None
"""
token = request.headers.get('Authorization')
headers = {'Authorization': token}
try:
#response = requests.get(AUTH_URL,headers=headers,verify = false)
response = request.get(AUTH_URL, headers=headers, verify=false)
if response.status_code == 200:
response = flask.make_response()
response.status_code = 200
response.mimetype = 'application/json'
response.data = json.dumps({"Message" "Verified and authorised"})
return response
elif (response.status_code == 401):
response = flask.make_response()
response.status_code = 401
response.mimetype = 'application/json'
response.data = json.dumps({"Message" "Unauthorised"})
return response
elif (response.status_code != 200):
response = flask.make_response()
response.status_code = 500
response.mimetype = 'application/json'
response.data = json.dumps({"Authorisation failure"})
except Exception as error:
response = {"error": "Exception occured while calling the uRL"}
return response
def makeresponse(req):
result = req.get("result")
parameters = result.get("parameters")
city = parameters.get("geo-city")
date = parameters.get("date")
r = request.get('api.openweathermap.org/data/2.5/forecast?q='+city+'api=0f083506be5607c1c5314158c0b683b9')
json_object = r.json()
weather = json_object('list')
for i in len(weather):
if date in weather[i]['dt_txt']:
condition = weather[i]['weather'][0]['description']
#The dialogflow expect the response from the webhook as
#{"speech":"","display_text":"","source":""}
speech = 'The weather forecast for'+city+'for'+date+'is:'+condition
return {
"speech":speech,
"display_text": speech,
"source":"apiai-weather-webhook"
}
def authorized():
response = microsoft.authorized_response()
if response is None:
return "Access Denied: Reason=%s\nError=%s" % (
response.get('error'), request.get('error_description'))
# Check response for state
print("Response: " + str(response))
if str(session['state']) != str(request.args['state']):
raise Exception('State has been messed with, end authentication')
# Okay to store this in a local variable, encrypt if it's going to client
# machine or database. Treat as a password.
session['microsoft_token'] = (response['access_token'], '')
session['expires_at'] = datetime.now() + timedelta(
seconds=int(response['expires_in']))
if 'refresh_token' in response:
session['refresh_token'] = response['refresh_token']
return redirect(url_for('home'))
def _get_launcher_script(self, upload_info):
"""Get launcher script path."""
launcher_script = request.get('launcher_script')
if not upload_info:
return launcher_script
if not launcher_script:
return None
if upload_info.size > ARCHIVE_READ_SIZE_LIMIT:
return launcher_script
reader = self._read_to_bytesio(upload_info.gcs_path)
launcher_script = archive.get_first_file_matching(launcher_script, reader,
upload_info.filename)
if not launcher_script:
raise helpers.EarlyExitException(
'Specified launcher script was not found in archive!', 400)
return launcher_script
def resolve_conflicts(self):
#使用共识算法解决冲突，使用网络中最长的链
neighbours = self.nodes
new_chain = None
max_length = len(self.chain)
for node in neighbours:
response = request.get('http://' + '{}'.format(node) + '/chain')
if response.status_code == 200:
length = response.json(['length'])
chain = response.json(['chain'])
if length > max_length and self.valid_chain(chain):
max_length = length
new_chain = chain
if new_chain:
self.chain = new_chain
return True
return False
def authorized():
response = microsoft.authorized_response()
if response is None:
return "Access Denied: Reason=%s\nError=%s" % (
response.get('error'), request.get('error_description'))
# Check response for state
print("Response: " + str(response))
if str(session['state']) != str(request.args['state']):
raise Exception('State has been messed with, end authentication')
# Okay to store this in a local variable, encrypt if it's going to client
# machine or database. Treat as a password.
access_token = response['access_token']
session['microsoft_token'] = (access_token, '')
session['claims'] = json.loads(
jws.verify(access_token, keys, algorithms=['RS256']))
return redirect(url_for('me'))
def validate_params(self, request):
params_keys = ["datasource", "metadata[]", "measurement", "regions"]
params = {}
for key in params_keys:
if request.has_key(key):
params[key] = request.get(key)
if key == "start" and params[key] in [None, ""]:
params[key] = 1
elif key == "end" and params[key] in [None, ""]:
params[key] = sys.maxint
elif key == "regions":
params[key] = eval(params[key])
elif key == "metadata[]":
del params["metadata[]"]
params["metadata"] = request.getlist(key)
else:
if key not in ["measurement", "genome", "metadata[]"]:
raise Exception("missing params in request")
return params
def consensus():
global blockchain
longest_chain = None
current_len = len(blockchain.chain)
for node in peers:
response = request.get('http://{}/chain'.format(node))
length = response.json()['length']
chain = response.json()['chain']
if length > current_len and blockchain.check_chain_validity(chain):
current_len = length
longest_chain = chain
if longest_chain:
blockchain = longest_chain
return True
return False
def delete_user():
"""
Delete the user details with the given user name
.. example::
$ curl http://localhost:5000/api/deleteuser -X POST \
-d '{"username":"******"}' -H "Authorization: Bearer <your_token>"
"""
print("a new user request")
request = flask.request.get_json(force=True)
username = request.get('username', None)
#password = request.get('password', None)
#roles = 'guest';
user = User.query.filter_by(username=username).first()
#guest = User(username = username,password=guard.hash_password(password),roles=roles);
if user:
db.session.delete(user)
db.session.commit()
return {"message": "User account deleted"}, 200
else:
return {"message": "User doesn't exist"}, 500
def wrapper(self, *args, **kwargs):
"""Check to see if this handler has a valid CSRF token provided to it."""
token_value = request.get('csrf_token')
user = auth.get_current_user()
if not user:
raise helpers.AccessDeniedException('Not logged in.')
query = data_types.CSRFToken.query(
data_types.CSRFToken.value == token_value,
data_types.CSRFToken.user_email == user.email)
token = query.get()
if not token:
raise helpers.AccessDeniedException('Invalid CSRF token.')
# Make sure that the token is not expired.
if token.expiration_time < datetime.datetime.utcnow():
token.key.delete()
raise helpers.AccessDeniedException('Expired CSRF token.')
return func(self, *args, **kwargs)
def makeResponse(req):
result = req.get("result")
parameters = result.get("parameters")
city = parameters.get("geo-city")
date = parameters.get("date")
r = request.get('https://openweathermap.org/data/2.5/weather?q=' + city +
'&appid=b6907d289e10d714a6e88b30761fae22')
json_object = r.json()
weather = json_object['list']
for i in range(0, 30):
if date in weather[i]['dt_txt']:
condition = weather[i]['weather'][0]['description']
speech = "The forecast for" + city + "for " + date + "is " + condition
return {
"speech": speech,
"displayText": speech,
"source": "apiai-weather-webhook"
}
def CartesianGraph():
request = flask.request.get_json(force=True)
fileName = request.get('fileName', None)
print("FileName is :", fileName)
if fileName is None:
return "Error: No fileName field provided. Please specify an fileName."
file = 'C:/R3D/HF_PST_PROCESSING_OUTPUT_FILES/' + fileName + '.dat'
# file = '/home/nithivarn/Downloads/' + fileName + '.dat'
data = pd.read_csv(file, header=None, skiprows=3)
data1 = data[0].str.split(expand=True)
X, Y, Z = data1[0].astype('float').values, data1[1].astype('float').values, data1[2].astype('float').values
fig = plt.figure()
triang = tri.Triangulation(X, Y)
tcf = plt.tricontourf(triang, Z, cmap='jet')
plt.title(fileName, fontsize=14, fontweight='bold')
plt.xlabel('X', fontsize=14, fontweight='bold')
plt.ylabel('Y', fontsize=14, fontweight='bold')
plt.colorbar()
plt.savefig(fileName+'.png')
return send_file(fileName+".png", mimetype='image/gif')
def get_post_comments(id):
post = Post.query.get_or_404(id)
page = request.get('page', 1, type=int)
pagination = post.comments.order_by(Comment.timestamp.asc()).paginate(
page,
per_page=current_app.config['BOOK_COMMENTS_PER_PAGE'],
error_out=False)
comments = pagination.items
prev = None
if pagination.has_prev:
prev = url_for('api.get_post_comments', page=page - 1, _external=True)
next = None
if pagination.has_next:
next = url_for('api.get_post_comments', page=page + 1, _external=True)
return jsonify({
'comments': [comment.to_json() for comment in comments],
'prev': prev,
'next': next,
'count': pagination.total
})
def create_account():
if request.method == 'GET':
return render_template('signup.html')
elif request.method == 'POST':
username = request.get('username')
email = request.form.get('email')
password = request.form.get('password')
user = User(file)
if user.check_username(username):
return render_template(
'signup.html', msg='Username already exists!'
)
if user.check_email(email):
return render_template(
'signup.html', msg='You have already signed up!'
)
else:
user.signup(username, password)
return render_template(
'user_login.html',
msg='Successfully signed up! Enter username and password to login'
)
def authorized():
response = microsoft.authorized_response()
if response is None:
tc.track_exception()
tc.flush()
return "Access Denied: Reason=%s\nError=%s" % (
response.get('error'),
request.get('error_description')
)
# Check response for state
logger.debug("Response: " + str(response))
if str(session['state']) != str(request.args['state']):
raise Exception('State has been messed with, end authentication')
# Okay to store this in a local variable, encrypt if it's going to client
# machine or database. Treat as a password.
session['microsoft_token'] = (response['access_token'], '')
access_token = session['microsoft_token'][0]
session['decoded_access_token'] = jwt.decode(access_token, verify=False)
# ToDo : サブスクリプションがない場合の例外処理
try:
subscription_list = (microsoft.get(
'subscriptions?api-version=2014-04-01').data)['value']
except:
pass
else:
session['subscription_list'] = subscription_list
session['selected_subscription'] = subscription_list[0]
tc.context.user.id = session['decoded_access_token']['unique_name']
logger.debug(session)
logger.debug(access_token)
logger.debug(session['decoded_access_token'])
logger.info("Authorized successful")
return redirect(url_for('subscriptions', subscription_id=session['selected_subscription']['subscriptionId']))
def consensus():
# Our simple consensus algorithm. If a longer valid chain is
# found, our chain is replaced with it.
global blockchain
longest_chain = None
current_len = len(blockchain.chain)
for node in peers:
response = request.get('{}/chain'.format(node))
length = response.json()['length']
chain = response.json()['chain']
if length > current_len and blockchain.check_chain_validity(chain):
# Longer valid chain found!
current_len = length
longest_chain = chain
if longest_chain:
blockchain = longest_chain
return True
return False
def create_music(request):
if request is None:
raise MissingItem('request')
db.session.add(
Music(title=request.get('title'),
artist=request.get('artist'),
media=request.get('media'),
cover=request.get('cover')))
music = Music.query.filter_by(media=request.get('media')).first()
for tag_name in request.get('tags', []):
tag = retrieve_tag_by_name(tag_name)
if tag is None:
db.session.add(Tag(name=tag_name))
tag = retrieve_tag_by_name(tag_name)
music.tags.append(tag)
db.session.commit()
return music
def get_command_from_req(
request: JSON,
workspace: Workspace) -> Tuple[Optional[List[str]], bool]:
try:
split = shlex.split(request.get('text', '') \
.replace('“','"') \
.replace('”','"'))
except ValueError as e:
send_ephemeral_message(
workspace,
request.get('channel_id', ''),
request.get('user_id', ''),
f'We had trouble parsing that - {e}',
)
return None, False
if ANON_KEYWORDS.isdisjoint(split):
anonymous = False
else:
anonymous = True
split = [word for word in split if word not in ANON_KEYWORDS]
if len(split) < 3:
send_ephemeral_message(
workspace,
request.get('channel_id', ''),
request.get('user_id', ''),
'Oops - a poll needs to have at least two options. ' \
'Try again with `/votey "question" "option 1" "option 2"`',
)
return None, False
if len(split) > 11:
send_ephemeral_message(
workspace,
request.get('channel_id', ''),
request.get('user_id', ''),
'Sorry - Votey only supports 10 options at the moment.',
)
return None, False
return split, anonymous
def make_webhook_result(request):
result = request.get("queryResult")
action = result.get('action')
parameters = result.get('parameters')
contexts = result.get('outputContexts')
if action in info_response_db.keys():
fulfillment_text = info_response_db.get(action).get(
parameters.get('disease'))
elif action == 'report.symptom':
store_symptoms_in_db(parameters, db)
outbreak_report = check_for_outbreak()
fulfillment_text = report_response_db['report.symptom.opening']
for disease, outbreak in outbreak_report.items():
if outbreak:
fulfillment_text += report_response_db[
'warning.doctor'].format(disease)
fulfillment_text += report_response_db[
'report.symptom.closing'].format(disease)
elif action == 'epidemics.information':
outbreak_report = check_for_outbreak()
fulfillment_text = ''
for disease, outbreak in outbreak_report.items():
if outbreak:
fulfillment_text += info_response_db[
'epidemics.information.epidemic'].format(disease)
if not fulfillment_text:
fulfillment_text = info_response_db['epidemics.information.ok']
else:
fulfillment_text = info_response_db['default']
return {
"fulfillmentText": fulfillment_text,
}
