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