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 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 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 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 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 main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
huge = Account("Finance", 2013)
office = Office("New York", 10, huge)
corporate = Department("Corporate", huge)
ceo = Role(huge, "Senior Developer", corporate, 150000, 50000)
aaron = User(huge, "Atish Narlawar", "*****@*****.**", office, ceo, 100000, datetime.date(2012, 1, 1))
aaron.set_password("atish")
aaron.is_administrator = True
salary = Salary(aaron, 100000, 1, datetime.date(2012, 1, 1), 100)
aaron.salary_history.append(salary)
DBSession.add(aaron)
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
huge = Account("Finance", 2013)
office = Office("New York", 10, huge)
corporate = Department("Corporate", huge)
ceo = Role(huge, "Senior Developer", corporate, 150000, 50000)
aaron = User(huge, "Atish Narlawar", "*****@*****.**", office,
ceo, 100000, datetime.date(2012, 1, 1))
aaron.set_password("atish")
aaron.is_administrator = True
salary = Salary(aaron, 100000, 1, datetime.date(2012, 1, 1), 100)
aaron.salary_history.append(salary)
DBSession.add(aaron)
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 skillset_entry_add(request):
rating = request.matchdict.get('rating')
skillset_id = request.matchdict.get('skillset_id')
person_id = request.matchdict.get('person_id')
review_id = request.matchdict.get('review_id')
interval = request.matchdict.get('interval')
is_midyear = False
if interval == "midyear":
is_midyear = True
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()
review = DBSession.query(Review).filter_by(id=long(review_id)).first()
skillset = DBSession.query(Skillset).filter_by(
id=long(skillset_id)).first()
if user.permissions.is_administrator or person.manager_id == user.id:
if is_midyear and (
datetime.datetime.now() > account.midyear_review_end_date
or datetime.datetime.now() < account.midyear_review_start):
return {'ok': 'False'}
if is_midyear == False and (
datetime.datetime.now() > account.annual_review_end_date
or datetime.datetime.now() < account.annual_review_start):
return {'ok': 'False'}
skillset_entry = SkillsetEntry(review, is_midyear, skillset, rating)
DBSession.add(skillset_entry)
transaction.commit()
return {"ok": "True"}
return {'ok': 'False'}
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 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 freelancer_convert(request):
try:
freelancer_id = long(request.matchdict['freelancer_id'])
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 = DBSession.query(Freelancer).filter_by(account_id=account_id).filter_by(id=freelancer_id).first()
if freelancer is None:
return HTTPFound(request.application_url)
if request.method == "POST":
email = request.params["email"]
person = DBSession.query(User).filter_by(email=email).first()
if person is not None:
source = 'financials'
else:
account = DBSession.query(Account).filter_by(id=account_id).first()
name = request.params["name"].lower()
if request.params.get("employee_number") is None or request.params.get("employee_number") == '':
employee_number = 0
else:
employee_number = long(request.params.get("employee_number"))
if request.params.get("salary") is None or request.params.get("salary") == '':
salary = 0
else:
salary_local = long(request.params.get("salary"))
if user.currency is None:
salary = salary_local
else:
salary = salary_local * user.currency.currency_to_usd
if request.params.get("office_id") is None or request.params.get("office_id") == '':
office_id = None
office = None
else:
office_id = long(request.params.get("office_id"))
office = DBSession.query(Office).filter_by(id=office_id).filter_by(account_id=account_id).first()
if request.params.get("role_id") is None or request.params.get("role_id") == '':
role_id = None
return HTTPFound(request.application_url + "/person/add")
else:
role_id = long(request.params.get("role_id"))
role = DBSession.query(Role).filter_by(id=role_id).first()
if request.params.get("percent_billable") is None or request.params.get("percent_billable") == '':
percent_billable = 100
elif request.params.get("percent_billable") == '0':
percent_billable = 0
else:
percent_billable = long(request.params.get("percent_billable"))
if request.params.get("currency_id") is None or request.params.get("currency_id") == '':
currency_id = None
currency = None
else:
currency_id = long(request.params.get("currency_id"))
currency = DBSession.query(Currency).filter_by(id=currency_id).filter_by(
account_id=account_id).first()
start_date_text = request.params.get("start_date")
if start_date_text is None or start_date_text == '':
start_date = datetime.datetime.now()
else:
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("end_date")
if end_date_text is None or end_date_text == '':
end_date = None
else:
end_dateparts = end_date_text.split("/")
end_date = datetime.date(long(end_dateparts[2]), long(end_dateparts[0]), long(end_dateparts[1]))
is_administrator = False
is_hr_administrator = False
u = DBSession.query(User).filter_by(email=email).first()
if u is not None:
return HTTPFound(request.application_url + "/person/add")
new_user = User(account, name, email, office, role, salary, start_date)
new_user.employee_number = employee_number
new_user.percent_billable = percent_billable
new_user.end_date = end_date
new_user.is_administrator = is_administrator
new_user.is_hr_administrator = is_hr_administrator
new_user.currency = currency
s = Salary(new_user, salary, role.id, start_date)
new_user.salary_history.append(s)
DBSession.add(new_user)
freelancer.converted_fulltime = True
expected_freelancer_end_date = start_date - timedelta(days=1)
if freelancer.end_date.date() > expected_freelancer_end_date:
freelancer.end_date = expected_freelancer_end_date
DBSession.flush()
return HTTPFound(request.application_url + "/client/" + str(freelancer.client.id) + "/utilization/" + str(datetime.datetime.now().year))
departments = DBSession.query(Department).filter_by(account_id=account_id).all()
offices = DBSession.query(Office).filter_by(account_id=account_id).all()
roles = DBSession.query(Role).filter_by(account_id=account_id).all()
currencies = DBSession.query(Currency).filter_by(account_id=account_id).all()
return dict(logged_in=authenticated_userid(request), header=Header('financials'),
offices=offices, roles=roles, freelancer=freelancer, currencies=currencies, user=user,
account=account, departments=departments)
except:
print("*************")
traceback.print_exc()
return HTTPFound(request.application_url)
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 administration_expenses_clients(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()
year = str(datetime.datetime.now().year)
quarter_end_year_text = None
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 client in account.clients:
if request.params.get(str(client.id) + "-expense") is not None and request.params.get(
str(client.id) + "-expense") != "":
expense_lc = long(request.params.get(str(client.id) + "-expense"))
else:
expense_lc = 0
if user.currency is None:
expense_local = expense_lc
else:
expense_local = expense_lc * user.currency.currency_to_usd
actual_expense = DBSession.query(ActualExpense).filter_by(client_id=client.id).filter_by(
quarter_end_date=quarter_end_date).first()
if actual_expense is not None:
actual_expense.expense_local += expense_local
else:
actual_expense = ActualExpense(None, client, expense_local, None, quarter_end_date)
DBSession.add(actual_expense)
DBSession.flush()
usd_to_local = 1
if user.currency is not None:
usd_to_local = user.currency.usd_to_currency
if quarter_end_year_text is not None:
expense_year = int(quarter_end_year_text)
else:
expense_year = int(year)
all_client_expense_sga = []
for client in account.clients:
client_expense_sga = [0, 0, 0, 0]
for actual_expense in client.actual_expenses:
if actual_expense.quarter_end_date.year == expense_year:
if actual_expense.quarter_end_date.month == 3:
if actual_expense.expense_local is not None:
client_expense_sga[0] = actual_expense.expense_local * usd_to_local
elif actual_expense.quarter_end_date.month == 6:
if actual_expense.expense_local is not None:
client_expense_sga[1] = actual_expense.expense_local * usd_to_local
elif actual_expense.quarter_end_date.month == 9:
if actual_expense.expense_local is not None:
client_expense_sga[2] = actual_expense.expense_local * usd_to_local
elif actual_expense.quarter_end_date.month == 12:
if actual_expense.expense_local is not None:
client_expense_sga[3] = actual_expense.expense_local * usd_to_local
all_client_expense_sga.append(client_expense_sga)
return dict(logged_in=authenticated_userid(request), header=Header("administration"), account=account,
user=user, year=year, all_client_expense_sga=all_client_expense_sga, expense_year=expense_year)
except:
traceback.print_exc()
return HTTPFound(request.application_url)
def administration_expenses_clients(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()
year = str(datetime.datetime.now().year)
quarter_end_year_text = None
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 client in account.clients:
if request.params.get(str(client.id) + "-expense"
) is not None and request.params.get(
str(client.id) + "-expense") != "":
expense_lc = long(
request.params.get(str(client.id) + "-expense"))
else:
expense_lc = 0
if user.currency is None:
expense_local = expense_lc
else:
expense_local = expense_lc * user.currency.currency_to_usd
actual_expense = DBSession.query(ActualExpense).filter_by(
client_id=client.id).filter_by(
quarter_end_date=quarter_end_date).first()
if actual_expense is not None:
actual_expense.expense_local += expense_local
else:
actual_expense = ActualExpense(None, client, expense_local,
None, quarter_end_date)
DBSession.add(actual_expense)
DBSession.flush()
usd_to_local = 1
if user.currency is not None:
usd_to_local = user.currency.usd_to_currency
if quarter_end_year_text is not None:
expense_year = int(quarter_end_year_text)
else:
expense_year = int(year)
all_client_expense_sga = []
for client in account.clients:
client_expense_sga = [0, 0, 0, 0]
for actual_expense in client.actual_expenses:
if actual_expense.quarter_end_date.year == expense_year:
if actual_expense.quarter_end_date.month == 3:
if actual_expense.expense_local is not None:
client_expense_sga[
0] = actual_expense.expense_local * usd_to_local
elif actual_expense.quarter_end_date.month == 6:
if actual_expense.expense_local is not None:
client_expense_sga[
1] = actual_expense.expense_local * usd_to_local
elif actual_expense.quarter_end_date.month == 9:
if actual_expense.expense_local is not None:
client_expense_sga[
2] = actual_expense.expense_local * usd_to_local
elif actual_expense.quarter_end_date.month == 12:
if actual_expense.expense_local is not None:
client_expense_sga[
3] = actual_expense.expense_local * usd_to_local
all_client_expense_sga.append(client_expense_sga)
return dict(logged_in=authenticated_userid(request),
header=Header("administration"),
account=account,
user=user,
year=year,
all_client_expense_sga=all_client_expense_sga,
expense_year=expense_year)
except:
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 person_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 and user.is_hr_administrator == False):
return HTTPFound(request.application_url)
person_id = long(request.matchdict['person_id'])
person = DBSession.query(User).filter_by(id=person_id).first()
if request.method == "GET":
try:
source = request.params["source"]
except:
source = 'administration'
if request.method == "POST":
name = request.params["name"].lower()
employee_number = request.POST.get('employee_number')
source = request.params["source"]
email = request.params["email"].lower()
salary = long(request.params["salary"])
is_raise = request.POST.get('raise')
change_allocation = request.POST.get('change_allocation')
office_id = request.POST.get('office_id')
if office_id == '':
office = None
else:
office_id = long(office_id)
office = DBSession.query(Office).filter_by(id=office_id).filter_by(account_id=account_id).first()
role_id = long(request.params["role_id"])
role = DBSession.query(Role).filter_by(id=role_id).filter_by(account_id=account_id).first()
percent_billable = long(request.params["percent_billable"])
start_date_text = request.POST.get('start_date')
if start_date_text == '':
start_date = datetime.datetime.now()
else:
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.POST.get('end_date')
if end_date_text == '':
end_date = None
else:
end_dateparts = end_date_text.split("/")
end_date = datetime.date(long(end_dateparts[2]), long(end_dateparts[0]), long(end_dateparts[1]))
currency_id = request.POST.get('currency_id')
if currency_id != '':
currency_id = long(currency_id)
currency = DBSession.query(Currency).filter_by(id=currency_id).first()
else:
currency = None
is_a = long(request.POST.get('is_administrator', '0'))
if is_a == 1:
is_administrator = True
else:
is_administrator = False
is_h_a = long(request.POST.get('is_hr_administrator', '0'))
if is_h_a == 1:
is_hr_administrator = True
else:
is_hr_administrator = False
is_e_a = long(request.POST.get('employee_assignment_access', '0'))
if is_e_a == 1:
employee_assignment_access = True
else:
employee_assignment_access = False
u = DBSession.query(User).filter_by(email=email).first()
if u is None or u.id == person_id:
permissions_office_financials = request.params.getall("permissions_office_financials")
permissions_global_financials = False
for office_id in permissions_office_financials:
if office_id == "all":
permissions_global_financials = True
break
permissions_office_utilization = request.params.getall("permissions_office_utilization")
permissions_global_utilization = False
for office_id in permissions_office_utilization:
if office_id == "all":
permissions_global_utilization = True
break
permissions_office_pipeline = request.params.getall("permissions_office_pipeline")
permissions_global_pipeline = False
for office_id in permissions_office_pipeline:
if office_id == "all":
permissions_global_pipeline = True
break
parsed_name = HumanName(name.lower())
person.first_name = parsed_name.first
person.middle_name = parsed_name.middle
person.last_name = parsed_name.last
person.employee_number = employee_number
person.email = email.lower()
person.salary = salary
person.office = office
person.role = role
person.percent_billable = percent_billable
person.start_date = start_date
person.end_date = end_date
person.currency = currency
person.is_administrator = is_administrator
person.is_hr_administrator = is_hr_administrator
person.employee_assignment_access = employee_assignment_access
person.permissions_global_financials = permissions_global_financials
person.permissions_global_utilization = permissions_global_utilization
person.permissions_global_pipeline = permissions_global_pipeline
person.permissions_office_financials = []
if person.permissions_global_financials == False:
for office_id in permissions_office_financials:
office = DBSession.query(Office).filter_by(account_id=account_id).filter_by(
id=office_id).first()
if office is not None:
person.permissions_office_financials.append(office)
person.permissions_office_utilization = []
if person.permissions_global_utilization == False:
for office_id in permissions_office_utilization:
office = DBSession.query(Office).filter_by(account_id=account_id).filter_by(
id=office_id).first()
if office is not None:
person.permissions_office_utilization.append(office)
person.permissions_office_pipeline = []
if person.permissions_global_pipeline == False:
for office_id in permissions_office_pipeline:
office = DBSession.query(Office).filter_by(account_id=account_id).filter_by(
id=office_id).first()
if office is not None:
person.permissions_office_pipeline.append(office)
person.permissions_client_financials = []
permissions_client_financials = request.params.getall("permissions_client_financials")
for client_id in permissions_client_financials:
client = DBSession.query(Client).filter_by(account_id=account_id).filter_by(id=client_id).first()
if client is not None:
person.permissions_client_financials.append(client)
person.permissions_client_utilization = []
permissions_client_utilization = request.params.getall("permissions_client_utilization")
for client_id in permissions_client_utilization:
client = DBSession.query(Client).filter_by(account_id=account_id).filter_by(id=client_id).first()
if client is not None:
person.permissions_client_utilization.append(client)
person.permissions_client_pipeline = []
permissions_client_pipeline = request.params.getall("permissions_client_pipeline")
for client_id in permissions_client_pipeline:
client = DBSession.query(Client).filter_by(account_id=account_id).filter_by(id=client_id).first()
if client is not None:
person.permissions_client_pipeline.append(client)
person.permissions_department_financials = []
permissions_department_financials = request.params.getall("permissions_department_financials")
for department_id in permissions_department_financials:
department = DBSession.query(Department).filter_by(account_id=account_id).filter_by(
id=client_id).first()
if department is not None:
person.permissions_department_financials.append(department)
person.permissions_department_utilization = []
permissions_department_utilization = request.params.getall("permissions_client_utilization")
for department_id in permissions_client_utilization:
department = DBSession.query(Department).filter_by(account_id=account_id).filter_by(
id=department_id).first()
if department is not None:
person.permissions_department_utilization.append(department)
s = DBSession.query(Salary).filter_by(user_id=person.id).order_by(Salary.start_date.desc()).first()
if (is_raise is not None or change_allocation is not None) and (datetime.datetime.now().date() != s.start_date.date()):
s = Salary(person, salary, role.id, datetime.datetime.now(), percent_billable)
DBSession.add(s)
else:
s.salary = salary
s.role_id = int(role.id)
s.percent_billable = percent_billable
DBSession.flush()
if source == "reviews":
return HTTPFound(request.application_url + "/people/all/all/all")
else:
return HTTPFound(request.application_url + "/administration/employees")
departments = DBSession.query(Department).filter_by(account_id=account_id).all()
offices = DBSession.query(Office).filter_by(account_id=account_id).all()
clients = DBSession.query(Client).filter_by(account_id=account_id).all()
roles = DBSession.query(Role).filter_by(account_id=account_id).all()
currencies = DBSession.query(Currency).filter_by(account_id=account_id).all()
return dict(logged_in=authenticated_userid(request), header=Header(source), departments=departments,
offices=offices, clients=clients, roles=roles, user=user, person=person, currencies=currencies)
except:
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 project_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:
return HTTPFound(request.application_url)
if request.method == "POST":
name = request.params["name"].lower()
code = request.params["project_code"]
client_id = long(request.params["client_id"])
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]))
client = DBSession.query(Client).filter_by(account_id=account_id).filter_by(id=client_id).first()
if client is None or user.can_access_client(client, "financials") == False:
return HTTPFound(request.application_url)
for project in client.projects:
if project.name == name:
return HTTPFound(request.application_url)
new_project = Project(name, code, account, client, revenue, start_date, end_date)
DBSession.add(new_project)
DBSession.flush()
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))
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 + "/client/" + str(client_id) + "/projects/" + str(
datetime.datetime.now().year))
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)
return dict(logged_in=authenticated_userid(request), header=Header("financials"), clients=clients, user=user,
account=account)
except:
return HTTPFound(request.application_url)
def freelancer_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:
return HTTPFound(request.application_url)
if request.method == "POST":
name = request.params["name"].lower()
role_id = long(request.params["role_id"])
client_id = request.params.get('client_id')
office_id = request.params.get('office_id')
client = None
if client_id is not None and client_id != '' and len(client_id) > 0:
client = DBSession.query(Client).filter_by(account_id=account_id).filter_by(id=long(client_id)).first()
office = None
if office_id is not None and office_id != '' and len(office_id) > 0:
office = DBSession.query(Office).filter_by(account_id=account_id).filter_by(id=long(office_id)).first()
if client is None and office is None:
return HTTPFound(request.application_url)
utilization = long(request.params["utilization"])
hourly_rate_local = long(request.params["hourly_rate"])
if user.currency is None:
hourly_rate = hourly_rate_local
else:
hourly_rate = hourly_rate_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]))
role = DBSession.query(Role).filter_by(id=role_id).filter_by(account_id=account_id).first()
if office is not None and user.can_access_office(office, "utilization") == False:
return HTTPFound(request.application_url)
if client is not None and user.can_access_client(client, "utilization") == False:
return HTTPFound(request.application_url)
freelancer = Freelancer(account, name, role, start_date, end_date, hourly_rate, utilization, client, office)
DBSession.add(freelancer)
DBSession.flush()
if request.params.get("add_another") is None:
if client is not None:
return HTTPFound(request.application_url + "/client/" + str(client_id) + "/utilization/" + str(
datetime.datetime.now().year))
if office is not None:
return HTTPFound(request.application_url + "/office/" + str(office_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()
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)
offices_all = DBSession.query(Office).filter_by(account_id=account_id).all()
offices = []
if user.is_administrator or user.permissions_global_utilization:
offices = offices_all
else:
for office in offices_all:
if user.can_access_office(office, "utilization"):
offices.append(office)
if len(offices) == 0:
return HTTPFound(request.application_url)
roles = DBSession.query(Role).filter_by(account_id=account_id).all()
return dict(logged_in=authenticated_userid(request), header=Header('financials'), clients=clients,
offices=offices, roles=roles, user=user, account=account, currentClient=currentClient)
except:
return HTTPFound(request.application_url)
def person_assign_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:
return HTTPFound(request.application_url)
person_id = long(request.matchdict['person_id'])
person = DBSession.query(User).filter_by(id=person_id).first()
if person is None or user.can_access_office(person.office, "utilization") == False:
return HTTPFound(request.application_url)
if request.method == "POST":
client_id = request.params.get("client_id")
ghost_client_id = request.params.get("ghost_client_id")
client = None
ghost_client = None
if client_id is not None and client_id != '' and len(client_id) > 0:
client = DBSession.query(Client).filter_by(id=client_id).filter_by(account_id=account_id).first()
if ghost_client_id is not None and ghost_client_id != '' and len(ghost_client_id) > 0:
ghost_client = DBSession.query(GhostClient).filter_by(id=ghost_client_id).filter_by(
account_id=account_id).first()
if client is None and ghost_client is None:
print("*** no client")
return HTTPFound(request.application_url)
if client is not None and user.can_access_client(client, "utilization") == False:
print("*** no client permission")
return HTTPFound(request.application_url)
if ghost_client is not None and user.can_access_office(ghost_client.office, "utilization") == False:
print("*** no ghost client permission")
return HTTPFound(request.application_url)
utilization = long(request.params.get("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.start_date.date() > start_date or start_date > end_date:
print("*** late start")
return HTTPFound(request.path)
ua = UserAllocation(person, client, ghost_client, utilization, start_date, end_date)
DBSession.add(ua)
DBSession.flush()
return HTTPFound(request.application_url + "/office/" + str(person.office_id) + "/utilization/" + str(
datetime.datetime.now().year))
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)
ghost_clients_all = DBSession.query(GhostClient).filter_by(account_id=account_id).all()
ghost_clients = []
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)
if len(clients) == 0 and len(ghost_clients) == 0:
return HTTPFound(request.application_url)
return dict(logged_in=authenticated_userid(request), header=Header("financials"), clients=clients,
ghost_clients=ghost_clients, person=person, user=user, account=account)
except:
print("*****")
traceback.print_exc()
return HTTPFound(request.application_url)
def person_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 and user.is_hr_administrator == False):
return HTTPFound(request.application_url)
if request.method == "GET":
source = request.params.get("source")
if source is None or source == '' or len(source) == 0:
source = 'financials'
if request.method == "POST":
email = request.params["email"]
person = DBSession.query(User).filter_by(email=email).first()
if person is not None:
source = 'financials'
else:
account = DBSession.query(Account).filter_by(id=account_id).first()
name = request.params["name"].lower()
if request.params.get("employee_number") is None or request.params.get("employee_number") == '':
employee_number = 0
else:
employee_number = long(request.params.get("employee_number"))
source = request.params["source"]
if request.params.get("salary") is None or request.params.get("salary") == '':
salary = 0
else:
salary_local = long(request.params.get("salary"))
if user.currency is None:
salary = salary_local
else:
salary = salary_local * user.currency.currency_to_usd
if request.params.get("office_id") is None or request.params.get("office_id") == '':
office_id = None
office = None
else:
office_id = long(request.params.get("office_id"))
office = DBSession.query(Office).filter_by(id=office_id).filter_by(account_id=account_id).first()
if request.params.get("role_id") is None or request.params.get("role_id") == '':
role_id = None
return HTTPFound(request.application_url + "/person/add")
else:
role_id = long(request.params.get("role_id"))
role = DBSession.query(Role).filter_by(id=role_id).first()
if request.params.get("percent_billable") is None or request.params.get("percent_billable") == '':
percent_billable = 100
elif request.params.get("percent_billable") == '0':
percent_billable = 0
else:
percent_billable = long(request.params.get("percent_billable"))
if request.params.get("currency_id") is None or request.params.get("currency_id") == '':
currency_id = None
currency = None
else:
currency_id = long(request.params.get("currency_id"))
currency = DBSession.query(Currency).filter_by(id=currency_id).filter_by(account_id=account_id).first()
start_date_text = request.params.get("start_date")
if start_date_text is None or start_date_text == '':
start_date = datetime.datetime.now()
else:
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("end_date")
if end_date_text is None or end_date_text == '':
end_date = None
else:
end_dateparts = end_date_text.split("/")
end_date = datetime.date(long(end_dateparts[2]), long(end_dateparts[0]), long(end_dateparts[1]))
if request.params.get("is_administrator") is None or request.params.get("is_administrator") == '':
is_administrator = False
else:
is_administrator = True
if request.params.get("is_hr_administrator") is None or request.params.get("is_hr_administrator") == '':
is_hr_administrator = False
else:
is_hr_administrator = True
if request.params.get("employee_assignment_access") is None or request.params.get("employee_assignment_access") == '':
employee_assignment_access = False
else:
employee_assignment_access = True
u = DBSession.query(User).filter_by(email=email).first()
if u is not None:
return HTTPFound(request.application_url + "/person/add")
new_user = User(account, name, email, office, role, salary, start_date)
new_user.employee_number = employee_number
new_user.percent_billable = percent_billable
new_user.end_date = end_date
new_user.is_administrator = is_administrator
new_user.is_hr_administrator = is_hr_administrator
new_user.currency = currency
new_user.employee_assignment_access = employee_assignment_access
permissions_office_financials = request.params.getall("permissions_office_financials")
for office_id in permissions_office_financials:
if office_id == "all":
new_user.permissions_global_financials = True
break
if new_user.permissions_global_financials == False:
for office_id in permissions_office_financials:
office = DBSession.query(Office).filter_by(account_id=account_id).filter_by(id=office_id).first()
if office is not None:
new_user.permissions_office_financials.append(office)
permissions_office_pipeline = request.params.getall("permissions_office_pipeline")
for office_id in permissions_office_pipeline:
if office_id == "all":
new_user.permissions_global_pipeline = True
break
if new_user.permissions_global_pipeline == False:
for office_id in permissions_office_pipeline:
office = DBSession.query(Office).filter_by(account_id=account_id).filter_by(id=office_id).first()
if office is not None:
new_user.permissions_office_pipeline.append(office)
permissions_office_utilization = request.params.getall("permissions_office_utilization")
for office_id in permissions_office_utilization:
if office_id == "all":
new_user.permissions_global_utilization = True
break
if new_user.permissions_global_utilization == False:
for office_id in permissions_office_utilization:
office = DBSession.query(Office).filter_by(account_id=account_id).filter_by(id=office_id).first()
if office is not None:
new_user.permissions_office_utilization.append(office)
permissions_client_financials = request.params.getall("permissions_client_financials")
for client_id in permissions_client_financials:
client = DBSession.query(Client).filter_by(account_id=account_id).filter_by(id=client_id).first()
if client is not None:
new_user.permissions_client_financials.append(client)
permissions_client_pipeline = request.params.getall("permissions_client_pipeline")
for client_id in permissions_client_pipeline:
client = DBSession.query(Office).filter_by(account_id=account_id).filter_by(id=client_id).first()
if client is not None:
new_user.permissions_client_pipeline.append(client)
permissions_client_utilization = request.params.getall("permissions_client_utilization")
for client_id in permissions_client_utilization:
client = DBSession.query(Office).filter_by(account_id=account_id).filter_by(id=client_id).first()
if client is not None:
new_user.permissions_client_utilization.append(client)
permissions_department_financials = request.params.getall("permissions_department_financials")
for department_id in permissions_department_financials:
department = DBSession.query(Department).filter_by(account_id=account_id).filter_by(
id=department_id).first()
if department is not None:
new_user.permissions_department_financials.append(department)
permissions_department_utilization = request.params.getall("permissions_client_utilization")
for department_id in permissions_client_utilization:
department = DBSession.query(Department).filter_by(account_id=account_id).filter_by(
id=department_id).first()
if department is not None:
new_user.permissions_department_utilization.append(department)
s = Salary(new_user, salary, role.id, start_date)
new_user.salary_history.append(s)
DBSession.add(new_user)
DBSession.flush()
if request.params.get("add_another") is None:
if source == "reviews":
return HTTPFound(request.application_url + "/people/all/all/all")
else:
source = "financials"
return HTTPFound(request.application_url + "/administration/employees")
departments = DBSession.query(Department).filter_by(account_id=account_id).all()
offices = DBSession.query(Office).filter_by(account_id=account_id).all()
clients= DBSession.query(Client).filter_by(account_id=account_id).all()
roles = DBSession.query(Role).filter_by(account_id=account_id).all()
currencies = DBSession.query(Currency).filter_by(account_id=account_id).all()
return dict(logged_in=authenticated_userid(request), header=Header(source), offices=offices, roles=roles,
clients=clients, currencies=currencies, user=user, departments=departments)
except:
traceback.print_exc()
return HTTPFound(request.application_url)
def project_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:
return HTTPFound(request.application_url)
project_id = long(request.matchdict['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:
return HTTPFound(request.application_url)
if request.method == "POST":
name = request.params["name"].lower()
code = request.params["project_code"]
client_id = long(request.params["client_id"])
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]))
client = DBSession.query(Client).filter_by(account_id=account_id).filter_by(id=client_id).first()
if client is None or user.can_access_client(client, "financials") == False:
return HTTPFound(request.application_url)
for p in client.projects:
if p.name == name and p.id != project.id:
return HTTPFound(request.application_url)
matched_departments = []
for department in account.departments:
percent_allocation = request.params.get(str(department.id) + "-allocation")
for budget_allocation in project.budget_allocations:
if budget_allocation.department_id == department.id:
matched_departments.append(department.id)
if percent_allocation is None or percent_allocation == "":
DBSession.delete(budget_allocation)
else:
budget_allocation.percent_allocation = percent_allocation
for department in account.departments:
if department.id not in matched_departments:
percent_allocation = request.params.get(str(department.id) + "-allocation")
if percent_allocation is not None and percent_allocation != "":
ba = BudgetAllocation(department, project, None, int(percent_allocation))
DBSession.add(ba)
project.name = name
project.code = code
project.client = client
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))
matched_departments = []
for budget_allocation in project.budget_allocations:
matched_departments.append(budget_allocation.department_id)
budgetAllocations = project.budget_allocations
for department in account.departments:
if department.id not in matched_departments:
budgetAllocations.append(BudgetAllocation(department, project, None, 0))
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)
return dict(logged_in=authenticated_userid(request), header=Header("financials"), clients=clients, user=user,
account=account, project=project, budgetAllocations=budgetAllocations)
except:
return HTTPFound(request.application_url)
def project_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:
return HTTPFound(request.application_url)
if request.method == "POST":
name = request.params["name"].lower()
code = request.params["project_code"]
client_id = long(request.params["client_id"])
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]))
client = DBSession.query(Client).filter_by(
account_id=account_id).filter_by(id=client_id).first()
if client is None or user.can_access_client(client,
"financials") == False:
return HTTPFound(request.application_url)
for project in client.projects:
if project.name == name:
return HTTPFound(request.application_url)
new_project = Project(name, code, account, client, revenue,
start_date, end_date)
DBSession.add(new_project)
DBSession.flush()
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))
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 + "/client/" +
str(client_id) + "/projects/" +
str(datetime.datetime.now().year))
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)
return dict(logged_in=authenticated_userid(request),
header=Header("financials"),
clients=clients,
user=user,
account=account)
except:
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)
def project_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:
return HTTPFound(request.application_url)
project_id = long(request.matchdict['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:
return HTTPFound(request.application_url)
if request.method == "POST":
name = request.params["name"].lower()
code = request.params["project_code"]
client_id = long(request.params["client_id"])
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]))
client = DBSession.query(Client).filter_by(
account_id=account_id).filter_by(id=client_id).first()
if client is None or user.can_access_client(client,
"financials") == False:
return HTTPFound(request.application_url)
for p in client.projects:
if p.name == name and p.id != project.id:
return HTTPFound(request.application_url)
matched_departments = []
for department in account.departments:
percent_allocation = request.params.get(
str(department.id) + "-allocation")
for budget_allocation in project.budget_allocations:
if budget_allocation.department_id == department.id:
matched_departments.append(department.id)
if percent_allocation is None or percent_allocation == "":
DBSession.delete(budget_allocation)
else:
budget_allocation.percent_allocation = percent_allocation
for department in account.departments:
if department.id not in matched_departments:
percent_allocation = request.params.get(
str(department.id) + "-allocation")
if percent_allocation is not None and percent_allocation != "":
ba = BudgetAllocation(department, project, None,
int(percent_allocation))
DBSession.add(ba)
project.name = name
project.code = code
project.client = client
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))
matched_departments = []
for budget_allocation in project.budget_allocations:
matched_departments.append(budget_allocation.department_id)
budgetAllocations = project.budget_allocations
for department in account.departments:
if department.id not in matched_departments:
budgetAllocations.append(
BudgetAllocation(department, project, None, 0))
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)
return dict(logged_in=authenticated_userid(request),
header=Header("financials"),
clients=clients,
user=user,
account=account,
project=project,
budgetAllocations=budgetAllocations)
except:
return HTTPFound(request.application_url)
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_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)