def admin_login(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session():
self.redirect("/auth/login", abort=True)
user = auth.get_user_by_session()
if user and user["user_id"] == 5069036098420736:
return handler(self, *args, **kwargs)
else:
self.redirect("/", abort=True)
def check_login(self, *args, **kwargs):
auth = self.auth
if auth.get_user_by_session():
if auth.get_user_by_session(
)['account_type'] == 'presenter' or 'user' or 'admin' or 'super_admin':
return handler(self, *args, **kwargs)
else:
self.redirect('/login')
else:
self.redirect('/login')
def check_login(self, *args, **kwargs):
auth = self.auth
if auth.get_user_by_session():
if auth.get_user_by_session()['account_type'] == 'admin':
return handler(self, *args, **kwargs)
else:
self.redirect('/default')
else:
self.redirect('/default')
return check_login
def admin_login(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session():
self.redirect('/auth/login', abort=True)
user = auth.get_user_by_session()
queried_entity = User.get_by_id(user['user_id'])
if queried_entity and queried_entity.phb_user_admin_status == 'admin-1':
return handler(self, *args, **kwargs)
else:
self.redirect('/', abort = True)
def check_login(self, *args, **kwargs):
auth = self.auth
if auth.get_user_by_session():
if auth.get_user_by_session(
)['account_type'] == 'admin' or 'super_admin':
return handler(self, *args, **kwargs)
else:
self.redirect('/default')
elif os.environ['CURRENT_MODULE_ID'] == 'testing':
return handler(self, *args, **kwargs)
else:
self.redirect('/default')
def check_login(self, *args, **kwargs):
auth = self.auth
logging.info(auth)
if not auth.get_user_by_session():
self.redirect('/')
else:
return handler(self, *args, **kwargs)
def setup(self):
params = {
'admin': auth.get_user_by_session(),
'auth_secret': model.AuthSecret.to_json(True)
}
self.render_response('setup.html', **params)
def check_login(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session():
params = { 'dest': str(self.request.uri)}
self.redirect(self.uri_for('login')+"?"+ urllib.urlencode(params), abort=True)
else:
return handler(self, *args, **kwargs)
def check_login(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session() and not users.is_current_user_admin():
self.redirect(self.uri_for('login'), abort=True)
else:
return handler(self, *args, **kwargs)
def check_login(self, *args, **kargs):
auth = self.auth
user = auth.get_user_by_session()
if not user:
self.redirect(self.uri_for('marketAuthenticate', callback=self.request.url))
else:
return handler(self, *args, **kargs)
def check_login(self, *args, **kwargs):
auth = self.auth
user = auth.get_user_by_session()
if not user:
self.redirect(self.uri_for('login'), abort=True)
else:
return handler(self, *args, **kwargs)
def check_login(self, *args, **kargs):
auth = self.auth
user = auth.get_user_by_session()
if not user:
return handler(self, *args, **kargs)
else:
self.redirect(self.uri_for('marketMain'))
def check_login(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session():
# If handler has no login_url specified invoke a 403 error
try:
self.redirect(("/login?redirect=%s" % self.request.environ["PATH_INFO"]))
except (AttributeError, KeyError), e:
self.abort(403)
def get(self):
auth = self.auth
if auth.get_user_by_session():
user = self.user
if user:
self.redirect("/about")
params = {}
self.render_template('templates/home.html', params)
def check_authentication(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session():
self.redirect(self.uri_for('login'), abort=True)
else:
return handler(self, *args, **kwargs)
return check_authentication
def check_login(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session():
# If handler has no login_url specified invoke a 403 error
try:
self.redirect(self.auth_config['login_url'], abort=True)
except (AttributeError, KeyError), e:
self.abort(403)
def check_login(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session():
# If handler has no login_url specified invoke a 403 error
try:
self.redirect(self.auth_config['login_url'], abort=True)
except (AttributeError, KeyError), e:
self.abort(403)
def post(self):
auth = self.auth
if auth.get_user_by_session():
userID = strip_tags(str(self.user_info['user_id']))
userProfile = UserProfile.query(UserProfile.userID == userID).get()
userProfile.ux = strip_tags(self.request.get('ux'))
userProfile.put()
def check_login(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session():
self.redirect('login/' + self.request.path.replace('/',''))
#self.redirect(self.uri_for('login/' + self.request.path.replace('/','')), abort=True)
else:
return handler(self, *args, **kwargs)
def check_login(self, *args, **kwargs):
auth = self.auth
u = auth.get_user_by_session()
if not u:
self.redirect(self.uri_for('login'), abort=True)
elif u['isAdmin'] == False:
self.redirect(self.uri_for('login'), abort=True)
else:
return handler(self, *args, **kwargs)
def check_login(self, *args, **kwargs):
auth = self.auth
g_user = None
if users.get_current_user():
g_user = self.user_model.get_by_auth_id(users.get_current_user().email())
if not g_user and not auth.get_user_by_session():
self.redirect(self.uri_for('login'), abort=True)
else:
return handler(self, *args, **kwargs)
def check_login(self, *args, **kwargs):
auth = self.auth
print("Reached check login")
if not auth.get_user_by_session():
print("Check login doesn't work")
self.redirect(self.uri_for('login'), abort=True)
else:
print("Check login works")
return handler(self, *args, **kwargs)
def decorate(self, *args, **kwargs):
auth = self.auth
user = auth.get_user_by_session()
if not user.is_admin:
self.send_error(403, 'Not authorised, user is not a admin.')
return
return handlar(self, *args, **kwargs)
def check_login(self, *args, **kwargs):
logging.info('---user_required-check login')
auth = self.auth
if not auth.get_user_by_session():
logging.info('---not logged in!!!')
#self.redirect(self.uri_for('login'), abort=True)
self.redirect("/login", abort=True)
#return False
else:
return handler(self, *args, **kwargs)
def check_login(self, *args, **kwargs):
logging.info('---user_required-check login')
auth = self.auth
if not auth.get_user_by_session():
logging.info('---not logged in!!!')
#self.redirect(self.uri_for('login'), abort=True)
self.redirect("/login", abort=True)
#return False
else:
return handler(self, *args, **kwargs)
def get(self):
auth = get_auth(self.request)
user = auth.get_user_by_session()
if user is not None:
return webapp2.redirect("/")
api = get_brave_api()
success = self.request.host_url + '/loginok'
failure = self.request.host_url + '/login'
result = api.core.authorize(success=success, failure=failure)
return webapp2.redirect(result.location)
def get(self):
auth = get_auth(self.request)
user = auth.get_user_by_session()
if user is not None:
return webapp2.redirect("/")
api = get_brave_api()
success = self.request.host_url + '/loginok'
failure = self.request.host_url + '/login'
result = api.core.authorize(success=success, failure=failure)
return webapp2.redirect(result.location)
def check_login(self, *args, **kwargs):
# *args, **kwargs 関数定義に使用した場合、余った引数を受け取るタプル
# どんな引数でも受け取ることが可能。
auth = self.auth
if not auth.get_user_by_session():
# チェック 403 エラー
try:
self.redirect(self.auth_config['login_url'],abort=True)
except (AttributeError, KeyError), e:
self.abort(403)
def login(self):
auth = self.auth
if not auth.get_user_by_session():
params = {
'xsrf': authentication.CSRFHandlar().xsrf_token(
'/api/auth/login')
}
self.render_response('login.html', **params)
else:
self.redirect_to('dashboard')
def post(self):
email = (self.request.get('email')).lower()
password = self.request.get('password')
auth = self.auth
if not auth.get_user_by_session():
accType = 'customer'
customer = models.Customer()
else:
accType = self.request.get('accType')
customer = models.Staff()
customer.Email = email
customer.First_Name = self.request.get('firstname')
customer.Last_Name = self.request.get('lastname')
customer.Contact_No = int(self.request.get('contact'))
customer.Address = self.request.get('address')
customer.postalCode = int(self.request.get('postalcode'))
#unique_properties = ['email_address']
acct_data = self.user_model.create_user(email, email_address=email, password_raw=password, first_name=customer.First_Name, accounType = accType, verified=False)
if not mail.is_email_valid(email):
self.display_message('invalid email entered')
return
if not acct_data[0]: #acct_data is a tuple
self.display_message('Unable to create user for email %s because \
it already exist' % (email))
return
customer.put()
user = acct_data[1]
user_id = user.get_id()
token = self.user_model.create_signup_token(user_id)
verification_url = self.uri_for('verification', type='v', user_id=user_id,
signup_token=token, _full=True)
msg = 'Send an email to user in order to verify their address. \
They will be able to do so by visiting <a href="{url}">{url}</a>'
message = mail.EmailMessage()
message.sender = '*****@*****.**'
message.to = email
message.body = """
testing email
%s
""" % msg.format(url=verification_url)
message.Send()
#self.display_message(msg.format(url=verification_url))
self.display_message('A verification email has been sent to the respective email!')
def check_login(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session():
self.response.status = 401
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(
json.dumps({
'status': 'error',
'message': 'login required'
}))
else:
return handler(self, *args, **kwargs)
def _serve_page(self, message= False, failed=False):
username = self.request.get('username')
auth = self.auth
if not auth.get_user_by_session():
params = {
'username': username,
'failed': failed,
'message' : message
}
self.render_template('login.html', params)
else:
self.redirect(self.uri_for('authenticated'))
def _serve_page(self, message=False, failed=False):
username = self.request.get('username')
auth = self.auth
if not auth.get_user_by_session():
params = {
'username': username,
'failed': failed,
'message': message
}
self.render_template('login.html', params)
else:
self.redirect(self.uri_for('authenticated'))
def get(self):
auth = self.auth
if auth.get_user_by_session():
if hasattr(self.user, 'auth_ids'):
userProfile = UserProfile.query(UserProfile.userID == str(self.user_info['user_id'])).get()
self.response.out.write('success:::' + userProfile.ux + ':::' + userProfile.privacy)
else:
self.response.out.write('failure:::')
else:
self.response.out.write('failure:::')
def get(self):
self.response.headers.add_header('Access-Control-Allow-Origin', '*')
self.response.headers['Content-Type'] = 'text/plain'
auth = self.auth
if auth.get_user_by_session():
logging.error(self.user_info)
logging.error('!!!!!!!!!!!!!!')
logging.error(str(self.user_info['name']))
#publicQuotationr = str(self.user_info['trustedQuotationr'])
self.response.write('authenticated')
else:
self.response.write('not authenticted')
def get_context(auth):
context = {}
current_session = auth.get_user_by_session()
if not current_session is None:
user_objects = auth.store.user_model.get_by_auth_token(current_session['user_id'], current_session['token'])
user_object = user_objects[0]
if not user_object is None:
context['username'] = user_object.auth_ids[0]
context['is_admin'] = user_object.is_admin
context['is_employee'] = user_object.is_employee
return context
def check_login(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session():
if self.request.path=='/':
locale=self.request.get('locale',None)
if locale:
self.redirect(self.uri_for('login',locale=locale),abort=True)
else:
self.redirect(self.uri_for('login'),abort=True)
else:
self.redirect(self.uri_for('login',originalurl=self.request.url),abort=True)
else:
u = self.user_info
user = self.user_model.get_by_id(u['user_id'])
user.put()
return handler(self, *args, **kwargs)
def get(self):
auth = get_auth(self.request)
user = auth.get_user_by_session()
if user is not None:
return webapp2.redirect("/")
token = self.request.GET['token']
api = get_brave_api()
info = api.core.info(token)
session_info = {
'user_id': info['character']['id'],
'perms': info['perms'],
}
auth.set_session(session_info)
session_store = webapp2_extras.sessions.get_store(request=self.request)
session_store.save_sessions(self.response)
return webapp2.redirect("/", response=self.response)
def get(self):
auth = get_auth(self.request)
user = auth.get_user_by_session()
if user is not None:
return webapp2.redirect("/")
token = self.request.GET['token']
api = get_brave_api()
info = api.core.info(token)
session_info = {
'user_id': info['character']['id'],
'perms': info['perms'],
}
auth.set_session(session_info)
session_store = webapp2_extras.sessions.get_store(request=self.request)
session_store.save_sessions(self.response)
return webapp2.redirect("/", response=self.response)
def check_login(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session():
if self.request.path == "/":
locale = self.request.get("locale", None)
if locale:
self.redirect(self.uri_for("login", locale=locale), abort=True)
else:
self.redirect(self.uri_for("login"), abort=True)
else:
self.redirect(self.uri_for("login", originalurl=self.request.url), abort=True)
else:
u = self.user_info
user = self.user_model.get_by_id(u["user_id"])
user.put()
return handler(self, *args, **kwargs)
def get(self):
"""Logs a user out. Checks if the user is logged in natively and logs them out, otherwise will log
them out of google"""
auth = self.auth
session_user = auth.get_user_by_session()
user_object = None
if session_user:
try:
user_object = datamodel.User.get_by_id(session_user['user_id'])
except:
pass
if user_object:
self.auth.unset_session()
else:
self.redirect(google_authentication.create_logout_url(self.uri_for('login')))
return
self.redirect(self.uri_for('login'))
def check_permission(self,*args,**kargs):
auth = self.auth
if not auth.get_user_by_session():
self.redirect(self.uri_for('login'), abort=True)
else:
u=model.user.OurUser()
uw = self.auth.get_user_by_session()
qry=u.query().filter(ndb.GenericProperty("email_address")==uw['email_address']).fetch()
logging.info(qry)
logging.info(qry[0].role.get().permissions)
for acct in qry:
for acct1 in acct.role.get().permissions:
logging.info(self.request.path.split('/')[1])
if acct1.get().url in (self.request.path.split('/')[1]):
return True
return False
def get(self):
"""Logs a user out. Checks if the user is logged in natively and logs them out, otherwise will log
them out of google"""
auth = self.auth
session_user = auth.get_user_by_session()
user_object = None
if session_user:
try:
user_object = datamodel.User.get_by_id(session_user['user_id'])
except:
pass
if user_object:
self.auth.unset_session()
else:
self.redirect(
google_authentication.create_logout_url(self.uri_for('login')))
return
self.redirect(self.uri_for('login'))
def check_permission(self, *args, **kargs):
auth = self.auth
if not auth.get_user_by_session():
self.redirect(self.uri_for('login'), abort=True)
else:
u = model.user.OurUser()
uw = self.auth.get_user_by_session()
qry = u.query().filter(
ndb.GenericProperty("email_address") ==
uw['email_address']).fetch()
logging.info(qry)
logging.info(qry[0].role.get().permissions)
for acct in qry:
for acct1 in acct.role.get().permissions:
logging.info(self.request.path.split('/')[1])
if acct1.get().url in (self.request.path.split('/')[1]):
return True
return False
def get_gift_exchange_member(self):
"""Gets the member object associated with a particular session"""
gift_exchange_member = None
gift_exchange_key = get_gift_exchange_key(DEFAULT_GIFT_EXCHANGE_NAME)
#first see if the user is in the DB
auth = self.auth
session_user = auth.get_user_by_session()
if session_user:
try:
user_object = User.get_by_id(session_user['user_id'])
gift_exchange_member = GiftExchangeMember.get_member_by_user_key(gift_exchange_key, user_object.key)
except:
pass
if gift_exchange_member is None:
try:
google_user = google_authentication.get_current_user()
gift_exchange_member = GiftExchangeMember.update_and_retrieve_member_by_google_user(gift_exchange_key, google_user)
except:
pass
return gift_exchange_member
def get_site_member(self):
"""Gets the member object associated with a particular session"""
site_member = None
root_key = get_root_key(DEFAULT_ROOT_KEY_NAME)
#first see if the user is in the DB
auth = self.auth
session_user = auth.get_user_by_session()
if session_user:
try:
user_object = User.get_by_id(session_user['user_id'])
site_member = SiteMember.get_member_by_user_key(root_key, user_object.key)
except:
pass
if site_member is None:
try:
google_user = google_authentication.get_current_user()
site_member = SiteMember.update_and_retrieve_member_by_google_user(root_key, google_user)
except:
pass
return site_member
def post(self):
#make sure this user is authenticated
auth = self.auth
if auth.get_user_by_session():
#grab the data from the quotationr form
tags = strip_tags(self.request.get('quotationrTags'))
quotation = strip_tags(urllib.unquote(self.request.get('quotationrQuotation')))
url = strip_tags(self.request.get('quotationrUrl'))
website = strip_tags(self.request.get('quotationrWebsite'))
title = strip_tags(urllib.unquote(self.request.get('quotationrTitle')).decode('unicode_escape').encode('ascii','ignore'))
favicon = strip_tags(self.request.get('quotationrFavicon'))
userID = strip_tags(str(self.user_info['user_id']))
userNickname = strip_tags(str(self.user_info['name']))
start = int(strip_tags(self.request.get('quotationrStart')))
end = int(strip_tags(self.request.get('quotationrEnd')))
userProfile = UserProfile.query(UserProfile.userID == userID).get()
trustedQuotationr = userProfile.trustedQuotationr
logging.error('-------------------')
logging.error(quotation)
logging.error('-------------------')
#if 1 == 1:
if quotation.strip() != "":
#-------------------------------------------------------------------------------------
#-------------------------------------------------------------------------------------
# create a full text search document
#-------------------------------------------------------------------------------------
#-------------------------------------------------------------------------------------
quotationDoc = search.Document(
fields=[
search.TextField(name='quotation', value=quotation),
search.TextField(name='tags', value=tags),
search.TextField(name='url', value=url),
search.TextField(name='urlHash', value=hashlib.md5(url).hexdigest()),
search.TextField(name='website', value=website),
search.TextField(name='favicon', value=favicon),
search.TextField(name='title', value=title),
search.TextField(name='user', value=userID),
search.TextField(name='nickname', value=userNickname),
search.TextField(name='public', value=trustedQuotationr),
search.NumberField(name='start', value=start),
search.NumberField(name='end', value=end),
search.DateField(name='submitted', value=datetime.now()),
])
try:
index = search.Index(name="quotationrIndex")
index.put(quotationDoc)
self.response.out.write('success:::' + userProfile.privacy)
except search.Error:
logging.exception('Put failed')
self.response.out.write('fail:::Login failed')
#--------------------------------------------------------------------------------------
#- END - creating a full text search document
#--------------------------------------------------------------------------------------
#create a holder so we can batch put all the docs we are going to potentially create
docHolder = []
docCount = 0
#---------------------------------------------------------------------------------------
#see if the user has already used these tags.............
#---------------------------------------------------------------------------------------
existingTagQuery = UserTags.query(UserTags.tag.IN(tags.split(' ')), UserTags.userID == userID )
existingTags = []
existingTagNameArray = []
#loop through the existing tags and increment the quote counter
logging.error("Existing Tags:")
for existingTag in existingTagQuery:
logging.error(existingTag.tag)
#add this tag the an array. we will use this below to figure out what tags are new
existingTagNameArray.append(existingTag.tag)
logging.error('Exising Tag Caught')
docCount += 1
existingTag.quotationCount += 1
docHolder.append(existingTag)
#figure out what tags are new
newTags = set(tags.split(' ')) - set(existingTagNameArray)
logging.error("New Tags:")
for newTag in newTags:
docCount += 1
logging.error(newTag)
newTagDoc = UserTags()
newTagDoc.tag = newTag
newTagDoc.quotationCount = 1
newTagDoc.userID = userID
docHolder.append(newTagDoc)
logging.error('write out everything')
logging.error(docCount)
#--------------------------------------------------------------------------------------
#loop through each of the tags the user submitted for this quote
#--------------------------------------------------------------------------------------
for tag in tags.split(' '):
#see if we can find and tag + link + user docs
existingLinkTagQuery = UserLinkTag.query(UserLinkTag.tag == tag,UserLinkTag.link == url,UserLinkTag.userID == userID).count()
#if we can't find a doc, we need to create a new one
if ( existingLinkTagQuery == 0 ):
docCount += 1
newLinkTagDoc = UserLinkTag()
newLinkTagDoc.tag = tag
newLinkTagDoc.link = url
newLinkTagDoc.title = title
newLinkTagDoc.favicon = favicon
newLinkTagDoc.userID = str(self.user_info['user_id'])
docHolder.append(newLinkTagDoc)
#---------------------------------------------------------------------------------------
#see if the user has already bookmarked this.............
#---------------------------------------------------------------------------------------
linkDoc = UserLink.query(UserLink.link == url, UserLink.userID == userID ).get()
#linkDocCount = existingLinkQuery.count()
#if they haven't create a link record
if linkDoc:
#h = hashlib.new('md5')
#h.update(url)
linkDoc.tags += " " + " ".join(newTags)
linkDoc.croned = "false"
docHolder.append(linkDoc)
else:
linkDoc = UserLink()
linkDoc.link = url
linkDoc.urlHash = hashlib.md5(url).hexdigest()
linkDoc.title = title
linkDoc.tags = tags
linkDoc.favicon = favicon
linkDoc.croned = "false"
linkDoc.userID = str(self.user_info['user_id'])
linkDoc.name = str(self.user_info['name'])
docHolder.append(linkDoc)
#---------------------------------------------------------------
#put all the docs we created and put them in the database.......
newDocKeys = ndb.put_multi(docHolder)
#---------------------------------------------------------------
else: #after HTML strip nothing was left so do nothing
self.response.out.write('success:::')
else:
self.response.out.write('fail:::Not Logged In')
def check_login(self, *args, **kwargs):
auth = self.auth
if auth.get_user_by_session():
self.redirect('/application')
else:
return handler(self, *args, **kwargs)
def get(self):
if config.require_login:
auth = get_auth(self.request)
user = auth.get_user_by_session()
if user is None:
return self.redirect('/login')
if config.braveapi_perm_view not in user['perms']:
self.response.status = 403
self.response.write("permission denied :(")
return
cache = config.get_evelink_cache(
) if config.get_evelink_cache else None
api = evelink.api.API(api_key=(keyid, vcode), cache=cache)
knees = evelink.corp.Corp(api)
eve = evelink.eve.EVE(api)
contracts = knees.contracts()
pending = []
total_volume = 0.0
for contract in contracts.result.itervalues():
if (contract['assignee'] == config.corp_id
and contract['status'] in ('Outstanding', 'InProgress')
and 'opsec' not in contract['title'].lower()):
cn = {}
# Basic info
cn['type'] = contract['type']
cn['status'] = contract['status']
cn['issuer'] = eve.character_name_from_id(
contract['issuer']).result
date = datetime.datetime.fromtimestamp(contract['issued'])
cn['dateissued'] = date.strftime("%Y-%m-%d %H:%M")
cn['volume'] = "{:,.3f}".format(contract['volume'])
total_volume += contract['volume']
# Source and destination
cn['from'] = location_display_from_id(contract['start'])
if contract['type'] == 'Courier':
cn['to'] = location_display_from_id(contract['end'])
else:
cn['to'] = "???"
# Accepter
if contract['accepted']:
cn['accepted'] = eve.character_name_from_id(
contract['acceptor']).result
else:
cn['accepted'] = ""
# Time remaining
maxdays = datetime.timedelta(days=config.sla_days)
delta = date + maxdays - datetime.datetime.today()
cn['timedelta_remaining'] = delta
cn['remaining'] = timedelta_display(delta)
if delta < datetime.timedelta(hours=12):
cn['class'] = 'text-error'
elif delta < datetime.timedelta(days=1):
cn['class'] = 'text-warning'
else:
cn['class'] = 'text-info'
pending.append(cn)
pending = sorted(pending,
key=lambda contract: contract['timedelta_remaining'])
template = JINJA_ENVIRONMENT.get_template('index.html')
self.response.write(
template.render({
'pending': pending,
'calc_url': config.calc_url,
'doc_url': config.doc_url,
'total_volume': "{:,.3f}".format(total_volume),
}))
def check_login(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session():
self.redirect('/', abort=True)
else:
return handler(self, *args, **kwargs)
def post(self):
email = (self.request.get('email')).lower()
password = self.request.get('password')
auth = self.auth
if not auth.get_user_by_session():
accType = 'customer'
customer = models.Customer()
else:
accType = self.request.get('accType')
customer = models.Staff()
customer.Email = email
customer.First_Name = self.request.get('firstname')
customer.Last_Name = self.request.get('lastname')
customer.Contact_No = int(self.request.get('contact'))
customer.Address = self.request.get('address')
customer.postalCode = int(self.request.get('postalcode'))
#unique_properties = ['email_address']
acct_data = self.user_model.create_user(email,
email_address=email,
password_raw=password,
first_name=customer.First_Name,
accounType=accType,
verified=False)
if not mail.is_email_valid(email):
self.display_message('invalid email entered')
return
if not acct_data[0]: #acct_data is a tuple
self.display_message('Unable to create user for email %s because \
it already exist' % (email))
return
customer.put()
user = acct_data[1]
user_id = user.get_id()
token = self.user_model.create_signup_token(user_id)
verification_url = self.uri_for('verification',
type='v',
user_id=user_id,
signup_token=token,
_full=True)
msg = 'Send an email to user in order to verify their address. \
They will be able to do so by visiting <a href="{url}">{url}</a>'
message = mail.EmailMessage()
message.sender = '*****@*****.**'
message.to = email
message.body = """
testing email
%s
""" % msg.format(url=verification_url)
message.Send()
#self.display_message(msg.format(url=verification_url))
self.display_message(
'A verification email has been sent to the respective email!')
def check_login(self, *args, **kwargs):
auth = self.auth
if auth.get_user_by_session():
self.redirect(self.uri_for('home'), abort=True)
else:
return handler(self, *args, **kwargs)
def check_login(self, *args, **kwargs):
auth = self.auth
if not auth.get_user_by_session():
self.redirect(self.uri_for('login'))
else:
return handler(self, *args, **kwargs)
