def create_roles_if_not_exists():
# create instance directory
if not os.path.exists("instance"):
os.makedirs("instance")
db.create_all()
super_user_role_exists = False
reader_role_exists = False
super_user_exists = False
roles = models.Role.query.all()
super_user_role = None
for role in roles:
if role.name == "superuser":
super_user_role_exists = True
super_user_role = role
if role.name == "readonly":
reader_role_exists = True
if not super_user_role_exists:
super_user_role = models.Role(name="superuser")
db.session.add(super_user_role)
db.session.commit()
print("Added superuser role")
if not reader_role_exists:
reader_role = models.Role(name="readonly")
db.session.add(reader_role)
db.session.commit()
print("Added readonly role")
# Check if super user exists
users = models.User.query.all()
for user in users:
if super_user_role in user.roles:
super_user_exists = True
break
# Create super user if not
if not super_user_exists:
if "DEFAULT_SUPER_USER_MAIL" not in app.config:
raise RuntimeError(
"ERROR: Can't create default superuser. "
"DEFAULT_SUPER_USER_MAIL is not defined in config")
if "DEFAULT_SUPER_USER_PASSWORD" not in app.config:
raise RuntimeError(
"ERROR: Can't create default superuser. "
"DEFAULT_SUPER_USER_PASSWORD is not defined in config")
super_user = user_datastore.create_user(
email=app.config["DEFAULT_SUPER_USER_MAIL"],
password=app.config["DEFAULT_SUPER_USER_PASSWORD"],
roles=[super_user_role])
db.session.commit()
print("Added default superuser!")
def add_entry():
"""Adds new post to the database."""
if not session.get("logged_in"):
abort(401)
# POSSIBLE ISSUES
# 1. numeric values (assignment_id, career_level_from, career_level_to, candidates)
# 2. date formats yyyy-mm-dd (created_date, requested_start_date, end_date)
# 3. boolean formats (sold (Yes/No), gcp_preference (Y/N), client_contract_based (Yes/No))
new_entry = models.Role(int(request.form["assignment_id"]), request.form["demand_type"], \
request.form["career_track"], request.form["location_radius"], request.form["source_location"], \
request.form["gu"], request.form["assignment_fulfillment_entity"], request.form["client"], \
request.form["project"], request.form["project_metro_city"], request.form["project_supervising_entity"], \
request.form["project_client_supply_demand_specialist"], request.form["sold"] == "Yes", \
request.form["gcp_preference"] == "Y", request.form["client_contract_based"] == "Yes", \
request.form["assignment_title"], request.form["description"], request.form["fulfillment_channel"], \
request.form["created_date"], request.form["source"], request.form["requested_start_date"], \
request.form["end_date"], request.form["status"], int(request.form["career_level_from"]), \
int(request.form["career_level_to"]), request.form["talent_segment"], request.form["assigned_role"], \
request.form["work_location"], \
request.form["assignment_primary_specialization_level_one"], \
request.form["assignment_primary_specialization_level_two"], \
request.form["assignment_primary_specialization_level_three"], \
request.form["assignment_primary_specialization_level_four"], \
request.form["assignment_primary_specialization_level_five"], \
request.form["assignment_primary_specialization_paths"], \
request.form["skill_and_proficiency"], request.form["primary_contact"], \
request.form["assignment_audit"], request.form["role_client_supply_demand_specialist"], \
int(request.form["candidates"]))
db.session.add(new_entry)
db.session.commit()
return redirect(url_for("search"))
def create_role(
*,
db: Session = Depends(deps.get_db),
role_create: schemas.RoleCreate,
) -> Any:
"""ADD new Role."""
# ROLE
role = {
"name": role_create.name,
"description": role_create.description,
"order": role_create.order
}
role = models.Role(**role)
db.add(role)
db.flush()
# ROLE_MENU
menus_list = dfs_tree_to_list(role_create.routes)
menus_list = [
models.Role_Menu(**{
"role_id": role.id,
"menu_id": menu_id
}) for menu_id in menus_list
]
db.bulk_save_objects(menus_list)
return {"code": 20000, "data": {"id": role.id}}
def item_seed():
"""Seed the database."""
stream = io.open('items.yaml', 'r')
items_to_seed = yaml.safe_load(stream)
for item_name in items_to_seed['items']:
existing_item = models.Item().query.filter_by(name=item_name).first()
if not existing_item:
item = models.Item(name=item_name)
db.session.add(item)
db.session.commit()
for role_name in ('raider', 'council', 'initiate'):
role = models.Role.query.filter_by(name=role_name).first()
if not role:
db.session.add(models.Role(name=role_name))
db.session.commit()
if not models.User.query.filter(models.User.username == 'admin').first():
user1 = models.User(username='******',
email='*****@*****.**',
active=True,
password=user_manager.hash_password('asdf'))
council_role = models.Role.query.filter_by(name='council').first()
user1.roles.append(council_role)
db.session.add(user1)
db.session.commit()
db.session.commit()
def post_role():
name = flask.request.json.get('name')
default = flask.request.json.get('default') or False
permissions = flask.request.json.get('permissions') or 0
if not name:
msg = flask_babel.gettext("Roles are required to have a name.")
return flask.jsonify({'message': msg}), 400
elif len(name) > 64:
msg = flask_babel.gettext(
"Role names can not be longer than 64 characters.")
return flask.jsonify({'message': msg}), 400
if default:
default_exists = models.Role.query.filter_by(default=True).first()
if default_exists:
msg = flask_babel.gettext("A default role already exists.")
return flask.jsonify({'message': msg}), 400
role = models.Role(name=name, default=default, permissions=permissions)
app.db.session.add(role)
app.db.session.commit()
return flask.jsonify(role.__getstate__()), 200
def test_get_role(get_db):
for role in data.roles:
db.session.add(models.Role(**role))
db.session.commit()
r = app.test_client().get('/rest/roles')
assert r.json == data.roles
def create_role(
*,
db: Session = Depends(deps.get_db),
role_in: schemas.RoleCreate,
current_user: models.User = Depends(deps.get_current_active_user),
) -> Any:
"""
Create new Role.
"""
role = {
"key": role_in.key,
"name": role_in.name,
"description": role_in.description,
}
role = models.Role(**role)
db.add(role)
db.flush()
#更新权限菜单 Role_Menu
routes = role_in.routes
db.query(models.Role_Menu).filter(
models.Role_Menu.role_key == role.id).delete()
for route in routes:
role_menu = menus_to_list(route)
for index, menu in enumerate(role_menu):
role_menu = {
"role_id": role.id,
"role_key": role.key,
"menu_id": menu['id']
}
db.add(models.Role_Menu(**role_menu))
db.commit()
return {"code": 20000, "data": {"key": role_in.key}}
def test_remove_role(get_db, add_admin):
db.session.add(models.Role('Teacher'))
db.session.commit()
r = app.test_client().delete('/rest/roles/Teacher',
headers={'X-Api-Key': add_admin})
assert r.status_code == 204
assert data.roles[2] not in app.test_client().get('/rest/roles').json
def roll_add():
form = forms.Role()
if form.validate_on_submit():
role_obj = models.Role(name=form.name.data,
auths='|'.join(form.auths.data))
mysql_db.session.add(role_obj)
mysql_db.session.commit()
return redirect(url_for('admin.roll', page=1))
return render_template('admin/roll_add.html', form=form)
def role_add():
form = RoleForm()
if form.validate_on_submit():
data = form.data
role = app_models.Role(name=data["name"],
auths=",".join(
map(lambda v: str(v), data["auths"])))
db.session.add(role)
db.session.commit()
flash("添加角色成功！", "ok")
return render_template("admin/role_add.html", form=form)
def initial_db():
### Drop All tables
db.reflect()
db.drop_all()
### Clear sessions
session.clear()
session.pop('username', None)
### Create Tables
db.create_all()
### Create Roles
administrative_staff = models.Role(name='IdariPersonel')
teacher = models.Role(name='Ogretmen')
student = models.Role(name='Ogrenci')
db.session.add(administrative_staff)
db.session.add(teacher)
db.session.add(student)
db.session.commit()
### Create Role Funcs
func_create_user = models.RoleFuncs(name='CreateUser', role_id=administrative_staff.id)
func_see_all_user = models.RoleFuncs(name='SeeAllUser', role_id=administrative_staff.id)
db.session.add(func_create_user)
db.session.add(func_see_all_user)
db.session.commit()
func_danisman_ata = models.RoleFuncs(name='AssignCons', role_id=administrative_staff.id)
db.session.add(func_danisman_ata)
db.session.commit()
###################### Create Administrative Staff
new_administrative_staff = create_new_user(
uname="admin",
password="******",
fname= "Mustafa",
mname= "Kemal",
sname= "Ataturk",
email= "*****@*****.**",
role_id=administrative_staff.id
)
return '<a href="/">Ok!</a>'
def startScheduler():
db.create_all()
#create default roles!
if not db.session.query(
models.Role).filter(models.Role.name == "admin").first():
admin_role = models.Role(name='admin',
description='Administrator Role')
user_role = models.Role(name='user', description='User Role')
db.session.add(admin_role)
db.session.add(user_role)
db.session.commit()
try:
import tzlocal
tz = tzlocal.get_localzone()
logger.info("local timezone: %s" % tz)
except:
tz = None
if not tz or tz.zone == "local":
logger.error(
'Local timezone name could not be determined. Scheduler will display times in UTC for any log'
'messages. To resolve this set up /etc/timezone with correct time zone name.'
)
tz = pytz.utc
#in debug mode this is executed twice :(
#DONT run flask in auto reload mode when testing this!
scheduler = BackgroundScheduler(logger=sched_logger, timezone=tz)
scheduler.add_job(notify.task,
'interval',
seconds=config.SCAN_INTERVAL,
max_instances=1,
start_date=datetime.datetime.now(tz) +
datetime.timedelta(seconds=2))
scheduler.start()
sched = scheduler
def user_with_no_permissions():
"""A user that has no permissions"""
fake = Faker()
role_with_no_permissions = models.Role(name=fake.job(), permissions=0)
db.session.add(role_with_no_permissions)
db.session.commit()
user_with_no_permissions = models.User(email=fake.email(),
username=fake.user_name(),
password=fake.password(),
name=fake.name(),
role=role_with_no_permissions)
db.session.add(user_with_no_permissions)
db.session.commit()
return user_with_no_permissions
def admin_roles(sesh):
selected_role = request.args.get('selected_role', default=0, type=int)
""" Forms """
newrole = NewRole()
dnform = DNName()
# Begin POST block
if request.method == 'POST':
if request.form.getlist('delete_role'):
role_id = request.form['delete_role']
role = get_role(sesh, role_id)
role.disabled = True
sesh.add(role)
sesh.commit()
flash("Deleted role {}".format(role.name))
elif dnform.dnname.data:
role = sesh.query(models.Role).filter_by(id=selected_role).first()
role.ldap_group_dn = dnform.dnname.data
sesh.add(role)
sesh.commit()
flash("Role {} ldap DN changed to {}".format(
role.name, role.ldap_group_dn))
elif newrole.newrole.data:
role = models.Role(newrole.newrole.data)
if newrole.ldap_dn.data:
role.ldap_group_dn = newrole.ldap_dn.data
sesh.add(role)
sesh.commit()
flash("Added role {}".format(role.name))
return redirect(url_for('admin_roles'))
# End POST block
# Begin GET block
if request.method == 'GET':
roles = []
for r in sesh.query(models.Role).all():
if not r.disabled:
roles.append(r)
if selected_role:
selected_role_data = sesh.query(
models.Role).filter_by(id=selected_role).first()
dnform.dnname.data = selected_role_data.ldap_group_dn
return render_template('admin_roles.html',
selected_role=selected_role,
roles=roles,
newrole=newrole,
dnform=dnform,
version_number=version_number)
def test_remove_user(get_db):
db.session.add(models.Role(**data.roles[2]))
db.session.add(models.User(**data.users[2]))
db.session.commit()
credentials = base64.b64encode(
bytes(f'{data.users[2]["username"]}:{data.users[2]["password"]}',
encoding='utf-8')).decode('utf-8')
user = app.test_client().get(
'/login', headers={'Authorization': f'Basic {credentials}'})
r = app.test_client().delete(
f'/rest/users/{get_user_id(data.users[2]["username"])}',
headers={'X-Api-Key': user.json['token']})
assert r.status_code == 204
assert models.User.query.filter_by(
username=data.users[2]['username']).first() is None
def post(self):
name = request.form.get('name')
permission_ids = request.form.get('permissions').split(',')
if not name or models.Role.query.filter_by(name=name).first():
abort(400)
r = models.Role(name=name)
db.session.add(r)
for permission_id in permission_ids:
if not models.Permission.query.filter_by(id=permission_id).first():
abort(400)
rp = models.RolePermissons()
rp.permission_id = permission_id
rp.role_id = r.id
db.session.add(rp)
db.session.commit()
return jsonify({'id':r.id,'name':r.name})
def app():
dt_format = '%Y-%m-%dT%H:%M:%S'
app = create_app(is_test=True)
with app.app_context():
db.drop_all()
db.create_all()
user1 = models.User(
id=1,
username='******',
logins=2,
note='primary admin',
created=datetime.strptime('2020-01-01T01:01:00', dt_format),
)
user2 = models.User(
id=2,
username='******',
is_active=False,
logins=100,
note='backup admin',
created=datetime.strptime('2021-01-01T01:01:00', dt_format),
)
user3 = models.User(
id=3,
username='******',
logins=51,
created=datetime.strptime('2021-01-01T06:01:00', dt_format),
supervisor=user1,
)
odduser = models.User(id=4,
username='******',
logins=500,
created=datetime.strptime(
'2021-03-05T07:30:00', dt_format))
admin_role = models.Role(
id=1,
name='admin',
users=[
user1,
user2,
],
)
operator_role = models.Role(
id=2,
name='operator',
users=[
user1,
user3,
],
)
comment1 = models.Comment(
id=1,
user=user1,
body='some text',
created=datetime.strptime('2021-03-05T07:30:00', dt_format),
)
comment2 = models.Comment(
id=2,
user=user1,
body='a response',
created=datetime.strptime('2021-03-06T07:30:00', dt_format),
)
comment3 = models.Comment(
id=3,
user=user1,
body='additional text',
created=datetime.strptime('2021-03-07T07:30:00', dt_format),
)
comment4 = models.Comment(
id=4,
user=user2,
body='keep going',
created=datetime.strptime('2021-03-08T07:30:00', dt_format),
)
comment5 = models.Comment(
id=5,
user=user2,
body='ongoing discussion',
created=datetime.strptime('2021-03-09T07:30:00', dt_format),
)
comment6 = models.Comment(
id=6,
user=user3,
body='talking to myself',
created=datetime.strptime('2021-03-10T07:30:00', dt_format),
)
db.session.add_all([
user1,
user2,
user3,
odduser,
admin_role,
operator_role,
comment1,
comment2,
comment3,
comment4,
comment5,
comment6,
])
db.session.flush()
db.session.commit()
yield app
def run(self):
print("Clearing out all models")
models.Citizen.query.delete()
models.CitizenState.query.delete()
models.Channel.query.delete()
models.Period.query.delete()
models.PeriodState.query.delete()
models.SRState.query.delete()
models.ServiceReq.query.delete()
models.Service.query.filter_by(actual_service_ind=1).delete()
models.Service.query.delete()
models.CSR.query.delete()
models.CSRState.query.delete()
models.Office.query.delete()
models.SmartBoard.query.delete()
models.Role.query.delete()
db.session.commit()
print("Starting to bootstrap data")
smartboard1 = models.SmartBoard(sb_type="nocallbyticket")
smartboard2 = models.SmartBoard(sb_type="callbynumber")
smartboard3 = models.SmartBoard(sb_type="callbyname")
db.session.add(smartboard1)
db.session.add(smartboard2)
db.session.add(smartboard3)
db.session.flush()
office1 = models.Office(
office_name="Summerland",
office_number=1,
sb_id=smartboard2.sb_id
)
office2 = models.Office(
office_name="Victoria",
office_number=2,
sb_id=smartboard2.sb_id
)
office3 = models.Office(
office_name="Vernon",
office_number=3,
sb_id=smartboard2.sb_id
)
office4 = models.Office(
office_name="Test Office",
office_number=4,
sb_id=smartboard2.sb_id
)
db.session.add(office1)
db.session.add(office2)
db.session.add(office3)
db.session.add(office4)
db.session.flush()
category1 = models.Service(
service_code = "abc123",
service_name = "Licenses",
service_desc = "Licenses - this is a description",
prefix = "L",
display_dashboard_ind = 0,
actual_service_ind = 0
)
category2 = models.Service(
service_code = "abc1234",
service_name = "Taxes",
service_desc = "Taxes - this is a description",
prefix = "T",
display_dashboard_ind = 0,
actual_service_ind = 0
)
category3 = models.Service(
service_code = "abc1235",
service_name = "ICBC",
service_desc = "ICBC - this is a description",
prefix = "I",
display_dashboard_ind = 0,
actual_service_ind = 0
)
db.session.add(category1)
db.session.add(category2)
db.session.add(category3)
db.session.flush()
service1 = models.Service(
service_name = "Fishing",
service_desc = "Fishing - this is a description",
parent_id = category1.service_id,
service_code = "abc1236",
prefix = "F",
display_dashboard_ind = 1,
actual_service_ind = 1
)
service2 = models.Service(
service_name = "Hunting",
service_desc = "Hunting - this is a description",
parent_id = category1.service_id,
service_code = "abc1237",
prefix = "G",
display_dashboard_ind = 1,
actual_service_ind = 1
)
service3 = models.Service(
service_name = "Gold Mining",
service_desc = "Gold Mining - this is a description",
parent_id = category1.service_id,
service_code = "abc1238",
prefix = "G",
display_dashboard_ind = 1,
actual_service_ind = 1
)
service4 = models.Service(
service_name = "Property Taxes",
service_desc = "Property Taxes - this is a description",
parent_id = category2.service_id,
service_code = "abc1239",
prefix = "P",
display_dashboard_ind = 1,
actual_service_ind = 1
)
service5 = models.Service(
service_name = "MSP",
service_desc = "MSP - this is a description",
parent_id = category2.service_id,
service_code = "abc12310",
prefix = "M",
display_dashboard_ind = 1,
actual_service_ind = 1
)
service6 = models.Service(
service_name = "Class 5 Test",
service_desc = "Class 5 Test - this is a description",
parent_id = category3.service_id,
service_code = "abc12311",
prefix = "C",
display_dashboard_ind = 1,
actual_service_ind = 1
)
service7 = models.Service(
service_name = "Speeding Ticket",
service_desc = "Speeding Ticket - this is a description",
parent_id = category3.service_id,
service_code = "abc12312",
prefix = "S",
display_dashboard_ind = 1,
actual_service_ind = 1
)
service8 = models.Service(
service_name = "Class 6 Test",
service_desc = "Class 6 Test - this is a description",
parent_id = category3.service_id,
service_code = "abc12313",
prefix = "C",
display_dashboard_ind = 1,
actual_service_ind = 1
)
service9 = models.Service(
service_name = "DUI",
service_desc = "DUI - this is a description",
parent_id = category3.service_id,
service_code = "abc12314",
prefix = "D",
display_dashboard_ind = 1,
actual_service_ind = 1
)
db.session.add(service1)
db.session.add(service2)
db.session.add(service3)
db.session.add(service4)
db.session.add(service5)
db.session.add(service6)
db.session.add(service7)
db.session.add(service8)
db.session.add(service9)
db.session.commit()
office1.services.append(category1)
office1.services.append(category2)
office1.services.append(category3)
office1.services.append(service1)
office1.services.append(service2)
office1.services.append(service3)
office1.services.append(service4)
office1.services.append(service5)
office1.services.append(service6)
office1.services.append(service7)
office1.services.append(service8)
office1.services.append(service9)
office2.services.append(category2)
office2.services.append(category3)
office2.services.append(service4)
office2.services.append(service5)
office2.services.append(service6)
office2.services.append(service7)
office2.services.append(service8)
office2.services.append(service9)
office3.services.append(category1)
office3.services.append(category2)
office3.services.append(service1)
office3.services.append(service2)
office3.services.append(service3)
office3.services.append(service4)
office3.services.append(service5)
office4.services.append(category1)
office4.services.append(category2)
office4.services.append(category3)
office4.services.append(service1)
office4.services.append(service2)
office4.services.append(service3)
office4.services.append(service4)
office4.services.append(service5)
office4.services.append(service6)
office4.services.append(service7)
office4.services.append(service8)
office4.services.append(service9)
sr_state1 = models.SRState(
sr_code="Pending",
sr_state_desc="Service Request is pending."
)
sr_state2 = models.SRState(
sr_code="Active",
sr_state_desc="Service Request is active."
)
sr_state3 = models.SRState(
sr_code="Complete",
sr_state_desc="Service Request is complete."
)
db.session.add(sr_state1)
db.session.add(sr_state2)
db.session.add(sr_state3)
db.session.commit()
period_state1 = models.PeriodState(
ps_name="Waiting",
ps_desc="Waiting in line to see a CSR, after a ticket has been created for them. The time they are in this state is the Citizen Wait Time",
ps_number=1
)
period_state2 = models.PeriodState(
ps_name="Ticket Creation",
ps_desc="A receptionist is creating a service request / ticket for the citizen. This is the first state a citizen will be in. The time they are in this state is the CSR prep time.",
ps_number=2
)
period_state3 = models.PeriodState(
ps_name="Invited",
ps_desc="Has been called from the waiting area to be served. The time they are in this state is the time it takes them to walk from the waiting area, to the CSR, until the CSR starts to serve them.",
ps_number=4
)
period_state4 = models.PeriodState(
ps_name="Being Served",
ps_desc="Is being servbed by a CSR. The time they are in this state is the Service time.",
ps_number=7
)
period_state5 = models.PeriodState(
ps_name="On hold",
ps_desc="Has been placed on hold be a csr. The time they are in this state is the Hold time",
ps_number=11
)
db.session.add(period_state1)
db.session.add(period_state2)
db.session.add(period_state3)
db.session.add(period_state4)
db.session.add(period_state5)
db.session.commit()
role1 = models.Role(
role_code="GA",
role_desc="GA"
)
role2 = models.Role(
role_code="CSR",
role_desc="CSR"
)
db.session.add(role1)
db.session.add(role2)
db.session.commit()
csr_state1 = models.CSRState(
csr_state_name="Logout",
csr_state_desc="Logging out"
)
csr_state2 = models.CSRState(
csr_state_name="Login",
csr_state_desc="Logging in"
)
csr_state3 = models.CSRState(
csr_state_name="Break",
csr_state_desc="Currently on break"
)
csr_state4 = models.CSRState(
csr_state_name="Serving",
csr_state_desc="Serving a citizen"
)
csr_state5 = models.CSRState(
csr_state_name="Back Office",
csr_state_desc="Currently in back office"
)
db.session.add(csr_state1)
db.session.add(csr_state2)
db.session.add(csr_state3)
db.session.add(csr_state4)
db.session.add(csr_state5)
db.session.commit()
adamkroon = models.CSR(
username="******",
office_id=office1.office_id,
role_id=role2.role_id,
qt_xn_csr_ind=1,
receptionist_ind=1,
deleted=None,
csr_state_id=csr_state1.csr_state_id
)
cdmcinto = models.CSR(
username="******",
office_id=office2.office_id,
role_id=role1.role_id,
qt_xn_csr_ind=1,
receptionist_ind=1,
deleted=None,
csr_state_id=csr_state2.csr_state_id
)
kgillani = models.CSR(
username="******",
office_id=office1.office_id,
role_id=role2.role_id,
qt_xn_csr_ind=1,
receptionist_ind=1,
deleted=None,
csr_state_id=csr_state3.csr_state_id
)
scottrumsby = models.CSR(
username="******",
office_id=office4.office_id,
role_id= role1.role_id,
qt_xn_csr_ind=1,
receptionist_ind=1,
deleted=None,
csr_state_id=csr_state4.csr_state_id
)
seanrumsby = models.CSR(
username="******",
office_id=office3.office_id,
role_id=role2.role_id,
qt_xn_csr_ind=1,
receptionist_ind=1,
deleted=None,
csr_state_id=csr_state5.csr_state_id
)
cfms_postman_operator = models.CSR(
username="******",
office_id=office4.office_id,
role_id=role2.role_id,
qt_xn_csr_ind=1,
receptionist_ind=1,
deleted=None,
csr_state_id=csr_state5.csr_state_id
)
cfms_postman_nonoperator = models.CSR(
username="******",
office_id=office4.office_id,
role_id=role2.role_id,
qt_xn_csr_ind=0,
receptionist_ind=1,
deleted=None,
csr_state_id=csr_state5.csr_state_id
)
db.session.add(adamkroon)
db.session.add(cdmcinto)
db.session.add(kgillani)
db.session.add(scottrumsby)
db.session.add(seanrumsby)
db.session.add(cfms_postman_operator)
db.session.add(cfms_postman_nonoperator)
db.session.commit()
cs1 = models.CitizenState(
cs_state_name="Active",
cs_state_desc="Citizen is active"
)
cs2 = models.CitizenState(
cs_state_name="Received Services",
cs_state_desc="Citizen has received services"
)
cs3 = models.CitizenState(
cs_state_name="Left before receiving services",
cs_state_desc="Citizen is now gone"
)
db.session.add(cs1)
db.session.add(cs2)
db.session.add(cs3)
db.session.flush()
channel1 = models.Channel(
channel_name="In Person"
)
channel2 = models.Channel(
channel_name="Telephone"
)
channel3 = models.Channel(
channel_name="Email"
)
db.session.add(channel1)
db.session.add(channel2)
db.session.add(channel3)
db.session.commit()
def start_load(self):
company_names = []
self.logger.info(f"starting load using URL {self.url}")
self.logger.info("rebuilding data database")
rebuild_db(self.db)
self.logger.info('dropping reporting tables')
self.application.reporting_service.delete_all()
self.application.logger.info('loading roles')
for role in dataset['roles']:
self.logger.info(f" |-> loading {role['name']}")
db_role = models.Role.query.filter_by(name=role['name']).first()
if db_role is None:
db_role = models.Role(name=role['name'])
db_role.reset_permissions()
for perm in role['permissions']:
db_role.add_permission(self.perm_vars[perm])
db_role.default = role['default']
self.db.session.add(db_role)
self.db.session.commit()
role['sys_id'] = db_role.id
admin_role = models.Role.query.filter_by(name='Admin').first()
project_manager_role = models.Role.query.filter_by(name='Project Manager').first()
labor_inspector_role = models.Role.query.filter_by(name='Labor Inspector').first()
self.application.logger.info('loading survey response statuses')
models.SurveyResponseStatus.insert_survey_response_statuses()
self.application.logger.info('loading case statuses')
for status in dataset['case_statuses']:
db_status = models.CaseStatus.query.get(status['id'])
if db_status is None:
db_status = models.CaseStatus(
id=status['id'],
name=status['name'],
default=status['default'],
is_final=status['is_final'],
color=status['color']
)
self.db.session.add(db_status)
self.db.session.commit()
self.application.logger.info('loading superadmin')
superadmin = dataset['superadmin']
superuser = models.User(email=superadmin['email'],
username=superadmin['username'],
password=superadmin['password'],
name=superadmin['name'],
role=admin_role)
self.db.session.add(superuser)
self.db.session.commit()
superadmin['sys_id'] = superuser.id
self.application.logger.info('loading system properties')
eps_property = models.EPSProperty(property='default_dashboard_id', value=None)
self.db.session.add(eps_property)
self.db.session.commit()
self.application.logger.info("logging into API")
url = f"{self.url}/auth/login"
request_headers = {'Content-type': 'application/json'}
loc = fake.latlng()
data = {"login": "******", "password": superadmin['password'], "latitude": loc[0], "longitude": loc[1]}
auth_response = make_request(url=url, headers=request_headers, data=data, logger=self.logger,
request_type=RequestType.Post)
access_token = auth_response['access_token']
self.application.logger.info(f" |-> successful login, token = {access_token}")
request_headers = {'Content-type': 'application/json', 'Authorization': f"Bearer {access_token}"}
self.application.logger.info("loading project information")
url = f"{self.url}/project"
data = dataset['project_info']
_ = make_request(url=url, headers=request_headers, data=data, logger=self.logger, request_type=RequestType.Post)
data_dir = os.path.join(os.getcwd(), 'data', 'impaq')
self.application.logger.info("loading surveys")
for survey in dataset['surveys']:
self.application.logger.info(f" |-> loading survey {survey['name']}")
with open(os.path.join(data_dir, survey['file'])) as form_file:
form_data = json.load(form_file)
data = {
"name": form_data['title'],
"structure": form_data
}
url = f'{self.url}/surveys/'
survey_response = make_request(url=url, headers=request_headers, data=data, logger=self.logger,
request_type=RequestType.Post)
survey['sys_id'] = int(survey_response['id'])
self.application.logger.info("creating case definitions")
for case_defn in dataset['case_definitions']:
self.application.logger.info(f" |-> creating case definition {case_defn['name']}")
url = f'{self.url}/case_definitions/'
data = {
'key': case_defn['key'],
'name': case_defn['name'],
'description': case_defn['description'],
'documents': case_defn['documents'],
'custom_fields': case_defn['custom_fields']
}
case_defn_response = make_request(url=url, headers=request_headers, data=data, logger=self.logger,
request_type=RequestType.Post)
case_defn['sys_id'] = case_defn_response['id']
self.application.logger.info(" |-> creating activity definitions")
dataset_surveys = dataset['surveys']
url = f'{self.url}/activity_definitions'
act_defns = []
for act_defn in case_defn['activity_definitions']:
self.application.logger.info(f" |-> creating activity definition {act_defn['name']}")
act_defn_surveys = []
for act_defn_survey_name in act_defn['surveys']:
found_survey_id = [ds['sys_id'] for ds in dataset_surveys if ds['name'] == act_defn_survey_name]
if found_survey_id:
act_defn_surveys += found_survey_id
data = {
'name': act_defn['name'],
'description': act_defn['description'],
'case_definition_id': case_defn['sys_id'],
'surveys': act_defn_surveys
}
act_defn_response = make_request(url=url, headers=request_headers, data=data, logger=self.logger,
request_type=RequestType.Post)
act_defns.append(act_defn_response)
act_defn['sys_id'] = act_defn_response['id']
self.application.logger.info(" |-> adding cases")
for _ in range(random.randint(5, 10)):
company_name = get_unique_name(fake.company, company_names)
company_names.append(company_name)
loc = fake.latlng()
case_name = f"{company_name} Case"
self.application.logger.info(f" |-> adding {case_name}")
url = f"{self.url}/case_definitions/{case_defn['sys_id']}/cases"
# custom fields
custom_fields = []
for custom_field in case_defn_response['custom_fields']:
lat, lng, city, *_ = fake.local_latlng()
if custom_field['name'] in ['Inspection Type', 'Business Sector', 'Region']:
custom_field_value = random.choice(custom_field['selections'])['id']
elif custom_field['name'] == 'Business Name':
custom_field_value = company_name
elif custom_field['name'] == 'Address':
custom_field_value = fake.address()
elif custom_field['name'] == 'City':
custom_field_value = city
elif custom_field['name'] == 'Location (GPS) Latitude':
custom_field_value = lat
elif custom_field['name'] == 'Location (GPS) Longitude':
custom_field_value = lng
elif custom_field['name'] == 'Date Scheduled':
custom_field_value = fake.date_between_dates(date_start=datetime.date(2019, 1, 1))
else:
custom_field_value = None
custom_fields.append({
'name': custom_field['name'],
'field_type': custom_field['field_type'],
'selections': custom_field['selections'],
'validation_rules': custom_field['selections'],
'case_definition_custom_field_id': custom_field['id'],
'custom_section_id': None,
'help_text': custom_field['help_text'],
'sort_order': custom_field['sort_order'],
'value': custom_field_value,
'model_type': 'Case'
})
data = {
"name": case_name,
"description": f"This is the case for {company_name}. {' '.join(fake.paragraphs())}",
"case_definition_id": {case_defn['sys_id']},
"latitude": loc[0],
"longitude": loc[1],
"custom_fields": custom_fields
}
case_response = make_request(url=url, headers=request_headers, data=data, logger=self.logger,
request_type=RequestType.Post)
case_id = case_response['id']
url = f'{self.url}/cases/{case_id}'
data = {
'status_id': random.choice([1, 2, 3, 5])
}
_ = make_request(url=url, headers=request_headers, data=data, logger=self.logger,
request_type=RequestType.Put)
# do activities
activity_names = ['Initial Inspection', 'Re-Inspection #1', 'Re-Inspection #2', 'Re-Inspection #3']
for activity_name in activity_names:
if activity_name == 'Initial Inspection':
act_defn = [a for a in act_defns if a['name'] == 'Scheduled Inspection'][0]
else:
act_defn = [a for a in act_defns if a['name'] == 'Re-Inspection'][0]
self.application.logger.info(f" |-> adding activity {activity_name} for {act_defn['name']}")
url = f'{self.url}/activities'
data = {
"activity_definition_id": act_defn['id'],
"case_id": case_id,
"name": activity_name,
"description": f"This is the {activity_name} for the {case_response['name']} case"
}
activity_response = make_request(url=url, headers=request_headers, data=data, logger=self.logger,
request_type=RequestType.Post)
if case_response['case_definition']['name'] == 'Occupational Safety and Health':
# Occupational Safety and Health Case
# each activity gets on of Occupational Safety and Health Issues and Inspector Conclusions
self.application.logger.info(
" |-> adding response for Occupational Safety and Health Issues")
loc = fake.latlng()
survey_id = [s['sys_id'] for s in dataset['surveys'] if
s['file'] == 'occupational_safety_and_health_issues.json'][0]
survey_record = get_occupational_safety_and_health_issues_record()
url = f"{self.url}/surveys/{survey_id}/responses"
data = {
"survey_id": survey_id,
"structure": survey_record,
"source_type": "Activity",
"case_id": case_id,
"activity_id": activity_response['id'],
"latitude": loc[0],
"longitude": loc[1]
}
_ = make_request(url=url, headers=request_headers, data=data, logger=self.logger,
request_type=RequestType.Post)
self.application.logger.info(" |-> adding response for Inspector Conclusions")
loc = fake.latlng()
survey_id = [s['sys_id'] for s in dataset['surveys'] if
s['file'] == 'inspector_conclusions.json'][0]
survey_record = get_inspector_conclusions_record()
url = f"{self.url}/surveys/{survey_id}/responses"
data = {
"survey_id": survey_id,
"structure": survey_record,
"source_type": "Activity",
"case_id": case_id,
"activity_id": activity_response['id'],
"latitude": loc[0],
"longitude": loc[1]
}
_ = make_request(url=url, headers=request_headers, data=data, logger=self.logger,
request_type=RequestType.Post)
elif case_response['case_definition']['name'] == 'Wage and Hour':
# Wage and Hour
# each activity gets on of Wage and Hour Issues and Inspector Conclusions
self.application.logger.info(
" |-> adding response for Wage and Hour Issues")
loc = fake.latlng()
survey_id = [s['sys_id'] for s in dataset['surveys'] if
s['file'] == 'wage_and_hour_issues.json'][0]
survey_record = get_wage_and_hour_issues_record()
url = f"{self.url}/surveys/{survey_id}/responses"
data = {
"survey_id": survey_id,
"structure": survey_record,
"source_type": "Activity",
"case_id": case_id,
"activity_id": activity_response['id'],
"latitude": loc[0],
"longitude": loc[1]
}
_ = make_request(url=url, headers=request_headers, data=data, logger=self.logger,
request_type=RequestType.Post)
self.application.logger.info(" |-> adding response for Inspector Conclusions")
loc = fake.latlng()
survey_id = [s['sys_id'] for s in dataset['surveys'] if
s['file'] == 'inspector_conclusions.json'][0]
survey_record = get_inspector_conclusions_record()
url = f"{self.url}/surveys/{survey_id}/responses"
data = {
"survey_id": survey_id,
"structure": survey_record,
"source_type": "Activity",
"case_id": case_id,
"activity_id": activity_response['id'],
"latitude": loc[0],
"longitude": loc[1]
}
_ = make_request(url=url, headers=request_headers, data=data, logger=self.logger,
request_type=RequestType.Post)
elif case_response['case_definition']['name'] == 'Workplace Accident':
# Workplace Accident
# each activity gets one Workplace Accidents
self.application.logger.info(" |-> adding response for Workplace Accidents")
loc = fake.latlng()
survey_id = [s['sys_id'] for s in dataset['surveys'] if
s['file'] == 'workplace_accidents.json'][0]
survey_record = get_workplace_accidents_record()
url = f"{self.url}/surveys/{survey_id}/responses"
data = {
"survey_id": survey_id,
"structure": survey_record,
"source_type": "Activity",
"case_id": case_id,
"activity_id": activity_response['id'],
"latitude": loc[0],
"longitude": loc[1]
}
_ = make_request(url=url, headers=request_headers, data=data, logger=self.logger,
request_type=RequestType.Post)
elif case_response['case_definition']['name'] == 'COVID-19 Health Checklist':
# COVID-19 Health Checklist
# each activity gets one COVID-19 Health Checklist
self.application.logger.info(" |-> adding response for COVID-19 Health Checklist")
loc = fake.latlng()
survey_id = [s['sys_id'] for s in dataset['surveys'] if
s['file'] == 'COVID-19_health_checklist.json'][0]
survey_record = get_COVID_19_health_checklist_record()
url = f"{self.url}/surveys/{survey_id}/responses"
data = {
"survey_id": survey_id,
"structure": survey_record,
"source_type": "Activity",
"case_id": case_id,
"activity_id": activity_response['id'],
"latitude": loc[0],
"longitude": loc[1]
}
_ = make_request(url=url, headers=request_headers, data=data, logger=self.logger,
request_type=RequestType.Post)
self.logger.info("loading complete")
# for debugging
# app.debug = True
# toolbar = DebugToolbarExtension(app)
# for login
login = LoginManager(app)
from app import models
# initialize db
db.create_all()
print("--------- DB created ----------")
print(models.Role.query.filter_by(name="Admin").first())
if not models.Role.query.filter_by(name="Admin").first():
print("------------ No Admin Role found ------------")
role_admin = models.Role(name='Admin')
db.session.add(role_admin)
db.session.commit()
if not models.Role.query.filter_by(name="User").first():
print("------------ No User Role found ------------")
role_user = models.Role(name='User')
db.session.add(role_user)
db.session.commit()
if not models.User.query.filter_by(password="******").first():
print("------------ No Admin User found ------------")
role_ = models.Role.query.filter_by(name="Admin").first()
admin_user = models.User(password="******", used=False)
admin_user.roles = [
role_,
]
db.session.add(admin_user)
skt = os.urandom(128)
skt = hashlib.md5(skt).hexdigest()
with open(str(user_config), 'w') as user_config_file:
user_config_file.write(user_config_base %
(sps, sk, skt, server_name, orga_name))
app = create_app()
print('Change to app context')
with app.app_context():
print("Create new database")
db.create_all()
db.session.commit()
import app.models as model
user_data_store = SQLAlchemyUserDatastore(db, model.User, model.Role)
user_role = model.Role(name='user')
super_user_role = model.Role(name='superuser')
db.session.add(user_role)
db.session.add(super_user_role)
db.session.commit()
print('Set the password for the "admin" account')
admin_key = getpass.getpass()
test_user = user_data_store.create_user(first_name='Admin',
email='admin',
password=hash_password(admin_key),
roles=[user_role, super_user_role])
db.session.commit()
print('Finished')
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from flask_user import UserManager
from flask_wtf.csrf import CSRFProtect
app = Flask(__name__, static_url_path='/static')
app._set_static_folder = '/static'
app.config.from_object(Config)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
from app import routes, models
user_manager = UserManager(app, db, models.User)
if not models.User.query.filter(models.User.username == 'member').first():
user = models.User(
username='******',
password=user_manager.hash_password('Password1'),
)
db.session.add(user)
db.session.commit()
# Create '*****@*****.**' user with 'Admin' and 'Agent' roles
if not models.User.query.filter(models.User.username == 'admin').first():
user = models.User(
username='******',
password=user_manager.hash_password('Password1'),
)
user.roles.append(models.Role(name='Admin'))
user.roles.append(models.Role(name='Agent'))
db.session.add(user)
db.session.commit()
completed = models.Status(3, 'completed')
failed = models.Status(4, 'failed')
failedbattr = models.Status(5, 'failed: bad attribute')
sesh.add(new)
sesh.add(inprogress)
sesh.add(completed)
sesh.add(failed)
sesh.add(failedbattr)
sesh.commit()
except:
sesh.rollback()
raise
finally:
sesh.close()
""" Add admin user """
sesh = db.session()
try:
user = models.User('admin', 'admin', 'admin', password='******')
techrole = models.Role('technician')
adminrole = models.Role('admin')
user.roles.append(adminrole)
user.roles.append(techrole)
sesh.add(user)
sesh.commit()
except:
sesh.rollback()
raise
finally:
sesh.close()
print("DB Initialized")
def run(self):
print("Clearing out all models")
models.Period.query.delete()
models.PeriodState.query.delete()
models.ServiceReq.query.delete()
models.SRState.query.delete()
models.Citizen.query.delete()
models.CitizenState.query.delete()
models.CSR.query.delete()
models.CSRState.query.delete()
# models.OfficeService.query.delete() # This needs to be updated.
models.Office.query.delete()
models.SmartBoard.query.delete()
# models.RolePermission.query.delete() # No data in this table yet.
models.Role.query.delete()
# models.Permission.query.delete() # No data in this table yet.
models.Service.query.filter_by(actual_service_ind=1).delete()
models.Service.query.delete()
models.Channel.query.delete()
db.session.commit()
print("Starting to bootstrap data")
#-- Channels --------------------------------------------------------
print("--> Channels")
channel1 = models.Channel(channel_name="In Person")
channel2 = models.Channel(channel_name="Phone")
channel3 = models.Channel(channel_name="Back Office")
channel4 = models.Channel(channel_name="Email/Fax/Mail")
channel5 = models.Channel(channel_name="CATs Assist")
channel6 = models.Channel(channel_name="Mobile Assist")
db.session.add(channel1)
db.session.add(channel2)
db.session.add(channel3)
db.session.add(channel4)
db.session.add(channel5)
db.session.add(channel6)
db.session.commit()
#-- Roles -----------------------------------------------------------
print("--> Roles")
role_csr = models.Role(role_code="CSR",
role_desc="Customer Service Representative")
role_ga = models.Role(role_code="GA", role_desc="Government Agent")
role3 = models.Role(role_code="HELPDESK",
role_desc="Help Desk Functions")
role4 = models.Role(role_code="SUPPORT",
role_desc="All Administrative Functions")
role5 = models.Role(
role_code="ANALYTICS",
role_desc="Analtyics Team to update Services per Office")
db.session.add(role_csr)
db.session.add(role_ga)
db.session.add(role3)
db.session.add(role4)
db.session.add(role5)
db.session.commit()
#-- Period State ----------------------------------------------------
print("--> Period States")
period_state1 = models.PeriodState(
ps_name="Waiting",
ps_desc=
"Waiting in line to see a CSR, after a ticket has been created for them. The time they are in this state is the Citizen Wait Time",
ps_number=1)
period_state2 = models.PeriodState(
ps_name="Ticket Creation",
ps_desc=
"A receptionist is creating a service request / ticket for the citizen. This is the first state a citizen will be in. The time they are in this state is the CSR prep time.",
ps_number=2)
period_state3 = models.PeriodState(
ps_name="Invited",
ps_desc=
"Has been called from the waiting area to be served. The time they are in this state is the time it takes them to walk from the waiting area, to the CSR, until the CSR starts to serve them.",
ps_number=4)
period_state4 = models.PeriodState(
ps_name="Being Served",
ps_desc=
"Is being servbed by a CSR. The time they are in this state is the Service time.",
ps_number=7)
period_state5 = models.PeriodState(
ps_name="On hold",
ps_desc=
"Has been placed on hold be a csr. The time they are in this state is the Hold time",
ps_number=11)
db.session.add(period_state1)
db.session.add(period_state2)
db.session.add(period_state3)
db.session.add(period_state4)
db.session.add(period_state5)
db.session.commit()
#-- Smartboard values -----------------------------------------------
print("--> Smartboard")
smartboard_call_name = models.SmartBoard(sb_type="callbyname")
smartboard_call_ticket = models.SmartBoard(sb_type="callbyticket")
smartboard_no_call = models.SmartBoard(sb_type="nocallonsmartboard")
db.session.add(smartboard_call_name)
db.session.add(smartboard_call_ticket)
db.session.add(smartboard_no_call)
db.session.commit()
#-- Citizen state values --------------------------------------------
print("--> Citizen State")
cs1 = models.CitizenState(
cs_state_name="Active",
cs_state_desc=
"Citizen is active, a ticket is being or has been created for them"
)
cs2 = models.CitizenState(
cs_state_name="Received Services",
cs_state_desc="Citizen left after receiving services")
cs3 = models.CitizenState(
cs_state_name="Left before receiving services",
cs_state_desc=
"Citizen left, after ticket creation, before service was started for them"
)
db.session.add(cs1)
db.session.add(cs2)
db.session.add(cs3)
db.session.commit()
#-- CSR state values --------------------------------------------
print("--> CSR State")
csr_state_logout = models.CSRState(csr_state_name="Logout",
csr_state_desc="Logged out")
csr_state2 = models.CSRState(csr_state_name="Login",
csr_state_desc="Logged in")
csr_state3 = models.CSRState(csr_state_name="Break",
csr_state_desc="Currently on break")
csr_state4 = models.CSRState(csr_state_name="Serving",
csr_state_desc="Serving a citizen")
csr_state5 = models.CSRState(
csr_state_name="Back Office",
csr_state_desc="Currently doing back office work")
db.session.add(csr_state_logout)
db.session.add(csr_state2)
db.session.add(csr_state3)
db.session.add(csr_state4)
db.session.add(csr_state5)
db.session.commit()
#-- Service Request values ------------------------------------------
print("--> Service Request states")
sr_state1 = models.SRState(
sr_code="Pending",
sr_state_desc=
"Service Request is pending, citizen has not started receiving services yet."
)
sr_state2 = models.SRState(
sr_code="Active",
sr_state_desc=
"Service Request is active. A citizen has started being served.")
sr_state3 = models.SRState(
sr_code="Complete",
sr_state_desc=
"The service has been received for this Service Request.")
db.session.add(sr_state1)
db.session.add(sr_state2)
db.session.add(sr_state3)
db.session.commit()
#-- Service Category values -----------------------------------------
print("--> Categories and Services")
category_msp = models.Service(service_code="MSP",
service_name="MSP",
service_desc="Medical Services Plan",
prefix="A",
display_dashboard_ind=0,
actual_service_ind=0)
category_ptax = models.Service(service_code="PTAX",
service_name="Property Tax",
service_desc="Property Tax",
prefix="A",
display_dashboard_ind=0,
actual_service_ind=0)
category_back_office = models.Service(service_code="Back Office",
service_name="Back Office",
service_desc="Back Office",
prefix="B",
display_dashboard_ind=0,
actual_service_ind=0)
db.session.add(category_msp)
db.session.add(category_ptax)
db.session.add(category_back_office)
db.session.commit()
#-- Service values --------------------------------------------------
service_msp6 = models.Service(
service_code="MSP - 006",
service_name="Payment - MSP",
service_desc=
"MSP- SC686, SC1089 -Pay direct payment, employer payment",
parent_id=category_msp.service_id,
prefix="A",
display_dashboard_ind=1,
actual_service_ind=1)
service_ptax4 = models.Service(
service_code="PTAX - 004",
service_name="Other - PTAX",
service_desc=
"PTax/RPT - Providing information, forms, searches, tax clearance certificate, address changes, add new owner, extensions, forfeiture status, tax search, etc.",
parent_id=category_ptax.service_id,
prefix="A",
display_dashboard_ind=1,
actual_service_ind=1)
service_ptax1 = models.Service(
service_code="PTAX - 001",
service_name="Deferment Application",
service_desc=
"PTax/RPT - Process application - new and renewal, post note, etc.",
parent_id=category_ptax.service_id,
prefix="A",
display_dashboard_ind=1,
actual_service_ind=1)
service_ptax2 = models.Service(
service_code="PTAX - 002",
service_name="Deferment Payment",
service_desc="PTax/RPT - Full or Partial deferment account payment",
parent_id=category_ptax.service_id,
prefix="A",
display_dashboard_ind=1,
actual_service_ind=1)
service_msp1 = models.Service(
service_code="MSP - 001",
service_name="Account Enquiry/Update",
service_desc=
"MSP-Address or family changes, personal information updates, general status enquiries, billing information from Biller Direct, immigration documents to HIBC, needs PHN, etc.",
parent_id=category_msp.service_id,
prefix="A",
display_dashboard_ind=1,
actual_service_ind=1)
service_msp2 = models.Service(
service_code="MSP - 002",
service_name="BCSC Non Photo",
service_desc=
"MSP- SC2607 RAPID ordering , status enquiry, address update, also for the non photo form process when photo eligible, etc.",
parent_id=category_msp.service_id,
prefix="A",
display_dashboard_ind=1,
actual_service_ind=1)
service_bo1 = models.Service(service_code="Back Office - 001",
service_name="Batching",
service_desc="Batching",
parent_id=category_back_office.service_id,
prefix="B",
display_dashboard_ind=1,
actual_service_ind=1)
service_bo2 = models.Service(service_code="Back Office - 002",
service_name="Cash Out",
service_desc="Cash Out",
parent_id=category_back_office.service_id,
prefix="B",
display_dashboard_ind=1,
actual_service_ind=1)
db.session.add(service_bo1)
db.session.add(service_bo2)
db.session.add(service_msp1)
db.session.add(service_msp2)
db.session.add(service_msp6)
db.session.add(service_ptax1)
db.session.add(service_ptax2)
db.session.add(service_ptax4)
db.session.commit()
#-- Office values ---------------------------------------------------
print("--> Offices")
office_test = models.Office(office_name="Test Office",
office_number=999,
sb_id=smartboard_call_ticket.sb_id)
office_100 = models.Office(office_name="100 Mile House",
office_number=1,
sb_id=smartboard_no_call.sb_id)
office_victoria = models.Office(office_name="Victoria",
office_number=61,
sb_id=smartboard_call_name.sb_id)
db.session.add(office_test)
db.session.add(office_100)
db.session.add(office_victoria)
db.session.commit()
#-- CSR values ------------------------------------------------------
print("--> CSRs")
cfms_postman_operator = models.CSR(
username="******",
office_id=office_test.office_id,
role_id=role_csr.role_id,
qt_xn_csr_ind=1,
receptionist_ind=1,
deleted=None,
csr_state_id=csr_state_logout.csr_state_id)
cfms_postman_non_operator = models.CSR(
username="******",
office_id=office_test.office_id,
role_id=role_csr.role_id,
qt_xn_csr_ind=0,
receptionist_ind=1,
deleted=None,
csr_state_id=csr_state_logout.csr_state_id)
demo_ga = models.CSR(username="******",
office_id=office_test.office_id,
role_id=role_ga.role_id,
qt_xn_csr_ind=0,
receptionist_ind=1,
deleted=None,
csr_state_id=csr_state_logout.csr_state_id)
demo_csr = models.CSR(username="******",
office_id=office_test.office_id,
role_id=role_csr.role_id,
qt_xn_csr_ind=0,
receptionist_ind=1,
deleted=None,
csr_state_id=csr_state_logout.csr_state_id)
db.session.add(cfms_postman_operator)
db.session.add(cfms_postman_non_operator)
db.session.add(demo_ga)
db.session.add(demo_csr)
db.session.commit()
#-- The Office / Services values ------------------------------------
print("--> Office Services")
office_test.services.append(category_back_office)
office_test.services.append(category_msp)
office_test.services.append(category_ptax)
office_test.services.append(service_bo1)
office_test.services.append(service_bo2)
office_test.services.append(service_msp1)
office_test.services.append(service_msp2)
office_test.services.append(service_msp6)
office_test.services.append(service_ptax1)
office_test.services.append(service_ptax2)
office_test.services.append(service_ptax4)
office_victoria.services.append(category_back_office)
office_victoria.services.append(category_msp)
office_victoria.services.append(service_bo1)
office_victoria.services.append(service_bo2)
office_victoria.services.append(service_msp1)
office_victoria.services.append(service_msp2)
office_victoria.services.append(service_msp6)
office_100.services.append(category_back_office)
office_100.services.append(category_ptax)
office_100.services.append(service_bo1)
office_100.services.append(service_bo2)
office_100.services.append(service_ptax1)
office_100.services.append(service_ptax2)
office_100.services.append(service_ptax4)
db.session.commit()
app.config.from_object('settings.DevelopmentConfig')
db.init_app(app) # 注册db到app
return app
# 建库
def CreateDB():
print('[create movie db OK!]')
base_mysql = 'mysql -u' + MYSQL['USR'] + ' -p' + MYSQL['PWD'] + ' -e'
read_mysql = base_mysql + '"create database IF NOT EXISTS %s;"' % MYSQL[
'DB']
os.system(read_mysql)
# 添加角色 （）
role_admin = models.Role(name='超级管理员', auths='') # 超管 id为1 按插入顺序
role_vip_user = models.Role(name='VIP会员') # id为 2
role_user = models.Role(name='普通会员') # 普通会员 id为3
# 添加 管理员
admin_egan = models.Admin(name=USER_ADMIN['name'],
pwd=generate_password_hash(USER_ADMIN['pwd']),
is_super=0,
role_id=1)
CreateDB() # 建库
app = create_app() # 实例app
# 每个操作使用上下文管理进行, 不能在同一个with 中进行
with app.app_context():
db.create_all() # 建表
# db.drop_all() # 删表
def add_admin():
db.session.add(models.Role(**data.roles[0]))
db.session.add(models.User(**data.users[0]))
db.session.commit()
return get_token(data.users[0])
