async def main(req: func.HttpRequest) -> func.HttpResponse: # create api client line_api = AioLineBotApi( channel_access_token="<YOUR CHANNEL ACCESS TOKEN>") # get events from request parser = WebhookParser(channel_secret="<YOUR CHANNEL SECRET>") events = parser.parse(req.get_body().decode("utf-8"), req.headers.get("X-Line-Signature", "")) for ev in events: # reply echo await line_api.reply_message( ev.reply_token, TextMessage(text=f"You said: {ev.message.text}")) # 200 response return func.HttpResponse("ok")
def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse: sess = get_inference_session() data = req.params.get("data") if data is not None: try: data = json.loads(data) data = inference.predict(sess, np.array([data], dtype=np.float32)) data = np.argmax(data[0], axis=1) data = data.tolist()[0] except ValueError: data = None return func.HttpResponse(json.dumps(inference.format_results(sess, data), indent=4), status_code=200)
def main(req: azf.HttpRequest, file: bytes) -> azf.HttpResponse: """ Read a blob (bytes) and respond back (in HTTP response) with the number of bytes read and the MD5 digest of the content. """ assert isinstance(file, bytes) content_size = len(file) content_md5 = hashlib.md5(file).hexdigest() response_dict = {'content_size': content_size, 'content_md5': content_md5} response_body = json.dumps(response_dict, indent=2) return azf.HttpResponse(body=response_body, mimetype="application/json", status_code=200)
def main(req: func.HttpRequest) -> func.HttpResponse: return func.HttpResponse(json.dumps([ { 'action': 'talk', 'text': 'Welcome to the emotion reporting hotline. Please enter 1 if you are happy, or 2 if you are sad.', 'bargeIn': True, }, { 'action': 'input', 'eventUrl': [f'https://{req.headers["host"]}/api/emotion_feedback'], 'maxDigits': 1, 'timeOut': 10, }, ]), mimetype='application/json')
def main(req: func.HttpRequest): challenge = req.get_json() client = get_client(os.environ[env_constants.MONGO_CONNECTION_STRING]) # Get the owner id from the JSON an add "enrolledIndividuals" owner_id = challenge["ownerId"] # Add the enrolled individual to the JSON in the ObjectId form. challenge["enrolledIndiviuals"] = [ObjectId(owner_id)] # Insert the challenge insert_one(client, mongo_constants.GAMIFYRE_DB, mongo_constants.collections.CHALLENGE, challenge) return func.HttpResponse(status_code=200)
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('Python HTTP trigger function processed a request.') random_image, image_name = fetch_image.fetch_random_image() image_coded = image_helper.encode_image_base64(random_image) image_id = image_helper.get_hash(image_name) json_response = { 'id': image_id, 'encoded_image': image_coded } return func.HttpResponse( json.dumps(json_response), headers={'Access-Control-Allow-Origin': '*'}, status_code=200, mimetype='application/json' )
def main(req: func.HttpRequest) -> func.HttpResponse: image_url = req.params.get('img') top = 20 try: top = int(req.params.get('top')) except: pass logging.info('Image URL received: ' + image_url) logging.info('with top n: ' + str(top)) results = predict_image_from_url(image_url, top) headers = { "Content-type": "application/json", "Access-Control-Allow-Origin": "*" } return func.HttpResponse(json.dumps(results), headers=headers)
def main(req: func.HttpRequest) -> func.HttpResponse: data = req.get_json() user_query = data['message'] preprocessed_query = map_request.preprocess_query(user_query, format='str') store_url = constants.Globals.SEARCH_URL.format( preprocessed_query.replace(' ', '%20')) response = { "reply": "Kanskje det er dette du leter etter?", "buttons": [{ "button_type": "link", "label": constants.Globals.STORE_NAME, "value": store_url }] } return func.HttpResponse(body=json.dumps(response), mimetype="application/json")
def main(req: func.HttpRequest) -> func.HttpResponse: file_path = "" df = pd.read_excel('file_path') output = df.to_csv(index=False) STORAGEACCOUNTNAME = "*****" STORAGEACCOUNTKEY = "*****" blobService = BlockBlobService(account_name=STORAGEACCOUNTNAME, account_key=STORAGEACCOUNTKEY) blobService.create_blob_from_text('csv', 'test2.csv', output) name = {"test": "test"} return func.HttpResponse( json.dumps(name), mimetype="application/json", )
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('HTTP trigger function processing a request') img_gif = Image.open(BytesIO(req.get_body())) img_byte_arr = BytesIO() img_gif.save(img_byte_arr, format='webp', save_all=True, duration=img_gif.info['duration'], optimize=True, quality=100) logging.info('HTTP trigger function processed gif to webp') return func.HttpResponse(body=img_byte_arr.getvalue(), mimetype='image/webp', status_code=200)
def main(req: func.HttpRequest, documents: func.DocumentList) -> func.HttpResponse: if not documents: logging.warning("document not found") return "Bad robot! :(" else: logging.info("Found Document, Description=%s", documents[0].to_json()) resp_headers = { "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": "Get, Post, Options" } response = func.HttpResponse(headers=resp_headers, body=documents[0].to_json()) return response
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('Python HTTP trigger function processed a request.') # Get the request body from previous step in Logic App req_body = req.get_json() file_name = req_body.get('fileName') file_content = req_body['fileContent']['$content'] # Convert file content to bytes file_data = base64.decodebytes(file_content.encode()) # Generate date time object of the run dt = datetime.datetime.now().strftime('%Y-%m-%dT%H-%M-%S') # Extract original PDF file name pdf_prefix_file_name = ''.join(file_name.split('.pdf')[:1]) + '_' # Open multi-page PDF file with io.BytesIO(file_data) as open_pdf_file: read_pdf = PyPDF2.PdfFileReader(open_pdf_file) # Extract each page and write out to individual files pdf_list = [] for i in range(read_pdf.numPages): output = PyPDF2.PdfFileWriter() output.addPage(read_pdf.getPage(i)) # Temporarily write PDF to disk temp_pdf_fn = pdf_prefix_file_name + str(i + 1) + '_' + dt + str( ".pdf") with open(temp_pdf_fn, "wb") as outputStream: output.write(outputStream) # Read back in the PDF to get the bytes-like version with open(temp_pdf_fn, 'rb') as temp_pdf_file: file_data = base64.b64encode(temp_pdf_file.read()).decode() # Record the filename and the bytes-like data of single-page PDF ind_pdf = {'fileName': temp_pdf_fn, 'fileContent': file_data} pdf_list.append(ind_pdf) # Finalize response object respObj = {'individualPDFs': pdf_list} return func.HttpResponse(body=json.dumps(respObj))
def main(req: func.HttpRequest) -> func.HttpResponse: try: driver = "{ODBC Driver 17 for SQL Server}" server = "kumulus-paoli.database.windows.net" database = "test_database" user = "******" password = "******" conn = f"""Driver={driver};Server=tcp:{server},1433;Database={database}; Uid={user};Pwd={password};Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30;""" params = urllib.parse.quote_plus(conn) conn_str = 'mssql+pyodbc:///?autocommit=true&odbc_connect={}'.format( params) engine = create_engine(conn_str, echo=False) Model.metadata.create_all(engine) session = Session(engine) except: return func.HttpResponse("Failed to connect") name = req.params.get('name') description = req.params.get('description') price = req.params.get('price') if not name: return func.HttpResponse("No name given :(") if session.query(Product).filter(Product.name == name).first() is None: return func.HttpResponse("Name do not exist :(") else: if not description: if not price: return func.HttpResponse("No enough stuff :(") else: session.query(Product).filter(Product.name == name).update( {"price": price}, synchronize_session=False) else: if not price: session.query(Product).filter(Product.name == name).update( {"description": description}, synchronize_session=False) return func.HttpResponse("Product updated ):)") else: session.query(Product).filter(Product.name == name).update( {"description": description}, synchronize_session=False) session.query(Product).filter(Product.name == name).update( {"price": price}, synchronize_session=False) return func.HttpResponse("Product updated ):)") return func.HttpResponse("Product updated ):)")
def main(req: func.HttpRequest) -> func.HttpResponse: # Log to Azure function apps online logging.info('Python HTTP trigger function processed a request.') def create_welcome_card(): # Create card blue_background = "https://images.unsplash.com/photo-1557683311-eac922347aa1?ixlib=rb-1.2.1&w=1000&q=80" bot_icon = "https://i.ibb.co/dmmWb6s/Lingo-Bot-Bare.png" card = AdaptiveCard(backgroundImage=blue_background) card.add([ Container(), "<", Image(url=bot_icon, spacing="medium", height="130px", horizontalAlignment="center"), TextBlock(text=f"Hey! I'm Lingo", spacing="Large", weight="bolder", size="ExtraLarge", horizontalAlignment="center", color="light"), TextBlock(text="Your Personal Digital Banking Assistant", weight="bolder", size="Large", horizontalAlignment="center", wrap="true", color="light"), TextBlock(text="I can speak more than 70 languages!", weight="bolder", size="Medium", horizontalAlignment="center", wrap="true", color="light"), ActionSet(spacing="Large"), "action", ActionSubmit( title="Help", data={"action": "help"}, iconUrl="https://img.icons8.com/ios/50/000000/help.png") ]) return card.to_json() result = create_welcome_card() return func.HttpResponse(body=result, status_code=200)
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('Getting the results.') return_data = {} votes = db.votes Bob = 0 Eric = 0 Marry = 0 Others = 0 Total = 0 Total = votes.find().count() Bob = votes.find({'VotedFor': 'Bob'}).count() Eric = votes.find({'VotedFor': 'Eric'}).count() Marry = votes.find({'VotedFor': 'Marry'}).count() Others = Total - Bob - Eric - Marry return_data['TotalVotes'] = Total return_data['Bob'] = Bob return_data['Eric'] = Eric return_data['Marry'] = Marry return_data['Others'] = Others return_data = json.dumps(return_data) teamsWebHook = os.environ['TeamsWebHook'] teamsMsg = pymsteams.connectorcard(teamsWebHook) teamsMsg.title("Demo Voting Results !") teamsSection = pymsteams.cardsection() teamsSection.addFact('Timestamp:', datetime.datetime.now().strftime("%m/%d/%Y-%H:%M:%S")) teamsSection.addFact('TotalVotes :', Total) teamsSection.addFact('Bob :', Bob) teamsSection.addFact('Eric :', Eric) teamsSection.addFact('Marry :', Marry) teamsSection.addFact('Others :', Others) teamsMsg.addSection(teamsSection) teamsMsg.text("Greeting !") teamsMsg.send() return func.HttpResponse(body=return_data ,status_code=200)
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('HTTP trigger function processed a request, calling rss2csv') url = req.params.get('url') if not url: try: req_body = req.get_json() except ValueError: pass else: url = req_body.get('url') if url: logmsg = f"Processing url: {url}\n" interesting = [ 'client-ip', 'x-forwarded-for', 'accept-language', 'user-agent' ] for key, value in req.headers.items(): if key in interesting: logmsg += f"{key}: {value}\n" logging.info(logmsg) rc = fetchRSSandOutputCSV(url) if 'SLACK_WEBHOOK' in os.environ: # if configured send update to Slack room slackmsg = f"Feed: {url}\n" if 'x-forwarded-for' in req.headers: ip = req.headers['x-forwarded-for'] start = time.time() geo = geoIP(ip) delta = int((time.time() - start) * 1000) logging.info(f"time-geoip: {delta} ms") slackmsg += f"Geo: {geo}\n" start = time.time() stat = requests.post(os.environ['SLACK_WEBHOOK'], json={'text': slackmsg}) delta = int((time.time() - start) * 1000) logging.info(f"time-slack: {delta} ms") logging.info(f"Slack post response {stat.status_code}") return rc else: return func.HttpResponse( "Please pass 'url' parameter in query request or body.\n", status_code=400)
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('Python HTTP trigger function processed a request.') req_body = req.get_json() br = mechanize.Browser() br.set_handle_robots(False) br.open("https://relief.jogno.net/login") br.select_form(nr=0) br["email"] = req_body.get('email') br["password"] = req_body.get('password') br.submit() page = br.open("https://relief.jogno.net/newnotes/") rundate = req_body.get('year') + '-' + req_body.get( 'month') + '-' + req_body.get('day') newurl = page.geturl() + '?d=' + rundate br.open(newurl) br.select_form(nr=0) try: temp = br.form.find_control(name="Jog[distance][]") except: req_body = req.get_json() br.form.new_control('text', 'Jog[distance][]', {'value': ''}) br.form.new_control('text', 'Jog[hour][]', {'value': ''}) br.form.new_control('text', 'Jog[minute][]', {'value': ''}) br.form.new_control('text', 'Jog[second][]', {'value': ''}) br.form.new_control('text', 'Jog[memo][]', {'value': ''}) br.form.fixup() br["Jog[distance][]"] = req_body.get('distance') br["Jog[hour][]"] = req_body.get('hour') br["Jog[minute][]"] = req_body.get('minute') br["Jog[second][]"] = req_body.get('second') br["diary"] = req_body.get('diary') br["Jog[memo][]"] = req_body.get('memo') # br["image_file[]"] = "" # br["condition[weight]"] = "" # print(br.form) br.submit() return func.HttpResponse( "This HTTP triggered function executed successfully.", status_code=200)
def main(req: func.HttpRequest) -> func.HttpResponse: try: # log the encoded message logging.info(f"Encoded body: {req.get_body()}") # decode hex values message = unquote(req.get_body().decode()) # log the decoded message logging.info(f"Decoded body: {message}") # split the message at markdown= or text= content_type, message = message.split('=', 1) # split the message at the timestamp time_stamp, message = message.split('|') # remove extraneous white space characters from the timestamp time_stamp = time_stamp.replace("+", " ") # convert the message from a string to a datetime object time_stamp = datetime.strptime(time_stamp.strip(), '%m/%d/%Y %I:%M:%S %p') # convert from UTC to EST time_stamp = time_stamp - timedelta(hours=4) # assemble the final message message = f"{content_type}={time_stamp.strftime('%m/%d/%Y %I:%M:%S %p')} | {message.strip()}" # correct space formatting message = message.replace(" ", "+") # Teams does not support em dash characters in webhooks message = message.replace("—", "--") # Teams does not support % characters in webhooks message = message.replace("%", "percent") # Teams does not support ° characters in webhooks message = message.replace("°", "degress ") # PRTG converts '<' to '{' so revert message = message.replace("{", "<") # PRTG converts '>' to '}' so revert message = message.replace("}", ">") # log the final message logging.info(f"Final body: {message}") if message: post = requests.post( WEBEX_WEBHOOK_URL, data=message.encode('utf-8'), headers={'Content-Type': 'application/x-www-form-urlencoded'} ) return func.HttpResponse(post.reason, status_code=post.status_code) except Exception as e: # log the exception logging.info(f"Error: {e}") # log the final message for debugging logging.info(f"Final body: {message}")
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('Python HTTP trigger function processed a request.') name = req.params.get('name') if not name: try: req_body = req.get_json() except ValueError: pass else: name = req_body.get('name') if name: return func.HttpResponse(f"Hello {name}!") else: return func.HttpResponse( print (response) "Please pass a name on the query string or in the request body", status_code=400 )
def main(req: func.HttpRequest, rating: func.DocumentList) -> str: logging.info('Python HTTP trigger function processed a request.') logging.info(req.params["ratingId"]) if not rating: logging.warning("rating item not found") return func.HttpResponse(f"Not foound", status_code=404) else: logging.info("Found rating item, Notes=%s", rating[0]['UserNotes']) data = { "id": rating[0]["id"], "userId": rating[0]["userId"], "ProductId": rating[0]["ProductId"], "timestamp": rating[0]["timestamp"], "locationName": rating[0]["locationName"], "Rating": rating[0]["Rating"], "UserNotes": rating[0]["UserNotes"], } return json.dumps(data)
def main(req: func.HttpRequest) -> func.HttpResponse: num_of_rows = req.params.get('num_of_rows') num_of_cols = req.params.get('num_of_cols') start = time() tmpl = PageTemplate(BIGTABLE_ZPT) data = {} for i in range(num_of_cols): data[str(i)] = i table = [data for x in range(num_of_rows)] options = {'table': table} data = tmpl.render(options=options) latency = time() - start return func.HttpResponse(str(latency))
def main(req: func.HttpRequest) -> func.HttpResponse: id = req.route_params.get("id") logging.info(f"Requesting crowdedness for restaurant: {id}") total_capacity = random.randint(10, 20) crowdedness = random.random() current_visitors = int(total_capacity * crowdedness) days_visitors = random.randint(4 * current_visitors, 12 * current_visitors) return func.HttpResponse( body=json.dumps( { "crowdedness": crowdedness, "last_hour": current_visitors, "last_day": days_visitors, } ) )
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('Python HTTP trigger function processed a request.') post = req.get_json() logging.info(post['video']) # get messages via url youtube_messages = get_chat_replay('https://www.youtube.com/watch?v=xxxxxxxxxxx') twitch_messages = get_chat_replay('https://www.twitch.tv/videos/xxxxxxxxx') # get messages via id youtube_messages = get_youtube_messages('xxxxxxxxxxx') twitch_messages = get_twitch_messages('xxxxxxxxx') return func.HttpResponse( "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.", status_code=200 )
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('Python HTTP trigger function processed a request.') temp_image = "/tmp/image.jpeg" image_data = req.get_body() f = open(temp_image, 'wb') f.write(image_data) print("Image Written to", temp_image) predicted_bus_number = bus_project.check_bus_number(temp_image) if predicted_bus_number != "-1" and predicted_bus_number != "-2": predict_string = "Bus " + predicted_bus_number + " is Coming Now!\n" elif predicted_bus_number == "-1": predict_string = "No Bus Detected in Image\n" else: predict_string = "Could Not Read Bus Number on Bus" return func.HttpResponse(predict_string, status_code=200)
def main(req: func.HttpRequest, doc:func.DocumentList) -> func.HttpResponse: logging.info('Python HTTP trigger function processed a request.') users_json = [] for user in doc: user_json = { "id": user['id'], "name": user['name'] } users_json.append(user_json) return func.HttpResponse( json.dumps(users_json), status_code=200, mimetype="application/json" )
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('Python HTTP trigger function processed a request.') tweet_id = req.params.get('tweet_id') logging.info(f'Tweet id: {tweet_id}.') try: status = api.get_status(tweet_id, include_entities=True, tweet_mode='extended') (valid, resp) = filter_tweet(status) if not valid: return resp response = process_image(status) if response is None: return func.HttpResponse(f"No image attached") return post_tweet(response, tweet_id) except Exception as e: logging.error(f'btw: {e}') raise e
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('Python HTTP trigger function processed a request.') # getting request params urls = getParam("urls", req) entity_id = getParam("entity_id", req) org_id = getParam("org_id", req) # creating in&out in storage # preparing data from storage # invokation of the queuers for current in urls: urllib.request.urlopen(current) # return function result return func.HttpResponse("done")
def main(req: func.HttpRequest) -> func.HttpResponse: TAG = "convert_excel_to_csv.__init__.main" LogHelper.log_info(TAG, 'Python HTTP trigger function processed a request.') request_params = req.get_json() convert_helper = ConvertHelper() blob_account = os.environ["BlobStorageAccount"] blob_key = os.environ["BlobStorageKey"] convert_helper.connect_to_blob(blob_account, blob_key) convert_helper.convert_excel_to_csv(request_params) blob_name = request_params['blob_input']['blobname'] message_string = "Convert blob %s successfully" % blob_name return_json = "{ \"message\" : \"%s\" }" % message_string return func.HttpResponse(return_json, status_code=200)
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('Python HTTP trigger function processed a request.') cnx = mysql.connector.connect(user=DB_USER, password=DB_PASSWORD, host=DB_HOST, port=3306, database=DB_NAME) cursor = cnx.cursor() cursor.execute("SELECT nombre FROM `personas`") results = cursor.fetchall() resp = "" for row in results: resp += '\n >> ' + str(row[0]) return func.HttpResponse(f"Personas:{resp}")
def main(req: func.HttpRequest, documentsin: func.DocumentList, documentsout: func.Out[func.Document]) -> func.HttpResponse: body = list() body_bag = {"messages": body} for doc in documentsin: d = dict() for keep in ['user_name', 'key', 'color', 'effect', 'text']: d[keep] = doc[keep] body.append(d) logger.info(body) doc['read'] = 'T' documentsout.set(func.Document.from_dict(doc)) body_bag = {"messages": body} return func.HttpResponse(body=json.dumps(body_bag), headers={"Content-type": "application/json"}, status_code=200)