def use_logging_handler(): # [START logging_handler_setup] # Imports the Google Cloud client library import google.cloud.logging # Instantiates a client client = google.cloud.logging.Client() # Connects the logger to the root logging handler; by default this captures # all logs at INFO level and higher client.setup_logging() # [END logging_handler_setup] # [START logging_handler_usage] # Imports Python standard library logging import logging # The data to log text = 'Hello, world!' # Emits the data using the standard logging module logging.warning(text) # [END logging_handler_usage] print('Logged: {}'.format(text))
def orders_paid(): """ This is the public endpoint (no auth) for shopify orders_paid webhook. """ data = flask.request.json logging.info(f'Receiving orders_paid request {data}') if data.get('topic') != 'ORDERS_PAID': logging.warning(f'Invalid not ORDERS_PAID data received {data}') elif not data.get('domain') or not data.get('payload'): logging.warning(f'Invalid shop/customer data received {data}') else: try: shop = data.get('domain') order_id = data.get('payload').get('id') customer_id = data.get('payload').get('customer').get('id') payload = data.get('payload') res = sql_handler.save_orders_paid(shop, order_id, customer_id, payload) if res.status_code == 200: logging.info('Data saved to cloud SQL') except Exception as e: logging.error(f'Saving events error: {e}') response = flask.jsonify('OK') response.status_code = 200 return response
def fetch_single_profile(force_update, userId, social_platform='instagram'): profile = None if not force_update: profile, update_time = sql_handler.get_profile( userId, platform=social_platform) logging.info( f'Not forcing profile update, and obtained profile {profile}') if not profile or len(profile) == 0: for i in range(0, 5): logging.info( f'Fetching profile from Modash for userid {userId}: # {i+1}th try' ) url = f'{MODASH_API_ENDPINT}/{social_platform}/profile/{userId}/report' logging.info(f'Receiving request for url {url}') headers = {'Authorization': MODASH_AUTH_HEADER} profile_res = requests.get(url, headers=headers) profile_json = profile_res.json() logging.info( f'Modash {social_platform} profile response is: {profile_res.json()}' ) profile = profile_json.get('profile') if profile: save_modash_profile_firebase(userId, profile, social_platform) sql_handler.save_profile(userId, social_platform, profile) break else: logging.warning('Modash API not responding, retrying') time.sleep(1) return profile
def track(): """ public endpoint (no auth) Note: Shopify client side is using the following code snippet to send tracking events: # req.send(JSON.stringify({ # lifo_tracker_id: lifo_tracker_id, # shop: getShop(), # location: document.location, # navigator: navigator.userAgent, # referrer: document.referrer, # discount_code, # })), """ data = flask.request.json logging.info(f'Receiving /track request {data}') if not data.get('shop'): logging.warning(f'Invalid shop data received {data}') elif not data.get('lifo_tracker_id'): logging.debug(f'Skip none lifo event {data}') else: try: res = sql_handler.save_track_visit(data) if res.status_code == 200: logging.info('Data saved to cloud SQL') except Exception as e: logging.error(f'Saving events error: {e}') response = flask.jsonify({'status': 'OK'}) response.status_code = 200 return response
def use_logging_handler(): # [START logging_handler_setup] # Imports the Cloud Logging client library import google.cloud.logging # Instantiates a client client = google.cloud.logging.Client() # Retrieves a Cloud Logging handler based on the environment # you're running in and integrates the handler with the # Python logging module. By default this captures all logs # at INFO level and higher client.get_default_handler() client.setup_logging() # [END logging_handler_setup] # [START logging_handler_usage] # Imports Python standard library logging import logging # The data to log text = 'Hello, world!' # Emits the data using the standard logging module logging.warning(text) # [END logging_handler_usage] print('Logged: {}'.format(text))
def verify_auth_status(): """ This is an API that verifies the authorization status. Called when user loads up the page. """ from cloud_sql import sql_handler uid = flask.session['uid'] logging.info(f'verifying auth sync status for uid {uid}') access_token, email = sql_handler.get_nylas_authorize_info(uid) if not access_token: logging.info(f'The account {uid} has not authorized yet') response = flask.jsonify({'status': 'no auth'}) response.status_code = 402 return response try: nylas_client = APIClient( app_id=app.config["NYLAS_OAUTH_CLIENT_ID"], app_secret=app.config["NYLAS_OAUTH_CLIENT_SECRET"], access_token=access_token, ) sync_state = nylas_client.account.sync_state logging.info(f'Current syncing status is {sync_state}') logging.info(f'The account {uid} is in sync') response = flask.jsonify({'email': email or flask.session['email']}) response.status_code = 200 return response except Exception as e: # Here we simplify the status into binary cases. # for more statuses, check https://docs.nylas.com/reference#account-sync-status logging.warning(f'The account {uid} need resync') response = flask.jsonify({'status': 'Need resync'}) response.status_code = 200 return response
def archiveLog(self, job, wsdef, workstepLog ): proj = self.projects[job.projectId] # un-backslash filename in case of windows shenanigans workstepLog = self.unbackslashPath( workstepLog ) # Check that we're configured to publish stuff if not proj.bucketName: logging.warning("archiveLog: No bucketName set in project, can't archive log.") return False # Make sure the file exists if not os.path.exists(workstepLog): logging.warning( f"archiveLog: Workstep log file {workstepLog} does not exist." ) return False else: logging.info(f"Archiving {workstepLog} to bucket {proj.bucketName}") if self.storage_client is None: self.storage_client = google.cloud.storage.Client() logFilename = os.path.split(workstepLog)[-1] bucket = self.storage_client.bucket(proj.bucketName) blobName = self.unbackslashPath( os.path.join(proj.projectId, job.jobKey, "logs", logFilename) ) blob = bucket.blob(blobName) result = blob.upload_from_filename(workstepLog, content_type="text/plain;charset=UTF-8") logArchiveUrl = f"https://{bucket.name}.storage.googleapis.com/{blob.name}" logging.info(f"Result of upload is {logArchiveUrl}")
def rate(request, post_channel, post_user, type, post_url): logging.debug('rate: C=%s U=%s T=%s P=%s' % (post_channel, post_user, type, post_url)) types = ['up', 'down', 'wtf', 'nsfw'] if type in types: name = ''.join( re.findall( '[a-zA-Z0-9_-]', post_channel + '_' + post_user + '_' + type + '_' + post_url))[:500] try: taskqueue.add(name=name, queue_name='default', url='/tasks/rate', params={ 'channel': post_channel, 'post_user': post_user, 'type': type, 'post_url': post_url }) except taskqueue.TombstonedTaskError: logging.warning('Duplicate task name %s' % name) else: logging.warning('Wrong type (%s)! %s %s %s' % (type, post_channel, post_user, post_url)) return HttpResponseRedirect('/url/')
def post(self): post_channel = self.request.get('post_channel', '') post_user = self.request.get('post_user', '') post_url = self.request.get('post_url', '') post_extra = self.request.get('extra', '') # Related/tag if post_extra.startwith('#'): # TODO: check if post_extra[1:].isdigit(): type = 'related' else: type = 'tag' else: type = 'comment' url = Url.all().filter('url =', post_url).get() channel = Channel.all().filter('name =', post_channel).get() channelurl = ChannelUrl.all().filter('channel =', channel).filter('url =', url).get() if channelurl: extra = Extra() extra.channelurl = channelurl extra.user = post_user setattr(extra, type, post_extra) extra.put() else: logging.warning('ChannelUrl not found: %s %s' % (post_channel, post_url))
def workstepFetch(self, job, wsdef, fpLog ): proj = self.projects[job.projectId] pristineRepoPath = self.updatePristineRepo( proj, wsdef, fpLog ) if not pristineRepoPath: return False # Now clone the pristine repo into the work dir workdirRepoPath = os.path.join( proj.workDir, job.jobDirShort ) if os.path.exists( workdirRepoPath ): # Might make this a fatal error later, or nuke and re-copy this dir, but for # now we'll allow this to make debugging easier. logging.warning( f"Workdir repo {workdirRepoPath} already exists, using that.") else: gitCloneCommand = [ "git", "clone", pristineRepoPath, workdirRepoPath ] retVal, cmdTime = self.echoRunCommand(gitCloneCommand, fpLog) if retVal: return False # Now bring the workdir copy of the repo up to date with what we're # trying to build gitCheckoutCommand = [ "git", "-C", workdirRepoPath, "checkout", job.commitVer ] retVal, cmdTime = self.echoRunCommand( gitCheckoutCommand, fpLog ) if retVal: return False return True
def publishArtifact( self, proj, job, wsdef, workdirRepoPath ): # Check that we're configured to publish stuff if not proj.bucketName: logging.warning("publishArtifact: No bucketName set in project, can't publish.") return False # Make sure the file exists artifactFile = wsdef.artifact artifactFile = self.replacePathVars( artifactFile, workdirRepoPath, proj, job ) if not os.path.exists( artifactFile ): failMsg = f"Artifact file {artifactFile} does not exist." logging.warning( failMsg ) job.lastError = failMsg return False else: logging.info( f"Publishing {artifactFile} to bucket {proj.bucketName}") if self.storage_client is None: self.storage_client = google.cloud.storage.Client() artifactFileName = os.path.split( artifactFile )[-1] bucket = self.storage_client.bucket( proj.bucketName ) blobName = self.unbackslashPath( os.path.join( proj.projectId, job.jobKey, artifactFileName) ) blob = bucket.blob( blobName ) result = blob.upload_from_filename( artifactFile ) artifactUrl = f"https://storage.googleapis.com/{bucket.name}/{blob.name}" logging.info( f"Result of upload is {artifactUrl}") # Make an artifact entry in the DB artifact = TKArtifact() artifact.project = proj.projectId artifact.commitVer = job.commitVer artifact.jobKey = job.jobKey artifact.builtfile = artifactUrl # If the artifact has a manifestBundleId, make a manifest for it if proj.manifestBundleId: artifact.addManifestInfo( proj.manifestAppTitle, proj.manifestBundleId, job.version, job.buildNum, artifactUrl ) # maybe want to make this more configurable manifestName = f"{proj.projectId}_manifest_{job.version}_build_{job.buildNum}.plist" manifestBlobName = os.path.join( proj.projectId, job.jobKey, manifestName) manifestBlob = bucket.blob( manifestBlobName ) result = manifestBlob.upload_from_string( artifact.generateManifestFile()) manifestUrl = f"https://storage.googleapis.com/{bucket.name}/{manifestBlob.name}" artifact.manifest['manifestURL'] = manifestUrl logging.info( f"Uploaded IOS manifest to {manifestUrl}" ) pubArtifactRef = self.db.collection(u'artifacts').document() pubArtifactRef.set( artifact.toFirebaseDict() ) logging.info( f"Added artifact with ref {pubArtifactRef.id}") return True
def info(request): today = datetime.date.today() now = datetime.datetime.now() l = list(string.ascii_uppercase) l.append('Z') DEFAULT_COUNTER_NAME = chr(now.isocalendar()[0] - 2010 + 65) + l[(now.isocalendar()[1] - 1) / 2] id = None url = None if request.method == "POST": try: data = simplejson.loads(request.raw_post_data) id = str(data.get('id', '')).upper() url = data.get('url', '') logging.debug('id: %s/url: %s' % (id, url)) except Exception as e: logging.warning('Error %s' % (e)) try: id = int(id) if id < 1000: id = DEFAULT_COUNTER_NAME + str(id) # logging.debug('%s' % id) except: pattern1 = r'^[A-Z]{1}$' pattern2 = r'^[A-Z]{2}$' if re.match(pattern1, id): id = DEFAULT_COUNTER_NAME[0] + str(id) # logging.debug('%s' % id) id = id + str(counter.get_count(id)) # logging.debug('%s' % id) elif re.match(pattern2, id): id = id + str(counter.get_count(id)) channelurl = ChannelUrl.get_by_id(id) if channelurl: url = channelurl.url.get().url url_title = channelurl.url.get().title rate = channelurl.rating() extra = channelurl.extras(plain='True') posts = channelurl.posts() channel = channelurl.channel.get().name retval = simplejson.dumps({ 'id': channelurl.key.id(), 'url': url, 'title': url_title, 'rate': rate, 'extra': extra, 'posts': posts }) else: retval = simplejson.dumps({'id': 0}) return HttpResponse(retval, mimetype="application/json")
def shop_customer_info(): """ This endpoint is called upon AM to access Shopify shop products for access_token """ shop = flask.request.args.get('shop') days_range = flask.request.args.get('days_range') try: days_range = int(days_range) except Exception as e: logging.warning('Illegal days_range, revert to default value') days_range = DEFFAULT_DATE_RANGE res = get_shopify_access_token(shop) if not res: res = {'status': 'access token not found'} response = flask.jsonify(res) response.status_code = 404 return response shop_access_token = res if request.method == 'PUT': created_at_min = datetime.datetime.now() - datetime.timedelta( days=days_range) url = f'https://{shop}/admin/api/{API_VERSION}/customers.json' logging.info(f'Receiving request for url {url}') headers = {"X-Shopify-Access-Token": shop_access_token} params = { 'limit': MAX_SHOPIFY_RESULTS_LIMIT, 'created_at_min': created_at_min.isoformat() } res = requests.get(url, headers=headers, params=params) data = res.json() logging.info(f'Obtained shop information for shop {shop}: {data}') customers = data.get('customers') if customers: for customer_json in customers: customer_id = customer_json.get('id') sql_handler.save_customer_info(shop, customer_id, customer_json) logging.info(f'Saved {len(customers)} for shop {shop}') else: logging.info('No customers found') else: logging.info(f'Getting customer location data for shop {shop}') query_results = sql_handler.get_shop_customers_locations(shop) data = [] for row in query_results: cur_res = {} cur_res['city'] = row[0] cur_res['province'] = row[1] cur_res['location_cnt'] = row[2] data.append(cur_res) response = flask.jsonify(data) response.status_code = 200 return response
def createFromConfigFile(cls, agentConfigFile ): # Use where the agent Cfg is located as the default for the build dir defaultTkBuildDir = os.path.split( agentConfigFile )[0] if not os.path.exists(agentConfigFile): logging.warning("WARN: agent config file doesn't exist or can't be read:", agentConfigFile) else: with open(agentConfigFile) as fpconfig: configData = yaml.full_load(fpconfig) return cls.createFromConfig( configData, defaultTkBuildDir )
def send_message_to_pubsub(message, file_name, storage_bucket_name): publisher = pubsub_v1.PublisherClient() logging.warning("PubSub: {} to topic: {}".format(message, topic_name_output)) message = message.encode('utf-8') topic_path = publisher.topic_path(project_id, topic_name_output) status = publisher.publish(topic_path, message, object=label_to_detect, file_name=file_name, storage_bucket_name=storage_bucket_name)
def peekVersion( self, job, versionFile ): if not os.path.exists( versionFile ): logging.warning( f"Version file {versionFile} does not exist.") return with open( versionFile ) as fp: verLine = fp.readline().strip() if verLine: job.version = verLine logging.info( f"PeekVersion: Version is {job.version}" )
def serverUpdate(self): logging.info( f"Agent update ... {self.updCount}") self.updCount += 1 print( f" {len(self.jobList)} avail jobs:") # Report our status to the server self.updateCurrentStatus( AgentStatus.IDLE ) # Check if there are any obsolete jobs, and delete them self.cleanupObsoleteJobs() # Check if there are any jobdirs that do not exist in the job list. If so, clean up those job dirs. self.cleanupOldJobDirs() # Check if there are jobs we can do for job in self.jobList: proj = self.projects[job.projectId] # Ignore jobs with tags we can't match if not self.matchTags( job.tags, self.agentInfo.tags ): print("Skipping job with tags ", job.tags, "our tags are ", self.agentInfo.tags ) continue # Ignore jobs marked "RUN" ... this might be running on another node (todo) but # probably is just stale because firebase updates are not instant. if JobStatus.RUN in job.worksteps.values(): logging.warning("Job is marked RUN?? but we're not running it.") #sys.exit(1) continue # If the job has work left to do if job.hasWorkRemaining( proj.workstepNames ): print("job ", job, "has work left...") self.currentJob = job break else: print( "No work remains", job, job.worksteps ) # Did we find a job to run? if self.currentJob == None: logging.info("No matching jobs found to run.") else: # run the job self.runNextJobStep( self.currentJob ) # clear the current job self.currentJob = None
def get(self): doc_id = self.request.get('doc_id', '') if doc_id: try: prefix = self.request.get('prefix', '') name = str(prefix) + str(doc_id) taskqueue.add(name=name, queue_name='document', url='/tasks/update_document', params={'doc_id': doc_id}) except taskqueue.TombstonedTaskError: logging.warning('TombstonedTaskError %s' % (name)) except taskqueue.TaskAlreadyExistsError: logging.warning('TaskAlreadyExistsError %s' % (name)) else: doc_ids = [] url_keys = Url.query().order(Url.document_date).fetch( 100, keys_only=True) for key in url_keys: doc_id = key.id() try: prefix = self.request.get('prefix', '') name = str(prefix) + str(doc_id) taskqueue.add(name=str(doc_id), queue_name='document', url='/tasks/update_document', params={'doc_id': str(doc_id)}) except taskqueue.TombstonedTaskError: logging.warning('TombstonedTaskError %s' % (str(name))) except taskqueue.TaskAlreadyExistsError: logging.warning('TaskAlreadyExistsError %s' % (str(name)))
def garagecommand_callback(message): logging.info(f"Received command: {message.data}") try: msgDict = json.loads(message.data) except: logging.warning("Bad command, ignoring...") return cmd = msgDict.get('command') if cmd: if cmd == "open": import garagedoorgpio garagedoorgpio.open_door() elif cmd == "close": import garagedoorgpio garagedoorgpio.close_door() else: logging.warning(f"Unknown command: {msgDict['command']}") message.ack()
def request_handling(): logging.warning('Arguments: {}'.format(request.args)) logging.warning('Method: {}'.format(request.method)) logging.warning('URL: {}'.format(request.url)) if request.method == 'POST': result = request.form logging.warning(result) return "ok"
def modash_match(): filters = flask.request.json if not filters: response = flask.jsonify({"error": "None empty post body required!"}) response.status_code = 412 return response field_range_filters = filters.get('field_range_filters') field_contain_filters = filters.get('field_contain_filters') prefix_filters = filters.get('prefix_filters') modash_profile_ref = db.collection('modash') if field_range_filters: logging.warning('Field range filters are not supported in server side') modash_profile_ref = prefix_filters_handler(modash_profile_ref, prefix_filters) snap_list = modash_profile_ref.limit(1000).get() results = [doc.to_dict().get('profile_json') for doc in snap_list] response = flask.jsonify(results) response.status_code = 200 return response
def extra(request, post_channel, post_user, extra, post_url): logging.debug('rate: C=%s U=%s E=%s P=%s' % (post_channel, post_user, extra, post_url)) name = ''.join( re.findall( '[a-zA-Z0-9_-]', post_channel + '_' + post_user + '_' + extra + '_' + post_url))[:500] try: taskqueue.add(name=name, queue_name='default', url='/tasks/extra', params={ 'channel': post_channel, 'post_user': post_user, 'extra': extra, 'post_url': post_url }) except taskqueue.TombstonedTaskError: logging.warning('Duplicate task name %s' % name) return HttpResponseRedirect('/url/')
def post(self): post_channel = self.request.get('post_channel', '') post_user = self.request.get('post_user', '') post_url = self.request.get('post_url', '') type = self.request.get('type', '') url = Url.all().filter('url =', post_url).get() channel = Channel.all().filter('name =', post_channel).get() channelurl = ChannelUrl.all().filter('channel =', channel).filter('url =', url).get() if channelurl: rate = Rate() rate.channelurl = channelurl rate.user = post_user rate.type = type rate.put() else: logging.warning('ChannelUrl not found: %s %s' % (post_channel, post_url))
def post(request, post_url, post_channel=None, post_user=None): if not post_user: post_user = '******' if not post_channel: post_channel = '!' + post_user logging.debug('post: C=%s U=%s P=%s' % (post_channel, post_user, post_url)) name = ''.join( re.findall('[a-zA-Z0-9_-]', post_channel + '_' + post_user + '_' + post_url))[:500] try: taskqueue.add(name=name, queue_name='default', url='/tasks/post', params={ 'post_channel': post_channel, 'post_user': post_user, 'post_url': post_url }) except taskqueue.TombstonedTaskError: logging.warning('Duplicate task name %s' % name) return HttpResponseRedirect('/url/')
def edit_post(id): form = PostForm() post = get_model().from_datastore(get_model().read(id, 'Post')) file = '' if not check_post_author(post['author_id'], current_user.id): flash('Only the owner of the post can edit it that post', 'warning') return redirect(url_for('blog.view_post', id=post['id'])) if request.method == 'POST': data = request.form.to_dict(flat=True) post_time = datetime.now().timestamp() #datetime.now().replace(second=0, microsecond=0) try: file = file_upload(request.files.get('file')) logging.info(file) if not file: file = post['picture_url'] except Exception as e: logging.warning(e) print('Could not upload file, something went wrong error is:{0}'. format(e)) sql_data = { 'title': data['title'], 'content': data['post_data'], 'author': current_user.name, 'author_id': current_user.id, 'updated_timestamp': post_time, 'timestamp': post['timestamp'], 'picture_url': file } post = get_model().update(sql_data, id=id) return redirect(url_for('blog.view_post', id=post['id'])) return render_template("form.html", action='blog.edit_post', post=post, id=post['id'], form=form)
def post(request): # today=datetime.date.today() topic = None nick = None channel = None date = None retval = {} if request.method == "POST": logging.debug('raw_post_data %s' % (request.raw_post_data)) try: data = simplejson.loads(request.raw_post_data) logging.debug('data %s' % (data)) topic = data.get('topic') channel = data.get('channel') nick = data.get('nick') date = datetime.datetime.strptime(data.get('date'), '%Y%m%d%H%M') logging.debug('date: %s, nick: %s, channel, %s, topic: %s' % (date, nick, channel, topic)) except Exception as e: logging.warning('TOPIC/POST: Somewhere near %s' % (e)) retval = {'id': 0, 'topic': e} else: try: t = Topic(channel=channel, nick=nick, topic=topic, date=date) t.put() except Exception as e: logging.warning('TOPIC/POST/NEW: Somewhere near %s' % (e)) retval = {'id': 0, 'topic': e} else: retval = {'id': t.key.id(), 'topic': topic} # TODO private channel? # News(content='Topic: %s @ %s' % (topic,channel),link='/topic/').put() News(content='Topic', link_text='%s @ %s' % (topic, channel), link='/topic/').put() logging.debug('Return: %s' % (retval)) return HttpResponse(simplejson.dumps(retval), mimetype="application/json")
def order_complete(): """ Public endpoint (no auth) Don't confuse this one with Shopify webhook. Note: Shopify client side is using the following code snippet to send order_complete events: # n.send(JSON.stringify({ # lifo_tracker_id: lifo_tracker_id, # shop: getShop(), # location: document.location, # navigator: navigator.userAgent, # referrer: document.referrer, # discount_code, # order_id, # customer_id: data.customer_id, # order_data, # })); """ data = flask.request.json logging.info(f'Receiving order_complete request {data}') if not data.get('shop') or not data.get('order_id') or not data.get( 'customer_id'): logging.warning(f'Invalid shop/customer data received {data}') elif not data.get('lifo_tracker_id'): logging.debug(f'Skip none lifo event {data}') else: try: order_data = data.get('order_data') # we use subtotal_price for calculation, before tax and shipping subtotal_price = float(order_data.get('subtotal_price')) logging.debug(f'Received order with revenue of {subtotal_price}') res = sql_handler.save_order_complete(data, subtotal_price) if res.status_code == 200: logging.info('Data saved to cloud SQL') except Exception as e: logging.error(f'Saving events error: {e}') response = flask.jsonify({'status': 'OK'}) response.status_code = 200 return response
def entitlement(): """ This should be replaced with matching algorithm with human supervision in near future before GA. Currently this assumes manual input of entitlement data (from BD and sales team) before each POC. :return: list of matched "shop" along with potential commission information (to be consumed) """ uid = flask.session['uid'] user = auth.get_user(uid) influencer_email = user.email if not influencer_email or not checkers.is_email(influencer_email): logging.warning(f'Influencer {user} does not have valid email') response = flask.jsonify({'Status': 'Need valid email'}) response.status_code = 422 return response shops = sql_handler.get_campaign_entitlement(influencer_email) res = { individual_shop['shop']: individual_shop for individual_shop in shops } response = flask.jsonify(res) response.status_code = 200 return response
def create_post(): form = PostForm() if form.validate_on_submit(): data = request.form.to_dict(flat=True) data['author'] = current_user.name image = '' post_time = datetime.now().timestamp() try: image = file_upload(request.files.get('file')) logging.info(image) if not image: image = 'https://storage.cloud.google.com/badgcloudstorage/pusheen-2019-12-10-233107.jpg' except Exception as e: logging.warning(e) print('Could not upload file, something went wrong error is:{0}'. format(e)) sql_data = { 'title': data['title'], 'content': data['post_data'], 'author': current_user.name, 'author_id': current_user.id, 'timestamp': post_time, 'picture_url': image } post = get_model().create(sql_data) return redirect(url_for('blog.view_post', id=post['id'])) else: try: flash(form.errors["post_data"][0], 'warning') except KeyError: pass return render_template("form.html", action='blog.create_post', post={}, form=form)
def get(self): id = self.request.get('id') if id: url = Url.get_by_id(int(id)) if url: try: prefix = self.request.get('prefix', '') name = str(prefix) + str(id) taskqueue.add(name=name, queue_name='urlfetch', url='/tasks/title', params={'id': id}) except taskqueue.TombstonedTaskError: logging.warning('TombstonedTaskError %s' % id) except taskqueue.TaskAlreadyExistsError: logging.warning('TaskAlreadyExistsError %s' % id) else: logging.info('No URL') else: logging.info('No id') redirect = self.request.get('redirect') if redirect: return self.redirect(redirect)