def post(self):
from google.appengine.api import mail, app_identity
from google.appengine.api.datastore_errors import BadValueError
from google.appengine.runtime import apiproxy_errors
import config
from models import models
to = self.request.get("to")
subject = self.request.get("subject")
body = self.request.get("body")
sender = self.request.get("sender")
if sender != '' or not utils.is_email_valid(sender):
if utils.is_email_valid(config.contact_sender):
sender = config.contact_sender
else:
app_id = app_identity.get_application_id()
sender = "%s <no-reply@%s.appspotmail.com>" % (app_id, app_id)
try:
logEmail = models.LogEmail(
sender = sender,
to = to,
subject = subject,
body = body,
when = utils.get_date_time("datetimeProperty")
)
logEmail.put()
except (apiproxy_errors.OverQuotaError, BadValueError):
logging.error("Error saving Email Log in datastore")
mail.send_mail(sender, to, subject, body)
def post(self):
from google.appengine.api import mail, app_identity
from google.appengine.api.datastore_errors import BadValueError
from google.appengine.runtime import apiproxy_errors
import config
from models import models
to = self.request.get("to")
subject = self.request.get("subject")
body = self.request.get("body")
sender = self.request.get("sender")
if sender != '' or not utils.is_email_valid(sender):
if utils.is_email_valid(config.contact_sender):
sender = config.contact_sender
else:
app_id = app_identity.get_application_id()
sender = "%s <no-reply@%s.appspotmail.com>" % (app_id, app_id)
try:
logEmail = models.LogEmail(
sender=sender,
to=to,
subject=subject,
body=body,
when=utils.get_date_time("datetimeProperty"))
logEmail.put()
except (apiproxy_errors.OverQuotaError, BadValueError):
logging.error("Error saving Email Log in datastore")
mail.send_mail(sender, to, subject, body)
def setUp(self):
# fix configuration if this is still a raw boilerplate code - required by tests with mails
if not utils.is_email_valid(config.contact_sender):
config.contact_sender = "*****@*****.**"
if not utils.is_email_valid(config.contact_recipient):
config.contact_recipient = "*****@*****.**"
# create a WSGI application.
w2config = config.webapp2_config
# use absolute path for templates
w2config["webapp2_extras.jinja2"]["template_path"] = os.path.join(
os.path.join(os.path.dirname(web.__file__), ".."), "templates"
)
self.app = webapp2.WSGIApplication(config=w2config)
routes.add_routes(self.app)
self.testapp = webtest.TestApp(self.app, extra_environ={"REMOTE_ADDR": "127.0.0.1"})
# activate GAE stubs
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_taskqueue_stub()
self.testbed.init_mail_stub()
self.mail_stub = self.testbed.get_stub(testbed.MAIL_SERVICE_NAME)
self.taskqueue_stub = self.testbed.get_stub(testbed.TASKQUEUE_SERVICE_NAME)
self.testbed.init_user_stub()
self.headers = {"User-Agent": "Safari", "Accept-Language": "en_US"}
def setUp(self):
# fix configuration if this is still a raw boilerplate code - required by tests with mails
if not utils.is_email_valid(config.contact_sender):
config.contact_sender = "*****@*****.**"
if not utils.is_email_valid(config.contact_recipient):
config.contact_recipient = "*****@*****.**"
# create a WSGI application.
w2config = config.webapp2_config
# use absolute path for templates
w2config['webapp2_extras.jinja2']['template_path'] = os.path.join(os.path.join(os.path.dirname(web.__file__), '..'), 'templates')
self.app = webapp2.WSGIApplication(config=w2config)
routes.add_routes(self.app)
self.testapp = webtest.TestApp(self.app, extra_environ={'REMOTE_ADDR' : '127.0.0.1'})
# activate GAE stubs
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_taskqueue_stub()
self.testbed.init_mail_stub()
self.mail_stub = self.testbed.get_stub(testbed.MAIL_SERVICE_NAME)
self.taskqueue_stub = self.testbed.get_stub(testbed.TASKQUEUE_SERVICE_NAME)
self.testbed.init_user_stub()
self.headers = {'User-Agent' : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) Version/6.0 Safari/536.25',
'Accept-Language' : 'en_US'}
def setUp(self):
# fix configuration if this is still a raw boilerplate code - required by tests with mails
if not utils.is_email_valid(config.contact_sender):
config.contact_sender = "*****@*****.**"
if not utils.is_email_valid(config.contact_recipient):
config.contact_recipient = "*****@*****.**"
# create a WSGI application.
w2config = config.webapp2_config
# use absolute path for templates
w2config['webapp2_extras.jinja2']['template_path'] = os.path.join(os.path.join(os.path.dirname(web.__file__), '..'), 'templates')
self.app = webapp2.WSGIApplication(config=w2config)
routes.add_routes(self.app)
self.testapp = webtest.TestApp(self.app, extra_environ={'REMOTE_ADDR' : '127.0.0.1'})
# activate GAE stubs
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_taskqueue_stub()
self.testbed.init_mail_stub()
self.mail_stub = self.testbed.get_stub(testbed.MAIL_SERVICE_NAME)
self.taskqueue_stub = self.testbed.get_stub(testbed.TASKQUEUE_SERVICE_NAME)
self.testbed.init_user_stub()
self.headers = {'User-Agent' : 'Safari', 'Accept-Language' : 'en_US'}
def post(self):
# check captcha
challenge = self.request.POST.get('recaptcha_challenge_field')
response = self.request.POST.get('recaptcha_response_field')
remoteip = self.request.remote_addr
cResponse = captcha.submit(challenge, response,
self.reCaptcha_private_key, remoteip)
if cResponse.is_valid:
# captcha was valid... carry on..nothing to see here
pass
else:
_message = _('Wrong image verification code. Please try again.')
self.add_message(_message, 'error')
return self.redirect_to('password-reset')
# load the email address
email = str(self.request.POST.get('email')).lower().strip()
if utils.is_email_valid(email):
user = models.User.get_by_email(email)
_message = _(
"You should receive an email from us shortly with instructions for resetting your password."
)
if user is not None:
user_id = user.get_id()
token = models.User.create_auth_token(user_id)
email_url = self.uri_for('taskqueue-send-email')
reset_url = self.uri_for('password-reset-check',
user_id=user_id,
token=token,
_full=True)
subject = _("%s Password Assistance" % config.app_name)
# load email's template
template_val = {
"username": user.username,
"email": user.email,
"reset_password_url": reset_url,
"support_url": self.uri_for("contact", _full=True),
"app_name": config.app_name,
}
body_path = "emails/reset_password.txt"
body = self.jinja2.render_template(body_path, **template_val)
logging.info("value is: %s" % reset_url)
taskqueue.add(url=email_url,
params={
'to': user.email,
'subject': subject,
'body': body,
'sender': config.contact_sender,
})
self.add_message(_message, 'success')
return self.redirect_to('login')
self.add_message(_message, 'warning')
return self.redirect_to('password-reset')
def setUp(self):
# create a WSGI application.
webapp2_config = config.config
self.app = webapp2.WSGIApplication(config=webapp2_config)
routes.add_routes(self.app)
boilerplate_routes.add_routes(self.app)
self.testapp = webtest.TestApp(self.app, extra_environ={'REMOTE_ADDR' : '127.0.0.1'})
# # use absolute path for templates
# self.app.config['webapp2_extras.jinja2']['template_path'] = ['/templates']
# activate GAE stubs
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_taskqueue_stub()
self.testbed.init_mail_stub()
self.mail_stub = self.testbed.get_stub(testbed.MAIL_SERVICE_NAME)
self.taskqueue_stub = self.testbed.get_stub(testbed.TASKQUEUE_SERVICE_NAME)
self.testbed.init_user_stub()
self.headers = {'User-Agent' : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) Version/6.0 Safari/536.25',
'Accept-Language' : 'en_US'}
# fix configuration if this is still a raw boilerplate code - required by test with mails
if not utils.is_email_valid(self.app.config.get('contact_sender')):
self.app.config['contact_sender'] = "*****@*****.**"
if not utils.is_email_valid(self.app.config.get('contact_recipient')):
self.app.config['contact_recipient'] = "*****@*****.**"
##: Setup global variables
self.deleteTestProduct()
product, best_price, productPriceTiers = self.getTestProduct()
urlsafeKey = product.key.urlsafe()
self.testProduct = product
self.testProduct_urlsafeKey = urlsafeKey
self.testProduct_bestPrice = best_price
self.testProduct_priceTiers = productPriceTiers
logging.info('product = {}'.format(self.testProduct))
logging.info('urlsafeKey = {}'.format(self.testProduct_urlsafeKey))
logging.info('best_price = {}'.format(self.testProduct_bestPrice))
def post(self):
"""
Get fields from POST dict
"""
username = str(self.request.POST.get('username')).lower().strip()
name = str(self.request.POST.get('name')).strip()
last_name = str(self.request.POST.get('last_name')).strip()
email = str(self.request.POST.get('email')).lower().strip()
country = str(self.request.POST.get('country')).strip()
if username == "" or email == "":
message = 'Sorry, some fields are required.'
self.add_message(message, 'error')
return self.redirect_to('edit-profile')
if not utils.is_email_valid(email):
message = 'Sorry, the email %s is not valid.' % email
self.add_message(message, 'error')
return self.redirect_to('edit-profile')
if not utils.is_alphanumeric(username):
message = 'Sorry, the username %s is not valid. '\
'Use only letters and numbers' % username
self.add_message(message, 'error')
return self.redirect_to('edit-profile')
#TODO: Update profile identifying unique_properties
# Passing password_raw=password so password will be hashed
# Returns a tuple, where first value is BOOL.
# If True ok, If False no new user is created
unique_properties = ['username','email']
auth_id = "own:%s" % username
user = self.auth.store.user_model.create_user(
auth_id, unique_properties, password_raw=password,
username=username, name=name, last_name=last_name, email=email,
country=country, ip=self.request.remote_addr,
)
if not user[0]: #user is a tuple
message = 'Sorry, This user {0:>s} '\
'is already registered.'.format(username)# Error message
self.add_message(message, 'error')
return self.redirect_to('register')
else:
# User registered successfully, let's try sign in the user and redirect to a secure page.
try:
self.auth.get_user_by_password(user[1].auth_ids[0], password)
message = 'Welcome %s you are now loged in.' % ( str(username) )
self.add_message(message, 'success')
return self.redirect_to('secure')
except (AttributeError, KeyError), e:
message = 'Unexpected error creating '\
'user {0:>s}.'.format(username)
self.add_message(message, 'error')
self.abort(403)
def post(self):
# check captcha
challenge = self.request.POST.get('recaptcha_challenge_field')
response = self.request.POST.get('recaptcha_response_field')
remoteip = self.request.remote_addr
cResponse = captcha.submit(
challenge,
response,
self.reCaptcha_private_key,
remoteip)
if cResponse.is_valid:
# captcha was valid... carry on..nothing to see here
pass
else:
_message = _('Wrong image verification code. Please try again.')
self.add_message(_message, 'error')
return self.redirect_to('password-reset')
# load the email address
email = str(self.request.POST.get('email')).lower().strip()
if utils.is_email_valid(email):
user = models.User.get_by_email(email)
_message = _("You should receive an email from us shortly with instructions for resetting your password.")
if user is not None:
user_id = user.get_id()
token = models.User.create_auth_token(user_id)
email_url = self.uri_for('taskqueue-send-email')
reset_url = self.uri_for('password-reset-check', user_id=user_id, token=token, _full=True)
subject = _("%s Password Assistance" % config.app_name)
# load email's template
template_val = {
"username": user.username,
"email": user.email,
"reset_password_url": reset_url,
"support_url": self.uri_for("contact", _full=True),
"app_name": config.app_name,
}
body_path = "emails/reset_password.txt"
body = self.jinja2.render_template(body_path, **template_val)
logging.info("value is: %s" % reset_url)
taskqueue.add(url = email_url, params={
'to': user.email,
'subject' : subject,
'body' : body,
'sender' : config.contact_sender,
})
self.add_message(_message, 'success')
return self.redirect_to('login')
self.add_message(_message, 'warning')
return self.redirect_to('password-reset')
def post(self):
# check captcha
challenge = self.request.POST.get('recaptcha_challenge_field')
response = self.request.POST.get('recaptcha_response_field')
remoteip = self.request.remote_addr
cResponse = captcha.submit(
challenge,
response,
self.reCaptcha_private_key,
remoteip)
if cResponse.is_valid:
# captcha was valid... carry on..nothing to see here
pass
else:
logging.warning(cResponse.error_code)
_message = _('Wrong image verification code. Please try again.')
self.add_message(_message, 'error')
return self.redirect_to('password-reset')
#check if we got an email or username
email_or_username = str(self.request.POST.get('email_or_username')).lower().strip()
if utils.is_email_valid(email_or_username):
user = models.User.get_by_email(email_or_username)
_message = _("If the e-mail address you entered") + " (<strong>%s</strong>) " % email_or_username
else:
auth_id = "own:%s" % email_or_username
user = models.User.get_by_auth_id(auth_id)
_message = _("If the username you entered") + " (<strong>%s</strong>) " % email_or_username
if user is not None:
user_id = user.get_id()
token = models.User.create_auth_token(user_id)
email_url = self.uri_for('taskqueue-send-email')
reset_url = self.uri_for('password-reset-check', user_id=user_id, token=token, _full=True)
subject = _("Password reminder")
body = _('Please click below to create a new password:'******'to': user.email,
'subject' : subject,
'body' : body,
'sender' : config.contact_sender,
})
_message = _message + _("is associated with an account in our records, you will receive "\
"an e-mail from us with instructions for resetting your password. "\
"<br>If you don't receive this e-mail, please check your junk mail folder or ") +\
'<a href="' + self.uri_for('contact') + '">' + _('contact us') + '</a> ' + _("for further assistance.")
self.add_message(_message, 'success')
return self.redirect_to('login')
_message = _('Your email / username was not found. Please try another or ') + '<a href="' + self.uri_for('register') + '">' + _('create an account') + '</a>'
self.add_message(_message, 'error')
return self.redirect_to('password-reset')
def post(self):
from google.appengine.api import mail, app_identity
to = self.request.get("to")
subject = self.request.get("subject")
body = self.request.get("body")
sender = self.request.get("sender")
if sender != '' or not utils.is_email_valid(sender):
if utils.is_email_valid(self.app.config.get('contact_sender')):
sender = self.app.config.get('contact_sender')
else:
app_id = app_identity.get_application_id()
sender = "%s <no-reply@%s.appspotmail.com>" % (app_id, app_id)
if self.app.config['log_email']:
try:
logEmail = models.LogEmail(
sender=sender,
to=to,
subject=subject,
body=body,
when=utils.get_date_time("datetimeProperty")
)
logEmail.put()
except (apiproxy_errors.OverQuotaError, BadValueError):
logging.error("Error saving Email Log in datastore")
try:
message = mail.EmailMessage()
message.sender = sender
message.to = to
message.subject = subject
message.html = body
message.send()
except Exception, e:
logging.error("Error sending email: %s" % e)
def post(self):
# check captcha
challenge = self.request.POST.get('recaptcha_challenge_field')
response = self.request.POST.get('recaptcha_response_field')
remoteip = self.request.remote_addr
cResponse = captcha.submit(
challenge,
response,
self.reCaptcha_private_key,
remoteip)
if cResponse.is_valid:
# captcha was valid... carry on..nothing to see here
pass
else:
logging.warning(cResponse.error_code)
_message = 'Wrong image verification code. Please try again.'
self.add_message(_message, 'error')
return self.redirect_to('password-reset')
#check if we got an email or username
email_or_username = str(self.request.POST.get('email_or_username')).lower().strip()
if utils.is_email_valid(email_or_username):
user = models.User.get_by_email(email_or_username)
_message = "If the e-mail address you entered <strong>%s</strong> " % email_or_username
else:
auth_id = "own:%s" % email_or_username
user = models.User.get_by_auth_id(auth_id)
_message = "If the username you entered <strong>%s</strong> " % email_or_username
if user is not None:
user_id = user.get_id()
token = models.User.create_auth_token(user_id)
email_send_url = self.uri_for('send-reset-email')
taskqueue.add(url = email_send_url, params={
'recipient_email': user.email,
'token' : token,
'user_id' : user_id,
})
_message = _message + "is associated with an account in our records, you will receive " \
"an e-mail from us with instructions for resetting your password. " \
"<br>If you don't receive this e-mail, please check your junk mail folder or " \
"<a href='/contact'>contact us</a> for further assistance."
self.add_message(_message, 'success')
return self.redirect_to('login')
_message = 'Your email / username was not found. Please try another or <a href="/register">create an account</a>.'
self.add_message(_message, 'error')
return self.redirect_to('password-reset')
def login(self, request):
"""Exposes an API endpoint to query for an upload URL.
Args:
Returns:
"""
salt=config.get('salt')
aes_key=config.get('aes_key')
if not request.username:
LoginResponse(message="Provide a username")
username = request.username.lower()
# try:
if utils.is_email_valid(username):
user = User.get_by_email(username)
if user:
auth_id = user.auth_ids[0]
else:
raise InvalidAuthIdError
else:
auth_id = "own:%s" % username
user = User.get_by_auth_id(auth_id)
password = request.password.strip()
remember_me=False
# Password to SHA512
password = utils.hashing(password, salt)
# Try to login user with password
# Raises InvalidAuthIdError if user is not found
# Raises InvalidPasswordError if provided password
# doesn't match with specified user
user = User.get_by_auth_id(auth_id)
if not user:
raise endpoints.BadRequestException('Password/Username Do Not Match')
if not security.check_password_hash(password, user.password):
raise endpoints.BadRequestException('Password/Username Do Not Match')
else:
self.user_apikey = ApiKeys.get_apikey_by_user_id(user.key.id()).key.id()
return LoginResponse(apikey=self.user_apikey)
def post(self):
"""
username: Get the username from POST dict
password: Get the password from POST dict
"""
if not self.form.validate():
return self.get()
username = self.form.username.data.lower()
try:
if utils.is_email_valid(username):
user = models.User.get_by_email(username)
if user:
auth_id = user.auth_ids[0]
else:
raise InvalidAuthIdError
else:
auth_id = "own:%s" % username
user = models.User.get_by_auth_id(auth_id)
password = self.form.password.data.strip()
remember_me = True if str(self.request.POST.get('remember_me')) == 'on' else False
# Password to SHA512
password = utils.encrypt(password, config.salt)
# Try to login user with password
# Raises InvalidAuthIdError if user is not found
# Raises InvalidPasswordError if provided password
# doesn't match with specified user
self.auth.get_user_by_password(
auth_id, password, remember=remember_me)
visitLog = models.VisitLog(
user=user.key,
uastring=self.request.user_agent,
ip=self.request.remote_addr,
timestamp=utils.get_date_time()
)
visitLog.put()
self.redirect_to('secure')
except (InvalidAuthIdError, InvalidPasswordError), e:
# Returns error message to self.response.write in
# the BaseHandler.dispatcher
message = _("Login invalid, Try again") + ". " + _("Don't have an account?") + \
' <a href="' + self.uri_for('register') + '">' + _("Sign Up") + '</a>'
self.add_message(message, 'error')
return self.redirect_to('login')
def post(self):
"""
validate contact form
"""
remoteip = self.request.remote_addr
user_agent = self.request.user_agent
name = self.request.POST.get('name').strip()
email = self.request.POST.get('email').strip()
message = self.request.POST.get('message').strip()
if name == "" or email == "" or message == "":
message = 'Sorry, some fields are required.'
self.add_message(message, 'error')
return self.redirect_to('contact')
if not utils.is_email_valid(email):
message = 'Sorry, this email %s is not valid.' % email
self.add_message(message, 'error')
return self.redirect_to('contact')
try:
app_id = app_identity.get_application_id()
sender_address = "%s <no-reply@%s.appspotmail.com>" % (app_id, app_id)
subject = "Contact"
body = """
IP Address : %s
Web Browser : %s
Sender : %s <%s>
%s
""" % (remoteip, user_agent, name, email, message)
mail.send_mail(sender_address, config.contact_recipient, subject, body)
message = 'Message sent successfully.'
self.add_message(message, 'success')
return self.redirect_to('contact')
except (AttributeError, KeyError), e:
message = 'Error sending the message. Please try again later.'
self.add_message(message, 'error')
return self.redirect_to('contact')
def post(self):
sensordata = ArduinoSensorData()
try:
#get values
weight = int(self.request.get('weight'))
email_or_username = str(self.request.get('email')).lower().strip()
#password = str(self.request.get('password'))
#sensordata.test = "yes"
#check if we got an email or username
if utils.is_email_valid(email_or_username):
#sensordata.test1 = "yes"
#user_info = users.get_by_email(email_or_username)
user = users.User(email_or_username)
#password = utils.hashing(password, self.app.config.get('salt'))
#auth_id = user_info.auth_ids[0]
# authenticate user by its password
#try:
# self.user_model.get_by_auth_password(auth_id, password)
# sensordata.test2 = "yes"
#except (InvalidAuthIdError, InvalidPasswordError):
# sensordata.test2 = "no"
# pass
if user:
sensordata.email = email_or_username
sensordata.weight = weight
sensordata.timestamp = datetime.datetime.now()
sensordata.put()
except ValueError:
#sensordata.test = "no"
pass
def post(self):
# check captcha
challenge = self.request.POST.get('recaptcha_challenge_field')
response = self.request.POST.get('recaptcha_response_field')
remoteip = self.request.remote_addr
cResponse = captcha.submit(
challenge,
response,
self.app.config.get('captcha_private_key'),
remoteip)
if cResponse.is_valid:
# captcha was valid... carry on..nothing to see here
pass
else:
_message = _('Wrong image verification code. Please try again.')
self.add_message(_message, 'error')
return self.redirect_to('password-reset')
#check if we got an email or username
email_or_username = str(self.request.POST.get('email_or_username')).lower().strip()
if utils.is_email_valid(email_or_username):
user = models.User.get_by_email(email_or_username)
_message = _("If the e-mail address you entered") + " (<strong>%s</strong>) " % email_or_username
else:
auth_id = "own:%s" % email_or_username
user = models.User.get_by_auth_id(auth_id)
_message = _("If the username you entered") + " (<strong>%s</strong>) " % email_or_username
_message = _message + _("is associated with an account in our records, you will receive "
"an e-mail from us with instructions for resetting your password. "
"<br>If you don't receive instructions within a minute or two, "
"check your email's spam and junk filters, or ") +\
'<a href="' + self.uri_for('contact') + '">' + _('contact us') + '</a> ' + _("for further assistance.")
if user is not None:
user_id = user.get_id()
token = models.User.create_auth_token(user_id)
email_url = self.uri_for('taskqueue-send-email')
reset_url = self.uri_for('password-reset-check', user_id=user_id, token=token, _full=True)
subject = _("%s Password Assistance" % self.app.config.get('app_name'))
# load email's template
template_val = {
"username": user.username,
"email": user.email,
"reset_password_url": reset_url,
"support_url": self.uri_for("contact", _full=True),
"app_name": self.app.config.get('app_name'),
}
body_path = "emails/reset_password.txt"
body = self.jinja2.render_template(body_path, **template_val)
taskqueue.add(url = email_url, params={
'to': user.email,
'subject' : subject,
'body' : body,
'sender' : self.app.config.get('contact_sender'),
})
self.add_message(_message, 'warning')
return self.redirect_to('login')
def post(self):
"""
username: Get the username from POST dict
password: Get the password from POST dict
"""
if not self.form.validate():
return self.get()
username = self.form.username.data.lower()
continue_url = self.request.get('continue_url').encode('ascii', 'ignore')
try:
if utils.is_email_valid(username):
user = models.User.get_by_email(username)
if user:
auth_id = user.auth_ids[0]
else:
raise InvalidAuthIdError
else:
auth_id = "own:%s" % username
user = models.User.get_by_auth_id(auth_id)
password = self.form.password.data.strip()
remember_me = True if str(self.request.POST.get('remember_me')) == 'on' else False
# Password to SHA512
password = utils.hashing(password, self.app.config.get('salt'))
# Try to login user with password
# Raises InvalidAuthIdError if user is not found
# Raises InvalidPasswordError if provided password
# doesn't match with specified user
self.auth.get_user_by_password(
auth_id, password, remember=remember_me)
# if user account is not activated, logout and redirect to home
if (user.activated == False):
# logout
self.auth.unset_session()
# redirect to home with error message
resend_email_uri = self.uri_for('resend-account-activation', user_id=user.get_id(),
token=models.User.create_resend_token(user.get_id()))
message = _('Your account has not yet been activated. Please check your email to activate it or') +\
' <a href="'+resend_email_uri+'">' + _('click here') + '</a> ' + _('to resend the email.')
self.add_message(message, 'error')
return self.redirect_to('home')
# check twitter association in session
twitter_helper = twitter.TwitterAuth(self)
twitter_association_data = twitter_helper.get_association_data()
if twitter_association_data is not None:
if models.SocialUser.check_unique(user.key, 'twitter', str(twitter_association_data['id'])):
social_user = models.SocialUser(
user = user.key,
provider = 'twitter',
uid = str(twitter_association_data['id']),
extra_data = twitter_association_data
)
social_user.put()
# check facebook association
fb_data = None
try:
fb_data = json.loads(self.session['facebook'])
except:
pass
if fb_data is not None:
if models.SocialUser.check_unique(user.key, 'facebook', str(fb_data['id'])):
social_user = models.SocialUser(
user = user.key,
provider = 'facebook',
uid = str(fb_data['id']),
extra_data = fb_data
)
social_user.put()
# check linkedin association
li_data = None
try:
li_data = json.loads(self.session['linkedin'])
except:
pass
if li_data is not None:
if models.SocialUser.check_unique(user.key, 'linkedin', str(li_data['id'])):
social_user = models.SocialUser(
user = user.key,
provider = 'linkedin',
uid = str(li_data['id']),
extra_data = li_data
)
social_user.put()
# end linkedin
logVisit = models.LogVisit(
user=user.key,
uastring=self.request.user_agent,
ip=self.request.remote_addr,
timestamp=utils.get_date_time()
)
logVisit.put()
if continue_url:
self.redirect(continue_url)
else:
self.redirect_to('home')
except (InvalidAuthIdError, InvalidPasswordError), e:
# Returns error message to self.response.write in
# the BaseHandler.dispatcher
message = _("Your username or password is incorrect. "
"Please try again (make sure your caps lock is off)")
self.add_message(message, 'error')
self.redirect_to('login', continue_url=continue_url) if continue_url else self.redirect_to('login')
def post(self):
# check captcha
challenge = self.request.POST.get('recaptcha_challenge_field')
response = self.request.POST.get('recaptcha_response_field')
remoteip = self.request.remote_addr
cResponse = captcha.submit(challenge, response,
self.reCaptcha_private_key, remoteip)
if cResponse.is_valid:
# captcha was valid... carry on..nothing to see here
pass
else:
logging.warning(cResponse.error_code)
_message = _('Wrong image verification code. Please try again.')
self.add_message(_message, 'error')
return self.redirect_to('password-reset')
# check if we got an email or username
email_or_username = str(
self.request.POST.get('email_or_username')).lower().strip()
if utils.is_email_valid(email_or_username):
user = models.User.get_by_email(email_or_username)
_message = _("If the e-mail address you entered"
) + " (<strong>%s</strong>) " % email_or_username
else:
auth_id = "own:%s" % email_or_username
user = models.User.get_by_auth_id(auth_id)
_message = _("If the username you entered"
) + " (<strong>%s</strong>) " % email_or_username
if user is not None:
user_id = user.get_id()
token = models.User.create_auth_token(user_id)
email_url = self.uri_for('taskqueue-send-email')
reset_url = self.uri_for('password-reset-check',
user_id=user_id,
token=token,
_full=True)
subject = _("Password reminder")
body = _('Please click below to create a new password:'******'to': user.email,
'subject': subject,
'body': body,
'sender': config.contact_sender,
})
_message = _message + _("is associated with an account in our records, you will receive "\
"an e-mail from us with instructions for resetting your password. "\
"<br>If you don't receive this e-mail, please check your junk mail folder or ") +\
'<a href="' + self.uri_for('contact') + '">' + _('contact us') + '</a> ' + _("for further assistance.")
self.add_message(_message, 'success')
return self.redirect_to('login')
_message = _(
'Your email / username was not found. Please try another or '
) + '<a href="' + self.uri_for('register') + '">' + _(
'create an account') + '</a>'
self.add_message(_message, 'error')
return self.redirect_to('password-reset')
def post(self):
"""
username: Get the username from POST dict
password: Get the password from POST dict
"""
if not self.form.validate():
return self.get()
username = self.form.username.data.lower()
try:
if utils.is_email_valid(username):
user = models.User.get_by_email(username)
if user:
auth_id = user.auth_ids[0]
else:
raise InvalidAuthIdError
else:
auth_id = "own:%s" % username
user = models.User.get_by_auth_id(auth_id)
password = self.form.password.data.strip()
remember_me = True if str(
self.request.POST.get('remember_me')) == 'on' else False
# Password to SHA512
password = utils.encrypt(password, config.salt)
# Try to login user with password
# Raises InvalidAuthIdError if user is not found
# Raises InvalidPasswordError if provided password
# doesn't match with specified user
self.auth.get_user_by_password(auth_id,
password,
remember=remember_me)
# if user account is not activated, logout and redirect to home
if (user.activated == False):
# logout
self.auth.unset_session()
# redirect to home with error message
resend_email_uri = self.uri_for('resend-account-activation',
encoded_email=utils.encode(
user.email))
message = _('Sorry, your account') + ' <strong>{0:>s}</strong>'.format(username) + " " +\
_('has not been activated. Please check your email to activate your account') + ". " +\
_('Or click') + " <a href='"+resend_email_uri+"'>" + _('this') + "</a> " + _('to resend the email')
self.add_message(message, 'error')
return self.redirect_to('home')
# check twitter association in session
twitter_helper = twitter.TwitterAuth(self)
twitter_association_data = twitter_helper.get_association_data()
if twitter_association_data is not None:
if models.SocialUser.check_unique(
user.key, 'twitter',
str(twitter_association_data['id'])):
social_user = models.SocialUser(
user=user.key,
provider='twitter',
uid=str(twitter_association_data['id']),
extra_data=twitter_association_data)
social_user.put()
logVisit = models.LogVisit(user=user.key,
uastring=self.request.user_agent,
ip=self.request.remote_addr,
timestamp=utils.get_date_time())
logVisit.put()
self.redirect_to('home')
except (InvalidAuthIdError, InvalidPasswordError), e:
# Returns error message to self.response.write in
# the BaseHandler.dispatcher
message = _("Login invalid, Try again.") + "<br/>" + _("Don't have an account?") + \
' <a href="' + self.uri_for('register') + '">' + _("Sign Up") + '</a>'
self.add_message(message, 'error')
return self.redirect_to('login')
def post(self):
"""
username: Get the username from POST dict
password: Get the password from POST dict
"""
if not self.form.validate():
return self.get()
username = self.form.username.data.lower()
try:
if utils.is_email_valid(username):
user = models.User.get_by_email(username)
if user:
auth_id = user.auth_ids[0]
else:
raise InvalidAuthIdError
else:
auth_id = "own:%s" % username
user = models.User.get_by_auth_id(auth_id)
password = self.form.password.data.strip()
remember_me = True if str(self.request.POST.get('remember_me')) == 'on' else False
# Password to SHA512
password = utils.hashing(password, config.salt)
# Try to login user with password
# Raises InvalidAuthIdError if user is not found
# Raises InvalidPasswordError if provided password
# doesn't match with specified user
self.auth.get_user_by_password(
auth_id, password, remember=remember_me)
# if user account is not activated, logout and redirect to home
if (user.activated == False):
# logout
self.auth.unset_session()
# redirect to home with error message
message = _('Your account has been suspended. Please contact support for more information.')
self.add_message(message, 'error')
return self.redirect_to('login')
# REMOVE ME
#check twitter association in session
twitter_helper = twitter.TwitterAuth(self)
twitter_association_data = twitter_helper.get_association_data()
if twitter_association_data is not None:
if models.SocialUser.check_unique(user.key, 'twitter', str(twitter_association_data['id'])):
social_user = models.SocialUser(
user = user.key,
provider = 'twitter',
uid = str(twitter_association_data['id']),
extra_data = twitter_association_data
)
social_user.put()
logVisit = models.LogVisit(
user=user.key,
uastring=self.request.user_agent,
ip=self.request.remote_addr,
timestamp=utils.get_date_time()
)
logVisit.put()
self.redirect_to('home')
except (InvalidAuthIdError, InvalidPasswordError), e:
# Returns error message to self.response.write in
# the BaseHandler.dispatcher
message = _("Your username or password is incorrect. Caps lock?")
self.add_message(message, 'error')
return self.redirect_to('login')
def post(self):
"""
username: Get the username from POST dict
password: Get the password from POST dict
"""
if not self.form.validate():
return self.get()
username = self.form.username.data.lower()
try:
if utils.is_email_valid(username):
user = models.User.get_by_email(username)
if user:
auth_id = user.auth_ids[0]
else:
raise InvalidAuthIdError
else:
auth_id = "own:%s" % username
user = models.User.get_by_auth_id(auth_id)
password = self.form.password.data.strip()
remember_me = True if str(self.request.POST.get('remember_me')) == 'on' else False
# Password to SHA512
password = utils.encrypt(password, config.salt)
# Try to login user with password
# Raises InvalidAuthIdError if user is not found
# Raises InvalidPasswordError if provided password
# doesn't match with specified user
self.auth.get_user_by_password(
auth_id, password, remember=remember_me)
# if user account is not activated, logout and redirect to home
if (user.activated == False):
# logout
self.auth.unset_session()
# redirect to home with error message
resend_email_uri = self.uri_for('resend-account-activation', encoded_email=utils.encode(user.email))
message = _('Sorry, your account') + ' <strong>{0:>s}</strong>'.format(username) + " " +\
_('has not been activated. Please check your email to activate your account') + ". " +\
_('Or click') + " <a href='"+resend_email_uri+"'>" + _('this') + "</a> " + _('to resend the email')
self.add_message(message, 'error')
return self.redirect_to('home')
#check twitter association in session
twitter_helper = twitter.TwitterAuth(self)
twitter_association_data = twitter_helper.get_association_data()
if twitter_association_data is not None:
if models.SocialUser.check_unique(user.key, 'twitter', str(twitter_association_data['id'])):
social_user = models.SocialUser(
user = user.key,
provider = 'twitter',
uid = str(twitter_association_data['id']),
extra_data = twitter_association_data
)
social_user.put()
logVisit = models.LogVisit(
user=user.key,
uastring=self.request.user_agent,
ip=self.request.remote_addr,
timestamp=utils.get_date_time()
)
logVisit.put()
self.redirect_to('home')
except (InvalidAuthIdError, InvalidPasswordError), e:
# Returns error message to self.response.write in
# the BaseHandler.dispatcher
message = _("Login invalid, Try again.") + "<br/>" + _("Don't have an account?") + \
' <a href="' + self.uri_for('register') + '">' + _("Sign Up") + '</a>'
self.add_message(message, 'error')
return self.redirect_to('login')
def post(self):
"""
username: Get the username from POST dict
password: Get the password from POST dict
"""
username = str(self.request.POST.get('username')).lower().strip()
name = str(self.request.POST.get('name')).strip()
last_name = str(self.request.POST.get('last_name')).strip()
email = str(self.request.POST.get('email')).lower().strip()
password = str(self.request.POST.get('password')).strip()
c_password = str(self.request.POST.get('c_password')).strip()
country = str(self.request.POST.get('country')).strip()
if username == "" or email == "" or password == "":
message = 'Sorry, some fields are required.'
self.add_message(message, 'error')
return self.redirect_to('create-user')
if password != c_password:
message = 'Sorry, Passwords are not identical, ' \
'you have to repeat again.'
self.add_message(message, 'error')
return self.redirect_to('create-user')
if not utils.is_email_valid(email):
message = 'Sorry, the email %s is not valid.' % email
self.add_message(message, 'error')
return self.redirect_to('create-user')
if not utils.is_alphanumeric(username):
message = 'Sorry, the username %s is not valid. ' \
'Use only letters and numbers' % username
self.add_message(message, 'error')
return self.redirect_to('create-user')
# Passing password_raw=password so password will be hashed
# Returns a tuple, where first value is BOOL.
# If True ok, If False no new user is created
unique_properties = ['username','email']
user = self.auth.store.user_model.create_user(
username, unique_properties, password_raw=password,
username=username, name=name, last_name=last_name, email=email,
country=country, ip=self.request.remote_addr,
)
if not user[0]: #user is a tuple
message = 'Sorry, User {0:>s} ' \
'is already created.'.format(username)# Error message
self.add_message(message, 'error')
return self.redirect_to('create-user')
else:
# User is created, let's try redirecting to login page
try:
message = 'User %s created successfully.' % ( str(username) )
self.add_message(message, 'success')
self.redirect(self.auth_config['login_url'])
except (AttributeError, KeyError), e:
message = 'Unexpected error creating ' \
'user {0:>s}.'.format(username)
self.add_message(message, 'error')
self.abort(403)
def post(self):
"""
username: Get the username from POST dict
password: Get the password from POST dict
"""
if not self.form.validate():
return self.get()
username = self.form.username.data.lower()
try:
if utils.is_email_valid(username):
user = models.User.get_by_email(username)
if user:
auth_id = user.auth_ids[0]
else:
raise InvalidAuthIdError
else:
auth_id = "own:%s" % username
user = models.User.get_by_auth_id(auth_id)
password = self.form.password.data.strip()
remember_me = True if str(
self.request.POST.get('remember_me')) == 'on' else False
# Password to SHA512
password = utils.hashing(password, config.salt)
# Try to login user with password
# Raises InvalidAuthIdError if user is not found
# Raises InvalidPasswordError if provided password
# doesn't match with specified user
self.auth.get_user_by_password(auth_id,
password,
remember=remember_me)
# if user account is not activated, logout and redirect to home
if (user.activated == False):
# logout
self.auth.unset_session()
# redirect to home with error message
message = _(
'Your account has been suspended. Please contact support for more information.'
)
self.add_message(message, 'error')
return self.redirect_to('login')
# REMOVE ME
#check twitter association in session
twitter_helper = twitter.TwitterAuth(self)
twitter_association_data = twitter_helper.get_association_data()
if twitter_association_data is not None:
if models.SocialUser.check_unique(
user.key, 'twitter',
str(twitter_association_data['id'])):
social_user = models.SocialUser(
user=user.key,
provider='twitter',
uid=str(twitter_association_data['id']),
extra_data=twitter_association_data)
social_user.put()
logVisit = models.LogVisit(user=user.key,
uastring=self.request.user_agent,
ip=self.request.remote_addr,
timestamp=utils.get_date_time())
logVisit.put()
self.redirect_to('home')
except (InvalidAuthIdError, InvalidPasswordError), e:
# Returns error message to self.response.write in
# the BaseHandler.dispatcher
message = _("Your username or password is incorrect. Caps lock?")
self.add_message(message, 'error')
return self.redirect_to('login')
def post(self):
"""
Get fields from POST dict
"""
username = self.request.POST.get('username').lower().strip()
name = self.request.POST.get('name', "").strip()
last_name = self.request.POST.get('last_name', "").strip()
email = self.request.POST.get('email').lower().strip()
country = self.request.POST.get('country', "").strip()
if username == "" or email == "":
message = 'Sorry, some fields are required.'
self.add_message(message, 'error')
return self.redirect_to('edit-profile')
if not utils.is_email_valid(email):
message = 'Sorry, the email %s is not valid.' % email
self.add_message(message, 'error')
return self.redirect_to('edit-profile')
if not utils.is_alphanumeric(username):
message = 'Sorry, the username %s is not valid. '\
'Use only letters and numbers' % username
self.add_message(message, 'error')
return self.redirect_to('edit-profile')
new_auth_id='own:%s' % username
try:
user_info = models.User.get_by_id(long(self.user_id))
try:
#checking if new username exists
message=''
new_user_info=models.User.get_by_auth_id(new_auth_id)
if new_user_info==None:
user_info.username=username
user_info.auth_ids[0]=new_auth_id
message+=' Your new username is %s .' % username
else:
if user_info.username == new_user_info.username:
message+='Your new username is %s.' % username
else:
message+='Username: %s is already taken. It is not changed.' % username
check_user_email=models.User.get_by_email(email)
if check_user_email==None:
user_info.email=email
elif check_user_email.email!=user_info.email:
message+='This email is %s already registered.' % email
else:
user_info.email=email
user_info.name=name
user_info.last_name=last_name
user_info.country=country
user_info.put()
logging.error(user_info)
message+=' Your profile has been updated! '
self.add_message(message,'success')
self.redirect_to('edit-profile')
except (AttributeError,KeyError), e:
message='Unable to update profile!'
self.add_message(message,'error')
self.redirect_to('edit-profile')
except (AttributeError,TypeError),e:
login_error_message='Sorry you are not logged in!'
self.add_message(login_error_message,'error')
self.redirect_to('login')
def post(self):
"""
Get fields from POST dict
"""
new_email = self.request.POST.get('new_email').strip()
password = self.request.POST.get('password').strip()
if new_email == "" or password == "":
message = 'Sorry, some fields are required.'
self.add_message(message, 'error')
return self.redirect_to('edit-email')
if not utils.is_email_valid(new_email):
message = 'Sorry, the email %s is not valid.' % new_email
self.add_message(message, 'error')
return self.redirect_to('edit-email')
try:
user_info = models.User.get_by_id(long(self.user_id))
auth_id = "own:%s" % user_info.username
# Password to SHA512
password = utils.encrypt(password, config.salt)
try:
# authenticate user by its password
user = models.User.get_by_auth_password(auth_id, password)
# if the user change his/her email address
if new_email != user.email:
# check whether the new email has been used by another user
aUser = models.User.get_by_email(new_email)
if aUser is not None:
message = "The email %s is already registered. Want to <a href='/login/'>login</a> or <a href='/password-reset/'>recover your password</a>?" % new_email
self.add_message(message, "error")
return self.redirect_to("edit-email")
# send email
subject = config.app_name + " Email Changed Notification"
user_token = models.User.create_auth_token(self.user_id)
confirmation_url = self.uri_for("email-changed-check",
user_id = user_info.get_id(),
encoded_email = utils.encode(new_email),
token = user_token,
_full = True)
# load email's template
template_val = {
"app_name": config.app_name,
"first_name": user.name,
"username": user.username,
"new_email": new_email,
"confirmation_url": confirmation_url,
"support_url": self.uri_for("contact", _full=True)
}
old_body_path = "emails/email_changed_notification_old.txt"
old_body = self.jinja2.render_template(old_body_path, **template_val)
new_body_path = "emails/email_changed_notification_new.txt"
new_body = self.jinja2.render_template(new_body_path, **template_val)
utils.send_email(user.email, subject, old_body)
utils.send_email(new_email , subject, new_body)
logging.error(user)
# display successful message
msg = "Please check your new email for confirmation. "
msg += "Your email will be updated after confirmation. "
self.add_message(msg, 'success')
return self.redirect_to('secure')
else:
self.add_message("You didn't change your email", "warning")
return self.redirect_to("edit-email")
except (InvalidAuthIdError, InvalidPasswordError), e:
# Returns error message to self.response.write in
# the BaseHandler.dispatcher
message = "Your password is wrong, please try again"
self.add_message(message, 'error')
return self.redirect_to('edit-email')
except (AttributeError,TypeError), e:
login_error_message = _('Sorry you are not logged in!')
self.add_message(login_error_message,'error')
self.redirect_to('login')
