Yes you have to when cloning with git, if you don't pyDAL module don't get
clone/fresh... You can confirm that, which version of pyDAL you run on, by
looking in gluon/packages/dal/pydal/init.py

You should have 16.03

Richard

On Thu, Jun 16, 2016 at 12:46 PM, Marty Jones <murtin.jo...@gmail.com>
wrote:

> believe i did clone, but can't remember if i did recursive. should i?
>
> i will get a new start and report back
>
> On Thursday, June 16, 2016 at 12:42:43 PM UTC-4, Richard wrote:
>>
>> I would download and start fresh... How did you get 2.14.5? git clone? If
>> so did you clone --recursive?
>>
>> On Thu, Jun 16, 2016 at 12:41 PM, Richard Vézina <ml.richa...@gmail.com>
>> wrote:
>>
>>> Do they share the same Database, if not it make no sens that auth_user
>>> already exists... Did you modify the welcome app.ini db config? I ask
>>> because web2py use welcome as template for new app...
>>>
>>> On Thu, Jun 16, 2016 at 12:36 PM, Marty Jones <murtin...@gmail.com>
>>> wrote:
>>>
>>>> The reason I suspect a non-application-specific issue is that creating
>>>> a new simple app from the web2py admin console results in a similar
>>>> database issue. Visiting the default/index of the new app spits back:
>>>>
>>>> Traceback (most recent call last):
>>>>   File "/home/murtyjones/app/gluon/restricted.py", line 227, in restricted
>>>>     exec ccode in environment
>>>>   File "/home/murtyjones/app/applications/test_users/models/db.py" 
>>>> <https://nolabills.com/admin/default/edit/test_users/models/db.py>, line 
>>>> 93, in <module>
>>>>     auth.define_tables(username=False, signature=False)
>>>>   File "/home/murtyjones/app/gluon/tools.py", line 2376, in define_tables
>>>>     format='%(first_name)s %(last_name)s (%(id)s)'))
>>>>   File "/home/murtyjones/app/gluon/packages/dal/pydal/base.py", line 576, 
>>>> in define_table
>>>>     table = self.lazy_define_table(tablename,*fields,**args)
>>>>   File "/home/murtyjones/app/gluon/packages/dal/pydal/base.py", line 615, 
>>>> in lazy_define_table
>>>>     polymodel=polymodel)
>>>>   File "/home/murtyjones/app/gluon/packages/dal/pydal/adapters/base.py", 
>>>> line 768, in create_table
>>>>     return self.migrator.create_table(*args, **kwargs)
>>>>   File "/home/murtyjones/app/gluon/packages/dal/pydal/migrator.py", line 
>>>> 269, in create_table
>>>>     self.adapter.create_sequence_and_triggers(query, table)
>>>>   File "/home/murtyjones/app/gluon/packages/dal/pydal/adapters/base.py", 
>>>> line 820, in create_sequence_and_triggers
>>>>     self.execute(query)
>>>>   File 
>>>> "/home/murtyjones/app/gluon/packages/dal/pydal/adapters/__init__.py", line 
>>>> 68, in wrap
>>>>     return f(*args, **kwargs)
>>>>   File "/home/murtyjones/app/gluon/packages/dal/pydal/adapters/base.py", 
>>>> line 417, in execute
>>>>     rv = self.cursor.execute(command, *args[1:], **kwargs)
>>>> OperationalError: table auth_user already exists
>>>>
>>>>
>>>>
>>>>
>>>> On Thursday, June 16, 2016 at 12:28:35 PM UTC-4, Richard wrote:
>>>>>
>>>>> There shouldn't be issue specific to SQLite (I mean it should work
>>>>> properly), though there is maybe a specific unnoticed issue with it as
>>>>> there has been a big refactoring of pyDAL, I don't recall it the 
>>>>> refactored
>>>>> pyDAL was present in 2.14.5
>>>>>
>>>>>
>>>>>
>>>>> On Thu, Jun 16, 2016 at 12:22 PM, Marty Jones <murtin...@gmail.com>
>>>>> wrote:
>>>>>
>>>>>> Done - no change.
>>>>>>
>>>>>> Is it possible that the issue is SQLite specific and I need to
>>>>>> migrate to MySQL or some other db?
>>>>>>
>>>>>> On Thursday, June 16, 2016 at 12:14:51 PM UTC-4, Richard wrote:
>>>>>>>
>>>>>>> Can you comment out the part of the scheduler, the db lock file may
>>>>>>> come from there...
>>>>>>>
>>>>>>> On Thu, Jun 16, 2016 at 12:05 PM, Marty Jones <murtin...@gmail.com>
>>>>>>> wrote:
>>>>>>>
>>>>>>>> Controller logic is below. Error 1 is occuring under the
>>>>>>>> "dashboard" function. Errors 2/3 under the user function.
>>>>>>>>
>>>>>>>> # -*- coding: utf-8 -*-
>>>>>>>> # this file is released under public domain and you can use without
>>>>>>>> limitations
>>>>>>>>
>>>>>>>>
>>>>>>>> ###############################################################################
>>>>>>>> ## Launch with all settings via "sudo python run_server.py"
>>>>>>>>
>>>>>>>> ###############################################################################
>>>>>>>>
>>>>>>>> import operator # needed for manager_status variable
>>>>>>>>
>>>>>>>> response.title = 'nolabills'
>>>>>>>>
>>>>>>>> def jspage():
>>>>>>>>     link = URL('static', 'main.js')
>>>>>>>>     return dict(link=link)
>>>>>>>>
>>>>>>>> def index():
>>>>>>>>     """
>>>>>>>>     For registered users, redirects to the requests page
>>>>>>>>     For unregistered users, displays intro message
>>>>>>>>     """
>>>>>>>>
>>>>>>>>     signup = URL(a=request.application, c='default',
>>>>>>>> f='user/register')
>>>>>>>>
>>>>>>>>     return dict(is_logged_in=auth.is_logged_in(), signup=signup)
>>>>>>>>
>>>>>>>> @auth.requires_membership('manager')
>>>>>>>> def manage():
>>>>>>>>     """
>>>>>>>>     This page, accessible by only managers, shows the current
>>>>>>>> employees
>>>>>>>>     of a company as well as any users who are registering
>>>>>>>> themselves as
>>>>>>>>     employees of the company.
>>>>>>>>     From this page a manager can approve a pending user's
>>>>>>>> membership,
>>>>>>>>     as well as revoke the membership of a user on the current
>>>>>>>> employee list.
>>>>>>>>     """
>>>>>>>>     pending_list = []
>>>>>>>>     approved_list = []
>>>>>>>>     if request.post_vars:
>>>>>>>>         for each in request.post_vars:
>>>>>>>>             key = request.post_vars.keys()[0]
>>>>>>>>             underscore = key.find('_')
>>>>>>>>             id = key[0:underscore]
>>>>>>>>             change = key[underscore+1:len(key)]
>>>>>>>>             change = None if change == "approve" else "unapproved"
>>>>>>>>             # modify db accordingly
>>>>>>>>             record = db(db.auth_user.id==id).select().first()
>>>>>>>>             record.registration_key=change
>>>>>>>>             record.update_record()
>>>>>>>>
>>>>>>>>     for row in db().select():
>>>>>>>>     #for row in
>>>>>>>> db(db.auth_user.company==auth.user.company).select():
>>>>>>>>         if row.registration_key: # if pending approval by manager
>>>>>>>>             pending_list.append({row.id:
>>>>>>>> {"first":row.first_name,"last":row.last_name}})
>>>>>>>>         else:
>>>>>>>>             manager_status = auth.has_membership('manager', row.id)
>>>>>>>>             approved_list.append({row.id:
>>>>>>>> {"first":row.first_name,"last":row.last_name,"manager_status":manager_status}})
>>>>>>>>     return dict(pending_list=pending_list,
>>>>>>>> approved_list=approved_list)
>>>>>>>>
>>>>>>>> @auth.requires_login()
>>>>>>>> def dashboard():
>>>>>>>>     """
>>>>>>>>     This page allows a user to send an email to
>>>>>>>>     a potential customer, requesting access to bill data
>>>>>>>>     """
>>>>>>>>     i = 0
>>>>>>>>     already_submitted = False # default is false; can only be
>>>>>>>> changed if request.post_vars == True
>>>>>>>>
>>>>>>>>     # SQLFORM version
>>>>>>>>     data_requests =
>>>>>>>> SQLFORM.grid(db(db.data_requests.company==auth.user.company),
>>>>>>>>
>>>>>>>>  fields=[db.data_requests.last_name, \
>>>>>>>>
>>>>>>>>  db.data_requests.first_name, \
>>>>>>>>                                          db.data_requests.email, \
>>>>>>>>                                          db.data_requests.status, \
>>>>>>>>                                          db.data_requests.bill_1,
>>>>>>>>                                          ],
>>>>>>>>
>>>>>>>>  headers={'data_requests.bill_1':'Most Recent Bill'},
>>>>>>>>                                  sortable=False,
>>>>>>>>                                  create=False,
>>>>>>>>                                  editable=False,
>>>>>>>>                                  deletable=True,
>>>>>>>>                                  details=False,
>>>>>>>>                                  maxtextlength=30,
>>>>>>>>                                  csv=False,
>>>>>>>>                                  upload=URL('download'),
>>>>>>>>                                  )
>>>>>>>>
>>>>>>>>     pending_list = db().select(db.data_requests.email)
>>>>>>>>     # if a new request has been made, update the database
>>>>>>>>     if request.post_vars:
>>>>>>>>
>>>>>>>>         while not already_submitted and i <= len(data_requests):
>>>>>>>>             already_submitted = [True for row in pending_list if
>>>>>>>> row.email == request.post_vars.email]
>>>>>>>>             i += 1
>>>>>>>>
>>>>>>>>         from entergy_scraper import download
>>>>>>>>         from mailer import send_request
>>>>>>>>
>>>>>>>>         if not already_submitted:
>>>>>>>>             # generate token
>>>>>>>>             import random, base64, sha
>>>>>>>>             token =
>>>>>>>> base64.b64encode(sha.sha(str(random.random())).hexdigest())[:8]
>>>>>>>>             db.tokens.insert(token = token,
>>>>>>>>                              first_name =
>>>>>>>> request.post_vars.first_name,
>>>>>>>>                              last_name =
>>>>>>>> request.post_vars.last_name,
>>>>>>>>                              email = request.post_vars.email,
>>>>>>>>                              company = auth.user.company,
>>>>>>>>                              )
>>>>>>>>
>>>>>>>>             # send request to user
>>>>>>>>             db.scheduler_task.insert(status = 'QUEUED',
>>>>>>>>                                      application_name =
>>>>>>>> request.application+'/default',
>>>>>>>>                                      task_name = 'request',
>>>>>>>>                                      group_name = 'email',
>>>>>>>>                                      function_name = 'send_request',
>>>>>>>>                                      args = '["{0}", "{1}", "{2}",
>>>>>>>> "{3}"]'.format( \
>>>>>>>>                                          request.post_vars.first,
>>>>>>>> request.post_vars.last, request.post_vars.email, token),
>>>>>>>>                                      vars = '{}',
>>>>>>>>                                      enabled = True,
>>>>>>>>                                      start_time = request.now,
>>>>>>>>                                      timeout = 500, # should take
>>>>>>>> less than 500 secs
>>>>>>>>                                      )
>>>>>>>>             # update data_requests to show that the task is
>>>>>>>> AWAITING_CUSTOMER
>>>>>>>>             db.data_requests.insert(first_name =
>>>>>>>> request.post_vars.first_name,
>>>>>>>>                                     last_name =
>>>>>>>> request.post_vars.last_name,
>>>>>>>>                                     email = request.post_vars.email,
>>>>>>>>                                     company = auth.user.company,
>>>>>>>>                                     status = 'AWAITING_CUSTOMER',
>>>>>>>>                                     )
>>>>>>>>
>>>>>>>>
>>>>>>>>     return dict(already_submitted=already_submitted,
>>>>>>>> data_requests=data_requests, pending_list=pending_list)
>>>>>>>>
>>>>>>>> def approve_request():
>>>>>>>>     """
>>>>>>>>     Allows a customer to approve a data request
>>>>>>>>     """
>>>>>>>>     submitted = 'submitted'
>>>>>>>>     valid_token = 'valid_token'
>>>>>>>>     invalid_token = 'invalid_token'
>>>>>>>>
>>>>>>>>
>>>>>>>>     # if the user has submitted their data and it's not already in
>>>>>>>> the database, let them know we'll get their data
>>>>>>>>     if request.post_vars:
>>>>>>>>         status = submitted
>>>>>>>>
>>>>>>>>         token_submitted = True if db(db.data_requests.email ==
>>>>>>>> request.post_vars.email).select(db.tokens.submitted).first() else False
>>>>>>>>
>>>>>>>>         if token_submitted == False:
>>>>>>>>         # download data
>>>>>>>>             db.data_requests.insert(first_name =
>>>>>>>> request.post_vars.first_name,
>>>>>>>>                                     last_name =
>>>>>>>> request.post_vars.last_name,
>>>>>>>>                                     email = request.post_vars.email,
>>>>>>>>                                     company = auth.user.company,
>>>>>>>>                                     energy_username =
>>>>>>>> request.post_vars.energy_username,
>>>>>>>>                                     energy_password =
>>>>>>>> request.post_vars.energy_password,
>>>>>>>>                                     )
>>>>>>>>
>>>>>>>>     # if no submission of info, try to give them the option to do so
>>>>>>>>     else:
>>>>>>>>         try:
>>>>>>>>             status = valid_token
>>>>>>>>             token = request.get_vars.token
>>>>>>>>             token_row = db(db.tokens.token ==
>>>>>>>> token).select().first()
>>>>>>>>             first_name = token_row.first_name
>>>>>>>>             last_name = token_row.last_name
>>>>>>>>             email = token_row.email
>>>>>>>>         except:
>>>>>>>>             status = invalid_token
>>>>>>>>
>>>>>>>>     if status == submitted or status == invalid_token:
>>>>>>>>         return dict(status=status, submitted=submitted,
>>>>>>>> invalid_token=invalid_token, token_submitted=token_submitted)
>>>>>>>>     else:
>>>>>>>>         return dict(status=status, first_name=first_name,
>>>>>>>> last_name=last_name, email=email, submitted=False, invalid_token=False,
>>>>>>>> token_submitted=False)
>>>>>>>>
>>>>>>>> def user():
>>>>>>>>     """
>>>>>>>>     exposes:
>>>>>>>>     http://..../[app]/default/user/login
>>>>>>>>     http://..../[app]/default/user/logout
>>>>>>>>     http://..../[app]/default/user/register
>>>>>>>>     http://..../[app]/default/user/profile
>>>>>>>>     http://..../[app]/default/user/retrieve_password
>>>>>>>>     http://..../[app]/default/user/change_password
>>>>>>>>     http://..../[app]/default/user/bulk_register
>>>>>>>>     use @auth.requires_login()
>>>>>>>>         @auth.requires_membership('group name')
>>>>>>>>         @auth.requires_permission('read','table name',record_id)
>>>>>>>>     to decorate functions that need access control
>>>>>>>>     also notice there is http://..../[app]/appadmin/manage/auth to
>>>>>>>> allow administrator to manage users
>>>>>>>>     """
>>>>>>>>     return dict(form=auth())
>>>>>>>>
>>>>>>>> @cache.action()
>>>>>>>> def download():
>>>>>>>>     """
>>>>>>>>     allows downloading of uploaded files
>>>>>>>>     http://..../[app]/default/download/[filename]
>>>>>>>>     """
>>>>>>>>     return response.download(request, db)
>>>>>>>>
>>>>>>>> def call():
>>>>>>>>     """
>>>>>>>>     exposes services. for example:
>>>>>>>>     http://..../[app]/default/call/jsonrpc
>>>>>>>>     decorate with @services.jsonrpc the functions to expose
>>>>>>>>     supports xml, json, xmlrpc, jsonrpc, amfrpc, rss, csv
>>>>>>>>     """
>>>>>>>>     return service()
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> On Thursday, June 16, 2016 at 9:36:18 AM UTC-4, Marty Jones wrote:
>>>>>>>>
>>>>>>>>> I uploaded a local application to my DigitalOcean droplet and have
>>>>>>>>> been having a nightmare of a time with the databases. I get this 
>>>>>>>>> variety of
>>>>>>>>> errors on various pages:
>>>>>>>>>
>>>>>>>>> *Error 1:*
>>>>>>>>>
>>>>>>>>> Traceback (most recent call last):
>>>>>>>>>   File "/home/murtyjones/app/gluon/restricted.py", line 227, in 
>>>>>>>>> restricted
>>>>>>>>>     exec ccode in environment
>>>>>>>>>   File 
>>>>>>>>> "/home/murtyjones/app/applications/nolabills/controllers/default.py" 
>>>>>>>>> <https://nolabills.com/admin/default/edit/nolabills/controllers/default.py>,
>>>>>>>>>  line 230, in <module>
>>>>>>>>>   File "/home/murtyjones/app/gluon/globals.py", line 417, in <lambda>
>>>>>>>>>     self._caller = lambda f: f()
>>>>>>>>>   File "/home/murtyjones/app/gluon/tools.py", line 4241, in f
>>>>>>>>>     return action(*a, **b)
>>>>>>>>>   File 
>>>>>>>>> "/home/murtyjones/app/applications/nolabills/controllers/default.py" 
>>>>>>>>> <https://nolabills.com/admin/default/edit/nolabills/controllers/default.py>,
>>>>>>>>>  line 73, in dashboard
>>>>>>>>>     data_requests = 
>>>>>>>>> SQLFORM.grid(db(db.data_requests.company==auth.user.company),
>>>>>>>>>   File "/home/murtyjones/app/gluon/packages/dal/pydal/objects.py", 
>>>>>>>>> line 91, in __getattr__
>>>>>>>>>     raise AttributeError
>>>>>>>>> AttributeError
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *Error 2 (trying to apply changes as a user to own profile):*
>>>>>>>>>
>>>>>>>>> Traceback (most recent call last):
>>>>>>>>>   File "/home/murtyjones/app/gluon/restricted.py", line 227, in 
>>>>>>>>> restricted
>>>>>>>>>     exec ccode in environment
>>>>>>>>>   File 
>>>>>>>>> "/home/murtyjones/app/applications/nolabills/controllers/default.py" 
>>>>>>>>> <https://nolabills.com/admin/default/edit/nolabills/controllers/default.py>,
>>>>>>>>>  line 230, in <module>
>>>>>>>>>   File "/home/murtyjones/app/gluon/globals.py", line 417, in <lambda>
>>>>>>>>>     self._caller = lambda f: f()
>>>>>>>>>   File 
>>>>>>>>> "/home/murtyjones/app/applications/nolabills/controllers/default.py" 
>>>>>>>>> <https://nolabills.com/admin/default/edit/nolabills/controllers/default.py>,
>>>>>>>>>  line 211, in user
>>>>>>>>>     return dict(form=auth())
>>>>>>>>>   File "/home/murtyjones/app/gluon/tools.py", line 1941, in __call__
>>>>>>>>>     return getattr(self, args[0])()
>>>>>>>>>   File "/home/murtyjones/app/gluon/tools.py", line 4026, in profile
>>>>>>>>>     hideerror=self.settings.hideerror):
>>>>>>>>>   File "/home/murtyjones/app/gluon/sqlhtml.py", line 1744, in accepts
>>>>>>>>>     self.id_field_name]).update(**fields)
>>>>>>>>>   File "/home/murtyjones/app/gluon/packages/dal/pydal/objects.py", 
>>>>>>>>> line 2041, in update
>>>>>>>>>     ret = db._adapter.update("%s" % table._tablename, self.query, 
>>>>>>>>> fields)
>>>>>>>>>   File 
>>>>>>>>> "/home/murtyjones/app/gluon/packages/dal/pydal/adapters/base.py", 
>>>>>>>>> line 519, in update
>>>>>>>>>     raise e
>>>>>>>>> OperationalError: attempt to write a readonly database
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *Error 3 (trying to logout as a user):*
>>>>>>>>>
>>>>>>>>> Traceback (most recent call last):
>>>>>>>>>   File "/home/murtyjones/app/gluon/restricted.py", line 227, in 
>>>>>>>>> restricted
>>>>>>>>>     exec ccode in environment
>>>>>>>>>   File 
>>>>>>>>> "/home/murtyjones/app/applications/nolabills/controllers/default.py" 
>>>>>>>>> <https://nolabills.com/admin/default/edit/nolabills/controllers/default.py>,
>>>>>>>>>  line 230, in <module>
>>>>>>>>>   File "/home/murtyjones/app/gluon/globals.py", line 417, in <lambda>
>>>>>>>>>     self._caller = lambda f: f()
>>>>>>>>>   File 
>>>>>>>>> "/home/murtyjones/app/applications/nolabills/controllers/default.py" 
>>>>>>>>> <https://nolabills.com/admin/default/edit/nolabills/controllers/default.py>,
>>>>>>>>>  line 211, in user
>>>>>>>>>     return dict(form=auth())
>>>>>>>>>   File "/home/murtyjones/app/gluon/tools.py", line 1941, in __call__
>>>>>>>>>     return getattr(self, args[0])()
>>>>>>>>>   File "/home/murtyjones/app/gluon/tools.py", line 3235, in logout
>>>>>>>>>     self.log_event(log, self.user)
>>>>>>>>>   File "/home/murtyjones/app/gluon/tools.py", line 2530, in log_event
>>>>>>>>>     self.table_event().insert(description=str(description % vars), 
>>>>>>>>> origin=origin, user_id=user_id)
>>>>>>>>>   File "/home/murtyjones/app/gluon/packages/dal/pydal/objects.py", 
>>>>>>>>> line 740, in insert
>>>>>>>>>     ret = self._db._adapter.insert(self, self._listify(fields))
>>>>>>>>>   File 
>>>>>>>>> "/home/murtyjones/app/gluon/packages/dal/pydal/adapters/base.py", 
>>>>>>>>> line 482, in insert
>>>>>>>>>     raise e
>>>>>>>>> IntegrityError: FOREIGN KEY constraint failed
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *db.py*
>>>>>>>>> ## app configuration made easy. Look inside private/appconfig.ini
>>>>>>>>> from gluon.contrib.appconfig import AppConfig
>>>>>>>>> ## import current for current.db = db line
>>>>>>>>> from gluon import current
>>>>>>>>>
>>>>>>>>> ## once in production, remove reload=True to gain full speed
>>>>>>>>> myconf = AppConfig(reload=True)
>>>>>>>>>
>>>>>>>>> ## if NOT running on Google App Engine use SQLite or other DB
>>>>>>>>> db = DAL(myconf.take('db.uri'),
>>>>>>>>> pool_size=myconf.take('db.pool_size', cast=int), migrate_enabled =
>>>>>>>>> myconf.get('db.migrate'), check_reserved=['all'])
>>>>>>>>>
>>>>>>>>> ## define current.db for module usage
>>>>>>>>> current.db = db
>>>>>>>>>
>>>>>>>>> ## by default give a view/generic.extension to all actions from
>>>>>>>>> localhost
>>>>>>>>> ## none otherwise. a pattern can be 'controller/function.extension'
>>>>>>>>> response.generic_patterns = ['*'] if request.is_local else []
>>>>>>>>> ## choose a style for forms
>>>>>>>>> response.formstyle = myconf.take('forms.formstyle')  # or
>>>>>>>>> 'bootstrap3_stacked' or 'bootstrap2' or other
>>>>>>>>> response.form_label_separator = myconf.take('forms.separator')
>>>>>>>>>
>>>>>>>>> from gluon.tools import Auth, Service, PluginManager
>>>>>>>>>
>>>>>>>>> auth = Auth(db)
>>>>>>>>> service = Service()
>>>>>>>>> plugins = PluginManager()
>>>>>>>>>
>>>>>>>>> auth.settings.extra_fields['auth_user']= [
>>>>>>>>>   Field('company'),
>>>>>>>>>   ]
>>>>>>>>>
>>>>>>>>> ## create all tables needed by auth if not custom tables
>>>>>>>>> auth.define_tables(username=False, signature=False, migrate=True,
>>>>>>>>> fake_migrate=True)
>>>>>>>>>
>>>>>>>>> ## configure email
>>>>>>>>> mail = auth.settings.mailer
>>>>>>>>> mail.settings.server = 'smtp.gmail.com'
>>>>>>>>> mail.settings.sender = 'em...@gmail.com'
>>>>>>>>> mail.settings.login = 'em...@gmail.com:password'
>>>>>>>>>
>>>>>>>>> ## configure auth policy
>>>>>>>>> auth.settings.registration_requires_verification = True
>>>>>>>>> auth.settings.registration_requires_approval = True
>>>>>>>>> auth.settings.reset_password_requires_verification = True
>>>>>>>>>
>>>>>>>>> ## after defining tables, uncomment below to enable auditing
>>>>>>>>> # auth.enable_record_versioning(db)
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> ## create list of companies for which this is available
>>>>>>>>> db.define_table('company_info',
>>>>>>>>>                 Field('name'),
>>>>>>>>>                 Field('street_address'),
>>>>>>>>>                 )
>>>>>>>>>
>>>>>>>>> ## create a table for the queue of not yet fulfilled data requests
>>>>>>>>> db.define_table('data_requests',
>>>>>>>>>                 Field('first_name'),
>>>>>>>>>                 Field('last_name'),
>>>>>>>>>                 Field('entergy_username'),
>>>>>>>>>                 Field('entergy_password'),
>>>>>>>>>                 Field('email'),
>>>>>>>>>                 Field('company'),
>>>>>>>>>                 Field('status', default='QUEUED'),
>>>>>>>>>                 Field('runs', 'integer', default=0),
>>>>>>>>>                 Field('bill_1', 'upload',
>>>>>>>>> uploadfield='bill_1_file'),
>>>>>>>>>                 Field('bill_1_file', 'blob'),
>>>>>>>>>                 )
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> ## create a table for generating tokens
>>>>>>>>> db.define_table('tokens',
>>>>>>>>>                 Field('first_name'),
>>>>>>>>>                 Field('last_name'),
>>>>>>>>>                 Field('email'),
>>>>>>>>>                 Field('company'),
>>>>>>>>>                 Field('token'),
>>>>>>>>>                 Field('submitted', default=False),
>>>>>>>>>                 )
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *sql.log*
>>>>>>>>> timestamp: 2016-06-15T14:20:52.811948
>>>>>>>>> CREATE TABLE auth_user(
>>>>>>>>>     id INTEGER PRIMARY KEY AUTOINCREMENT,
>>>>>>>>>     first_name CHAR(128),
>>>>>>>>>     last_name CHAR(128),
>>>>>>>>>     email CHAR(512),
>>>>>>>>>     password CHAR(512),
>>>>>>>>>     registration_key CHAR(512),
>>>>>>>>>     reset_password_key CHAR(512),
>>>>>>>>>     registration_id CHAR(512)
>>>>>>>>> );
>>>>>>>>> success!
>>>>>>>>> timestamp: 2016-06-15T14:20:52.856816
>>>>>>>>> CREATE TABLE auth_group(
>>>>>>>>>     id INTEGER PRIMARY KEY AUTOINCREMENT,
>>>>>>>>>     role CHAR(512),
>>>>>>>>>     description TEXT
>>>>>>>>> );
>>>>>>>>> success!
>>>>>>>>> timestamp: 2016-06-15T14:20:52.899975
>>>>>>>>> CREATE TABLE auth_membership(
>>>>>>>>>     id INTEGER PRIMARY KEY AUTOINCREMENT,
>>>>>>>>>     user_id INTEGER REFERENCES auth_user (id) ON DELETE CASCADE  ,
>>>>>>>>>     group_id INTEGER REFERENCES auth_group (id) ON DELETE CASCADE
>>>>>>>>> );
>>>>>>>>> success!
>>>>>>>>> timestamp: 2016-06-15T14:20:53.040386
>>>>>>>>> CREATE TABLE auth_permission(
>>>>>>>>>     id INTEGER PRIMARY KEY AUTOINCREMENT,
>>>>>>>>>     group_id INTEGER REFERENCES auth_group (id) ON DELETE CASCADE
>>>>>>>>>  ,
>>>>>>>>>     name CHAR(512),
>>>>>>>>>     table_name CHAR(512),
>>>>>>>>>     record_id INTEGER
>>>>>>>>> );
>>>>>>>>> success!
>>>>>>>>> timestamp: 2016-06-15T14:20:53.092848
>>>>>>>>> CREATE TABLE auth_event(
>>>>>>>>>     id INTEGER PRIMARY KEY AUTOINCREMENT,
>>>>>>>>>     time_stamp TIMESTAMP,
>>>>>>>>>     client_ip CHAR(512),
>>>>>>>>>     user_id INTEGER REFERENCES auth_user (id) ON DELETE CASCADE  ,
>>>>>>>>>     origin CHAR(512),
>>>>>>>>>     description TEXT
>>>>>>>>> );
>>>>>>>>> success!
>>>>>>>>> timestamp: 2016-06-15T14:20:53.223004
>>>>>>>>> CREATE TABLE auth_cas(
>>>>>>>>>     id INTEGER PRIMARY KEY AUTOINCREMENT,
>>>>>>>>>     user_id INTEGER REFERENCES auth_user (id) ON DELETE CASCADE  ,
>>>>>>>>>     created_on TIMESTAMP,
>>>>>>>>>     service CHAR(512),
>>>>>>>>>     ticket CHAR(512),
>>>>>>>>>     renew CHAR(1)
>>>>>>>>> );
>>>>>>>>> success!
>>>>>>>>> timestamp: 2016-06-15T14:22:53.166163
>>>>>>>>> ALTER TABLE auth_user ADD company CHAR(512);
>>>>>>>>> success!
>>>>>>>>> timestamp: 2016-06-15T14:22:53.554653
>>>>>>>>> CREATE TABLE company_info(
>>>>>>>>>     id INTEGER PRIMARY KEY AUTOINCREMENT,
>>>>>>>>>     name CHAR(512),
>>>>>>>>>     street_address CHAR(512)
>>>>>>>>> );
>>>>>>>>> success!
>>>>>>>>> timestamp: 2016-06-15T14:22:53.604055
>>>>>>>>> CREATE TABLE data_requests(
>>>>>>>>>     id INTEGER PRIMARY KEY AUTOINCREMENT,
>>>>>>>>>     first_name CHAR(512),
>>>>>>>>>     last_name CHAR(512),
>>>>>>>>>     entergy_username CHAR(512),
>>>>>>>>>     entergy_password CHAR(512),
>>>>>>>>>     email CHAR(512),
>>>>>>>>>     company CHAR(512),
>>>>>>>>>     status CHAR(512),
>>>>>>>>>     runs INTEGER,
>>>>>>>>>     bill_1 CHAR(512),
>>>>>>>>>     bill_1_file BLOB
>>>>>>>>> );
>>>>>>>>> success!
>>>>>>>>> timestamp: 2016-06-15T14:22:53.645905
>>>>>>>>> CREATE TABLE tokens(
>>>>>>>>>     id INTEGER PRIMARY KEY AUTOINCREMENT,
>>>>>>>>>     first_name CHAR(512),
>>>>>>>>>     last_name CHAR(512),
>>>>>>>>>     email CHAR(512),
>>>>>>>>>     company CHAR(512),
>>>>>>>>>     token CHAR(512),
>>>>>>>>>     submitted CHAR(512)
>>>>>>>>> );
>>>>>>>>> success!
>>>>>>>>> timestamp: 2016-06-15T14:22:56.435830
>>>>>>>>> CREATE TABLE scheduler_task(
>>>>>>>>>     id INTEGER PRIMARY KEY AUTOINCREMENT,
>>>>>>>>>     application_name CHAR(512),
>>>>>>>>>     task_name CHAR(512),
>>>>>>>>>     group_name CHAR(512),
>>>>>>>>>     status CHAR(512),
>>>>>>>>>     function_name CHAR(512),
>>>>>>>>>     uuid CHAR(255) UNIQUE,
>>>>>>>>>     args TEXT,
>>>>>>>>>     vars TEXT,
>>>>>>>>>     enabled CHAR(1),
>>>>>>>>>     start_time TIMESTAMP,
>>>>>>>>>     next_run_time TIMESTAMP,
>>>>>>>>>     stop_time TIMESTAMP,
>>>>>>>>>     repeats INTEGER,
>>>>>>>>>     retry_failed INTEGER,
>>>>>>>>>     period INTEGER,
>>>>>>>>>     prevent_drift CHAR(1),
>>>>>>>>>     timeout INTEGER,
>>>>>>>>>     sync_output INTEGER,
>>>>>>>>>     times_run INTEGER,
>>>>>>>>>     times_failed INTEGER,
>>>>>>>>>     last_run_time TIMESTAMP,
>>>>>>>>>     assigned_worker_name CHAR(512)
>>>>>>>>> );
>>>>>>>>> success!
>>>>>>>>> timestamp: 2016-06-15T14:22:56.501649
>>>>>>>>> CREATE TABLE scheduler_run(
>>>>>>>>>     id INTEGER PRIMARY KEY AUTOINCREMENT,
>>>>>>>>>     task_id INTEGER REFERENCES scheduler_task (id) ON DELETE
>>>>>>>>> CASCADE  ,
>>>>>>>>>     status CHAR(512),
>>>>>>>>>     start_time TIMESTAMP,
>>>>>>>>>     stop_time TIMESTAMP,
>>>>>>>>>     run_output TEXT,
>>>>>>>>>     run_result TEXT,
>>>>>>>>>     traceback TEXT,
>>>>>>>>>     worker_name CHAR(512)
>>>>>>>>> );
>>>>>>>>> success!
>>>>>>>>> timestamp: 2016-06-15T14:22:56.546304
>>>>>>>>> CREATE TABLE scheduler_worker(
>>>>>>>>>     id INTEGER PRIMARY KEY AUTOINCREMENT,
>>>>>>>>>     worker_name CHAR(255) UNIQUE,
>>>>>>>>>     first_heartbeat TIMESTAMP,
>>>>>>>>>     last_heartbeat TIMESTAMP,
>>>>>>>>>     status CHAR(512),
>>>>>>>>>     is_ticker CHAR(1),
>>>>>>>>>     group_names TEXT,
>>>>>>>>>     worker_stats TEXT
>>>>>>>>> );
>>>>>>>>> success!
>>>>>>>>> timestamp: 2016-06-15T14:22:56.589493
>>>>>>>>> CREATE TABLE scheduler_task_deps(
>>>>>>>>>     id INTEGER PRIMARY KEY AUTOINCREMENT,
>>>>>>>>>     job_name CHAR(512),
>>>>>>>>>     task_parent INTEGER,
>>>>>>>>>     task_child INTEGER REFERENCES scheduler_task (id) ON DELETE
>>>>>>>>> CASCADE  ,
>>>>>>>>>     can_visit CHAR(1)
>>>>>>>>> );
>>>>>>>>> success!
>>>>>>>>>
>>>>>>>>> No idea where to even start with this and would appreciate help.
>>>>>>>>>
>>>>>>>>> --
>>>>>>>> Resources:
>>>>>>>> - http://web2py.com
>>>>>>>> - http://web2py.com/book (Documentation)
>>>>>>>> - http://github.com/web2py/web2py (Source code)
>>>>>>>> - https://code.google.com/p/web2py/issues/list (Report Issues)
>>>>>>>> ---
>>>>>>>> You received this message because you are subscribed to the Google
>>>>>>>> Groups "web2py-users" group.
>>>>>>>> To unsubscribe from this group and stop receiving emails from it,
>>>>>>>> send an email to web2py+un...@googlegroups.com.
>>>>>>>> For more options, visit https://groups.google.com/d/optout.
>>>>>>>>
>>>>>>>
>>>>>>> --
>>>>>> Resources:
>>>>>> - http://web2py.com
>>>>>> - http://web2py.com/book (Documentation)
>>>>>> - http://github.com/web2py/web2py (Source code)
>>>>>> - https://code.google.com/p/web2py/issues/list (Report Issues)
>>>>>> ---
>>>>>> You received this message because you are subscribed to the Google
>>>>>> Groups "web2py-users" group.
>>>>>> To unsubscribe from this group and stop receiving emails from it,
>>>>>> send an email to web2py+un...@googlegroups.com.
>>>>>> For more options, visit https://groups.google.com/d/optout.
>>>>>>
>>>>>
>>>>> --
>>>> Resources:
>>>> - http://web2py.com
>>>> - http://web2py.com/book (Documentation)
>>>> - http://github.com/web2py/web2py (Source code)
>>>> - https://code.google.com/p/web2py/issues/list (Report Issues)
>>>> ---
>>>> You received this message because you are subscribed to the Google
>>>> Groups "web2py-users" group.
>>>> To unsubscribe from this group and stop receiving emails from it, send
>>>> an email to web2py+un...@googlegroups.com.
>>>> For more options, visit https://groups.google.com/d/optout.
>>>>
>>>
>>>
>> --
> Resources:
> - http://web2py.com
> - http://web2py.com/book (Documentation)
> - http://github.com/web2py/web2py (Source code)
> - https://code.google.com/p/web2py/issues/list (Report Issues)
> ---
> You received this message because you are subscribed to the Google Groups
> "web2py-users" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to web2py+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>

-- 
Resources:
- http://web2py.com
- http://web2py.com/book (Documentation)
- http://github.com/web2py/web2py (Source code)
- https://code.google.com/p/web2py/issues/list (Report Issues)
--- 
You received this message because you are subscribed to the Google Groups 
"web2py-users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to web2py+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to