def load_departments():
"""
Loads departments from connected Uber instance
:return:
"""
REQUEST_HEADERS = {'X-Auth-Token': cfg.uber_authkey}
# data being sent to API
request_data = {'method': 'dept.list'}
request = requests.post(url=cfg.api_endpoint,
json=request_data,
headers=REQUEST_HEADERS)
response = json.loads(request.text)
response = response['result'].items()
# print('loading departments')
session = models.new_sesh()
for dept in response:
try:
mydept = session.query(Department).filter_by(id=dept[0]).one()
if not mydept.name == dept[1]:
mydept.name = dept[1]
except sqlalchemy.orm.exc.NoResultFound:
mydept = Department()
mydept.id = dept[0]
mydept.name = dept[1]
session.add(mydept)
session.commit()
session.close()
return
def create_department():
department = Department()
department_data = json.loads(request.data)
update_department_data(department, department_data)
db_session.add(department)
db_session.commit()
return jsonify(department.to_dict())
def get_all_records(self):
sql = "SELECT * FROM departments"
cursor = connection.cursor()
cursor.execute(sql)
records = cursor.fetchall()
department_list = []
for record in records:
department = Department(record[0], record[1])
department_list.append(department.json())
return department_list
def test_update(self):
test_entity_new = Department.random()
test_entity_new.id = random.randint(1, MAX_ENTITY_NUM)
self.assertTrue(
Operator.update(Department,
marsh(vars(test_entity_new), DepartmentSchema)))
def dep_create():
if not session["logged_in"] or not session.get("person")["admin"]:
return redirect(url_for("dep_page"))
db = Database()
data = request.form
dep= Department(data["name"], data["fac_id"], data["bu_id"], data["ch_id"])
db.add_department(dep)
return redirect(url_for("dep_page"))
def deserialize(json):
return Employee(id=json["id"],
login_id=json["loginId"],
first_name=json["firstName"],
last_name=json["lastName"],
department=Department.deserialize(json["department"]),
role=Role.deserialize(json["role"]),
supervisor=Employee.deserialize(json["supervisor"]) if json["supervisor"] else None)
def get_department(id):
sql = "Select * from departments where id = %s"
cursor = connection.cursor()
cursor.execute(sql, [id])
record = cursor.fetchone()
department = Department(id=record[0], name=record[1], head=record[2])
return department
def get_department_by_id(self, id):
return Department.from_tuple(
self.cursor.execute(
"""
SELECT *
FROM departments
WHERE id = ?
""", (id, )).fetchone())
def create_record(self, department, fk1=None, fk2=None):
sql = "INSERT INTO departments VALUES (%s, %s) RETURNING *"
cursor = connection.cursor()
cursor.execute(
sql, (department.department_name, department.department_head))
connection.commit()
record = cursor.fetchone()
return Department(record[0], record[1])
def post_department():
try:
department = Department.json_parse(request.json)
department = DepartmentService.add_department(department)
return jsonify(department.json()), 201
except KeyError:
return "A name and department head must be entered to add a department.", 400
except ResourceNotFound as r:
return r.message, 404
def dci_from_data(dataset, db, conn):
for model in [Department(), Course(), Instructor()]:
sanitized_data = list(map(model.sanitize_from_raw, dataset))
sanitized_data = list({v['id']: v for v in sanitized_data}.values())
modeltable = model.__class__.__name__
result = r.db(db).table(modeltable).insert(sanitized_data).run(conn)
inserted = result['inserted']
errors = result['errors']
logging.info("{0} Inserted \t {1} \t Skipped {2}".format(
modeltable.ljust(12), inserted, errors))
def update_department(department_name):
try:
department = Department.json_parse(request.json)
department.department_name = department_name
DepartmentService.update_department(department)
return jsonify(department.json()), 200
except KeyError:
return "Please enter a new Department Head for this Department.", 400
except ResourceNotFound as r:
return r.message, 404
def populate_departments_tbl():
from models.department import Department
depts = [
'ANESTHESIOLOGY', 'CARDIOLOGY', 'CARDIOVASCULAR', 'CSP',
'EMERGENCY MEDICINE', 'FAMILY MEDICINE', 'GENERAL MEDICINE', 'GI',
'HEMATOLOGY', 'HOSPITAL MEDICINE', 'IHPI', 'INFECTIOUS DISEASE',
'INTERNAL MEDICINE', 'NEPHROLOGY', 'NURSING', 'PALLIATIVE CARE',
'PSYCHIATRY', 'PULMONARY', 'RADIATION ONCOLOGY', 'SPH', 'UROLOGY',
'VASCULAR SURGERY', 'VERAM'
]
print('Populating departments...')
for dept in depts:
try:
Department.add_rec(dao, dept)
except Exception as e:
print('Error adding department %s: %s' % (dept, str(e)))
return False
print('Departments populated!')
return True
def new_department():
new_department_data = Department.from_tuple(
tuple([0] + request.data.decode("utf-8").split(",")))
error = context.repository.add_department(
new_department_data.name, new_department_data.country,
new_department_data.city, new_department_data.address,
new_department_data.department_manager)
if error == "DEPARTMENT NAME DUPLICATE":
return "This department name is occupied", 400
context.repository.commit()
return "", 204
def test_update(self):
test_entity_new = Department.random()
test_entity_new_id = random.randint(1, MAX_ENTITY_NUM)
test_entity_new.id = test_entity_new_id
self.client.put(f'/departments/{test_entity_new_id}',
data=marsh(test_entity_new, DepartmentSchema))
get_response = self.client.get(f'/departments/{test_entity_new_id}')
self.assertEqual(marsh(test_entity_new, DepartmentSchema),
marsh(get_response.get_json(), DepartmentSchema))
def dep_insert():
if request.method == 'POST':
dep_name = request.form['dep_name']
description = request.form['description']
my_data = Department(dep_name, description)
db.session.add(my_data)
db.session.commit()
flash("Department inserted successfully")
return redirect(url_for('department.dep_index'))
def get_record(self, department_name, fk1=None, fk2=None):
sql = "SELECT * FROM departments WHERE department_name=%s"
cursor = connection.cursor()
cursor.execute(sql, [department_name])
record = cursor.fetchone()
if record:
return Department(record[0], record[1])
else:
raise ResourceNotFound(
f"Department with name {department_name} not found.")
def test_insert(self):
test_entity = Department.random()
post_response = self.client.post('/departments',
data=marsh(test_entity,
DepartmentSchema))
test_entity_id = post_response.get_json().get('data')
test_entity.id = test_entity_id
get_response = self.client.get(f'/departments/{test_entity.id}')
get_response_data = get_response.get_json()
self.assertEqual(marsh(test_entity, DepartmentSchema),
marsh(get_response_data, DepartmentSchema))
def load_departments():
"""
Loads departments from connected Uber instance
:return:
"""
REQUEST_HEADERS = {'X-Auth-Token': cfg.uber_authkey}
request_data = {'method': 'dept.list'}
request = requests.post(url=cfg.api_endpoint, json=request_data, headers=REQUEST_HEADERS)
response = json.loads(request.text)
response = response['result'].items()
session = models.new_sesh()
for dept in response:
try:
mydept = session.query(Department).filter_by(id=dept[0]).one()
if not mydept.name == dept[1]:
mydept.name = dept[1]
except sqlalchemy.orm.exc.NoResultFound:
mydept = Department()
mydept.id = dept[0]
mydept.name = dept[1]
session.add(mydept)
request_data = {'method': 'dept.jobs', "params": {"department_id": dept[0]}}
request = requests.post(url=cfg.api_endpoint, json=request_data, headers=REQUEST_HEADERS)
dept_details = json.loads(request.text)
# this checks if changed before updating because my memory tells me
# fewer changed records makes the SQL commit faster
if not mydept.is_shiftless == dept_details['result']['is_shiftless']:
mydept.is_shiftless = dept_details['result']['is_shiftless']
session.commit()
session.close()
return
def add_department(self, fields: str):
ref_id = generate_uuid()
department = Department(ref_id=ref_id, **fields, created_at=get_current_time(), updated_at=get_current_time())
db.session.add(department)
try:
db.session.commit()
except Exception as e:
print(str(e.orig))
error_orig = str(e.orig).replace("(", "").replace(")", "").split(",")[1].strip().replace("'", "").replace('"', '').split(":")[0]
raise IntegrityError(message=error_orig)
return department
def post(self):
"""Adds a department to the database.
Returns:
Department's id using marshal or
aborts with 404.
"""
try:
raw_data = lomarsh(request.form, DepartmentSchema)
raw_data['id'] = None
return Operator.insert(Department(**raw_data))
except IntegrityError:
abort(400)
def create_data(session: Session):
department1_id = uuid.uuid4().hex
department2_id = uuid.uuid4().hex
department1 = Department(id=department1_id,
title='Биология и Общая генетика')
department2 = Department(id=department2_id, title='Биотехнология')
session.add(department1)
session.add(department2)
mypath = "C:/Users/Andrey/Pictures/PNG"
onlyfiles = listdir(mypath)
added_objects = []
for obj in onlyfiles:
splited_obj = obj.split('_')
if splited_obj[0] in added_objects:
continue
obj_id = uuid.uuid4().hex
new_object = Object(id=obj_id,
title=splited_obj[0],
department_id=department1_id)
session.add(new_object)
for fl in onlyfiles:
splited_fl = fl.split('_')
zoom_fl = splited_fl[1].split('.')
if fl.find(splited_obj[0]) != -1:
fl_id = uuid.uuid4().hex
new_file = File(id=fl_id,
type='image',
url=fl,
zoom=zoom_fl[0],
object_id=obj_id)
session.add(new_file)
added_objects.append(splited_obj[0])
session.commit()
session.close()
def setUp(self):
app.config.from_object(TestConfiguration)
self.app = app.test_client()
db.create_all()
db.session.add(Department(id=10001, name='Test Department'))
db.session.add(
Employee(name='Steven Gray',
department_id=10001,
date_of_birthday=date(1997, 10, 1),
salary=Decimal(1000)))
db.session.add(
Employee(name='John Spins',
department_id=10001,
date_of_birthday=date(1997, 5, 11),
salary=Decimal(3000)))
db.session.commit()
def test_update(self):
self.assertEqual(
crud.Departments.update(10001, 10002, 'UpdatedDepartment'),
Department(id=10002,
name='UpdatedDepartment',
employees=[
Employee(id=1,
name='Steven Gray',
department_id=10002,
date_of_birthday=date(1997, 10, 1),
salary=Decimal(1000)),
Employee(id=2,
name='John Spins',
department_id=10002,
date_of_birthday=date(1997, 5, 11),
salary=Decimal(3000))
]))
def test_get_all(self):
self.assertEqual(crud.Departments.get_all(), ([
Department(id=10001,
name='Test Department',
employees=[
Employee(id=1,
name='Steven Gray',
department_id=10001,
date_of_birthday=date(1997, 10, 1),
salary=Decimal(1000)),
Employee(id=2,
name='John Spins',
department_id=10001,
date_of_birthday=date(1997, 5, 11),
salary=Decimal(3000))
])
], [(Decimal(2000), 10001)]))
def digest_file(filename, db, conn):
data = dataSet('data/csv/' + filename)
fcq_data = list(map(Fcq().sanitize_from_raw, data.raw_data))
for model in [Department(), Course(), Instructor()]:
sanitized_data = list(map(model.sanitize_from_raw, fcq_data))
sanitized_data = list({v['id']: v for v in sanitized_data}.values())
modeltable = model.__class__.__name__
result = r.db(db).table(modeltable).insert(sanitized_data).run(conn)
inserted = result['inserted']
errors = result['errors']
logging.info("{0} Inserted \t {1} \t Skipped {2}".format(modeltable.ljust(12), inserted, errors))
result = r.db(db).table('Fcq').insert(fcq_data).run(conn)
inserted = result['inserted']
errors = result['errors']
logging.info("{0} \t Inserted {1}".format(filename.ljust(12), inserted))
if errors:
first_error = result['first_error']
logging.warn("{0} Errors inserting fcqs. First Error:\n{1}".format(errors, first_error))
def add(dep_id, name):
"""
Adds new department
:param dep_id: The unique number of department
:param name: Department`s name
:return: New department that has been added
:rtype: Department
"""
try:
department = Department(id=dep_id, name=name)
except:
logger.debug(f'Department {dep_id} is exist, it can`t be added')
raise AttributeError
db.session.add(department)
db.session.commit()
logger.debug(f'Department {dep_id} was added')
return department
def create():
try:
input_json_data = request.get_json()
db.create_all()
db.session.commit()
if not input_json_data:
return {"message": "No input data provided"}, 400
new_category = input_json_data['category']
new_department = input_json_data['department']
department_results = Department.query.filter(
Department.department == new_department)
# validation of department details
for temp in department_results:
string_val = temp.serialize()
if (new_department == string_val.get('department')) and (
new_category == string_val.get('category')):
data = {
'Inserting Data': 'Failure',
'Error': "Department and Category have been already exists"
}
resp = jsonify(data), 205
return resp
# assign department details to Department model
department = Department(
department=input_json_data['department'],
department_id=Sequence('user_id_seq').next_value(),
category=input_json_data['category'],
details=input_json_data['details'])
db.session.add(department)
db.session.commit()
data = {'create': 'success', 'department_id': department.department_id}
resp = jsonify(data), 201
except Exception as e:
data = {'create': 'fail'}
resp = jsonify(data), 500
print(e)
return resp
def _get_data(self):
from dal.dao import Dao
from tests.ledger_data.test_data import invoices_q2_pre_query
from models.employee import Employee
from models.department import Department
from models.grant_admin import GrantAdmin
from models.invoice import Invoice
from models.assignment import Assignment
dao = Dao(db_path=self.db_path, stateful=True)
self._emp_rex = Employee.get_all(dao)
self._dept_rex = Department.get_all(dao)
self._grant_admin_rex = GrantAdmin.get_all(dao)
invoices_unpaid = Invoice.get_rex(dao)
# invoices_unpaid = invoices_q2
self._invoices_sent = [
invoice for invoice in invoices_unpaid if invoice.sent
]
self._invoices_unsent = [
invoice for invoice in invoices_unpaid if not invoice.sent
]
self._asn_rex = Assignment.get_billables(dao)
dao.close()
from models.grade import Grade
from models.course import Course
from models.instructor import Instructor
from models.department import Department
from handlers.not_found_handler import NotFoundHandler
import logging
settings = {
'cookie_secret': 'PqITv9b7QUyoAUUcgfRtReoZIXjQrEKKk9fpQpGu6MU=',
'template_path': 'templates/',
'static_path': 'static/',
'grade': Grade(),
'fcq': Fcq(),
'course': Course(),
'instructor': Instructor(),
'department': Department(),
'default_handler_class': NotFoundHandler,
'ui_modules': {
'chart_overtime': LineChartModule,
'fcq_card': FcqCardModule
}
}
def initialize_settings():
settings['debug'] = options.debug
settings['autoreload'] = options.debug
settings['site_port'] = options.port
database_name = options.database_name
database_port = options.database_port
database_host = options.database_host
def add_dept(self):
self.view.add_dept(Department())
