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 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 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_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 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 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 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
