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):
user = self.request.environ['current_user']
prs = PerformanceReview.gql("WHERE employee = :user ORDER BY date DESC", user = user)
prs = prs.fetch(1000)
user_is_manager = 0
for role in user.role:
if Role.get(role).value == "manager":
user_is_manager = 1
break
current_pr = None
comments = None
if not user_is_manager:
comments = CommentToForm.gql("WHERE manager = :manager AND comment = NULL", manager = user).fetch(1000)
comments = filter(lambda x: x.pr.period.is_open, comments)
if prs:
if prs[0].period.is_open:
current_pr = prs[0]
prs.remove(prs[0])
template_values = {'current_pr': current_pr,
'prs': prs,
'user': user,
'comments': comments
}
path = 'templates/api.employee.html'
self.response.out.write(template.render(path, template_values))
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)
if name == 'all':
departments = Dept.all().fetch(1000)
else:
departments = Dept.all().filter('name', name).fetch(1000)
for department in departments:
department.prs = filter(lambda x: x.employee.dept.name
== department.name and x.period.is_open, prs)
template_values = {'name': name,
'depts': departments,
'current_user': user.email}
path = 'templates/api.manager.departments.html'
self.response.out.write(template.render(path, template_values))
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
def get(self, key):
login_url = users.create_login_url(self.request.uri)
logout_url = users.create_logout_url(login_url)
user = self.request.environ['current_user']
emp = Model.get(key)
pr = PerformanceReview.all().filter('employee', emp).\
order('-date').get()
pr_form = pr.forms.filter('type', self.type).get()
if pr_form is None:
pr_form = PerformanceReviewForm(pr=pr,
type=self.type,
status='draft')
pr_form.put()
self.form = pr_form
if self.flag:
job_assessment = JobAssessment(form=pr_form)
job_assessment.put()
if self.flag:
self.redirect('/%(type)s/pr/get/%(type)s/%(key)s'
% {'type': self.type,
'key': pr.key()})
def get_prev_pr(pr):
prev_pr = PerformanceReview.all().order('-date').\
filter('date <', pr.date).\
filter('employee', pr.employee).get()
return prev_pr
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, pr_key):
pr = PerformanceReview.get(pr_key)
template_values = {
'pr': pr
}
path = 'templates/api.comments.html'
self.response.out.write(template.render(path, template_values))
def get(self, key):
user = self.request.environ['current_user']
login_url = users.create_login_url(self.request.uri)
logout_url = users.create_logout_url(login_url)
try:
pr = PerformanceReview.get(key)
except:
try:
form = PerformanceReviewForm.get(key)
pr = form.pr
except:
self.error(405)
return
if not pr.is_open and self.type == 'employee':
self.type = 'manager'
self.path = 'templates/api.employee_maf.html'
form = pr.forms.filter('type', self.type).get()
prev_pr = PerformanceReview.all().order('-date').\
filter('date <', pr.date).\
filter('employee', pr.employee).get()
if prev_pr is not None:
prev_form = prev_pr.forms.filter('type', 'manager').get()
else:
prev_form = None
upload_url = blobstore.create_upload_url('/upload')
upload_form_url = blobstore.create_upload_url('/upload_xml')
self.template_values.update({'form': form,
'file_key': form.file_key,
'user': user,
# 'upload_form_url': upload_form_url,
'upload_url': upload_url,
'prev_form': prev_form,
'file_name': form.file_name})
def post(self):
keys = self.request.get('keys')[:-1].split(',')
for key in keys:
try:
pr = PerformanceReview.get(key)
manager_form = pr.manager_form
manager_form.status = 'registered'
manager_form.put()
except BadKeyError, AttributeError:
self.error(404)
def get(self):
today = datetime.date.today()
subject = 'Performance Review'
month = datetime.timedelta(days=30)
week = datetime.timedelta(days=7)
day = datetime.timedelta(days=1)
prs = PerformanceReview.all().filter('start_date >=', today)
for pr in prs:
delta = pr.date - today
text = 'Your Performance Review starts in ' \
+ str(delta.days) + ' days'
if delta == month or delta == week or delta == day:
send_message(pr.employee.email, subject, text)
def post(self):
manager_email = self.request.get('manager_email')
pr_key = self.request.get('pr_key')
manager = User.gql("WHERE email = :manager_email", manager_email = manager_email).get()
pr = PerformanceReview.get(pr_key)
if manager is None:
self.response.out.write('Some error happened. Try again please')
return
comment_to_form = CommentToForm.gql("WHERE pr = :pr AND manager = :manager", pr = pr, manager = manager).get()
if comment_to_form is None:
comment_to_form = CommentToForm(manager = manager,
pr = pr)
comment_to_form.put()
self.response.out.write('You have successfully requested comment form %s %s' %(manager.first_name, manager.last_name))
else:
self.response.out.write('You have already requested comment form %s %s' %(manager.first_name, manager.last_name))
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, 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')
