def post(self):
user = self.request.environ['current_user']
role_key = Role.gql("WHERE value = :hr", hr='hr').get().key()
if role_key not in user.role:
self.error(403)
return
start_str = self.request.get('start')
finish_str = self.request.get('finish')
type = self.request.get('type')
event = Event.all().filter('type', type).get()
try:
first_date = event.first_effective_date
except AttributeError:
first_date = None
employees = self.request.get('employees')[:-1].split(',')
try:
start = datetime.datetime.strptime(start_str, '%Y-%m-%d').date()
finish = datetime.datetime.strptime(finish_str, '%Y-%m-%d').date()
except ValueError:
self.response.out.write('incorrect date')
self.error(403)
return
description = "PR %s: %s-%s" % (type, start_str, finish_str)
period = PerformanceReviewPeriod(type=type,
description=description,
start_date=start,
finish_date=finish)
period.put()
for employee in employees:
if employee != '':
user = Model.get(employee)
pr = PerformanceReview(employee=user,
first_effective_date=first_date,
manager=user.manager,
period=period,
date=start)
pr.put()
self.response.out.write(period.key())
def get(self):
manager = self.request.environ['current_user']
user_departments_keys = []
prs = PerformanceReview.all().filter('manager',
manager)
for pr in prs:
if pr.period.is_open:
if not pr.employee.dept.key() in user_departments_keys:
user_departments_keys.append(pr.employee.dept.key())
user_departments = map(lambda x: Dept.get(x), user_departments_keys)
archived_periods = PerformanceReviewPeriod.gql("WHERE is_open = false ORDER BY start_date DESC").fetch(1000)
def manager_has_pr_in_period(period):
for pr in period.performance_reviews:
if pr.manager.email == manager.email:
return True
archived_periods = filter(manager_has_pr_in_period, archived_periods)
comments = CommentToForm.gql("WHERE manager = :manager", manager = manager).fetch(1000)
comments = filter(lambda x: x.pr.period.is_open, comments)
template_values = {"departments": user_departments,
"archived_periods": archived_periods,
"comments": comments
}
path = 'templates/api.manager.home.html'
self.response.out.write(template.render(path, template_values))
def get(self, period_key):
user = self.request.environ['current_user']
period = PerformanceReviewPeriod.get(period_key)
if period.is_open:
period.is_open = False
period.put()
else:
self.response.out.write('Error. Period is already closed')
return
self.response.out.write('ok')
def get(self):
open_periods = PerformanceReviewPeriod.all().order("-start_date").filter('is_open', True).fetch(1000)
closed_periods = PerformanceReviewPeriod.all().order("-start_date").filter('is_open', False).fetch(1000)
for period in open_periods:
period.register = 'disabled'
period.delete = 'inline'
period.departments = []
for pr in period.performance_reviews:
if pr.period.is_open:
if not pr.employee.dept.key() in period.departments:
period.departments.append(pr.employee.dept.key())
period.departments = map(lambda x: Dept.get(x), period.departments)
for pr in period.performance_reviews:
if pr.manager_form or pr.employee_form:
period.delete = 'none'
for department in period.departments:
department.prs = filter(lambda x: x.employee.dept.name == department.name, period.performance_reviews)
for pr in department.prs:
pr.register = 'disabled'
if pr.manager_form:
if pr.manager_form.status == 'submitted':
department.register = ''
pr.register = ''
template_values = {'open_periods': open_periods,
'closed_periods': closed_periods}
path = 'templates/hr_table.html'
self.response.out.write(template.render(path, template_values))
def post(self):
period_key = self.request.get('period_key')
if period_key:
period = PerformanceReviewPeriod.get(period_key)
delete_pr = 1
for pr in period.performance_reviews:
if pr.manager_form or pr.employee_form:
delete_pr = 0
if delete_pr:
for pr in period.performance_reviews:
pr.delete()
period.delete()
def get(self, key):
period = PerformanceReviewPeriod.get(key)
prs = PerformanceReview.all().filter('period', period).fetch(1000)
prs = sorted(prs, key=lambda x: x.employee.dept.name)
for pr in prs:
if get_prev_pr(pr):
try:
if get_prev_pr(pr).manager_form.get_all_data['salary'].\
value != pr.manager_form.get_all_data['salary'].value:
pr.salary_highlight = 'highlight'
if get_prev_pr(pr).manager_form.get_all_data['grade'].\
value != pr.manager_form.get_all_data['grade'].value:
pr.grade_highlight = 'highlight'
except AttributeError:
pr.grade_highlight = None
path = 'templates/detailed_report.html'
self.response.out.write(template.render(path, {'prs': prs}))
def get(self, name):
user = self.request.environ['current_user']
name = urllib.unquote(name).decode('utf-8')
prs = PerformanceReview.all().filter('manager',
user).order("-date").fetch(1000)
def get_sub_prs(manager, prs):
current_manager_prs = PerformanceReview.all().filter('manager',
manager).order("-date").fetch(1000)
prs.extend(current_manager_prs)
for manager in manager.subs:
get_sub_prs(manager, prs)
return prs
if user.edit_sub_reviews:
prs = []
get_sub_prs(user, prs)
periods = PerformanceReviewPeriod.all().filter('description',
name).fetch(1000)
for period in periods:
period.prs = filter(lambda x: x.period.key() == period.key(), prs)
template_values = {'name': name,
'periods': periods,
'current_user': user.email}
path = 'templates/api.manager.periods.html'
self.response.out.write(template.render(path, template_values))
def get(self):
today = datetime.date.today()
events = Event.all()
employees = User.all()
month = datetime.timedelta(days=30)
week = datetime.timedelta(weeks=1)
for event in events:
if event.start_date < today:
event.start_date = event.start_date.replace(year = (today.year + 1))
event.put()
for employee in employees:
first_date = employee.first_date
if not first_date:
first_date = datetime.date.min
start_date = first_date + datetime.timedelta(weeks=13)
finish_date = start_date + datetime.timedelta(weeks=2)
if start_date - month == today:
description = "PR annual: %s-%s" % (start_date, finish_date)
period = PerformanceReviewPeriod(type='annual',
description=description,
start_date=start_date,
finish_date=finish_date)
period.put()
pr = PerformanceReview(employee=employee,
manager=employee.manager,
date=period.start_date,
period=period)
pr.put()
next_pr_start_date = start_date + 13 * week
for event in events:
delta = next_pr_start_date - event.start_date
if next_pr_start_date > today:
if delta < month and delta > -month:
if event.start_date - month == today:
description = "PR %s: %s-%s" % (event.type, event.start_date, event.finish_date)
period = PerformanceReviewPeriod(start_date=event.start_date,
description=description,
finish_date=event.finish_date)
period.put()
pr = PerformanceReview(period=period,
employee=employee,
manager=employee.manager,
date=period.start_date
)
pr.put()
else:
if next_pr_start_date == today + month:
finish_date = next_pr_start_date + 2 * week
description = "PR custom: %s-%s" % (next_pr_start_date, finish_date)
period = PerformanceReviewPeriod(start_date=next_pr_start_date,
description=description,
finish_date=finish_date)
period.put()
pr = PerformanceReview(period=period,
employee=employee,
manager=employee.manager,
date=period.start_date
)
pr.put()
else:
for event in events:
if event.start_date - month == today or event.start_date.replace(year=(today.year + 1)):
description = "PR %s: %s-%s" % (event.type, event.start_date, event.finish_date)
period = PerformanceReviewPeriod(start_date=event.start_date,
description=description,
finish_date=event.finish_date)
period.put()
pr = PerformanceReview(period=period,
employee=employee,
manager=employee.manager,
date=period.start_date
)
pr.put()
def get(self, key):
depts = Dept.all()
period = PerformanceReviewPeriod.get(key)
summary = []
for dept in depts:
existed_pr = filter(lambda x: x.self_pr.get(), dept.users)
all_dept_prs = filter(lambda x: x.self_pr.filter('period',
period).get(),
existed_pr)
if all_dept_prs:
employees = len(all_dept_prs)
clean_manager_form = filter(lambda x:
not x.self_pr.order('-date').get().
manager_form,
existed_pr)
clean_employee_form = filter(lambda x:
not x.self_pr.order('-date')
.get().
employee_form,
existed_pr)
clean_draft = len(clean_employee_form) + \
len(clean_manager_form)
not_clean_manager_form = filter(lambda x:
x.self_pr.order('-date').get().
manager_form,
existed_pr)
not_clean_employee_form = filter(lambda x:
x.self_pr.order('-date')
.get().
employee_form,
existed_pr)
man_draft_in_work = filter(lambda x:
x.self_pr.order('-date').get().
manager_form.status ==
'draft',
not_clean_manager_form)
emp_draft_in_work = filter(lambda x:
x.self_pr.order('-date').get().
employee_form.status ==
'draft', not_clean_employee_form)
in_work = len(man_draft_in_work) + len(emp_draft_in_work)
registered_pr = filter(lambda x:
x.self_pr.order('-date').get()
.manager_form.status ==
'registered', not_clean_manager_form)
reg_pr = len(registered_pr)
submitted_by_employee = filter(lambda x:
x.self_pr.order('-date').get().
employee_form.status
== 'submitted',
not_clean_employee_form)
emp_submit = len(submitted_by_employee)
submitted_by_manager = filter(lambda x:
x.self_pr.order('-date').get().
manager_form.status
== 'submitted',
not_clean_manager_form)
man_submit = len(submitted_by_manager)
approved_pr = filter(lambda x:
x.self_pr.order('-date').get()
.manager_form
.status ==
'approved', not_clean_manager_form)
approved = len(approved_pr)
all_draft = clean_draft + in_work + emp_submit + man_submit
percent = (approved * 100) / employees
dept_info = {'name': dept.name,
'employees': employees,
'clean': clean_draft,
'in_work': in_work,
'all_draft': all_draft,
'reg': reg_pr,
'percent': percent,
'approved': approved,
'emp_submit': emp_submit,
'man_submit': man_submit}
summary.append(dept_info)
template_values = {'summary': summary}
path = 'templates/summary_report.html'
self.response.out.write(template.render(path, template_values))
def get(self, role, pr_key, blob_key):
blob_key = str(urllib.unquote(blob_key))
blob_info = blobstore.BlobInfo.get(blob_key)
current_pr = PerformanceReview.get(pr_key)
if role == 'manager':
url = '/#/manager/pr/get/manager/%s' %current_pr.key()
elif role == 'hr':
url = '/#/hr/get/manager/%s' %current_pr.key()
elif role == 'employee':
url = '/#/employee/pr/get/employee/%s' %current_pr.key()
else:
url = '/'
file = blob_info.open()
employee = current_pr.employee
NAMESPACES = {
'w':"http://schemas.microsoft.com/office/word/2003/wordml",
'v':"urn:schemas-microsoft-com:vml",
'w10':"urn:schemas-microsoft-com:office:word",
'sl':"http://schemas.microsoft.com/schemaLibrary/2003/core",
'aml':"http://schemas.microsoft.com/aml/2001/core",
'wx':"http://schemas.microsoft.com/office/word/2003/auxHint",
'o':"urn:schemas-microsoft-com:office:office",
'dt':"uuid:C2F41010-65B3-11d1-A29F-00AA00C14882",
'wsp':"http://schemas.microsoft.com/office/word/2003/wordml/sp2",
'ns0':"GD_AssessmentReportManager.xsl",
}
ElementTree.register_namespace(
'o',
'urn:schemas-microsoft-com:office:office')
try:
parser = ElementTree.parse(file)
except SyntaxError:
self.response.out.write('incorrect type')
return
date = parser.find('.//w:body//ns0:ActionDateFormat//w:t',
namespaces=NAMESPACES).text
manager_type = parser.find(
'.//w:body//ns0:GD_ManagerAssessmentForm//w:t',
namespaces=NAMESPACES)
if manager_type is None:
blob_info.delete()
self.response.out.write('incorrect type')
#
return
fio = parser.find('.//w:body//ns0:EmployeeName//w:t',
namespaces=NAMESPACES).text.replace(' ',' ').strip()
last_name, first_name = fio.split(' ')[:2]
employee_from_form = User.gql(
"WHERE last_name = :last_name AND first_name = :first_name",
last_name=last_name,
first_name=first_name).get()
if employee_from_form is None or \
employee_from_form.email != employee.email:
blob_info.delete()
self.response.out.write('incorrect user')
return
date = datetime.datetime.strptime(date, '%d/%m/%Y').date()
type = 'annual'
description = "PR %s: %s-%s" % (type, date, date)
month = datetime.timedelta(days=30)
period = PerformanceReviewPeriod.gql("WHERE start_date >= \
:min_start_date AND \
start_date <= :max_start_date",
max_start_date=date+month,
min_start_date=date-month).get()
if period is None:
period = PerformanceReviewPeriod(start_date=date,
finish_date=date,
description=description,
type=type)
period.put()
pr = PerformanceReview(employee=employee,
first_effective_date=employee.first_date,
manager=employee.manager,
period=period,
date=date)
pr.put()
manager_form = PerformanceReviewForm(pr=pr,
status='approved',
type='manager')
manager_form.put()
achievements = parser.findall(
'.//w:body//ns0:AchievementMngList//ns0:Description//w:t',
namespaces=NAMESPACES)
for achievement in achievements:
achievement = achievement.text.replace('\n', '').replace(' ',' ')
logging.debug(achievement)
ach = Achievements(value=achievement,
form=manager_form)
ach.put()
challenges = parser.findall(
'.//w:body//ns0:ChallengeMngList//ns0:Description//w:t',
namespaces=NAMESPACES)
for challenge in challenges:
challenge = challenge.text.replace('\n', '').replace(' ',' ')
ch = Challenges(value=challenge,
form=manager_form)
ch.put()
goals = parser.findall(
'.//w:body//ns0:NextYearGoalsMng//ns0:Goal//w:t',
namespaces=NAMESPACES)
for goal in goals:
goal = goal.text.replace('\n', '').replace(' ',' ')
g = NextGoals(value=goal,
form=manager_form)
g.put()
blob_info.delete()
self.response.out.write('done')
