def defer_method (*args, **kwargs): # Collecting defered task header information headers = {} headers["queue_name"] = os.environ.get('HTTP_X_APPENGINE_QUEUENAME', '') headers["retry_count"] = os.environ.get('HTTP_X_APPENGINE_TASKRETRYCOUNT', 0) headers["task_name"] = os.environ.get('HTTP_X_APPENGINE_TASKNAME', '') if not tools.on_dev_server(): logging.info("deferred_task_decorator : {}".format(headers)) # Running for the first time ignore _retry_count = headers.get("retry_count", 0) retry_count = int(_retry_count) if tools.safeIsDigit(_retry_count) else 0 if retry_count < 1: return method(*args, **kwargs) # We are retying if retry_count == NOTIFY_RETRY_COUNT: if not tools.on_dev_server(): logging.warn("Found task retry count overboard ..{}:{}"\ .format(headers.get("queue_name"), headers.get("task_name"))) subject = "Task retried too many times" text = "{}:{} Task retried too many times - ({})".format( headers.get("queue_name"), headers.get("task_name"), retry_count) deferred.defer(mail.send_mail, SENDER_EMAIL, ERROR_EMAIL, EMAIL_PREFIX + subject, text) else: if not tools.on_dev_server(): logging.info("Found task retry count ok ..{}:{} - ({})"\ .format(headers.get("queue_name"), headers.get("task_name"), retry_count)) return method(*args, **kwargs)
def defer_method(*args, **kwargs): # Collecting defered task header information headers = {} headers["queue_name"] = os.environ.get('HTTP_X_APPENGINE_QUEUENAME', '') headers["retry_count"] = os.environ.get( 'HTTP_X_APPENGINE_TASKRETRYCOUNT', 0) headers["task_name"] = os.environ.get('HTTP_X_APPENGINE_TASKNAME', '') if not tools.on_dev_server(): logging.info("deferred_task_decorator : {}".format(headers)) # Running for the first time ignore _retry_count = headers.get("retry_count", 0) retry_count = int(_retry_count) if tools.safeIsDigit( _retry_count) else 0 if retry_count < 1: return method(*args, **kwargs) # We are retying if not tools.on_dev_server(): logging.info("Found task retry count ok ..{}:{} - ({})".format( headers.get("queue_name"), headers.get("task_name"), retry_count)) return method(*args, **kwargs)
def defer_method(*args, **kwargs): # Collecting defered task header information headers = {} headers["queue_name"] = os.environ.get('HTTP_X_APPENGINE_QUEUENAME', '') headers["retry_count"] = os.environ.get( 'HTTP_X_APPENGINE_TASKRETRYCOUNT', 0) headers["task_name"] = os.environ.get('HTTP_X_APPENGINE_TASKNAME', '') if not tools.on_dev_server(): logging.info("deferred_task_decorator : {}".format(headers)) # Running for the first time ignore _retry_count = headers.get("retry_count", 0) retry_count = int(_retry_count) if tools.safeIsDigit( _retry_count) else 0 if retry_count < 1: return method(*args, **kwargs) # We are retying if retry_count == NOTIFY_RETRY_COUNT: if not tools.on_dev_server(): logging.warn("Found task retry count overboard ..{}:{}"\ .format(headers.get("queue_name"), headers.get("task_name"))) subject = "Task retried too many times" text = "{}:{} Task retried too many times - ({})".format( headers.get("queue_name"), headers.get("task_name"), retry_count) deferred.defer(mail.send_mail, SENDER_EMAIL, ERROR_EMAIL, EMAIL_PREFIX + subject, text) else: if not tools.on_dev_server(): logging.info("Found task retry count ok ..{}:{} - ({})"\ .format(headers.get("queue_name"), headers.get("task_name"), retry_count)) return method(*args, **kwargs)
def send_airtime(enterprise, phone, amount, currency): """ Takes a payment object and requests airtime via Africa's Talking Example response: [ { "errorMessage":"None", "phoneNumber":"2547XXYYZZZZ", "amount":"KES 100", "status":"sent", "requestId":"ATQid_4fbec14b3c6b976d398957f9f8a65b3d" } ] """ AT_API_KEY = enterprise.get_gateway_property('atalking', 'ApiKey') AT_USERNAME = enterprise.get_gateway_property('atalking', 'username') amount_str = "[{\"phoneNumber\":\"+%s\",\"amount\":\"%s %d\"}]" % ( phone, currency, int(amount)) par_list = [('ApiKey', AT_API_KEY), ('username', AT_USERNAME), ('recipients', amount_str)] headers = { 'Content-Type': 'application/x-www-form-urlencoded', 'Accept': "application/json", 'ApiKey': AT_API_KEY } base_url = "http://api.africastalking.com/version1/airtime/send" enc = urllib.urlencode(par_list) dry = "DRY" if tools.on_dev_server() else "REAL" logging.debug("Making %s request: %s" % (dry, base_url + '?' + enc)) gateway_text_response = gateway_id = None success = False if tools.on_dev_server(): success = True gateway_text_response = "Dev server, Auto-success" gateway_id = str(random.randint(1, 99999)) else: try: response = urlfetch.fetch(url=base_url, payload=enc, method="POST", deadline=60, headers=headers) resp_content = None if response.status_code in [200, 201]: resp_content = json.loads(response.content) if resp_content and resp_content.has_key('responses'): resps = resp_content.get('responses') if len(resps): oresp = resps[0] if oresp.has_key('status') and oresp['status'].upper( ).strip() == 'SENT': gateway_id = oresp.get('requestId') success = True except Exception, e: pass
def send_airtime(enterprise, phone, amount, currency): """ Takes a payment object and requests airtime via Africa's Talking Example response: [ { "errorMessage":"None", "phoneNumber":"2547XXYYZZZZ", "amount":"KES 100", "status":"sent", "requestId":"ATQid_4fbec14b3c6b976d398957f9f8a65b3d" } ] """ AT_API_KEY = enterprise.get_gateway_property('atalking', 'ApiKey') amount_str = "[{\"phoneNumber\":\"+%s\",\"amount\":\"%s %d\"}]" % (phone, currency, int(amount)) par_list=[ ('ApiKey',AT_API_KEY), ('username',"echomobile"), ('recipients', amount_str) ] headers = { 'Content-Type': 'application/x-www-form-urlencoded', 'Accept': "application/json", 'ApiKey': AT_API_KEY } base_url="http://api.africastalking.com/version1/airtime/send" enc = urllib.urlencode(par_list) dry = "DRY" if tools.on_dev_server() else "REAL" logging.debug("Making %s request: %s" % (dry, base_url + '?' + enc)) gateway_text_response = gateway_id = None success = False if tools.on_dev_server(): success = True gateway_text_response = "Dev server, Auto-success" gateway_id = str(random.randint(1,99999)) else: try: response = urlfetch.fetch(url=base_url, payload=enc, method="POST", deadline=60, headers=headers) resp_content = None if response.status_code in [200, 201]: resp_content = json.loads(response.content) if resp_content and resp_content.has_key('responses'): resps = resp_content.get('responses') if len(resps): oresp = resps[0] if oresp.has_key('status') and oresp['status'].upper().strip() == 'SENT': gateway_id = oresp.get('requestId') success = True except Exception, e: pass
def process_exception(self, suppressed_exceptions=None): exception_name = sys.exc_info()[0].__name__ exception_details = str(sys.exc_info()[1]) exception_traceback = ''.join(traceback.format_exception(*sys.exc_info())) logging.error(exception_traceback) send_email = not (suppressed_exceptions and exception_name in suppressed_exceptions) if send_email: exception_expiration = 3600 # seconds (max 1 mail per hour for a particular exception) mail_admin = SENDER_EMAIL # must be admin for the application sitename = SITENAME ver = os.environ['CURRENT_VERSION_ID'] dev = any(keyword in ver for keyword in TEST_VERSIONS) or tools.on_dev_server() sitename += ":DEV" if dev else ":PROD" session = self.session ename = "Unknown Org" if session and session.has_key('enterprise'): ename = session['enterprise'].name throttle_name = 'exception-' + exception_name throttle = memcache.get(throttle_name) if throttle is None and not dev: memcache.add(throttle_name, 1, exception_expiration) subject = '[%s] exception for %s [%s: %s]' % (sitename, ename, exception_name, exception_details) body = exception_traceback + "\n\n" + self.request.uri mail.send_mail(to=ERROR_EMAIL, sender=mail_admin, subject=subject, body=body) return exception_name, exception_details, exception_traceback
def writeData(self): total_i = self.counters['run'] while True: self.query = self._get_gql_query() if self.query: entities, self.cursor, more = self.KIND.gql(self.query).fetch_page(self.batch_size, start_cursor=self.cursor) if not entities: logging.debug("No rows returned by query -- done") return else: logging.debug("Got %d rows" % len(entities)) for entity in entities: if entity: ed = self.entityData(entity) else: continue if self.report.ftype == REPORT.CSV: csv.writer(self.gcs_file).writerow(tools.normalize_list_to_ascii(ed)) self.gcs_file.flush() total_i += 1 self.counters['run'] += 1 if total_i % 100 == 0: cancelled = self.updateProgressAndCheckIfCancelled() if cancelled: self.report.CleanDelete() logging.debug("Worker cancelled by user, report deleted.") return logging.debug("Batch of %d done" % len(entities)) elapsed_ms = tools.unixtime() - self.worker_start elapsed = elapsed_ms / 1000 if elapsed >= MAX_REQUEST_SECONDS or (tools.on_dev_server() and TEST_TOO_LONG_ON_EVERY_BATCH): logging.debug("Elapsed %ss" % elapsed) raise TooLongError()
def google_oauth2_callback(self, d): ''' Handle server-side oauth2 callback ''' error = self.request.get('error') code = self.request.get('code') scope = self.request.get('scope') # state_scopes = self.request.get('state') if code: from settings.secrets import GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET from constants import SECURE_BASE base = 'http://localhost:8080' if tools.on_dev_server() else SECURE_BASE credentials = client.credentials_from_code( GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, scope, code, redirect_uri=base + "/api/auth/google/oauth2callback") if self.user: cr_json = credentials.to_json() logging.debug(type(cr_json)) self.user.set_integration_prop('google_credentials', cr_json) self.user.put() self.update_session_user(self.user) elif error: logging.error(error) self.redirect("/app/integrations")
def send_sms(enterprise, phone, message): logging.info("Sending SMS to %s" % (phone)) AT_USERNAME = enterprise.get_gateway_property('atalking', 'username') AT_FROM_SHORTCODE = enterprise.get_gateway_property( 'atalking', 'shortcode') AT_API_KEY = enterprise.get_gateway_property('atalking', 'ApiKey') if not tools.on_dev_server() and (AT_USERNAME and AT_API_KEY): url = "http://api.africastalking.com/version1/messaging" params = [('username', AT_USERNAME), ('to', '+' + phone), ('message', message), ('bulkSMSMode', 1), ('enqueue', 1)] if AT_FROM_SHORTCODE: params.append(('from', AT_FROM_SHORTCODE)) enc = urllib.urlencode(params) headers = { 'Content-Type': 'application/x-www-form-urlencoded', 'Accept': "application/json", 'ApiKey': AT_API_KEY } response = urlfetch.fetch(url=url, payload=enc, method="POST", deadline=60, headers=headers) if response.status_code == 200: logging.debug(response.content) else: logging.warning(response.status_code)
def serve(self, d): import cloudstorage as gcs rkey = self.request.get('rkey') r = Report.GetAccessible(rkey, self.user, urlencoded_key=True) if r: if r.is_done() and r.gcs_files: gcsfn = r.gcs_files[0] if tools.on_dev_server(): try: gcs_file = gcs.open(gcsfn, 'r') except gcs.NotFoundError, e: self.response.out.write("File not found") else: self.response.headers[ 'Content-Type'] = Report.content_type(r.extension) self.response.headers['Content-Disposition'] = str( 'attachment; filename="%s"' % r.filename()) self.response.write(gcs_file.read()) gcs_file.close() else: signed_url = tools.sign_gcs_url(gcsfn, expires_after_seconds=5) response = self.redirect(signed_url) logging.info(response) else: self.set_response(success=False, status=404, message="Report not ready") # Not found
def send_response(self): if self.fb_id and (self.reply or self.message_data): message_object = {} if self.reply and 'attachment' not in self.message_data: message_object['text'] = self.reply if self.message_data: message_object.update(self.message_data) body = { "recipient": { "id": self.fb_id }, "message": message_object } logging.debug(body) url = "https://graph.facebook.com/v2.6/me/messages?access_token=%s" % secrets.FB_ACCESS_TOKEN if tools.on_dev_server(): logging.debug("Not sending request, on dev") else: response = urlfetch.fetch(url, payload=json.dumps(body), headers={"Content-Type": "application/json"}, method="POST") logging.debug(response.status_code) if response.status_code != 200: logging.warning(response.content) return body
def writeData(self): total_i = self.counters['run'] while True: self.query = self._get_query() if self.query: entities = self.query.fetch(limit=self.batch_size) self.cursor = self._get_cursor() if not entities: logging.debug("No rows returned by query -- done") return else: logging.debug("Got %d rows" % len(entities)) if entities and self.prefetch_props: entities = tools.prefetch_reference_properties( entities, *self.prefetch_props, missingRefNone=True) for entity in entities: if entity: ed = self.entityData(entity) else: continue string = '?' if self.report.ftype == REPORT.CSV: csv.writer(self.gcs_file).writerow( tools.normalize_list_to_ascii(ed)) elif self.report.ftype == REPORT.XLS: self.gcs_file.write(json.dumps(ed) + "\n") if total_i > REPORT.XLS_ROW_LIMIT: self.setProgress({ 'error': "XLS row limit (%d) exceeded!" % REPORT.XLS_ROW_LIMIT, 'status': REPORT.ERROR }) return self.gcs_file.flush() total_i += 1 self.counters['run'] += 1 if total_i % 100 == 0: cancelled = self.updateProgressAndCheckIfCancelled() if cancelled: self.report.CleanDelete() logging.debug( "Worker cancelled by user, report deleted.") return logging.debug("Batch of %d done" % len(entities)) elapsed_ms = tools.unixtime() - self.worker_start elapsed = elapsed_ms / 1000 if elapsed >= MAX_REQUEST_SECONDS or ( tools.on_dev_server() and TEST_TOO_LONG_ON_EVERY_BATCH): logging.debug("Elapsed %ss" % elapsed) raise TooLongError()
def get_auth_flow(self, scope): base = 'http://localhost:8080' if tools.on_dev_server() else SECURE_BASE flow = client.OAuth2WebServerFlow(client_id=GOOGLE_CLIENT_ID, client_secret=GOOGLE_CLIENT_SECRET, scope=scope, access_type='offline', prompt='consent', redirect_uri=base + "/api/auth/google/oauth2callback") flow.params['include_granted_scopes'] = 'true' # flow.params['access_type'] = 'offline' return flow
def defer_method(*args, **kwargs): # Collecting defered task header information headers = {} headers["queue_name"] = os.environ.get('HTTP_X_APPENGINE_QUEUENAME', '') headers["retry_count"] = os.environ.get('HTTP_X_APPENGINE_TASKRETRYCOUNT', 0) headers["task_name"] = os.environ.get('HTTP_X_APPENGINE_TASKNAME', '') if not tools.on_dev_server(): logging.info("deferred_task_decorator : {}".format(headers)) # Running for the first time ignore _retry_count = headers.get("retry_count", 0) retry_count = int(_retry_count) if tools.safeIsDigit(_retry_count) else 0 if retry_count < 1: return method(*args, **kwargs) # We are retying if not tools.on_dev_server(): logging.info("Found task retry count ok ..{}:{} - ({})" .format(headers.get("queue_name"), headers.get("task_name"), retry_count)) return method(*args, **kwargs)
def get_auth_flow(self, scope): base = 'http://localhost:8080' if tools.on_dev_server( ) else SECURE_BASE flow = client.OAuth2WebServerFlow(client_id=GOOGLE_CLIENT_ID, client_secret=GOOGLE_CLIENT_SECRET, scope=scope, access_type='offline', prompt='consent', redirect_uri=base + "/api/auth/google/oauth2callback") flow.params['include_granted_scopes'] = 'true' # flow.params['access_type'] = 'offline' return flow
def serveResource(self, bk, size=0): USE_SERVING_URL = True try: # Fix? if USE_SERVING_URL and not tools.on_dev_server(): url = images.get_serving_url(bk) url += "=s%d" % size self.redirect(url) else: blob_info = blobstore.BlobInfo.get(bk) self.send_blob(blob_info, content_type="image/jpeg") except Exception, e: logging.error("Error in serveResource: %s" % e) self.error(404)
def get_auth_flow(cls, scope, user=None): import os CLIENT_SECRET_FILE = os.path.join(os.path.dirname(__file__), 'client_secrets.json') base = 'http://localhost:8080' if tools.on_dev_server() else BASE flow = client.flow_from_clientsecrets( CLIENT_SECRET_FILE, scope=scope, cache=memcache, login_hint=user.email if user else None, message="Woops! client_secrets.json missing or invalid", redirect_uri='%s/api/auth/oauth2callback' % base) flow.params['include_granted_scopes'] = 'true' flow.params['access_type'] = 'offline' return flow
def get(self, *args, **kwargs): from settings.secrets import G_MAPS_API_KEY # gmods = { # "modules": [ # ] # } d = kwargs.get('d') d['constants'] = {'dev': tools.on_dev_server()} d['alt_bootstrap'] = { "UserStore": { 'user': self.user.json(is_self=True) if self.user else None } } # d['gautoload'] = urllib.quote_plus(json.dumps(gmods).replace(' ','')) d['gmap_api_key'] = G_MAPS_API_KEY self.render_template("index.html", **d)
def writeData(self): total_i = self.counters['run'] while True: self.query = self._get_query() if self.query: entities = self.query.fetch(limit=self.batch_size) self.cursor = self._get_cursor() if not entities: logging.debug("No rows returned by query -- done") return if entities and self.prefetch_props: entities = tools.prefetch_reference_properties(entities, *self.prefetch_props, missingRefNone=True) for entity in entities: if entity: ed = self.entityData(entity) else: continue string = '?' if self.report.ftype == REPORT.CSV: csv.writer(self.gcs_file).writerow(tools.normalize_list_to_ascii(ed)) if sections_data and self.has_section_files(): for section_gcs_file, sd in zip(self.section_gcs_files, sections_data): for sd_rows in zip(*sd): csv.writer(section_gcs_file).writerow(tools.normalize_list_to_ascii(sd_rows)) elif self.report.ftype == REPORT.XLS: self.gcs_file.write(json.dumps(ed)+"\n") if total_i > REPORT.XLS_ROW_LIMIT: self.setProgress({'error': "XLS row limit (%d) exceeded!" % REPORT.XLS_ROW_LIMIT, 'status': REPORT.ERROR}) return self.gcs_file.flush() total_i += 1 self.counters['run'] += 1 if total_i % 100 == 0: cancelled = self.updateProgressAndCheckIfCancelled() if cancelled: self.report.CleanDelete() logging.debug("Worker cancelled by user, report deleted.") return logging.debug("Batch of %d done" % len(entities)) elapsed = tools.unixtime(local=False) - self.worker_start if elapsed >= MAX_REQUEST_SECONDS or (tools.on_dev_server() and TEST_TOO_LONG_ON_EVERY_BATCH): logging.debug("Elapsed %ss" % elapsed) raise TooLongError()
def action(self, action, d): base = "http://localhost:8080" if tools.on_dev_server() else BASE if action == 'login': scope = "email profile" flow = User.get_auth_flow(scope=scope) flow.params['access_type'] = 'offline' flow.params['include_granted_scopes'] = 'true' auth_uri = flow.step1_get_authorize_url(state=scope) self.json_out({'auth_uri': auth_uri}, success=True, debug=True) elif action == 'oauth2callback': error = self.request.get('error') code = self.request.get('code') scope = self.request.get('scope') state_scopes = self.request.get('state') if code: CLIENT_SECRET_FILE = os.path.join(os.path.dirname(__file__), 'client_secrets.json') credentials = client.credentials_from_clientsecrets_and_code( CLIENT_SECRET_FILE, scope.split(' '), code, redirect_uri=base + "/api/auth/oauth2callback") user = self.user if not user: email = credentials.id_token['email'] user = User.GetByEmail(email) if not user: # Create account user = User.Create(email=email) if user: user.save_credentials(credentials) user.put() self.session['user'] = user elif error: logging.error(error) self.redirect("/app/settings")
def forgot_password(self, email_or_phone, d): success = False override_sitename = self.request.get('override_sitename') if email_or_phone: user = User.FuzzyGet(email_or_phone) if user: if user.email: new_password = user.setPass() user.put() success = True if tools.on_dev_server(): logging.debug(new_password) message = "Password reset successful - check your email" prefix = EMAIL_PREFIX if not override_sitename else "[ %s ] " % override_sitename deferred.defer(mail.send_mail, SENDER_EMAIL, user.email, prefix + "Password Reset", "Your password has been reset: %s. You can change this upon signing in." % new_password) else: message = "No email address on file for that user. Please contact support." else: message = "User not found..." else: message = "Email or phone required" self.json_out(success=success, message=message)
def send_sms(enterprise, phone, message): logging.info("Sending SMS to %s" % (phone)) AT_USERNAME = enterprise.get_gateway_property('atalking', 'username') AT_FROM_SHORTCODE = enterprise.get_gateway_property('atalking', 'shortcode') AT_API_KEY = enterprise.get_gateway_property('atalking', 'ApiKey') if not tools.on_dev_server() and (AT_USERNAME and AT_FROM_SHORTCODE and AT_API_KEY): url = "http://api.africastalking.com/version1/messaging" enc = urllib.urlencode([ ('username', AT_USERNAME), ('to', '+' + phone), ('from', AT_FROM_SHORTCODE), ('message', message), ('bulkSMSMode', 1), ('enqueue', 1) ]) headers = { 'Content-Type': 'application/x-www-form-urlencoded', 'Accept': "application/json", 'ApiKey': AT_API_KEY } response = urlfetch.fetch(url=url, payload=enc, method="POST", deadline=60, headers=headers) if response.status_code == 200: logging.debug(response.content)
def get(self): if tools.on_dev_server(): self.display_index(self.test_uid)
def check_login(self, *args, **kwargs): d = { 'SITENAME': SITENAME, 'COMPANY_NAME': COMPANY_NAME, 'YEAR': datetime.now().year, 'CURTIME': datetime.now(), 'GA_ID': GA_ID, 'DEV': tools.on_dev_server(), } allow = False handled = False error_code = 0 user = enterprise = None session = self.session messages.get_messages(self, d) if session.has_key('user'): user = session['user'] if 'enterprise' in session: enterprise = session['enterprise'] if not role: allow = True elif role == "user": if user: allow = True elif role == "admin": if user and user.is_admin(): allow = True elif role == "api": status = None from models import User api_auth = self.request.get('auth') if not user: if api_auth == API_AUTH: uid = self.request.get_range('uid') pw = self.request.get('pw') token = self.request.get('token') if uid: _user = User.get_by_id(uid) if _user and pw and _user.validatePassword(pw): user = _user # Authorized client API else: error_code = 5 # Auth failed else: error_code = 4 # Malformed else: error_code = 1 # Unauthorized status = 401 if user: d['user'] = user if not enterprise: enterprise = user.enterprise self.user = d['user'] = user self.enterprise = d['enterprise'] = enterprise else: error_code = 3 # User not found if not error_code: kwargs['d'] = d handler_method(self, *args, **kwargs) else: message = messages.ERROR.LABELS.get(error_code) logging.error(message) self.json_out(success=False, error=error_code, message=message, status=status) handled = True if not handled: if allow: d['user'] = user d['enterprise'] = enterprise d['logout_url'] = "/logout" #users.create_logout_url("/logout") kwargs['d'] = d handler_method(self, *args, **kwargs) else: self.redirect("/login")
def check_login(self, *args, **kwargs): d = { 'SITENAME':SITENAME, 'COMPANY_NAME': COMPANY_NAME, 'YEAR':datetime.now().year, 'CURTIME': datetime.now(), 'GA_ID': GA_ID, 'DEV': tools.on_dev_server(), } allow = False handled = False error_code = 0 user = enterprise = None session = self.session messages.get_messages(self, d) if session.has_key('user'): user = session['user'] if 'enterprise' in session: enterprise = session['enterprise'] if not role: allow = True elif role == "user": if user: allow = True elif role == "admin": if user and user.is_admin(): allow = True elif role == "api": status = None from models import User api_auth = self.request.get('auth') if not user: if api_auth == API_AUTH: uid = self.request.get_range('uid') pw = self.request.get('pw') token = self.request.get('token') if uid: _user = User.get_by_id(uid) if _user and pw and _user.validatePassword(pw): user = _user # Authorized client API else: error_code = 5 # Auth failed else: error_code = 4 # Malformed else: error_code = 1 # Unauthorized status = 401 if user: d['user'] = user if not enterprise: enterprise = user.enterprise self.user = d['user'] = user self.enterprise = d['enterprise'] = enterprise else: error_code = 3 # User not found if not error_code: kwargs['d'] = d handler_method(self, *args, **kwargs) else: message = messages.ERROR.LABELS.get(error_code) logging.error(message) self.json_out(success=False, error=error_code, message=message, status=status) handled = True if not handled: if allow: d['user'] = user d['enterprise'] = enterprise d['logout_url'] = "/logout" #users.create_logout_url("/logout") kwargs['d'] = d handler_method(self, *args, **kwargs) else: self.redirect("/login")
def get_auth_uri(self, scope, state=None): base = 'http://localhost:8080' if tools.on_dev_server() else BASE flow = User.get_auth_flow(scope=scope, user=self) auth_uri = flow.step1_get_authorize_url(state=state) return auth_uri