def request_tokens(self): ''' Method to request API tokens from ecobee ''' url = 'https://api.ecobee.com/token' params = { 'grant_type': 'ecobeePin', 'code': self.authorization_code, 'client_id': self.api_key } try: request = requests.post(url, params=params) except RequestException: logger.warn( "Error connecting to Ecobee. Possible connectivity outage." "Could not request token.") return if request.status_code == requests.codes.ok: self.access_token = request.json()['access_token'] self.refresh_token = request.json()['refresh_token'] self.write_tokens_to_file() self.pin = None else: logger.warn('Error while requesting tokens from ecobee.com.' ' Status code: ' + str(request.status_code) + '\n' + 'request: ' + json.dumps(request.json(), indent=4) + '\n' + 'params: ' + json.dumps(params, indent=4)) return
def api(isbn): request = requests.get("https://www.goodreads.com/book/review_counts.json", params={ "key": "hVKf909VqkHtK6iHy3Mbw", "isbns": isbn }) result_query = db.execute("SELECT * FROM books WHERE isbn=:isbn", { "isbn": isbn }).fetchall() average_rating = request.json()['books'][0]['average_rating'] work_ratings_count = request.json()['books'][0]['work_ratings_count'] api_query = db.execute("SELECT * FROM books WHERE isbn=:isbn", { "isbn": isbn }).fetchone() if api_query == None: return 'Error oooooo' #render_template("error.html") data = { "title": api_query.title, "author": api_query.author, "year": api_query.year, "isbn": api_query.isbn, "review_count": work_ratings_count, "average_score": average_rating } dump = json.dumps(data) return render_template("api.html", api=dump)
def locations(): if request.method == 'GET': location_lst = HousingLocation.query.all() result = locations_schema.dump(location_lst) return jsonify(result), 200 else: if request.is_json(): latitude = float(request.json('latitude')) longitude = float(request.json('longitude')) housing_type_id = int(request.json('housing_type_id')) beds_available = int(request.json('beds_available')) location = HousingLocation(latitude=latitude, longitude=longitude, housing_type_id=housing_type_id, beds_available=beds_available) db.session.add(location) db.session.commit() result = location_schema.dump(location) return jsonify(result), 201 else: return jsonify(message='request not valid json'), 500
def location(location_id): location = HousingLocation.query.filter_by(location_id=location_id).first() if not location: return 404 if request.method == 'GET': result = location_schema.dump(location) return jsonify(result) elif request.method == 'PUT': if request.is_json(): location.latitude = float(request.json('latitude')) location.longitude = float(request.json('longitude')) location.housing_type_id = int(request.json('housing_type_id')) location.beds_available = int(request.json('beds_available')) db.session.commit() result = location_schema.dump(location) return jsonify(result), 202 else: return 500 else: pass
def test_travis_like(): request = requests.post( 'https://api.' + app.config['APP_DOMAIN'] + '/v0.2/tty', verify=False, auth=('key', app.config['API_KEY']), json={ "username": "******" + app.config['APP_DOMAIN'], "repo": "https://*****:*****@github.com/it-dojo/user.sample.test.git", "action": "init", }, ) if request.ok: app.logger.debug(request.json()) data = request.json() app.logger.debug(data['tty']['uri']) response = requests.get('http://' + data['tty']['uri']) counter = 0 while not response.status_code == requests.codes.ok: time.sleep(1) counter += 1 app.logger.debug("Waiting %ss for %s ...", counter, data['tty']['uri']) response = requests.get('http://' + data['tty']['uri']) return render_template("test-travis-like.html", title="Test Travis Like Interface", uri=data['tty']['uri'], instructions=data['tty']['readme'])
def api_run_pipeline(): """ Invoke a servable. Returns: (str): Response from the servables """ return jsonify({ "error": "This function is now deprecated. Please update your dlhub_sdk." }) servables = [] if 'servables' in request.json(): servables = request.json()['servables'] resolved_servables = [] for x in servables: servable_namespace = x.split('/')[0] servable_name = x.split('/')[1] resolved_servables.append( _resolve_namespace_model(cur, conn, servable_namespace, servable_name)) output = _perform_invocation(resolved_servables, request, type='run') return output
def api_v1_count(): cursor = conn.cursor() if request.method == 'POST' and request.is_json and request.json().get( 'key'): key = str(request.json().get('key')) imgid = str(request.json().get('imgid')) elif request.method == 'POST' and request.form.get('key'): key = str(request.form.get('key')) imgid = str(request.form.get('imgid')) elif request.method == 'GET' and request.args.get('key'): key = str(request.args.get('key')) imgid = str(request.args.get('imgid')) else: return abort(403) cursor.execute('SELECT userid FROM apikeys WHERE key = ?', [key]) userid = cursor.fetchall() if userid: cursor.execute('SELECT count FROM counter WHERE id = ? AND userid = ?', [imgid, userid[0][0]]) count = cursor.fetchall() if count: return jsonify({ 'imgname': imgid, 'count': count[0][0], 'imgurl': URLROOT + 'img/' + imgid, 'counturl': URLROOT + 'count/' + imgid }) return abort(403) return abort(403)
def request_pin(self): ''' Method to request a PIN from ecobee for authorization ''' url = 'https://api.ecobee.com/authorize' params = { 'response_type': 'ecobeePin', 'client_id': self.api_key, 'scope': 'smartWrite' } try: request = requests.get(url, params=params) except RequestException: logger.warn( "Error connecting to Ecobee. Possible connectivity outage." "Could not request pin.") return try: self.authorization_code = request.json()['code'] except: logger.error('Error calling request_pin.\nRequest output:\n' + json.dumps(request.json(), indent=4) + '\nRequest params:\n' + json.dumps(params, indent=4) + '\nRequest URL: ' + url) self.pin = request.json()['ecobeePin'] logger.error( 'Please authorize your ecobee developer app with PIN code ' + self.pin + '\nGoto https://www.ecobee.com/consumerportal' '/index.html, click\nMy Apps, Add application, Enter Pin' ' and click Authorize.\nAfter authorizing, call request_' 'tokens() method.') # new: self.write_tokens_to_file()
def connect_to_network(): my_node = { 'nodeIp': myNodeIp, 'nodeName': myNodeName, } blockchain.nodes.add(myNodeIp) if firstnode != '': request = requests.post(f'http://{firstnode}/add_new_node', json = my_node) if request.status_code == 201: json = request.json() blockchain.nodes = set(json.get('nodeList')) message = json.get('message') print(message) print(f' Received nodes: {blockchain.nodes}') if len(blockchain.nodes) > 0: for node in blockchain.nodes: if node != myNodeIp and node != firstnode: #safe switch for double request = requests.post(f'http://{node}/add_new_node', json = my_node) if request.status_code == 201: json = request.json() #add recieved nodes from all nodes newNodes = set(json.get('nodeList')) blockchain.nodes = blockchain.nodes.union(newNodes) message = json.get('message') print(message) print(f' Received nodes: {blockchain.nodes}')
def configure(): # seems like this needs to be done in order to reference global vars inside of the flask server thread global keepWeeks global currencies global exchanges global interval global on_demand if flaskRequest.method == 'POST': #return the config settings TODO: error check so that the user doesn't have to submit everything at once. Also implement a form here. keepWeeks = flaskRequest.json("keepWeeks") exchanges = flaskRequest.json("exchanges") currencies = flaskRequest.json("currencies") interval = flaskRequest.json("interval") return { 'updated settings?': 'yes', 'keepWeeks': keepWeeks, 'currencies': currencies, 'exchanges': exchanges, 'interval': interval } else: return { 'updated settings?': 'no', 'keepWeeks': keepWeeks, 'currencies': currencies, 'on demand exchanges': list(ex_objs.keys()), 'cached exchanges': exchanges, 'interval': interval }
def api_queue(): print request.json()['_id'] db.queue. return jsonify({ 'success': True, 'data': [] })
def update_topic(id): topic = Topic.query.get(id) topic.title = request.json("title") topic.description = request.json("description") db.session.commit() return topic_schema.jsonify(topic)
def recommend_places(): cost=request.json('cost') seating=request.json('seating') location=request.json('location') category=request.json('category') preference=request.json('preference') output=dummy_recommender(cost,seating,location,category,preference) return jsonify({"Places":output}),200 #a string ,not a list,map UI accordingly
def update_picture(id): picture = Pictures.query.get(id) picture.ArticleID = request.json('ArticleID') picture.TagLine = request.json('TagLine') db.session.commit() return single_pschema.jsonify(picture)
def get_userbought(): current_user = auth_login_required() # check token if type(current_user) is dict: return jsonify(current_user) page = request.json().get('page') num = request.json().get('num') msg = ulord_helper.ulord_userbought(current_user.wallet) return jsonify({'result': 1, 'msg': msg})
def my_post(): if "key" not in request.json() or "value" not in request.json(): abort(400) key = request.json.get("key") value = request.json.get("value") if key in date.keys(): abort(409) date.update({key:value}) return jsonify({"your_result":value,"time":datetime.datetime.now()})
def recebe(troco): for trocos in troco: if trocos['notas'] == troco: trocos['notas'] = request.json().get('notas') for trocos in troco: if trocos['moedas'] == troco: trocos['moedas'] = request.json().get('moedas') return jsonify({'ERROR'}), 404
def update_journalist(id): journal = Journalist.query.get(id) journal.FName = request.json('FName') journal.LName = request.json('LName') journal.Description = request.json('Description') # journal.Pictures = request.json('Pictures') db.session.commit() return single_jschema.jsonify(journal)
def requisitar( page ): # this make the requisition from the backend response = [] __URL = 'http://localhost:3001/api/products?page='+ str(page) request = requests.get(url=__URL) pages = request.json()['pages'] data = request.json()['docs'] response.append(pages) response.append(data) return response
def update_article(id): article = Articles.query.get(id) article.Writer = request.json('Writer') article.Heading = request.json('Heading') article.Subheading = request.json('Subheading') article.Body = request.json('Body') db.session.commit() return single_aschema.jsonify(article)
def event_captains_api(event_id): if request.method == 'GET': captains = get_captains_from_db(event_id) return json.dumps([captain._asdict() for captain in captains]) elif request.method == 'POST': return add_captains(request.json()) elif request.method == 'DELETE': return delete_captains(request.json(), event_id) else: return utilities.NAVY_SEAL
def post(self): new_list ={ 'id':new_list[-1]['id']+1 'name':request.() 'divishion':request.json() 'blood':request.json() }
def api_v1_add(): cursor = conn.cursor() if request.method == 'POST' and request.is_json and request.json().get( 'key'): key = str(request.json().get('key')) url = request.json().get('url') startval = request.json().get('start') elif request.method == 'POST' and request.form.get('key'): key = str(request.form.get('key')) url = request.form.get('url') startval = request.form.get('start') elif request.method == 'GET' and request.args.get('key'): key = str(request.args.get('key')) url = request.args.get('url') startval = request.args.get('start') else: return abort(403) try: if url: url = str(url) if startval: startval = int(startval) else: startval = -2 else: return abort(400) except: return abort(400) cursor.execute('SELECT userid FROM apikeys WHERE key = ?', [key]) userid = cursor.fetchall() if userid: userid = userid[0][0] imgid = secrets.token_urlsafe(16) name = secrets.token_urlsafe(16) cursor.execute( 'INSERT INTO counter (id, name, userid, count, last, lastinfo, url) VALUES(?,?,?,?,?,?,?)', [ imgid, name, userid, startval, str( datetime.datetime.fromtimestamp( time.time()).strftime(r'%Y-%m-%d %H:%M:%S')), str(request.headers), url ]) conn.commit() return jsonify({ 'userid': userid, 'imgid': imgid, 'imgname': name, 'imgurl': URLROOT + 'img/' + imgid, 'endpoint': url, 'counturl': URLROOT + 'count/' + imgid }) else: return abort(403) return abort(500)
def send_message(chatId, text='Please wait a few seconds...!'): url = URL + 'sendMessage' answer = {'chat_id': chatId, 'text': text} print(answer) #r=requests.get(url,json=answer) #print(r.json()) request = requests.post(url, data=answer) print(request.json()) return request.json()
def create_contact(): logger.debug( "Creating a contact record: FirstName: {}. LastName: {}. Phone {}. Group Id {}" .format(request.json["firstName"], request.json["lastName"], request.json["phone"], request.json("groupId"))) contactId = contactDB.create(request.json["firstName"], request.json["lastName"], request.json["phone"], request.json("groupId")) return jsonify({'contactId': contactId}), 201
def chpass(user_id): current = request.json('current_password') new = request.json('new_password') repeat = request.json('repeat_password') user = User.fetch(user_id) if user is None: return jsonify({'error': 'user not found'}) elif new == repeat: return jsonify({'data': User().chpass(id, new)}) elif new != repeat: return jsonify({'error': 'password confirmation failed.'})
def move(): if not request.json(): return jsonify(err="can only send json") json = request.json() x = json["x"] y = json["y"] x = x + 1 if x < 1000 else 0 y = y + 1 if y < 1000 else 0 return jsonify(x=x, y=y)
def post(self): db_name = request.json('db') collection = request.json('collection') cols = request.json('cols') version = request.json('version') new_version = version + 1 connection = get_connection(username, password, db_name, host, port) input_df = read_mongo(db_name, collection) input_df.drop_duplicates(subset=cols, inplace=True) input_df[version] = new_version save_data(connection, db_name, collection, input_df) return jsonify({"message": "success"})
def departments(): request = requests.get(api_url + 'departments') depts = request.json() request = requests.get(api_url + 'employees/heads') heads = request.json() for dept in depts: head = next((item for item in heads if item["id"] == dept['head_id']), None) dept['head'] = ('unassigned' if head is None else '{} {}'.format( head["first_name"], head["last_name"])) return render_template('departments.html', depts=depts)
def get_paths(): try: request = session.get('http://localhost:9999') request.raise_for_status() path = request.json()['_directory'] tar = request.json()['_tar'] if path is None or not os.path.isdir(path): raise ValueError() if tar is None or not os.path.isfile(tar): raise ValueError() except Exception: raise ServiceUnavailable("No update ready") return path, tar
def department(name): request = requests.get(api_url + 'departments/' + name) dept = request.json() request = requests.get(api_url + 'employees/?department=' + dept['name']) employees = request.json() head = next( (person for person in employees if person["id"] == dept['head_id']), None) if head is not None: form = DepartmentForm(dept_name=dept['name'], head_salary=head['salary']) else: form = DepartmentForm(dept_name=dept['name']) dept['head'] = 'unassigned' if head is None \ else (format_emplyee(head['id'], head["first_name"], head["last_name"]) ) candidates_list = [(person['id'], format_emplyee(person['id'], person['first_name'], person['last_name'])) for person in employees] candidates_list.insert(0, (-1, 'Unassigned')) if head is not None: # making current head the first (default) option current_head = (head['id'], format_emplyee(head['id'], head['first_name'], head['last_name'])) candidates_list.remove(current_head) candidates_list.insert(0, current_head) form.dept_head.choices = candidates_list if form.validate_on_submit(): args_string = 'departments/{}?name={}'.format(name, form.dept_name.data) args_string += '&head_id={}'.format(form.dept_head.data) if form.head_salary.data is not None: args_string += '&head_salary={}'.format(form.head_salary.data) api_request = requests.put(api_url + args_string) print(api_request.status_code) return redirect(url_for('department', name=form.dept_name.data)) dept['head_salary'] = None if head is None else head['salary'] return render_template('department.html', dept=dept, employees=employees, form=form)
def set_location(): if request.method == 'POST': log_google_debug("Received a POST response on the location page") try: user_lat = request.json('lat') user_long = request.json('long') log_google_debug("Found coordinates: "+user_lat+", "+user_long) session['located'] = True session['lat'] = user_lat session['long'] = user_long log_google_debug("Added geolocation data to user cookie") except: log_google_error("Something went wrong reading coordinates from the POST request, nothing added to user cookie") return redirect(url_for('index'))
def send_with_mandrill(data): """ Sends mail with data using mandrill Returns True if sent successfully, False otherwise On error, switches the configuration to Mailgun """ app.logger.debug("Email sent with Mandrill") payload = {"key": app.config['MANDRILL_KEY'], "message": {"text": data["body"], "subject": data["subject"], "from_email": data["from"], "from_name": data["from_name"], "to": [{"email": data["to"], "name": data["to_name"], "type": "to"}] } } request = requests.post(app.config['MANDRILL_URL'], data=json.dumps(payload)) response = request.json() try: if response[0]['status'] == "sent": return True else: app.logger.warning("Mandrill Send Failed: " + response[0]['reject_reason']) except: app.logger.error("Mandrill Error: " + str(response)) # switch to mailgun app.logger.debug("Switch default to Mailgun") app.config['DEFAULT_MAIL_SERVICE'] = "mailgun" return False
def process_hook(): url = PIVOTAL_URL try: payload_json = request.json() commits = payload_json.get('commits') if commits: api_token = get_api_token(commits[0].get('author').get('email')) for commit in commits: xml_data = form_xml_post_data(commit) req = requests.post(url, data=xml_data, headers={ 'X-TrackerToken': api_token, 'Content-type': 'application/xml', } ) if not req: logging.debug( u"Commiting ticket to pivotal resulted in an error." " %s url with data %s and api_token %s", url, xml_data, api_token ) except Exception: logging.exception("Exception when attempting to process payload") return "Your hook made trouble so nothing done." else: return "Thank your for your hook"
def request_pin(self): logger.info(f'Attempting to request pin for {self.api_key}') url = f'{ecobee_url}authorize' params = { 'response_type': 'ecobeePin', 'client_id': self.api_key, 'scope': 'smartWrite' } try: request = requests.get(url, params=params) except RequestException: logger.warn(f'Pin request for {self.api_key} unsuccessful') else: if request.status_code == requests.codes.ok: logger.info(f'Pin request for {self.api_key} successful') self.authorization_code = request.json()['code'] self.pin = request.json()['ecobeePin'] else: return False
def inner(*args, **kwargs): if request.method == "GET": formdata = request.args else: formdata = request.form if request.form else MultiDict(request.json(force=True)) form = form_class(formdata) if not form.validate(): return api_error(10013) g.form = form
def request_tokens(self): logger.info(f'Attempting to request tokens for {self.api_key}') url = f'{ecobee_url}token' params = {'grant_type': 'ecobeePin', 'code': self.authorization_code, 'client_id': self.api_key} try: request = requests.post(url, params=params) except RequestException: return else: if request.status_code == requests.codes.ok: logger.info(f'Tokens request for {self.api_key} successful') self.access_token = request.json()['access_token'] self.refresh_token = request.json()['refresh_token'] self.write_to_db() self.pin = None else: logger.info(f'Tokens request for {self.api_key} unsuccessful') return
def event_notification(): try: request_params = request.json() command = request_params.get('command') data = request_params.get('data') template_id = request_params.get('template_id') from ..services import event_task_listener task = event_task_listener(command, template_id, data) return jsonify(dict(status='success', message='Successfully submitted the request', task=str(task.id))) except Exception, e: return jsonify(dict(status='error', message=str(e)))
def request_access_token(code): params = { 'grant_type': 'authorization_code', 'client_id': READMILL_CLIENT_ID, 'client_secret': READMILL_CLIENT_SECRET, 'redirect_uri': url_for_auth_callback(), 'code': code } request = requests.post(READMILL_ACCESS_TOKEN_URL, params=params) return request.json()
def create_patient(): if not request.json or not 'gender' in request.json: abort(400) patient = { 'id': patients[-1]['id'] + 1, 'gender': request.json['gender'], 'age': request.json('age'), 'height': request.json['height'], 'weight': request.json['weight'] } patients.append(patient) return jsonify( { 'patient': make_public_patient(patient) } ), 201
def get_results(params): ##Obtain these from Yelp's manage access page (adding this to test heroku) session = rauth.OAuth1Session( consumer_key = os.environ['yelp_consumer_key'] ,consumer_secret = os.environ['yelp_consumer_secret'] ,access_token = os.environ['yelp_token'] ,access_token_secret = os.environ['yelp_token_secret']) request = session.get("http://api.yelp.com/v2/search",params=params) #Transforms the JSON API response into a Python dictionary return request.json()
def get_yelp_results(businessID): # Session setup session = rauth.OAuth1Session( consumer_key = yelp_consumer_key, consumer_secret = yelp_consumer_secret, access_token = yelp_token, access_token_secret = yelp_token_secret) request = session.get('http://api.yelp.com/v2/search/' + businessID) # Transform JSON API response into Python dictionary data = request.json() session.close() return data
def writeMe(): if request.method == 'GET': user = request.args.get('chat_name') message = request.args.get('content') else: if request.json: user = request.json('chat_name') message = request.json('content') else: user = request.form['chat_name'] message = request.form['content'] app.logger.error(request) if user is None: user = "******" if message is None: message = "" chat = ChatLog(parent=chatlog_key(DEFAULT_CHAT_NAME)) chat.author = user chat.content = message chat.put() return make_response("", 200)
def exit_chat(identifier): conn = sqlite3.connect(FROLIC_DB) c = conn.cursor() c.execute("SELECT chat FROM chats WHERE identifier=?", [identifier]) chat = c.fetchone() chat = jsonpickle.decode(chat) body = request.json() token = body['token'] member = dict(chat['members'])[token] chat['members'].remove(member) c.execute("UPDATE chats SET chat = ? where identifier = ?", [identifier, jsonpickle.encode(chat)]) conn.commit() conn.close() return jsonify({})
def check_recaptcha(response, ip): # Prepare the recaptcha verification_data verification_data = { "secret": app.config.get("RECAPTCHA_SECRET_KEY"), "response": response, "remoteip": ip } # Make the request request = requests.get( app.config.get("RECAPTCHA_VERIFY_URL"), params = verification_data ) # Check the request results if request.json()["success"]: return True else: return False
def create_plant_logs(plant_id): if not request.json or not 'log_body' in request.json: abort(400) log_body = request.json('log_body') time_of_log = datetime.now() parent_plant = plant_id log_type = "Testing" #Put all of the submitted data into our Log model and assign it the variable log. log = Log(time_of_log, log_body, log_type, parent_plant) #Add the log to the current database session for submission. #Then commit the session data to the database. db.session.add(log) db.session.commit() return "Success. You logged '%s' to plant ID#%s" % log_body,
def post(self): input = request.json() terminal_no = input.get('terminal_no', '').strip() if not terminal_no: return jsonify(success=False, msg=u'设置默认终端失败:无效的终端号') q = db_session.query(TerminalInfo) \ .filter(TerminalInfo.terminal_no==terminal_no) \ .filter(TerminalInfo.shop_no.in_(db_session.query(ShopInfo).filter(ShopInfo.unit_no==session['unit_no']))) if q.count(): if q.one().status == '0': session['default_terminal'] == terminal_no return jsonify(success=True, msg=u'设置终端号成功', show_msg=True) else: return jsonify(success=False, msg=u'设置默认终端失败:此终端不可用', show_msg=True) else: return jsonify(success=False, msg=u'设置默认终端失败:无此终端', show_msg=True)
def do_request(params): #Obtain these from Yelp's manage access page consumer_key = "3J0vOb8Pkm0ZVj6RNT6SgQ" consumer_secret = "9PCim5pcmDmHAUFtqPQlFwfitRg" token = "WqA1ClKuVKCjalKpcD_93c0vXRWEBxD7" token_secret = "c7PZFWyW173hCwGj28u0KhaXoH0" print params session = rauth.OAuth1Session( consumer_key = consumer_key ,consumer_secret = consumer_secret ,access_token = token ,access_token_secret = token_secret) request = session.get("http://api.yelp.com/v2/search",params=params) #Transforms the JSON API response into a Python dictionary data = request.json() session.close() return data
def med_details(self, search_term): """ GET /medicine_details Parameters: id = SEARCH_STRING, key = API_KEY """ url = self.ENDPOINT + 'medicine_details/' self.__params(search_term) medicine_details = {} try: request = requests.get(url, params=self.params) result = request.json() if result['status'] == 'ok' or result['status'] == 200: medicine_details = result['response'] error_code = 0 error_msg = "Success" except: error_code = 1 error_msg = "Sorry, we are experiencing some connection issues right now. Please try again later." return medicine_details, error_code, error_msg
def med_suggestions(self, search_term, limit = 8): """ GET /medicine_suggestions Parameters: id = SEARCH_STRING, key = API_KEY, limit = LIMIT """ url = self.ENDPOINT + 'medicine_suggestions/' self.__params(search_term, limit) suggestions_list = [] try: request = requests.get(url, params=self.params) result = request.json() if result['status'] == 'ok' or result['status'] == 200: error_code = 0 error_msg = "Success" temp_list = result['response']['suggestions'] suggestions_list = [item['suggestion'] for item in temp_list] except: error_code = 1 error_msg = "Sorry, we are experiencing some connection issues right now. Please try again later." return suggestions_list, error_code, error_msg
def med_alternatives(self, search_term, limit = 5): """ GET /medicine_alternatives Parameters: id = SEARCH_STRING, key = API_KEY, limit = LIMIT """ url = self.ENDPOINT + 'medicine_alternatives/' self.__params(search_term, limit) alternatives_list = [] try: request = requests.get(url, params=self.params) result = request.json() if result['status'] == 'ok' or result['status'] == 200: temp_list = result['response']['medicine_alternatives'] alternatives_list = [{'brand': item['brand'], 'unit_price' : item['unit_price']} for item in temp_list] error_code = 0 error_msg = "Success" except: error_code = 1 error_msg = "Sorry, we are experiencing some connection issues right now. Please try again later." return alternatives_list, error_code, error_msg
def send_with_mailgun(data): """ Sends mail with data using mailgun Returns True if sent successfully, False otherwise On error, switches the configuration to Mandrill """ app.logger.debug("Email sent with Mailgun") payload = {"from": data["from_name"] + "<" + data["from"] + ">", "to": data["to_name"] + "<" + data["to"] + ">", "subject": data["subject"], "text": data["body"]} request = requests.post( app.config['MAILGUN_URL'], auth=("api", app.config['MAILGUN_KEY']), data=payload ) response = request.json() try: if response['message'] == "Queued. Thank you.": return True except: app.logger.error("Mailgun Error: " + str(response)) # switch to mandrill app.logger.debug("Switch default to Mandrill") app.config['DEFAULT_MAIL_SERVICE'] = "mandrill" return False
def msg_chat(identifier): conn = sqlite3.connect(FROLIC_DB) c = conn.cursor() c.execute("SELECT chat FROM chats WHERE identifier=?", [identifier]) chat = c.fetchone() chat = jsonpickle.decode(chat) body = request.json() token = body['token'] msg = body['msg'] member = chat['members'][token] chat['messages'] = deque(chat['messages']) chat['messages'].append((member, msg)) if len(chat['messages']) > 20: chat['messages'].popleft() response = {'token': token, 'members': chat['members'], 'messages': list(chat['messages']) } c.execute("UPDATE chats SET chat = ? where identifier = ?", [identifier, jsonpickle.encode(chat)]) conn.commit() conn.close() return jsonify(response)
def get_root(): url = api + reportEndpoint request = requests.get(url) return render_template('map.html', reports=request.json(), api_key=api_key)
def get_server_info(server_name): params = {"servername": str(server_name)} url_to_send = "{address}/get_server_info".format(address=handyrep_address) request= requests.get(url_to_send,params=params, auth=(username,password)) return request.json()
def get_speed(): result = {'command': 'get_speed', 'return_values':request.json()} print(result, file=sys.stderr) return jsonify(result)
def what_itis(): print(request.json()) loadedJson = json.loads(request.text) return loadedJson
def request_return(request): j = request.json() j[u'status'] = request.status_code return j
def get_php(): try: request = requests.get(config['env']['phpinfo'], params={'format': 'json'}) return request.json() except requests.exceptions.RequestException: return {'version': '<span class="text-danger">Cannot fetch, is Apache and Php containers running?</span>'}
def object(self): if isinstance(request.json, dict): return request.json else: return request.json()