def test_getDatetimeFromString():
site_config = get_site_config()
assert dates.getDatetimeFromString("12/14/12") == dates.make_tz_aware(
datetime(2012, 12, 14), site_config["TIME_ZONE"])
assert dates.getDatetimeFromString("2012-12-14") == dates.make_tz_aware(
datetime(2012, 12, 14), site_config["TIME_ZONE"])
assert dates.getDatetimeFromString("12/14/2012") == dates.make_tz_aware(
datetime(2012, 12, 14), site_config["TIME_ZONE"])
assert dates.getDatetimeFromString("2/8/19") == dates.make_tz_aware(
datetime(2019, 2, 8), site_config["TIME_ZONE"])
assert dates.getDatetimeFromString("2/8/51") == dates.make_tz_aware(
datetime(1951, 2, 8), site_config["TIME_ZONE"])
#test what happens when you pass in a date time
assert dates.getDatetimeFromString(datetime(2019, 2,
8)) == dates.make_tz_aware(
datetime(2019, 2, 8),
site_config["TIME_ZONE"])
assert dates.getDatetimeFromString(
datetime(2019, 2, 8, 6, 33,
00)) == dates.make_tz_aware(datetime(2019, 2, 8, 6, 33, 00),
site_config["TIME_ZONE"])
# Pass in a date
assert dates.getDatetimeFromString(date(2019, 2,
8)) == dates.make_tz_aware(
datetime(2019, 2, 8),
site_config["TIME_ZONE"])
def __init__(self, local_path='', resource_path=''):
from app import app
site_config = get_site_config()
if not resource_path:
resource_path = site_config.get('DOWNLOAD_FOLDER',
'resource/static')
self.resource_path = Path(
app.root_path, site_config.get('DOWNLOAD_FOLDER',
'resource/static'))
self.local_path = Path(
local_path
) # directory below resource_path to separate files from others
self.filename = None
self.success = True
self.error_text = ''
self.saved_file_path = Path()
default_extensions = {
'txt',
'pdf',
'png',
'jpg',
'jpeg',
'gif',
}
self.allowed_extensions = site_config.get("ALLOWED_EXTENSIONS",
default_extensions)
def docs(filename=None):
#setExits()
g.title = "Docs"
from shotglass2.shotglass import get_site_config
site_config = get_site_config()
#import pdb;pdb.set_trace()
file_exists = False
if not filename:
filename = "README.md"
else:
filename = filename.strip('/')
# first try to get it as a (possibly) valid path
temp_path = os.path.join(os.path.dirname(os.path.abspath(__name__)),filename)
if not os.path.isfile(temp_path):
# try the default doc dir
temp_path = os.path.join(os.path.dirname(os.path.abspath(__name__)),'docs',filename)
if not os.path.isfile(temp_path) and 'DOC_DIRECTORY_LIST' in site_config:
for path in site_config['DOC_DIRECTORY_LIST']:
temp_path = os.path.join(os.path.dirname(os.path.abspath(__name__)),path.strip('/'),filename)
if os.path.isfile(temp_path):
break
filename = temp_path
file_exists = os.path.isfile(filename)
if file_exists:
rendered_html = render_markdown_for(filename,mod)
return render_template('markdown.html',rendered_html=rendered_html)
else:
#file not found
return abort(404)
def send_static_file(filename, **kwargs):
"""Send the file if it exists, else try to send it from the static directory"""
from shotglass2.shotglass import get_site_config
path_list = kwargs.get('path_list', ['static', 'shotglass2/static'])
path = None
explain = get_site_config().get('EXPLAIN_TEMPLATE_LOADING', False)
if explain:
print("\nSearching for {}".format(filename))
for temp_path in path_list:
file_loc = os.path.join(os.path.dirname(os.path.abspath(__name__)),
temp_path, filename)
if os.path.isfile(file_loc):
path = temp_path
if explain:
print("{} was found at {}".format(
filename,
os.path.join(os.path.dirname(os.path.abspath(__name__)),
temp_path)))
break
else:
if explain:
print("{} was not found at {}".format(
filename,
os.path.join(os.path.dirname(os.path.abspath(__name__)),
temp_path)))
if path:
return send_from_directory(path, filename, as_attachment=False)
return abort(404)
def test_nowString():
# This is really an alias to datetime_as_string
site_config = get_site_config()
site_config['TIME_ZONE'] = 'US/Pacific'
now = dates.nowString()
assert now == dates.datetime_as_string(datetime.now())
def alert_admin(self,message):
"""Send an email to the admin address if an error is encountered or
if you just fell like talking...
"""
from shotglass2.takeabeltof.mailer import email_admin
from shotglass2.shotglass import get_site_config
email_admin("Error in database access for {}".format(get_site_config()['HOST_NAME']),message)
def start_app():
shotglass.start_logging(app)
get_db() # ensure that the database file exists
# shotglass.start_backup_thread(os.path.join(app.root_path,app.config['DATABASE_PATH']))
# use os.path.normpath to resolve true path to data file when using '../' shorthand
shotglass.start_backup_thread(
os.path.normpath(
os.path.join(app.root_path,
shotglass.get_site_config()['DATABASE_PATH'])))
def get_contact_email():
"""Return a tuple of the contact name and email address
or a list of tuples
or None"""
from shotglass2.shotglass import get_site_config
site_config = get_site_config()
to = None
to_name = None
to_addr = None
rec = Pref(g.db).get("Contact Name",
user_name=site_config.get("HOST_NAME"),
default=site_config.get(
"CONTACT_NAME",
site_config.get("MAIL_DEFAULT_SENDER",
"Site Contact")))
if rec:
to_name = rec.value
if site_config['TESTING']:
rec = Pref(g.db).select_one(
where="name='Contact Email Address' and user_name='test'")
else:
rec = Pref(g.db).get("Contact Email Address",
user_name=site_config.get("HOST_NAME"),
default=site_config.get(
"CONTACT_EMAIL_ADDR",
site_config.get(
"MAIL_DEFAULT_ADDR", "info@{}".format(
site_config.get(
"HOST_NAME", "example.com")))))
if rec:
to_addr = rec.value
# split the addresses into a list if there are commas
temp_addr_list = to_addr.split(',')
if len(temp_addr_list) > 1:
to = []
for index, val in enumerate(temp_addr_list):
if index == 0:
to.append((
to_name,
val,
))
else:
to.append((
None,
val,
))
else:
to = (
to_name,
to_addr,
)
return to
def test_make_tz_aware():
# make_tz_aware(the_datetime,time_zone=None)
site_config = get_site_config()
zone = site_config["TIME_ZONE"]
aware = dates.make_tz_aware(datetime.now(), zone)
now = dates.local_datetime_now()
assert aware.tzinfo.zone == zone
aware = dates.make_tz_aware(datetime.now())
assert aware.tzinfo.zone == site_config["TIME_ZONE"]
def get_time_zone_setting():
"""Return the TIME_ZONE config setting if it exists else None"""
try:
from shotglass2.shotglass import get_site_config
time_zone = get_site_config()['TIME_ZONE']
except:
time_zone = None
return time_zone
def __init__(self, address_list=[], **kwargs):
# import pdb;pdb.set_trace()
self._to = []
# some old code will set address_to to None
if address_list == None:
address_list = []
self.add_address(address_list)
self.site_config = get_site_config()
self.admin_name = self.site_config['MAIL_DEFAULT_SENDER']
self.admin_addr = self.site_config['MAIL_DEFAULT_ADDR']
self.kwargs = kwargs # templates may need values here...
self.body = kwargs.get('body', None)
self.body_is_html = kwargs.get('body_is_html', None)
self.text_template = kwargs.get('text_template', None)
self.html_template = kwargs.get('html_template', None)
self.subject_prefix = kwargs.get(
'subject_prefix', self.site_config.get("MAIL_SUBJECT_PREFIX", ''))
contact_address = get_contact_email()
sender_name = self.admin_name
sender_addr = self.admin_addr
if contact_address:
if isinstance(contact_address, list):
# if there are multiple addresses in the contact list, just use the first for the sender
contact_address = contact_address[0] # returns a tuple
sender_name = contact_address[0]
sender_addr = contact_address[1]
self.from_address = kwargs.get('from_address', sender_addr)
self.from_sender = kwargs.get('from_sender', sender_name)
self.reply_to = kwargs.get('reply_to', self.from_address)
self._cc = kwargs.get('cc', [])
self._bcc = kwargs.get('bcc', [])
# import pdb;pdb.set_trace()
try:
if self.site_config['BCC_ADMINS_ON_ALL_EMAIL']:
admins = self.site_config['ADMIN_EMAILS']
if self._bcc is None:
self._bcc = []
if not isinstance(admins, list):
admins = [admins]
self._bcc.extend(admins)
except KeyError:
pass
self._attachments = []
self.subject = kwargs.get('subject', '').strip()
# appends all attachments regardless of keyword used
self.add_attachment(kwargs.get('attachments', None))
self.add_attachment(kwargs.get('attachment', None))
self.success = False
self.result_text = 'initialized'
def _before():
# Force all connections to be secure
if app.config['REQUIRE_SSL'] and not request.is_secure:
return redirect(request.url.replace("http://", "https://"))
#ensure that nothing is served from the instance directory
if 'instance' in request.url:
return abort(404)
#import pdb;pdb.set_trace()
session.permanent = True
shotglass.get_site_config(app)
shotglass.set_template_dirs(app)
get_db()
# Is the user signed in?
g.user = None
if 'user' in session:
g.user = session['user']
#g.menu_items = shotglass.get_menu_items()
g.menu_items = [
{
'title': 'Home',
'url': '/'
},
# {'title':'RSVP','url':url_for('www.rsvp')},
# {'title':'Where to Stay','url':url_for('www.render_for', filename='where_to_stay')},
# {'title':'Things to Do','url':url_for('www.render_for', filename='things_to_do')},
# {'title':'Shopping','url':url_for('www.render_for', filename='shopping')},
# {'title':'The Menu','url':url_for('www.render_for', filename='menu')},
# {'title':'Churches','url':url_for('www.render_for',filename='churches')},
# {'title':'Questions','url':url_for('www.contact')},
]
g.admin = Admin(g.db) # This is where user access rules are stored
shotglass.user_setup(
) # g.admin now holds access rules Users, Prefs and Roles
def edit_from_list(id=None, item_id=None):
"""Handle creation of transaction from the Item record form"""
setExits()
#import pdb;pdb.set_trace()
item_id = cleanRecordID(item_id)
item_rec = None
rec = None
warehouses = Warehouse(g.db).select()
trx_types = get_site_config().get('trx_types', [
'Add',
'Remove',
])
transaction = Transaction(g.db)
trx_id = cleanRecordID(id)
if trx_id > 0:
rec = transaction.get(trx_id)
if rec:
item_id = rec.item_id
else:
rec = transaction.new()
rec.created = local_datetime_now()
if 'last_trx' in session:
transaction.update(rec, session['last_trx'])
# Handle Response?
if request.form:
#import pdb;pdb.set_trace()
error_list = []
transaction.update(rec, request.form)
if save_record(rec, error_list):
return "success" # the success function looks for this...
else:
pass
if item_id > 0:
item_rec = Item(g.db).get(item_id)
if not item_rec:
flash("This is not a valid item id")
return "failure: This is not a valid item id."
else:
rec.item_id = item_id
return render_template('trx_edit_from_list.html',
rec=rec,
current_item=item_rec,
warehouses=warehouses,
trx_types=trx_types)
def __init__(self, **kwargs):
site_config = get_site_config()
super().__init__(self)
self.add('version', '2.0')
self.add('calscale', 'GREGORIAN')
self.add('prodid',
kwargs.get('prodid', site_config['HOST_NAME'].lower()))
calendar_name = kwargs.get('calendar_name', None)
if not calendar_name:
self.add('x-priamry-calendar', 'TRUE')
else:
# give the calendar a name
self.add('x-wr-calname', calendar_name)
self.add('name', calendar_name)
def _text_to_numeric(self,field_name,value,column_type):
"""Attempt to coerce values for numeric fields to numbers if needed.
Params:
field_name: the name of the field being updated
value: the value to convert
column_type: the text name of the field type e.g. INTEGER, REAL, etc.
Return the number or the original value if not successful
Alerts admin on failure
"""
from shotglass2.shotglass import get_site_config
value = value.strip()
column_type = column_type.upper()
if type(value) != str:
#safety valve
return value
if value == '':
value = None
elif value.isdigit():
# convert to int
value = int(value)
else:
# may be a float
try:
value = float(value)
if column_type in self.integer_types:
value = int(value)
except Exception as e:
mes ="""A problem occurred while attempting to save the record for table {}.
It looks like a non-numeric value ('{}') was entered in the field '{}'.
The information in the record may not be what you expect...
""".format(self.table_name.title(),value,field_name)
if not get_site_config()['TESTING']:
flash(mes)
self.alert_admin(printException(mes,err=e))
return value
def test_local_datetime_now():
site_config = get_site_config()
#site_config['TIME_ZONE'] = 'US/Pacific'
now = datetime.now()
local_now = dates.local_datetime_now()
assert now.day == local_now.day
assert now.hour == local_now.hour
assert now.month == local_now.month
assert local_now.tzinfo is not None
assert local_now.tzinfo.zone == site_config["TIME_ZONE"]
# spcecify a time zone
zone = "US/Eastern"
east_now = dates.local_datetime_now(zone)
assert east_now.tzinfo is not None
assert east_now.tzinfo.zone == zone
def printException(mes="An Unknown Error Occurred", level="error", err=None):
"""Generate an error message, write it to the log and return the resulting
text.
mes: Some message text specific to the supposed cause of the error.
level: Any of 'error', 'info', 'debug'
When logging or in debug mode attempts to generate a description of the error
location.
"""
from shotglass2.shotglass import get_site_config
from app import app
site_config = get_site_config()
level = level.lower()
exc_type, exc_obj, tb = sys.exc_info()
debugMes = None
if tb is not None:
f = tb.tb_frame
lineno = tb.tb_lineno
filename = f.f_code.co_filename
linecache.checkcache(filename)
line = linecache.getline(filename, lineno, f.f_globals)
try:
debugMes = 'EXCEPTION IN ({}, LINE {} "{}"): {}'.format(
filename, lineno, line.strip(), exc_obj)
except ValueError:
debugMes = "Could not get error location info."
if level == "error" or site_config["DEBUG"]:
if debugMes:
app.logger.error(nowString() + " - " + debugMes)
elif err:
app.logger.error(nowString() + " - Error: " + str(err))
if mes:
app.logger.error(nowString() + " - " + mes)
if site_config["DEBUG"]:
if debugMes:
mes = mes + " -- " + debugMes
return mes
else:
return mes
def handle_request_error(error=None, request=None):
"""Usually used to handle a basic request error such as a db error"""
from shotglass2.takeabeltof.mailer import alert_admin
from shotglass2.shotglass import get_site_config
site_config = get_site_config()
#import pdb; pdb.set_trace()
mes = "An unknown error occured"
level = "error"
request_url = "No URL supplied"
if request and hasattr(request, 'url'):
request_url = request.url
try:
if error:
if hasattr(error, 'code'):
mes = 'The following error was reported from {}. Request status: {} '.format(
site_config['SITE_NAME'], error.code)
if request:
mes += ' - Request URL: {}'.format(request_url)
level = 'info' if error.code == 404 else "error"
if (error.code == 404 and
site_config['REPORT_404_ERRORS']) or error.code != 404:
if request and 'apple-touch-icon' not in request_url and 'favicon' not in request_url:
alert_admin(
"Request error [{}] at {}".format(
error.code, site_config['HOST_NAME']), mes)
printException(mes, level=level, err=error)
else:
temp_mes = str(error)
mes = printException(
"The following error occured: {} during request for {}".
format(temp_mes, request_url),
level=level,
err=error)
alert_admin(
"System error from {}".format(site_config['SITE_NAME']),
mes)
else:
mes = "Error message not provided"
except Exception as e:
alert_admin(
printException("An error was encountered in handle_request_error.",
err=e))
return mes # just to make it testable
def is_admin(self, user):
"""Return True if user (name or id) is an admin"""
from shotglass2.shotglass import get_site_config
rec = self.get(user)
if not rec:
return False
admin_roles = get_site_config().get('ADMIN_ROLES', [
'super',
'admin',
])
user_roles = self.get_roles(rec.id)
if user_roles:
for role in user_roles:
if role.name in admin_roles:
return True
return False
def getPasswordHash(pw, theSalt=None, timesAround='05',encoding='utf-8'):
"""Return a string hash of the password or None"""
from shotglass2.shotglass import get_site_config
if type(pw) is str:
pw = pw.strip()
if pw == "":
return None
if not theSalt:
theSalt = getPasswordSalt()
codeWord = str(pw) + theSalt
for i in range(int(timesAround) * 1000):
codeWord = hmac.new(bytearray(get_site_config()['SECRET_KEY'].encode(encoding)), str(codeWord).encode(encoding), hashlib.sha256).hexdigest()
return theSalt +'.'+timesAround+'.'+codeWord
return None
def get_credentials(self):
"""
Load the API credentials and return the service discovery object instance
Args: None
Returns: googleapiclient.discovery instance
Raises:
MailSettingsError
"""
site_config = get_site_config()
# TOKEN_FILE_PATH = site_config.get('MAIL_TOKEN_PATH','')
creds = None
# the file token.pickle stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first time
# set_trace()
try:
with open(self.token_file_path, "rb") as token:
creds = pickle.load(token)
except FileNotFoundError:
raise MailSettingsError("Gmail API token file not found.")
# if there are no (valid) credentials availablle stop here.
if not creds:
raise MailSettingsError("Gmail API credentials are missing.")
if site_config.get('TESTING', False):
return creds
if creds.expired: # and creds.refresh_token:
creds.refresh(Request())
# save the credentials for the next run
with open(self.token_file_path, "wb") as token:
pickle.dump(creds, token)
try:
return build('gmail', 'v1', credentials=creds)
except Exception as e:
raise MailSettingsError(
"Gmail API could not build a connection. Err: {}".format(
str(e)))
def get_db(filespec=None):
"""Return a connection to the database.
If the db path does not exist, create it and initialize the db"""
if not filespec:
filespec = shotglass.get_site_config()['DATABASE_PATH']
# This is probobly a good place to change the
# filespec if you want to use a different database
# for the current request.
# test the path, if not found, create it
initialize = shotglass.make_db_path(filespec)
g.db = Database(filespec).connect()
if initialize:
initalize_all_tables(g.db)
return g.db
def get_db(filespec=None):
"""Return a connection to the database.
If the db path does not exist, create it and initialize the db"""
if not filespec:
filespec = shotglass.get_site_config()['DATABASE_PATH']
# This is probobly a good place to change the
# filespec if you want to use a different database
# for the current request.
# test the path, if not found, try to create it
if shotglass.make_db_path(filespec):
g.db = Database(filespec).connect()
initalize_all_tables(g.db)
return g.db
else:
# was unable to create a path to the database
raise IOError(
"Unable to create path to () in app.get_db".format(filespec))
def email_admin(subject=None, message=None):
"""
Shortcut method to send a quick email to the admin
"""
try:
site_config = get_site_config()
if not subject:
subject = "An alert was sent from {}".format(
site_config['SITE_NAME'])
if not message:
message = "An alert was sent from {} with no message...".format(
site_config['SITE_NAME'])
return send_message(
None,
subject=subject,
body=message,
)
except Exception as e:
mes = "Not able to send message to admin."
printException(mes, err=e)
return (False, mes)
def contact():
setExits()
g.title = 'Contact Us'
from shotglass2.shotglass import get_site_config
from shotglass2.takeabeltof.mailer import send_message
rendered_html = render_markdown_for('contact.md',mod)
show_form = True
context = {}
success = True
bcc=None
passed_quiz = False
site_config = get_site_config()
mes = "No errors yet..."
if request.form:
#import pdb;pdb.set_trace()
quiz_answer = request.form.get('quiz_answer',"A")
if quiz_answer.upper() == "C":
passed_quiz = True
else:
flash("You did not answer the quiz correctly.")
if request.form['email'] and request.form['comment'] and passed_quiz:
context.update({'date':datetime_as_string()})
for key, value in request.form.items():
context.update({key:value})
# get best contact email
to = []
# See if the contact info is in Prefs
try:
from shotglass2.users.views.pref import get_contact_email
contact_to = get_contact_email()
if contact_to:
to.append(contact_to)
except Exception as e:
printException("Need to update home.contact to find contacts in prefs.","error",e)
try:
if not to:
to = [(site_config['CONTACT_NAME'],site_config['CONTACT_EMAIL_ADDR'],),]
if site_config['CC_ADMIN_ON_CONTACT'] and site_config['ADMIN_EMAILS']:
bcc = site_config['ADMIN_EMAILS']
except KeyError as e:
mes = "Could not get email addresses."
mes = printException(mes,"error",e)
if to:
#we have at least a to address, so continue
pass
else:
success = False
if success:
# Ok so far... Try to send
success, mes = send_message(
to,
subject = "Contact from {}".format(site_config['SITE_NAME']),
html_template = "home/email/contact_email.html",
context = context,
reply_to = request.form['email'],
bcc=bcc,
)
show_form = False
else:
context = request.form
flash('You left some stuff out.')
if success:
return render_template('contact.html',rendered_html=rendered_html, show_form=show_form, context=context,passed_quiz=passed_quiz)
handle_request_error(mes,request,500)
flash(mes)
return render_template('500.html'), 500
import sys
sys.path.append('') ##get import to look in the working dir
import datetime
from .rfeed.rfeed import *
has_local_date = False
author_name = "Unknown Jerome"
site_link = "http://www.example.com/rss"
## I Expect to use this from within a shotglass site
try:
from shotglass2.shotglass import get_site_config
from shotglass2.takeabeltof.date_utils import local_datetime_now
has_local_date = True
site_config = get_site_config()
author_name = site_config['SITE_NAME']
site_link = 'http://' + site_config['HOST_NAME']
except ImportError:
print('no shotglass package')
class FeedMe():
"""Setup the channel parmeters for the news feed prior to adding items
params:
title | <str>: Title for the feed
link | <str>: a link to the host ('http://example.com/'). Defaults to the
site_settings 'HOST_NAME' if available.
description | <str>: (optional) description of the feed
def _before():
# Force all connections to be secure
if app.config['REQUIRE_SSL'] and not request.is_secure:
return redirect(request.url.replace("http://", "https://"))
#ensure that nothing is served from the instance directory
if 'instance' in request.url:
return abort(404)
# import pdb;pdb.set_trace()
# print(app.url_map)
session.permanent = True
shotglass.get_site_config(app)
shotglass.set_template_dirs(app)
get_db()
# Is the user signed in?
g.user = None
if 'user' in session:
g.user = session['user']
# g.menu_items should be a list of dicts
# with keys of 'title' & 'url' used to construct
# the non-table based items in the main menu
g.menu_items = [
{
'title': 'Home',
'url': url_for('www.home')
},
{
'title': 'About',
'url': url_for('www.about')
},
{
'title': 'Contact Us',
'url': url_for('www.contact')
},
]
# g.admin items are added to the navigation menu by default
g.admin = Admin(g.db) # This is where user access rules are stored
# # Add a module to the menu
g.admin.register(
Event,
url_for('event.display'),
display_name='Events',
top_level=True,
minimum_rank_required=500,
)
g.admin.register(
Location,
url_for('location.display'),
display_name='Locations',
top_level=True,
minimum_rank_required=500,
)
# This one will set up the view log item
g.admin.register(
User,
url_for('tools.view_log'),
display_name='View Log',
top_level=True,
minimum_rank_required=500,
)
shotglass.user_setup(
) # g.admin now holds access rules Users, Prefs and Roles
def inject_site_config():
# Add 'site_config' dict to template context
return {'site_config': shotglass.get_site_config()}
def inform_admin_of_registration(rec):
site_config = get_site_config()
to = [(site_config['MAIL_DEFAULT_SENDER'],
site_config['MAIL_DEFAULT_ADDR'])]
#Add User List administrators
reply_to = to.copy()[0]
user_admin = Pref(g.db).get(
"New Account Admins",
user_name=site_config.get("HOST_NAME"),
default=site_config['MAIL_DEFAULT_ADDR'],
description=
"Admin for New User registrations. May use a comma separated list.",
)
to.append((user_admin.name, user_admin.value))
deleteURL = "{}://{}{}?delete={}".format(
site_config['HOST_PROTOCOL'],
site_config['HOST_NAME'],
g.deleteURL,
rec.access_token,
)
editURL = "{}://{}{}{}".format(
site_config['HOST_PROTOCOL'],
site_config['HOST_NAME'],
url_for('.edit'),
rec.id,
)
confirmURL = "{}://{}{}?activate={}".format(
site_config['HOST_PROTOCOL'],
site_config['HOST_NAME'],
url_for('.activate'),
rec.access_token,
)
context = {
'rec':
rec,
'deleteURL':
deleteURL,
'editURL':
editURL,
'registration_exp':
datetime.fromtimestamp(
rec.access_token_expires).strftime('%Y-%m-%d %H:%M:%S'),
'confirmURL':
confirmURL,
}
subject = 'Unconfirmed Account Request from - {}'.format(
site_config['SITE_NAME'])
if site_config.get('AUTOMATICALLY_ACTIVATE_NEW_USERS', False):
subject = 'New Account Auto Activated - {}'.format(
site_config['SITE_NAME'])
del context['confirmURL']
html_template = 'email/admin_activate_acct.html'
text_template = None
send_message(to,
context=context,
reply_to=reply_to,
subject=subject,
html_template=html_template,
text_template=text_template)
def register():
"""Allow people to sign up thier own accounts on the web site"""
setExits()
site_config = get_site_config()
g.title = "Account Registration"
g.editURL = url_for('.register')
g.listURL = '/' # incase user cancels
user = User(g.db)
rec = user.new()
is_admin = False
user_roles = None
roles = None
no_delete = True
success = True
help = render_markdown_for("new_account_help.md", mod)
next = request.form.get('next', request.args.get('next', ''))
# import pdb;pdb.set_trace()
if 'confirm' in request.args:
#Try to find the user record that requested registration
rec = user.select_one(where='access_token = "{}"'.format(
request.args.get('confirm', '')).strip())
if rec and rec.access_token_expires > time():
if site_config.get('ACTIVATE_USER_ON_CONFIRMATION', False):
rec.active = 1
user.save(rec, commit=True)
# log the user in
setUserStatus(rec.email, rec.id)
if rec.active == 1:
success = "active"
else:
success = "waiting"
#inform the admins
inform_admin_of_registration(rec)
return render_template('registration_success.html',
success=success,
next=next)
else:
flash("That registration request has expired")
return redirect('/')
if request.form:
#update the record
user.update(rec, request.form)
if validForm(rec):
rec.active = 0 # Self registered accounts are inactive by default
set_password_from_form(rec)
set_username_from_form(rec)
rec.access_token = get_access_token()
rec.access_token_expires = time() + (3600 * 48)
if site_config.get('AUTOMATICALLY_ACTIVATE_NEW_USERS', False):
rec.active = 1
success = "active"
try:
user.save(rec)
# give user default roles
for role in site_config.get('DEFAULT_USER_ROLES', ['user']):
User(g.db).add_role(rec.id, role)
g.db.commit()
# log the user in
setUserStatus(rec.email, rec.id)
#inform the admins
inform_admin_of_registration(rec)
#Send confirmation email to user if not already active
full_name = '{} {}'.format(rec.first_name,
rec.last_name).strip()
to = [(full_name, rec.email)]
context = {'rec': rec, 'confirmation_code': rec.access_token}
subject = 'Please confirm your account registration at {}'.format(
site_config['SITE_NAME'])
html_template = 'email/registration_confirm.html'
text_template = 'email/registration_confirm.txt'
if rec.active == 1:
subject = 'Your account is now active at {}'.format(
site_config['SITE_NAME'])
html_template = 'email/activation_complete.html'
text_template = 'email/activation_complete.txt'
send_message(to,
context=context,
subject=subject,
html_template=html_template,
text_template=text_template)
except Exception as e:
g.db.rollback()
mes = "An error occured while new user was attempting to register"
printException(mes, "error", e)
# Send email to the administrator
to = [(site_config['MAIL_DEFAULT_SENDER'],
site_config['MAIL_DEFAULT_ADDR'])]
context = {'mes': mes, 'rec': rec, 'e': str(e)}
body = "Signup Error\n{{context.mes}}\n{{context.e}}\nrec:\n{{context.rec}}"
send_message(to, context=context, body=body, subject=mes)
success = False
return render_template(
'registration_success.html',
success=success,
next=next,
)
return render_template(
'user_edit.html',
rec=rec,
no_delete=no_delete,
is_admin=is_admin,
next=next,
)