def office_add(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) account = DBSession.query(Account).filter_by(id=account_id).first() user = DBSession.query(User).filter_by(id=user_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) if request.method == "POST": name = request.params["name"].lower() office = DBSession.query(Office).filter_by( account_id=long(request.session['aid'])).filter_by( name=name).first() if office is None: benefits_and_bonus = long(request.params["benefits_and_bonus"]) new_office = Office(name, benefits_and_bonus, account) DBSession.add(new_office) DBSession.flush() if request.params.get("add_another") is None: return HTTPFound(request.application_url + "/administration/company") return dict(logged_in=authenticated_userid(request), header=Header("administration"), user=user) except: return HTTPFound(request.application_url)
def client_delete(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None: return HTTPFound(request.application_url) client_id = request.matchdict.get('client_id') client = DBSession.query(Client).filter_by(id=client_id).filter_by( account_id=account_id).first() if client is None or user.can_access_client(client, "financials") == False: return HTTPFound(request.application_url) client.is_active = False DBSession.flush() return HTTPFound(request.application_url + "/office/" + str(client.office_id) + "/clients/" + str(datetime.datetime.now().year)) except: return HTTPFound(request.application_url)
def project_delete(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None: print("************* no user") return HTTPFound(request.application_url) project_id = request.matchdict.get('project_id') project = DBSession.query(Project).filter_by(id=project_id).filter_by( account_id=account_id).first() if project is None or user.can_access_client(project.client, "financials") == False: print("************* no permissions") return HTTPFound(request.application_url) project.is_active = False project.end_date = datetime.datetime.now() DBSession.flush() return HTTPFound(location=request.application_url + "/client/" + str(project.client_id) + "/projects/" + str(datetime.datetime.now().year)) except: print("*************") traceback.print_exc() return HTTPFound(request.application_url)
def person_enable_login(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or (user.is_administrator == False and user.is_hr_administrator == False): return HTTPFound(request.application_url) person_id = request.matchdict.get('person_id') if user_id == person_id: return HTTPFound(request.application_url + "/administration/employees") person = DBSession.query(User).filter_by(id=person_id).filter_by(account_id=account_id).first() password = None if person is None: return HTTPFound(request.application_url + "/administration/employees") password = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(6)) encrypted_password = bcrypt.hashpw(password, bcrypt.gensalt()) person.password = encrypted_password DBSession.flush() return dict(logged_in=authenticated_userid(request), header=Header("administration"), person=person, user=user, password=password) except: return HTTPFound(request.application_url)
def person(request): #FIX PERMISSIONS! person_id = request.matchdict.get('person_id') review_year = request.params.get('year') user = DBSession.query(User).filter_by(id=long(request.session['uid'])).first() person = DBSession.query(User).filter_by(id=long(person_id)).first() account = DBSession.query(Account).filter_by(id=long(request.session['aid'])).first() if review_year is None or review_year == "": review_year = account.latest_review_year review = DBSession.query(Review).filter_by(user_id=person.id).filter_by(review_cycle_year=review_year).first() if review is None: if review_year == account.latest_review_year: review = Review(user, review_year) DBSession.add(review) DBSession.flush() else: HTTPFound(location=request.application_url) return dict(logged_in=authenticated_userid(request), person=person, user=user, review=review, account=account)
def currency_add(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) if request.method == "POST": name = request.params["name"].lower() currency_to_usd = float(request.params["currency_to_usd"]) error = False if name == "usd": error = True currency = DBSession.query(Currency).filter_by(account_id=account_id).filter_by(name=name).first() if currency is not None: error = True if error == False: new_currency = Currency(name, account, currency_to_usd) DBSession.add(new_currency) DBSession.flush() if request.params.get("add_another") is None: return HTTPFound(request.application_url + "/administration/company") return dict(logged_in=authenticated_userid(request), header=Header("administration"), user=user) except: return HTTPFound(request.application_url)
def _get_header(type_of_person, office_id, department_id): if ((office_id is None or office_id.lower() == "all") and ( department_id is None or department_id.lower() == "all")): if type_of_person == "direct": return "My Direct Reports" else: return "All People" if office_id is None or office_id.lower() == "all": department = DBSession.query(Department).filter_by(id=department_id).first() if type_of_person == "direct": return "My Direct Reports in " + department.name else: return "People in " + department.name if department_id is None or department_id.lower() == "all": office = DBSession.query(Office).filter_by(id=office_id).first() if type_of_person == "direct": return "My Direct Reports in " + office.name else: return "People in " + office.name department = DBSession.query(Department).filter_by(id=department_id).first() office = DBSession.query(Office).filter_by(id=office_id).first() if type_of_person == "direct": return "My Direct Reports in " + office.name + " for " + department.name else: return "People in " + office.name + " for " + department.name
def project_delete(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None: print("************* no user") return HTTPFound(request.application_url) project_id = request.matchdict.get('project_id') project = DBSession.query(Project).filter_by(id=project_id).filter_by(account_id=account_id).first() if project is None or user.can_access_client(project.client, "financials") == False: print("************* no permissions") return HTTPFound(request.application_url) project.is_active = False project.end_date = datetime.datetime.now() DBSession.flush() return HTTPFound(location=request.application_url + "/client/" + str(project.client_id) + "/projects/" + str( datetime.datetime.now().year)) except: print("*************") traceback.print_exc() return HTTPFound(request.application_url)
def client_financials(request): try: user_id = long(request.session['uid']) account_id = long(request.session['aid']) client_id = request.matchdict['client_id'] year = request.matchdict['year'] user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() client = DBSession.query(Client).filter_by( account_id=account_id).filter_by(id=client_id).first() access_financials = user.can_access_client(client, "financials") if user is None or account is None or client is None or access_financials == False: return HTTPFound(request.application_url) access_pipeline = user.can_access_client(client, "pipeline") access_utilization = user.can_access_client(client, "utilization") financials = client.getFinancials(year, user) return dict(logged_in=authenticated_userid(request), header=getHeader(client), financials=financials, client=client, year=year, user=user, account=account, access_pipeline=access_pipeline, access_utilization=access_utilization, access_financials=access_financials) except: #how to print out the exception problem: #traceback.print_exc() return HTTPFound(request.application_url)
def roles(request): department_id = request.matchdict.get('department_id') user = DBSession.query(User).filter_by(id=long(request.session['uid'])).first() roles = [] if department_id == 'all': if user.permissions.is_administrator or user.permissions.can_view_all_departments: roles = DBSession.query(Role).filter_by(account_id=long(request.session['aid'])).filter( Role.is_active == True).all() else: HTTPFound(request.application_url) else: if user.permissions.is_administrator or user.permissions.can_view_all_departments: roles = DBSession.query(Role).filter_by(department_id=department_id).filter(Role.is_active == True).all() else: dept_match = False for department in user.permissions.view_departments: if department.id == department_id: roles = DBSession.query(Role).filter_by(department_id=department_id).filter( Role.is_active is True).all() dept_match = True break if dept_match is False: HTTPFound(request.application_url) header = _get_header(department_id) account = DBSession.query(Account).filter_by(id=long(request.session['aid'])).first() return dict(logged_in=authenticated_userid(request), account=account, user=user, roles=roles, active_people="", active_roles="active", header=header, department_id=department_id)
def office_financials(request): try: user_id = long(request.session['uid']) account_id = long(request.session['aid']) office_id = request.matchdict['office_id'] year = request.matchdict['year'] user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() office = DBSession.query(Office).filter_by( account_id=account_id).filter_by(id=office_id).first() access_financials = user.can_access_office(office, "financials") if user is None or account is None or office is None or access_financials == False: return HTTPFound(request.application_url) access_pipeline = user.can_access_office(office, "pipeline") access_utilization = user.can_access_office(office, "utilization") financials = office.getFinancials(year, user) return dict(logged_in=authenticated_userid(request), header=getHeader(office), financials=financials, office=office, year=year, user=user, account=account, access_pipeline=access_pipeline, access_utilization=access_utilization, access_financials=access_financials) except: return HTTPFound(request.application_url)
def _get_header(type_of_person, office_id, department_id): if ((office_id is None or office_id.lower() == "all") and (department_id is None or department_id.lower() == "all")): if type_of_person == "direct": return "My Direct Reports" else: return "All People" if office_id is None or office_id.lower() == "all": department = DBSession.query(Department).filter_by( id=department_id).first() if type_of_person == "direct": return "My Direct Reports in " + department.name else: return "People in " + department.name if department_id is None or department_id.lower() == "all": office = DBSession.query(Office).filter_by(id=office_id).first() if type_of_person == "direct": return "My Direct Reports in " + office.name else: return "People in " + office.name department = DBSession.query(Department).filter_by( id=department_id).first() office = DBSession.query(Office).filter_by(id=office_id).first() if type_of_person == "direct": return "My Direct Reports in " + office.name + " for " + department.name else: return "People in " + office.name + " for " + department.name
def department_financials(request): try: user_id = long(request.session['uid']) account_id = long(request.session['aid']) department_id = request.matchdict['department_id'] year = request.matchdict['year'] user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() department = DBSession.query(Department).filter_by( account_id=account_id).filter_by(id=department_id).first() access_financials = user.can_access_department(department, "financials") if user is None or account is None or department is None or access_financials == False: return HTTPFound(request.application_url) access_utilization = user.can_access_department( department, "utilization") financials = department.getFinancials(year, user) return dict(logged_in=authenticated_userid(request), header=getHeader(department), financials=financials, department=department, year=year, user=user, account=account, access_utilization=access_utilization, access_financials=access_financials) except: traceback.print_exc() return HTTPFound(request.application_url)
def account_edit(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) account = DBSession.query(Account).filter_by(id=account_id).first() user = DBSession.query(User).filter_by(id=user_id).first() if user is None or user.is_administrator == False or account is None: return HTTPFound(request.application_url) if request.method == "POST": name = request.params["name"] benefits_and_bonus = long(request.params["benefits_and_bonus"]) acc = DBSession.query(Account).filter_by(name=name).first() if acc is None or acc.id == account.id: DBSession.query(Account).filter_by(id=account_id).update({ 'name': name, 'benefits_and_bonus': benefits_and_bonus }) DBSession.flush() return HTTPFound(request.application_url + "/administration/company") return dict(logged_in=authenticated_userid(request), header=Header("administration"), account=account, user=user) except: return HTTPFound(request.application_url)
def department_add(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) if request.method == "POST": name = request.params["name"].lower() dept = DBSession.query(Department).filter_by( account_id=account_id).filter_by(name=name).first() if dept is None: new_department = Department(name, account) DBSession.add(new_department) DBSession.flush() if request.params.get("add_another") is None: return HTTPFound(location=request.application_url + "/administration/company") return dict(logged_in=authenticated_userid(request), header=Header("administration"), user=user) except: return HTTPFound(request.application_url)
def account_edit(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) account = DBSession.query(Account).filter_by(id=account_id).first() user = DBSession.query(User).filter_by(id=user_id).first() if user is None or user.is_administrator == False or account is None: return HTTPFound(request.application_url) if request.method == "POST": name = request.params["name"] benefits_and_bonus = long(request.params["benefits_and_bonus"]) acc = DBSession.query(Account).filter_by(name=name).first() if acc is None or acc.id == account.id: DBSession.query(Account).filter_by(id=account_id).update( {'name': name, 'benefits_and_bonus': benefits_and_bonus}) DBSession.flush() return HTTPFound(request.application_url + "/administration/company") return dict(logged_in=authenticated_userid(request), header=Header("administration"), account=account, user=user) except: return HTTPFound(request.application_url)
def currency_edit(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) currency_id = long(request.matchdict['currency_id']) currency = DBSession.query(Currency).filter_by(id=currency_id).first() if currency == None: return HTTPFound(request.application_url + "/administration/company") if request.method == "POST": error = False name = request.params["name"].lower() if name == "usd": error = True currency_to_usd = float(request.params["currency_to_usd"]) cur = DBSession.query(Currency).filter_by(account_id=account_id).filter_by(name=name).first() if cur is not None and cur.id != currency_id: error = True if error == False: currency.name = name currency.currency_to_usd = currency_to_usd DBSession.flush() return HTTPFound(request.application_url + "/administration/company") return dict(logged_in=authenticated_userid(request), header=Header("administration"), currency=currency, user=user) except: return HTTPFound(request.application_url)
def client_projects_update(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None: return HTTPFound(request.application_url) client_id = long(request.matchdict['client_id']) client = DBSession.query(Client).filter_by(id=client_id).filter_by( account_id=account_id).first() if client is None or user.can_access_client(client, "financials") == False: return HTTPFound(request.application_url) if request.method == "POST": for project in account.projects: if project.is_active and project.client.office_id == client.office_id: revenue_local = long( request.params.get(str(project.id) + "-revenue")) if user.currency is None: revenue = revenue_local else: revenue = revenue_local * user.currency.currency_to_usd start_date_text = request.params.get( str(project.id) + "-start_date") start_dateparts = start_date_text.split("/") start_date = datetime.date(long(start_dateparts[2]), long(start_dateparts[0]), long(start_dateparts[1])) end_date_text = request.params.get( str(project.id) + "-end_date") end_dateparts = end_date_text.split("/") end_date = datetime.date(long(end_dateparts[2]), long(end_dateparts[0]), long(end_dateparts[1])) project.revenue = revenue project.start_date = start_date project.end_date = end_date DBSession.flush() return HTTPFound(request.application_url + "/client/" + str(client.id) + "/projects/" + str(datetime.datetime.now().year)) return dict(logged_in=authenticated_userid(request), header=Header("financials"), user=user, account=account, client=client) except: traceback.print_exc() return HTTPFound(request.application_url)
def role(request): role_id = request.matchdict.get('role_id') user = DBSession.query(User).filter_by(id=long(request.session['uid'])).first() role = DBSession.query(Role).filter_by(id=long(role_id)).first() return dict(logged_in=authenticated_userid(request), header=Header("reviews"), role=role, user=user)
def global_expenses(request): try: user_id = long(request.session['uid']) account_id = long(request.session['aid']) year = request.matchdict['year'] user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or not ( user.is_administrator or user.permissions_global_financials): return HTTPFound(request.application_url) offices = DBSession.query(Office).filter_by( account_id=account_id).all() if offices is None: return HTTPFound(request.application_url) if request.method == "POST": for office in offices: change = False ase = None sga = None ase_text = request.POST.get("ase_" + str(office.id)) if ase_text is not None and ase_text != '': ase_local = long(ase_text) if user.currency is None: ase = ase_local else: ase = ase_local * user.currency.currency_to_usd office.allocated_salary_expense = ase sga_text = request.POST.get("sga_" + str(office.id)) if sga_text is not None and sga_text != '': sga_local = long(sga_text) if user.currency is None: sga = sga_local else: sga = sga_local * user.currency.currency_to_usd office.sga_expense = sga DBSession.flush() # return HTTPFound(request.application_url + "/administration/expenses") return dict(logged_in=authenticated_userid(request), header=Header("financials"), offices=offices, year=year, user=user) except: traceback.print_exc() return HTTPFound(request.application_url)
def role_edit(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) role_id = long(request.matchdict['role_id']) role = DBSession.query(Role).filter_by(id=role_id).filter_by( account_id=account_id).first() if request.method == "POST": name = request.params["name"].lower() department_id = long(request.params["department_id"]) salary_low_local = long(request.params["salary_low"]) salary_high_local = long(request.params["salary_high"]) if user.currency is None: salary_low = salary_low_local salary_high = salary_high_local else: salary_low = salary_low_local * user.currency.currency_to_usd salary_high = salary_high_local * user.currency.currency_to_usd department = DBSession.query(Department).filter_by( id=department_id).filter_by(account_id=account.id).first() role_ok = True for r in department.roles: if r.name == name and r.id != role_id: role_ok = False if role_ok: role.name = name role.department = department role.salary_low = salary_low role.salary_high = salary_high DBSession.flush() return HTTPFound(request.application_url + "/administration/company") departments = DBSession.query(Department).filter_by( account_id=long(request.session['aid'])).all() return dict(logged_in=authenticated_userid(request), header=Header("administration"), departments=departments, user=user, role=role) except: return HTTPFound(request.application_url)
def role(request): role_id = request.matchdict.get('role_id') user = DBSession.query(User).filter_by( id=long(request.session['uid'])).first() role = DBSession.query(Role).filter_by(id=long(role_id)).first() return dict(logged_in=authenticated_userid(request), header=Header("reviews"), role=role, user=user)
def administration_revenue(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) account = DBSession.query(Account).filter_by(id=account_id).first() user = DBSession.query(User).filter_by(id=user_id).first() if user is None or account is None or not ( user.is_administrator or user.permissions_global_financials): return HTTPFound(request.application_url) if request.method == "POST": quarter_end_date_text = request.params.get("quarter_end_type") quarter_end_year_text = request.params.get("quarter_end_year") quarter_end_date_parts = quarter_end_date_text.split("/") quarter_end_date = datetime.date(long(quarter_end_year_text), long(quarter_end_date_parts[0]), long(quarter_end_date_parts[1])) for project in account.projects: revenue_local = long( request.params.get(str(project.id) + "-revenue")) if user.currency is None: revenue = revenue_local else: revenue = revenue_local * user.currency.currency_to_usd actual_revenue = DBSession.query(ActualRevenue).filter_by( project_id=project.id).filter_by( quarter_end_date=quarter_end_date).first() if actual_revenue is not None: actual_revenue.revenue = revenue else: actual_revenue = ActualRevenue(project, revenue, quarter_end_date) DBSession.flush() return HTTPFound(request.application_url + "/administration/company") return dict(logged_in=authenticated_userid(request), header=Header("administration"), account=account, user=user) except: traceback.print_exc() return HTTPFound(request.application_url)
def global_expenses(request): try: user_id = long(request.session['uid']) account_id = long(request.session['aid']) year = request.matchdict['year'] user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or not (user.is_administrator or user.permissions_global_financials): return HTTPFound(request.application_url) offices = DBSession.query(Office).filter_by(account_id=account_id).all() if offices is None: return HTTPFound(request.application_url) if request.method == "POST": for office in offices: change = False ase = None sga = None ase_text = request.POST.get("ase_" + str(office.id)) if ase_text is not None and ase_text != '': ase_local = long(ase_text) if user.currency is None: ase = ase_local else: ase = ase_local * user.currency.currency_to_usd office.allocated_salary_expense = ase sga_text = request.POST.get("sga_" + str(office.id)) if sga_text is not None and sga_text != '': sga_local = long(sga_text) if user.currency is None: sga = sga_local else: sga = sga_local * user.currency.currency_to_usd office.sga_expense = sga DBSession.flush() # return HTTPFound(request.application_url + "/administration/expenses") return dict(logged_in=authenticated_userid(request), header=Header("financials"), offices=offices, year=year, user=user) except: traceback.print_exc() return HTTPFound(request.application_url)
def administration_employees(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) account = DBSession.query(Account).filter_by(id=account_id).first() user = DBSession.query(User).filter_by(id=user_id).first() if user is None or account is None or (user.is_administrator == False and user.is_hr_administrator == False): return HTTPFound(request.application_url) return dict(logged_in=authenticated_userid(request), header=Header("administration"), account=account, user=user) except: return HTTPFound(request.application_url)
def _get_header(department_id): if (department_id is None or department_id.lower() == "all"): return "All Roles" else: department = DBSession.query(Department).filter_by( id=department_id).first() return "Roles in " + department.name
def login(request): login_url = request.route_url('login') referrer = request.url if referrer == login_url: referrer = '/' # never use the login form itself as came_from came_from = request.params.get('came_from', referrer) if came_from == None: came_from = request.application_url message = '' email = '' password = '' if 'form.submitted' in request.params: email = request.params['email'].lower() password = request.params['password'] user = DBSession.query(User).filter_by(email=email).first() if user is None: return dict(message='user not found', url=request.application_url + '/login', came_from=came_from, email=email) if user.is_valid_password(password): request.session['uid'] = str(user.id) request.session['aid'] = str(user.account_id) headers = remember(request, user.id) return HTTPFound(came_from, headers=headers) else: return dict(message='invalid password', url=request.application_url + '/login', came_from=came_from, email=email) return dict(message='failed login', url=request.application_url + '/login', came_from=came_from, email=email)
def currency_delete(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) currency_id = long(request.matchdict['currency_id']) DBSession.query(Currency).filter_by(id=currency_id).filter_by(account_id=account_id).delete() DBSession.flush() return HTTPFound(request.application_url + "/administration/company") except: return HTTPFound(request.application_url)
def administration_company(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) account = DBSession.query(Account).filter_by(id=account_id).first() user = DBSession.query(User).filter_by(id=user_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) return dict(logged_in=authenticated_userid(request), header=Header("administration"), account=account, user=user) except: return HTTPFound(request.application_url)
def client_projects_update(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None: return HTTPFound(request.application_url) client_id = long(request.matchdict['client_id']) client = DBSession.query(Client).filter_by(id=client_id).filter_by(account_id=account_id).first() if client is None or user.can_access_client(client, "financials") == False: return HTTPFound(request.application_url) if request.method == "POST": for project in account.projects: if project.is_active and project.client.office_id == client.office_id: revenue_local = long(request.params.get(str(project.id) + "-revenue")) if user.currency is None: revenue = revenue_local else: revenue = revenue_local * user.currency.currency_to_usd start_date_text = request.params.get(str(project.id) + "-start_date") start_dateparts = start_date_text.split("/") start_date = datetime.date(long(start_dateparts[2]), long(start_dateparts[0]), long(start_dateparts[1])) end_date_text = request.params.get(str(project.id) + "-end_date") end_dateparts = end_date_text.split("/") end_date = datetime.date(long(end_dateparts[2]), long(end_dateparts[0]), long(end_dateparts[1])) project.revenue = revenue project.start_date = start_date project.end_date = end_date DBSession.flush() return HTTPFound(request.application_url + "/client/" + str(client.id) + "/projects/" + str( datetime.datetime.now().year)) return dict(logged_in=authenticated_userid(request), header=Header("financials"), user=user, account=account, client=client) except: traceback.print_exc() return HTTPFound(request.application_url)
def role_edit(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) role_id = long(request.matchdict['role_id']) role = DBSession.query(Role).filter_by(id=role_id).filter_by(account_id=account_id).first() if request.method == "POST": name = request.params["name"].lower() department_id = long(request.params["department_id"]) salary_low_local = long(request.params["salary_low"]) salary_high_local = long(request.params["salary_high"]) if user.currency is None: salary_low = salary_low_local salary_high = salary_high_local else: salary_low = salary_low_local * user.currency.currency_to_usd salary_high = salary_high_local * user.currency.currency_to_usd department = DBSession.query(Department).filter_by(id=department_id).filter_by( account_id=account.id).first() role_ok = True for r in department.roles: if r.name == name and r.id != role_id: role_ok = False if role_ok: role.name = name role.department = department role.salary_low = salary_low role.salary_high = salary_high DBSession.flush() return HTTPFound(request.application_url + "/administration/company") departments = DBSession.query(Department).filter_by(account_id=long(request.session['aid'])).all() return dict(logged_in=authenticated_userid(request), header=Header("administration"), departments=departments, user=user, role=role) except: return HTTPFound(request.application_url)
def currency_delete(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) currency_id = long(request.matchdict['currency_id']) DBSession.query(Currency).filter_by(id=currency_id).filter_by( account_id=account_id).delete() DBSession.flush() return HTTPFound(request.application_url + "/administration/company") except: return HTTPFound(request.application_url)
def role_delete(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) role_id = request.matchdict.get('role_id') DBSession.query(Role).filter_by(id=role_id).filter_by(account_id=account_id).update({'is_active': False}) DBSession.flush() return HTTPFound(location=request.application_url + "/administration/company") except: return HTTPFound(request.application_url)
def person_assign_delete(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) person_id = long(request.matchdict.get('person_id')) assignment_id = long(request.matchdict.get('assignment_id')) person = DBSession.query(User).filter_by(id=person_id).filter_by(account_id=account_id).first() if person == None: return HTTPFound(request.application_url) source_type_text = request.params.get("source_type") if source_type_text is None: source_type = "office" elif source_type_text == "ghost_client": source_type = "ghost/client" elif source_type_text == "client": source_type = source_type_text else: source_type = "office" source_id_text = request.params.get("source_id") if source_id_text is None: source_id = person.office_id else: source_id = long(source_id_text) user_allocation = DBSession.query(UserAllocation).filter_by(id=assignment_id).first() if user_allocation == None or user_allocation.user_id != person.id: return HTTPFound(request.application_url) DBSession.delete(user_allocation) DBSession.flush() return HTTPFound(location=request.application_url + "/person/" + str( person_id) + "/assign/edit?source_type=" + source_type + "&source_id=" + str(source_id)) except: print("*****") traceback.print_exc() return HTTPFound(request.application_url)
def global_utilization(request): try: user_id = long(request.session['uid']) account_id = long(request.session['aid']) user = DBSession.query(User).filter_by(id=user_id).first() year = request.matchdict['year'] account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or ( user.is_administrator is False and user.permissions_global_utilization is False) and not user.is_hr_administrator: return HTTPFound(request.application_url) utilization = account.getUtilization(year) return dict(logged_in=authenticated_userid(request), header=getHeader(), utilization=utilization, year=year, account=account, user=user) except: return HTTPFound(request.application_url)
def person_delete(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or (user.is_administrator == False and user.is_hr_administrator == False): return HTTPFound(request.application_url) person_id = request.matchdict.get('person_id') DBSession.query(User).filter_by(id=person_id).filter_by(account_id=account_id).update( {'is_active': False, 'end_date': datetime.datetime.now()}) DBSession.flush() return HTTPFound(location=request.application_url + "/administration/employees") except: return HTTPFound(request.application_url)
def global_offices(request): try: user_id = long(request.session['uid']) account_id = long(request.session['aid']) user = DBSession.query(User).filter_by(id=user_id).first() year = request.matchdict['year'] account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or ( user.is_administrator == False and user.permissions_global_financials == False): return HTTPFound(request.application_url) financials = account.getFinancials(year, user) return dict(logged_in=authenticated_userid(request), header=getHeader(), financials=financials, year=year, account=account, user=user) except: return HTTPFound(request.application_url)
def administration_revenue(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) account = DBSession.query(Account).filter_by(id=account_id).first() user = DBSession.query(User).filter_by(id=user_id).first() if user is None or account is None or not (user.is_administrator or user.permissions_global_financials): return HTTPFound(request.application_url) if request.method == "POST": quarter_end_date_text = request.params.get("quarter_end_type") quarter_end_year_text = request.params.get("quarter_end_year") quarter_end_date_parts = quarter_end_date_text.split("/") quarter_end_date = datetime.date(long(quarter_end_year_text), long(quarter_end_date_parts[0]), long(quarter_end_date_parts[1])) for project in account.projects: revenue_local = long(request.params.get(str(project.id) + "-revenue")) if user.currency is None: revenue = revenue_local else: revenue = revenue_local * user.currency.currency_to_usd actual_revenue = DBSession.query(ActualRevenue).filter_by(project_id=project.id).filter_by( quarter_end_date=quarter_end_date).first() if actual_revenue is not None: actual_revenue.revenue = revenue else: actual_revenue = ActualRevenue(project, revenue, quarter_end_date) DBSession.flush() return HTTPFound(request.application_url + "/administration/company") return dict(logged_in=authenticated_userid(request), header=Header("administration"), account=account, user=user) except: traceback.print_exc() return HTTPFound(request.application_url)
def roles(request): department_id = request.matchdict.get('department_id') user = DBSession.query(User).filter_by( id=long(request.session['uid'])).first() roles = [] if department_id == 'all': if user.permissions.is_administrator or user.permissions.can_view_all_departments: roles = DBSession.query(Role).filter_by( account_id=long(request.session['aid'])).filter( Role.is_active == True).all() else: HTTPFound(request.application_url) else: if user.permissions.is_administrator or user.permissions.can_view_all_departments: roles = DBSession.query(Role).filter_by( department_id=department_id).filter( Role.is_active == True).all() else: dept_match = False for department in user.permissions.view_departments: if department.id == department_id: roles = DBSession.query(Role).filter_by( department_id=department_id).filter( Role.is_active is True).all() dept_match = True break if dept_match is False: HTTPFound(request.application_url) header = _get_header(department_id) account = DBSession.query(Account).filter_by( id=long(request.session['aid'])).first() return dict(logged_in=authenticated_userid(request), account=account, user=user, roles=roles, active_people="", active_roles="active", header=header, department_id=department_id)
def office_delete(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) office_id = request.matchdict.get('office_id') DBSession.query(Office).filter_by(id=office_id).filter_by( account_id=account_id).update({'is_active': False}) DBSession.flush() return HTTPFound(location=request.application_url + "/administration/company") except: return HTTPFound(request.application_url)
def role_add(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) if request.method == "POST": name = request.params["name"].lower() department_id = long(request.params["department_id"]) salary_low = long(request.params["salary_low"]) salary_high = long(request.params["salary_high"]) department = DBSession.query(Department).filter_by( id=department_id).filter_by(account_id=account.id).first() role_ok = True for role in department.roles: if role.name == name: role_ok = False break if role_ok: new_role = Role(account, name, department, salary_high, salary_low) DBSession.add(new_role) DBSession.flush() if request.params.get("add_another") is None: return HTTPFound(request.application_url + "/administration/company") departments = DBSession.query(Department).filter_by( account_id=long(request.session['aid'])).all() return dict(logged_in=authenticated_userid(request), header=Header("administration"), departments=departments, user=user) except: return HTTPFound(request.application_url)
def administration_password(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) account = DBSession.query(Account).filter_by(id=account_id).first() user = DBSession.query(User).filter_by(id=user_id).first() if user is None or account is None: return HTTPFound(request.application_url) if request.method == "POST": password = request.params["password"] user.set_password(password) transaction.commit() return HTTPFound(request.application_url) return dict(logged_in=authenticated_userid(request), header=Header("administration"), account=account, user=user) except: return HTTPFound(request.application_url)
def home(request): try: user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() if user is None: return HTTPFound(request.application_url + '/login') except: return HTTPFound(request.application_url + '/login') year = str(datetime.datetime.now().year) if user.is_administrator or user.permissions_global_financials: return HTTPFound(request.application_url + "/global/financials/" + year) if user.permissions_global_utilization or user.is_hr_administrator: return HTTPFound(request.application_url + "/global/utilization/" + year) if user.permissions_global_pipeline: return HTTPFound(request.application_url + "/global/pipeline/" + year) if len(user.permissions_office_financials) > 0: return HTTPFound(request.application_url + "/office/" + str(user.permissions_office_financials[0].id) + "/financials/" + year) if len(user.permissions_office_pipeline) > 0: return HTTPFound(request.application_url + "/office/" + str(user.permissions_office_pipeline[0].id) + "/pipeline/" + year) if len(user.permissions_office_utilization) > 0: return HTTPFound(request.application_url + "/office/" + str(user.permissions_office_utilization[0].id) + "/utilization/" + year) if len(user.permissions_client_financials) > 0: return HTTPFound(request.application_url + "/client/" + str(user.permissions_client_financials[0].id) + "/financials/" + year) if len(user.permissions_client_pipeline) > 0: return HTTPFound(request.application_url + "/client/" + str(user.permissions_client_pipeline[0].id) + "/pipeline/" + year) if len(user.permissions_client_utilization) > 0: return HTTPFound(request.application_url + "/client/" + str(user.permissions_client_utilization[0].id) + "/utilization/" + year) return HTTPFound(request.application_url + '/login')
def skillset_entry_update(request): print("skillset entry update") rating = request.matchdict.get('rating') skillset_entry_id = request.matchdict.get('skillset_entry_id') person_id = request.matchdict.get('person_id') account = DBSession.query(Account).filter_by( id=long(request.session['aid'])).first() user = DBSession.query(User).filter_by( id=long(request.session['uid'])).first() person = DBSession.query(User).filter_by(id=long(person_id)).first() skillset_entry = DBSession.query(SkillsetEntry).filter_by( id=long(skillset_entry_id)).first() if user.permissions.is_administrator or person.manager_id == user.id: if skillset_entry.is_midyear and ( datetime.datetime.now() > account.midyear_review_end_date or datetime.datetime.now() < account.midyear_review_start): return {'ok': 'False'} if skillset_entry.is_midyear == False and ( datetime.datetime.now() > account.annual_review_end_date or datetime.datetime.now() < account.annual_review_start): return {'ok': 'False'} DBSession.query(SkillsetEntry).filter_by(id=skillset_entry_id).update( {'ranking': rating}) return {"ok": "True"} return {'ok': 'False'}
def department_edit(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator is False: return HTTPFound(request.application_url) department_id = request.matchdict['department_id'] if request.method == "POST": name = request.params["name"].lower() dept = DBSession.query(Department).filter_by(account_id=account_id).filter_by(name=name).first() if dept is None or dept.id == department_id: DBSession.query(Department).filter_by(id=department_id).filter_by(account_id=account_id).update( {'name': name}) DBSession.flush() return HTTPFound(location=request.application_url + "/administration/company") department = DBSession.query(Department).filter_by(id=department_id).first() return dict(logged_in=authenticated_userid(request), header=Header("administration"), department=department, user=user) except: return HTTPFound(request.application_url)
def department_edit(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator is False: return HTTPFound(request.application_url) department_id = request.matchdict['department_id'] if request.method == "POST": name = request.params["name"].lower() dept = DBSession.query(Department).filter_by( account_id=account_id).filter_by(name=name).first() if dept is None or dept.id == department_id: DBSession.query(Department).filter_by( id=department_id).filter_by(account_id=account_id).update( {'name': name}) DBSession.flush() return HTTPFound(location=request.application_url + "/administration/company") department = DBSession.query(Department).filter_by( id=department_id).first() return dict(logged_in=authenticated_userid(request), header=Header("administration"), department=department, user=user) except: return HTTPFound(request.application_url)
def department_utilization(request): try: user_id = long(request.session['uid']) account_id = long(request.session['aid']) department_id = request.matchdict['department_id'] year = request.matchdict['year'] user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() department = DBSession.query(Department).filter_by(account_id=account_id).filter_by(id=department_id).first() access_utilization = user.can_access_department(department, "utilization") if user is None or account is None or department is None or access_utilization == False: return HTTPFound(request.application_url) access_financials = user.can_access_department(department, "financials") utilization = department.getUtilization(year) return dict(logged_in=authenticated_userid(request), header=getHeader(department), utilization=utilization, department=department, year=year, user=user, account=account, access_utilization=access_utilization, access_financials=access_financials) except: traceback.print_exc() return HTTPFound(request.application_url)
def currency_edit(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) currency_id = long(request.matchdict['currency_id']) currency = DBSession.query(Currency).filter_by(id=currency_id).first() if currency == None: return HTTPFound(request.application_url + "/administration/company") if request.method == "POST": error = False name = request.params["name"].lower() if name == "usd": error = True currency_to_usd = float(request.params["currency_to_usd"]) cur = DBSession.query(Currency).filter_by( account_id=account_id).filter_by(name=name).first() if cur is not None and cur.id != currency_id: error = True if error == False: currency.name = name currency.currency_to_usd = currency_to_usd DBSession.flush() return HTTPFound(request.application_url + "/administration/company") return dict(logged_in=authenticated_userid(request), header=Header("administration"), currency=currency, user=user) except: return HTTPFound(request.application_url)
def person_disable_login(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or (user.is_administrator == False and user.is_hr_administrator == False): return HTTPFound(request.application_url) person_id = request.matchdict.get('person_id') person = DBSession.query(User).filter_by(id=person_id).filter_by(account_id=account_id) if person is not None: password = None DBSession.query(User).filter_by(id=person_id).filter_by(account_id=account_id).update( {'password': password}) DBSession.flush() return HTTPFound(request.application_url + "/administration/employees") except: return HTTPFound(request.application_url)
def client_utilization(request): try: user_id = long(request.session['uid']) account_id = long(request.session['aid']) client_id = request.matchdict['client_id'] year = request.matchdict['year'] user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() client = DBSession.query(Client).filter_by(account_id=account_id).filter_by(id=client_id).first() access_utilization = user.can_access_client(client, "utilization") if user is None or account is None or client is None or access_utilization == False: return HTTPFound(request.application_url) access_pipeline = user.can_access_client(client, "pipeline") access_financials = user.can_access_client(client, "financials") utilization = client.getUtilization(year) return dict(logged_in=authenticated_userid(request), header=getHeader(client), utilization=utilization, client=client, year=year, user=user, account=account, access_pipeline=access_pipeline, access_utilization=access_utilization, access_financials=access_financials) except: return HTTPFound(request.application_url)
def client_delete(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None: return HTTPFound(request.application_url) client_id = request.matchdict.get('client_id') client = DBSession.query(Client).filter_by(id=client_id).filter_by(account_id=account_id).first() if client is None or user.can_access_client(client, "financials") == False: return HTTPFound(request.application_url) client.is_active = False DBSession.flush() return HTTPFound(request.application_url + "/office/" + str(client.office_id) + "/clients/" + str( datetime.datetime.now().year)) except: return HTTPFound(request.application_url)
def role_add(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) if request.method == "POST": name = request.params["name"].lower() department_id = long(request.params["department_id"]) salary_low = long(request.params["salary_low"]) salary_high = long(request.params["salary_high"]) department = DBSession.query(Department).filter_by(id=department_id).filter_by( account_id=account.id).first() role_ok = True for role in department.roles: if role.name == name: role_ok = False break if role_ok: new_role = Role(account, name, department, salary_high, salary_low) DBSession.add(new_role) DBSession.flush() if request.params.get("add_another") is None: return HTTPFound(request.application_url + "/administration/company") departments = DBSession.query(Department).filter_by(account_id=long(request.session['aid'])).all() return dict(logged_in=authenticated_userid(request), header=Header("administration"), departments=departments, user=user) except: return HTTPFound(request.application_url)
def freelancer_delete(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None: return HTTPFound(request.application_url) freelancer_id = request.matchdict.get('freelancer_id') freelancer = DBSession.query(Freelancer).filter_by(id=freelancer_id).filter_by(account_id=account_id).first() if freelancer is None: return HTTPFound(request.application_url) if freelancer.office is None and freelancer.client is None: return HTTPFound(request.application_url) if freelancer.office is not None and user.can_access_office(freelancer.office, "utilization") == False: return HTTPFound(request.application_url) if freelancer.client is not None and user.can_access_client(freelancer.client, "utilization") == False: return HTTPFound(request.application_url) source_id = freelancer.client_id DBSession.delete(freelancer) DBSession.flush() return HTTPFound( request.application_url + "/client/" + str(source_id) + "/utilization/" + str(datetime.datetime.now().year)) except: print("*************") traceback.print_exc() return HTTPFound(request.application_url)
def department_add(request): try: account_id = long(request.session['aid']) user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None or user.is_administrator == False: return HTTPFound(request.application_url) if request.method == "POST": name = request.params["name"].lower() dept = DBSession.query(Department).filter_by(account_id=account_id).filter_by(name=name).first() if dept is None: new_department = Department(name, account) DBSession.add(new_department) DBSession.flush() if request.params.get("add_another") is None: return HTTPFound(location=request.application_url + "/administration/company") return dict(logged_in=authenticated_userid(request), header=Header("administration"), user=user) except: return HTTPFound(request.application_url)
def client_edit(request): try: user_id = long(request.session['uid']) account_id = long(request.session['aid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() client_id = long(request.matchdict['client_id']) client = DBSession.query(Client).filter_by(account_id=account_id).filter_by(id=client_id).first() if user is None or account is None or client is None: return HTTPFound(request.application_url) if request.method == "POST": name = request.params["name"].lower() code = request.params["client_code"] target_margin = request.params["target_margin"] office_id = long(request.params["office_id"]) office_temp = DBSession.query(Office).filter_by(id=office_id).filter_by(account_id=account_id).first() client_temp = DBSession.query(Client).filter_by(account_id=account_id).filter_by(name=name).first() if office_temp is None or user.can_access_client(client, "financials") == False or user.can_access_office( office_temp, "financials") == False: return HTTPFound(request.application_url) if client_temp is not None and client_temp.id != client.id: return HTTPFound(request.application_url) client.name = name client.code = code client.office = office_temp client.target_margin = target_margin DBSession.flush() return HTTPFound( request.application_url + "/office/" + str(office_id) + "/clients/" + str(datetime.datetime.now().year)) offices_all = DBSession.query(Office).filter_by(account_id=long(request.session['aid'])).all() offices = [] if user.is_administrator or user.permissions_global_financials: offices = offices_all else: for office in offices_all: if user.can_access_office(office, "financials"): offices.append(office) if len(offices) == 0: return HTTPFound(request.application_url) return dict(logged_in=authenticated_userid(request), header=getHeader(client), offices=offices, user=user, client=client, account=account) except: return HTTPFound(request.application_url)
def home(request): try: user_id = long(request.session['uid']) user = DBSession.query(User).filter_by(id=user_id).first() if user is None: return HTTPFound(request.application_url + '/login') except: return HTTPFound(request.application_url + '/login') year = str(datetime.datetime.now().year) if user.is_administrator or user.permissions_global_financials: return HTTPFound(request.application_url + "/global/financials/" + year) if user.permissions_global_utilization or user.is_hr_administrator: return HTTPFound(request.application_url + "/global/utilization/" + year) if user.permissions_global_pipeline: return HTTPFound(request.application_url + "/global/pipeline/" + year) if len(user.permissions_office_financials) > 0: return HTTPFound(request.application_url + "/office/" + str( user.permissions_office_financials[0].id) + "/financials/" + year) if len(user.permissions_office_pipeline) > 0: return HTTPFound( request.application_url + "/office/" + str(user.permissions_office_pipeline[0].id) + "/pipeline/" + year) if len(user.permissions_office_utilization) > 0: return HTTPFound(request.application_url + "/office/" + str( user.permissions_office_utilization[0].id) + "/utilization/" + year) if len(user.permissions_client_financials) > 0: return HTTPFound(request.application_url + "/client/" + str( user.permissions_client_financials[0].id) + "/financials/" + year) if len(user.permissions_client_pipeline) > 0: return HTTPFound( request.application_url + "/client/" + str(user.permissions_client_pipeline[0].id) + "/pipeline/" + year) if len(user.permissions_client_utilization) > 0: return HTTPFound(request.application_url + "/client/" + str( user.permissions_client_utilization[0].id) + "/utilization/" + year) return HTTPFound(request.application_url + '/login')
def client_assign_ghost(request): try: user_id = long(request.session['uid']) account_id = long(request.session['aid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None: return HTTPFound(request.application_url) if request.method == "POST": ghost_user_id = request.params.get('ghost_user_id') if ghost_user_id is None or len(ghost_user_id) == 0 or ghost_user_id == '': return HTTPFound(request.application_url) ghost_user = DBSession.query(GhostUser).filter_by(id=ghost_user_id).filter_by(account_id=account_id).first() client_id = request.params.get('client_id') client = None if client_id is not None and len(client_id) > 0 and client_id != '': client = DBSession.query(Client).filter_by(account_id=account_id).filter_by(id=long(client_id)).first() ghost_client_id = request.params.get('ghost_client_id') ghost_client = None if ghost_client_id is not None and len(ghost_client_id) > 0 and ghost_client_id != '': ghost_client = DBSession.query(GhostClient).filter_by(account_id=account_id).filter_by( id=long(ghost_client_id)).first() if client is None and ghost_client is None: return HTTPFound(request.application_url) if client is not None and user.can_access_client(client, "utilization") == False: return HTTPFound(request.application_url) if ghost_client is not None and user.can_access_office(ghost_client.office, "utilization") == False: return HTTPFound(request.application_url) utilization = long(request.params["utilization"]) start_date_text = request.params["start_date"] start_dateparts = start_date_text.split("/") start_date = datetime.date(long(start_dateparts[2]), long(start_dateparts[0]), long(start_dateparts[1])) end_date_text = request.params["end_date"] end_dateparts = end_date_text.split("/") end_date = datetime.date(long(end_dateparts[2]), long(end_dateparts[0]), long(end_dateparts[1])) if ghost_user.start_date.date() > start_date or start_date > end_date: print('**** late start') return HTTPFound(request.path) gua = GhostAllocation(ghost_user, client, ghost_client, utilization, start_date, end_date) DBSession.add(gua) if ghost_user.start_date.date() > start_date: ghost_user.start_date = datetime.datetime.combine(start_date, datetime.time()) DBSession.flush() if client is not None: return HTTPFound(request.application_url + "/client/" + str(client_id) + "/utilization/" + str( datetime.datetime.now().year)) if ghost_client is not None: return HTTPFound( request.application_url + "/ghost/client/" + str(ghost_client_id) + "/utilization/" + str( datetime.datetime.now().year)) currentClientId = request.params.get('clientid') currentClient = None if currentClientId is not None: currentClient = DBSession.query(Client).filter_by(id=currentClientId).filter_by(is_active=True).first() currentGhostClientId = request.params.get('ghostclientid') currentGhostClient = None if currentGhostClientId is not None: currentGhostClient = DBSession.query(GhostClient).filter_by(id=currentGhostClientId).filter_by( is_active=True).first() clients_all = DBSession.query(Client).filter_by(account_id=account_id).all() clients = [] if user.is_administrator or user.permissions_global_utilization: clients = clients_all else: for client in clients_all: if user.can_access_client(client, "utilization"): clients.append(client) if len(clients) == 0: return HTTPFound(request.application_url) #fix to handle disabled ghost_users_all = DBSession.query(GhostUser).filter_by(account_id=account_id).all() ghost_users = [] if user.is_administrator or user.permissions_global_utilization: ghost_users = ghost_users_all else: for ghost_user in ghost_users: if user.can_access_office(ghost_user.office, "utilization"): ghost_users.append(ghost_user) ghost_clients = [] ghost_clients_all = DBSession.query(GhostClient).filter_by(account_id=account_id).all() if user.is_administrator or user.permissions_global_utilization: ghost_clients = ghost_clients_all else: for ghost_client in ghost_clients_all: if user.can_access_office(ghost_client.office, "utilization"): ghost_clients.append(ghost_client) return dict(logged_in=authenticated_userid(request), header=getHeader(None), clients=clients, ghost_users=ghost_users, user=user, account=account, ghost_clients=ghost_clients, currentClient=currentClient, currentGhostClient=currentGhostClient) except: print("*****") traceback.print_exc() return HTTPFound(request.application_url)
def client_assign_resource(request): try: user_id = long(request.session['uid']) account_id = long(request.session['aid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None: return HTTPFound(request.application_url) if request.method == "POST": client_id = long(request.params['client_id']) client = DBSession.query(Client).filter_by(account_id=account_id).filter_by(id=client_id).first() person_id = long(request.params["user_id"]) person = DBSession.query(User).filter_by(id=person_id).filter_by(account_id=account_id).first() utilization = long(request.params["utilization"]) start_date_text = request.params["start_date"] start_dateparts = start_date_text.split("/") start_date = datetime.date(long(start_dateparts[2]), long(start_dateparts[0]), long(start_dateparts[1])) end_date_text = request.params["end_date"] end_dateparts = end_date_text.split("/") end_date = datetime.date(long(end_dateparts[2]), long(end_dateparts[0]), long(end_dateparts[1])) if person is None or client is None or user.can_access_client(client, "utilization") == False: return HTTPFound(request.application_url) if person.start_date.date() > start_date or start_date > end_date: print("*** late start") return HTTPFound(request.path) ua = UserAllocation(person, client, None, utilization, start_date, end_date) DBSession.add(ua) DBSession.flush() return HTTPFound(request.application_url + "/client/" + str(client_id) + "/utilization/" + str( datetime.datetime.now().year)) clients_all = DBSession.query(Client).filter_by(account_id=account_id).filter_by(is_active=True).all() clients = [] if user.is_administrator or user.permissions_global_utilization: clients = clients_all else: for client in clients_all: if user.can_access_client(client, "utilization"): clients.append(client) if len(clients) == 0: return HTTPFound(request.application_url) access_administration = user.is_administrator # fix this so the filtering is btter instead of doing a big loop users_all = DBSession.query(User).filter_by(account_id=account_id).filter_by(is_active=True).all() users = [] for u in users_all: if u.is_active and u.percent_billable > 0 and user.can_access_office(u.office, "utilization"): users.append(u) if len(users) == 0: return HTTPFound(request.application_url) currentClientId = request.params.get('clientid') currentClient = None if currentClientId is not None: currentClient = DBSession.query(Client).filter_by(id=currentClientId).filter_by(is_active=True).first() return dict(logged_in=authenticated_userid(request), header=getHeader(None), clients=clients, users=users, user=user, account=account, access_administration=access_administration, currentClient=currentClient) except: print("*****") traceback.print_exc() return HTTPFound(request.application_url)
def client_add(request): try: user_id = long(request.session['uid']) account_id = long(request.session['aid']) user = DBSession.query(User).filter_by(id=user_id).first() account = DBSession.query(Account).filter_by(id=account_id).first() if user is None or account is None: return HTTPFound(request.application_url) if request.method == "POST": name = request.params["name"].lower() code = request.params["client_code"] office_id = long(request.params["office_id"]) project_name = request.params["project_name"] project_code = request.params["project_code"] target_margin = request.params["target_margin"] revenue_local = long(request.params["revenue"]) if user.currency is None: revenue = revenue_local else: revenue = revenue_local * user.currency.currency_to_usd start_date_text = request.params["start_date"] start_dateparts = start_date_text.split("/") start_date = datetime.date(long(start_dateparts[2]), long(start_dateparts[0]), long(start_dateparts[1])) end_date_text = request.params["end_date"] end_dateparts = end_date_text.split("/") end_date = datetime.date(long(end_dateparts[2]), long(end_dateparts[0]), long(end_dateparts[1])) office = DBSession.query(Office).filter_by(id=office_id).filter_by(account_id=account_id).first() client = DBSession.query(Client).filter_by(account_id=account_id).filter_by(name=name).first() if client is None and office is not None and user.can_access_office(office, "financials"): new_client = Client(name, office, code, target_margin) DBSession.add(new_client) new_project = Project(project_name, project_code, account, new_client, revenue, start_date, end_date) DBSession.add(new_project) department_matches = [] for department in account.departments: percent_allocation = request.params.get(str(department.id) + "-allocation") if percent_allocation is not None and percent_allocation != "": department_matches.append(str(department.id) + "-" + str(percent_allocation)) DBSession.flush() for d in department_matches: ds = d.split('-') department = DBSession.query(Department).filter_by(id=int(ds[0])).first() budget_allocation = BudgetAllocation(department, new_project, None, int(ds[1])) DBSession.add(budget_allocation) DBSession.flush() if request.params.get("add_another") is None: return HTTPFound(request.application_url + "/office/" + str(office_id) + "/clients/" + str( datetime.datetime.now().year)) officeId = request.params.get('officeid') currentOffice = None if officeId is not None: currentOffice = DBSession.query(Office).filter_by(id=officeId).filter_by(is_active=True).first() offices_all = DBSession.query(Office).filter_by(account_id=long(request.session['aid'])).all() offices = [] if user.is_administrator or user.permissions_global_financials: offices = offices_all else: for office in offices_all: if user.can_access_office(office, "financials"): offices.append(office) return dict(logged_in=authenticated_userid(request), header=getHeader(None), offices=offices, user=user, account=account, currentOffice=currentOffice) except: traceback.print_exc() return HTTPFound(request.application_url)