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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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_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 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_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 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 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 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 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 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 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 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_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 office_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 account is None or user.is_administrator == False:
return HTTPFound(request.application_url)
office_id = request.matchdict['office_id']
if request.method == "POST":
name = request.params["name"].lower()
off = DBSession.query(Office).filter_by(
account_id=long(request.session['aid'])).filter_by(
name=name).first()
if off is None or str(off.id) == office_id:
benefits_and_bonus = long(request.params["benefits_and_bonus"])
DBSession.query(Office).filter_by(id=office_id).filter_by(
account_id=account_id).update({
'name':
name,
'benefits_and_bonus':
benefits_and_bonus
})
DBSession.flush()
return HTTPFound(request.application_url +
"/administration/company")
office = DBSession.query(Office).filter_by(id=office_id).first()
return dict(logged_in=authenticated_userid(request),
header=Header("administration"),
office=office,
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 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 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)
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_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 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 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 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 freelancer_edit(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":
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 role is None or 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)
parsed_name = HumanName(name)
freelancer.first_name = parsed_name.first
freelancer.middle_name = parsed_name.middle
freelancer.last_name = parsed_name.last
freelancer.office = office
freelancer.client = client
freelancer.start_date = start_date
freelancer.end_date = end_date
freelancer.utilization = utilization
freelancer.hourly_rate = hourly_rate
DBSession.flush()
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))
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:
print("************* no c")
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:
print("************* no o")
return HTTPFound(request.application_url)
roles = DBSession.query(Role).filter_by(account_id=long(request.session['aid'])).all()
return dict(logged_in=authenticated_userid(request), header=Header('financials'), clients=clients,
offices=offices, roles=roles, freelancer=freelancer, user=user, account=account)
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 person_assign_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:
print("*** no user")
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:
print("*** no person")
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
elif source_type_text == "administration":
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)
if request.method == "POST":
for assignment in person.allocations:
client_id = None
ghost_client_id = None
client_id = request.params.get(str(assignment.id) + "-client_id")
ghost_client_id = request.params.get(str(assignment.id) + "-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:
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, "utilization") == False:
return HTTPFound(request.application_url)
utilization = long(request.params[str(assignment.id) + "-utilization"])
start_date_text = request.params[str(assignment.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[str(assignment.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]))
if person.start_date.date() > start_date or start_date > end_date:
print("*** late start")
return HTTPFound(request.path)
assignment.client = client
assignment.ghost_client = ghost_client
assignment.utilization = utilization
assignment.start_date = start_date
assignment.end_date = end_date
DBSession.flush()
return HTTPFound(request.application_url + "/" + source_type + "/" + str(source_id) + "/utilization/" + str(
datetime.datetime.now().year))
assignments_all = DBSession.query(UserAllocation).filter_by(user_id=person_id).all()
assignments = []
if user.is_administrator or user.permissions_global_utilization:
assignments = assignments_all
else:
for assignment in assignments_all:
if assignment.client_id is not None:
if user.can_access_client(assignment.client, "utilization"):
assignments.append(assignment)
elif assignment.ghost_client_id is not None:
if user.can_access_office(assignment.ghost_client.office, "utilization"):
assignments.append(assignment)
# Commented for now.
# if len(assignments) == 0:
# return HTTPFound(request.application_url + "/" + source_type + "/" + str(source_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):
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, assignments=assignments,
source_id=source_id, source_type=source_type, year=str(datetime.datetime.now().year))
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 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 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)