def _get_site_URL(self, user_id):
user = User.objects.get(pk=user_id)
if user.check_password(settings.DEFAULT_USER_PW):
hash_key_service = HashKeyService()
return "%semployee/signup/%s" % (
settings.SITE_URL, hash_key_service.encode_key(user_id))
return settings.SITE_URL
def onboard_email(name, company_id, to_emails, id):
try:
company = Company.objects.get(pk=company_id)
except Company.DoesNotExist:
raise Http404
hash_key_service = HashKeyService()
link = "%semployee/signup/%s" % (URL, hash_key_service.encode_key(id))
c = CONTENT % (name, company.name, link)
send_mail(SUBJECT, c, FROM, to_emails, fail_silently=False)
def build_from_record(self, compensation_record):
self.key_hasher = HashKeyService()
if compensation_record:
self.id = self.key_hasher.encode_key(compensation_record.id)
self.effective_date = compensation_record.effective_date
self.annual_base_salary = compensation_record.annual_base_salary
self.hourly_rate = compensation_record.hourly_rate
self.increase_percentage = compensation_record.increase_percentage
self.projected_hour_per_month = compensation_record.projected_hour_per_month
self.created_at = compensation_record.created_at
self.updated_at = compensation_record.updated_at
self.reason = compensation_record.reason
self.is_current = False
class ProjectService(object):
hash_key_service = HashKeyService()
request_service = WebRequestService()
def get_projects_by_company(self, company_id, active_only=False):
api_url = '{0}/company/{1}/projects'.format(
API_URL_COI,
self.hash_key_service.encode_key_with_environment(company_id))
# Make the request and parse the response as json
r = self.request_service.get(api_url)
projects = r.json()
if (active_only):
filtered = []
for project in projects:
if (project['status'] == PROJECT_STATUS_ACTIVE):
filtered.append(project)
projects = filtered
view_models = []
for project in projects:
view_models.append(self._map_domain_to_view_model(project))
return view_models
def _map_domain_to_view_model(self, domain_model):
return {
'project_id': domain_model['_id'],
'name': domain_model['name'],
'status': domain_model['status']
}
def _get_or_create_group(self, group_name, company_id):
comp_group = CompanyGroup.objects.filter(company=company_id,
name=group_name)
if not comp_group:
# Let's create a new company_group
new_comp_group = {'company': company_id, 'name': group_name}
group_serializer = CompanyGroupPostSerializer(data=new_comp_group)
if group_serializer.is_valid():
group_serializer.save()
hash_key_service = HashKeyService()
return hash_key_service.decode_key(group_serializer.data['id'])
else:
raise Exception(
"Group cannot be created with the name {}".format(
group_name))
else:
return comp_group[0].id
def _get_action_data(self):
hash_key_service = HashKeyService()
send_email_service = SendEmailService()
company_emails = send_email_service.get_employer_emails_for_all_companies(
)
result = []
for companyId in company_emails.keys():
result.append({
'descriptor':
hash_key_service.encode_key_with_environment(companyId),
'emailList':
company_emails[companyId]
})
return result
class TimeTrackingService(object):
hash_key_service = HashKeyService()
request_service = WebRequestService()
def get_all_users_submitted_work_timesheet_by_week_start_date(
self, week_start_date):
users = []
api_url = '{0}?start_date={1}&end_date={1}'.format(
API_URL_WORK_TIMESHEET, week_start_date.isoformat())
# Make the request and parse the response as json
r = self.request_service.get(api_url)
all_entries = r.json()
for entry in all_entries:
user_descriptor = entry['employee']['personDescriptor']
user_id = int(
self.hash_key_service.decode_key_with_environment(
user_descriptor))
users.append(user_id)
return users
def get_company_users_submitted_work_timesheet_by_week_range(
self, company_id, start_week_start_date, end_week_start_date):
week_user_timesheets = {}
api_url = '{0}api/v1/company/{1}/work_timesheets?start_date={2}&end_date={3}'.format(
settings.TIME_TRACKING_SERVICE_URL,
self.hash_key_service.encode_key_with_environment(company_id),
start_week_start_date.isoformat(), end_week_start_date.isoformat())
r = self.request_service.get(api_url)
if r.status_code == 404:
return week_user_timesheets
all_entries = r.json()
for entry in all_entries:
user_descriptor = entry['employee']['personDescriptor']
user_id = self.hash_key_service.decode_key_with_environment(
user_descriptor)
item = copy.deepcopy(entry)
item['user_id'] = user_id
# Group returned timesheet by work start date
week_start_date_str = entry['weekStartDate']
week_start_date = datetime.strptime(
week_start_date_str, '%Y-%m-%dT%H:%M:%S.%fZ').date()
if week_start_date in week_user_timesheets:
week_user_timesheets[week_start_date].append(item)
else:
week_user_timesheets[week_start_date] = [item]
return week_user_timesheets
class ContratorService(object):
hash_key_service = HashKeyService()
request_service = WebRequestService()
def get_contractor_by_id(self, contractor_id):
api_url = '{0}/contractor/{1}'.format(API_URL_COI, contractor_id)
# Make the request and parse the response as json
r = self.request_service.get(api_url)
entry = r.json()
return entry
def test_get_user_by_credential_successful(self):
email = '*****@*****.**'
credential = {
'email': email,
'password': '******'
}
response = self.client.post(
reverse('user_by_credential'),
json.dumps(credential),
content_type='application/json'
)
hash_key_service = HashKeyService()
response_object = json.loads(response.content)
self.assertTrue('user_info' in response_object)
user_info = response_object['user_info']
self.assertEqual(type(user_info), dict)
self.assertTrue('user_id' in user_info and user_info['user_id'])
self.assertTrue('user_id_env_encode' in user_info and user_info['user_id_env_encode'])
self.assertEqual(str(user_info['user_id']), hash_key_service.decode_key_with_environment(user_info['user_id_env_encode']))
self.assertTrue('account_email' in user_info and user_info['account_email'])
self.assertEqual(user_info['account_email'], email)
self.assertTrue('first_name' in user_info and user_info['first_name'])
self.assertTrue('last_name' in user_info and user_info['last_name'])
self.assertTrue('hourly_rate' in user_info and user_info['hourly_rate'])
self.assertTrue('company_info' in response_object)
company_info = response_object['company_info']
self.assertEqual(type(company_info), dict)
self.assertTrue('company_id' in company_info and company_info['company_id'])
self.assertTrue('company_id_env_encode' in company_info and company_info['company_id_env_encode'])
self.assertEqual(str(company_info['company_id']), hash_key_service.decode_key_with_environment(company_info['company_id_env_encode']))
self.assertTrue('app_features_info' in response_object)
app_features_info = response_object['app_features_info']
self.assertEqual(type(app_features_info), dict)
class TimeOffService(object):
hash_key_service = HashKeyService()
request_service = WebRequestService()
def get_company_users_time_off_records_by_date_range(
self, company_id, start_date, end_date):
user_records = []
api_url = '{0}api/v1/company/{1}/timeoffs?start_date={2}&end_date={3}'.format(
settings.TIME_TRACKING_SERVICE_URL,
self.hash_key_service.encode_key_with_environment(company_id),
start_date.isoformat(), end_date.isoformat())
r = self.request_service.get(api_url)
if r.status_code == 404:
return user_records
r.raise_for_status()
all_entries = r.json()
for entry in all_entries:
user_records.append(TimeOffRecord(entry))
# Sort the records by user ID
sorted_records = sorted(
user_records,
key=lambda record:
(record.requestor_user_id, record.start_date_time))
return sorted_records
def get_company_users_time_off_record_aggregates_by_date_range(
self, company_id, start_date, end_date):
mappings = {}
all_records = self.get_company_users_time_off_records_by_date_range(
company_id, start_date, end_date)
for record in all_records:
if record.requestor_user_id not in mappings:
mappings[
record.requestor_user_id] = EmployeeTimeOffRecordAggregate(
record.requestor_user_id)
mappings[record.requestor_user_id].add_record(record)
unsorted = mappings.values()
return sorted(unsorted, key=lambda aggregate: aggregate.user_id)
class CompensationInfo(object):
def __init__(self,
id=None,
effective_date=None,
annual_base_salary=None,
hourly_rate=None,
increase_percentage=None,
projected_hour_per_month=None,
created_at=None,
updated_at=None,
is_current=None,
reason=None):
self.id = id
self.effective_date = effective_date
self.annual_base_salary = annual_base_salary
self.hourly_rate = hourly_rate
self.increase_percentage = increase_percentage
self.projected_hour_per_month = projected_hour_per_month
self.created_at = created_at
self.updated_at = updated_at
self.is_current = is_current
self.reason = reason
def build_from_record(self, compensation_record):
self.key_hasher = HashKeyService()
if compensation_record:
self.id = self.key_hasher.encode_key(compensation_record.id)
self.effective_date = compensation_record.effective_date
self.annual_base_salary = compensation_record.annual_base_salary
self.hourly_rate = compensation_record.hourly_rate
self.increase_percentage = compensation_record.increase_percentage
self.projected_hour_per_month = compensation_record.projected_hour_per_month
self.created_at = compensation_record.created_at
self.updated_at = compensation_record.updated_at
self.reason = compensation_record.reason
self.is_current = False
def __cmp__(self, other):
if hasattr(other, 'effective_date'):
return self.effective_date.__cmp__(other.effective_date)
def __init__(self):
self.hash_service = HashKeyService()
class ViewTestBase(object):
hash_key_service = HashKeyService()
def normalize_key(self, key):
return self.hash_key_service.encode_key(key)
class TestHashKeyService(TestCase):
hash_key_service = HashKeyService()
''' encode a 'None' key, should return None
'''
def test_Encode_NoneKey_None(self):
key = None
encodedKey = self.hash_key_service.encode_key(key)
self.assertTrue(not encodedKey)
''' encode a valid key is expected to yield result with valid token format
'''
def test_Encode_Key_ValidFormat(self):
key = 20
encodedKey = self.hash_key_service.encode_key(key)
regex = re.compile(HashKeyService.HASH_TOKEN_REGEX_PATTERN)
self.assertTrue(not regex.match(encodedKey) is None)
def test_Encode_Key_With_Environment_ValidFormat(self):
key = 20
encoded_env_key = self.hash_key_service.encode_key_with_environment(key)
env_token = encoded_env_key.split('_', 1)[0]
self.assertEqual(env_token, settings.ENVIRONMENT_IDENTIFIER)
encoded_key = encoded_env_key.split('_', 1)[1]
regex = re.compile(HashKeyService.HASH_TOKEN_REGEX_PATTERN)
self.assertTrue(not regex.match(encoded_key) is None)
''' decode a 'None' key, should return None
'''
def test_Decode_NoneKey_None(self):
encodedkey = None
key = self.hash_key_service.decode_key(encodedkey)
self.assertTrue(not key)
''' decode an invalid key, should return None
'''
def test_Decode_InvalidKey_None(self):
encodedkey = 'This_Is_A_Bad_Token'
key = self.hash_key_service.decode_key(encodedkey)
self.assertTrue(not key)
''' encode a valid key then decode it, should return original key
'''
def test_EncodeAndDecode_Key_OriginalKey(self):
key = 20
encodedKey = self.hash_key_service.encode_key(key)
decodedKey = self.hash_key_service.decode_key(encodedKey)
self.assertEqual(str(key), str(decodedKey))
def test_Decode_With_Environment_InvalidEnvironment_None(self):
key = 20
encoded_key = self.hash_key_service.encode_key(key)
encoded_env_key = "{0}_{1}".format('invalidEnv', encoded_key)
decoded_key = self.hash_key_service.decode_key_with_environment(encoded_env_key)
self.assertTrue(not decoded_key)
def test_Decode_With_Environment_Valid_OriginalKey(self):
key = 20
encoded_env_key = self.hash_key_service.encode_key_with_environment(key)
decoded_key = self.hash_key_service.decode_key_with_environment(encoded_env_key)
self.assertTrue(str(key), str(decoded_key))
class PersonEnrollmentSummaryView(APIView):
""" Benefit enrollment status for a person """
def __init__(self):
self.hash_service = HashKeyService()
def get_person_info(self, person_id):
try:
person = Person.objects.get(pk=person_id)
serializer = PersonSerializer(person)
return serializer.data
except Person.DoesNotExist:
raise Http404
def get_health_benefit_enrollment(self, user_id):
enrollment = UserCompanyBenefitPlanOption.objects.filter(user=user_id)
serializer = UserCompanyBenefitPlanOptionSerializer(enrollment,
many=True,
required=False)
return serializer.data
def get_health_benefit_waive(self, user_id):
waived = UserCompanyWaivedBenefit.objects.filter(user=user_id)
serializer = UserCompanyWaivedBenefitSerializer(waived,
required=False,
many=True)
return serializer.data
def get_hra_plan(self, person_id):
hra_plan = PersonCompanyHraPlan.objects.filter(person=person_id)
serializer = PersonCompanyHraPlanSerializer(hra_plan,
required=False,
many=True)
return serializer.data
def get_fsa_plan(self, user_id):
fsa_plan = FSA.objects.filter(user=user_id)
serializer = FsaSerializer(fsa_plan, required=False, many=True)
return serializer.data
def get_hsa_plan(self, person_id):
hsa_plan = PersonCompanyGroupHsaPlan.objects.filter(person=person_id)
serializer = PersonCompanyGroupHsaPlanSerializer(hsa_plan,
required=False,
many=True)
return serializer.data
def get_life_insurance(self, user_id):
life_insurance = UserCompanyLifeInsurancePlan.objects.filter(
user=user_id)
serializer = UserCompanyLifeInsuranceSerializer(life_insurance,
required=False,
many=True)
return serializer.data
def get_supplimental_life_insurance(self, person_id):
supplimental_life = PersonCompSupplLifeInsurancePlan.objects.filter(
person=person_id)
serializer = PersonCompanySupplementalLifeInsurancePlanSerializer(
supplimental_life, required=False, many=True)
return serializer.data
def get_std_insurance(self, user_id):
std_insurance = UserCompanyStdInsurancePlan.objects.filter(
user=user_id)
serializer = UserCompanyStdInsuranceSerializer(std_insurance,
required=False,
many=True)
return serializer.data
def get_ltd_insurance(self, user_id):
ltd_insurance = UserCompanyLtdInsurancePlan.objects.filter(
user=user_id)
serializer = UserCompanyLtdInsuranceSerializer(ltd_insurance,
required=False,
many=True)
return serializer.data
def get(self, request, person_id, format=None):
person_info = self.get_person_info(person_id)
user_id = self.hash_service.decode_key(person_info['user'])
health_benefit = self.get_health_benefit_enrollment(user_id)
health_benefit_waived = self.get_health_benefit_waive(user_id)
hra_plan = self.get_hra_plan(person_id)
fsa_plan = self.get_fsa_plan(user_id)
hsa_plan = self.get_hsa_plan(person_id)
life_insurance = self.get_life_insurance(user_id)
supplemental_life = self.get_supplimental_life_insurance(person_id)
std_insurance = self.get_std_insurance(user_id)
ltd_insurance = self.get_ltd_insurance(user_id)
response = {
"person": person_info,
"health_benefit_enrolled": health_benefit,
"health_benefit_waived": health_benefit_waived,
"hra": hra_plan,
"fsa": fsa_plan,
"hsa": hsa_plan,
"basic_life": life_insurance,
"supplemental_life": supplemental_life,
"std": std_insurance,
"ltd": ltd_insurance
}
return Response(response)
class TimePunchCard(object):
hash_key_service = HashKeyService()
date_time_service = DateTimeService()
def __init__(self, punch_card_domain_model):
if (punch_card_domain_model is None):
raise ValueError('Must pass valid time punch card domain model.')
# List out instance variables
self.user_id = None
self.user_info = None
self.date = None
self.start = None
self.end = None
self.state = None
self.card_type = None
self.in_progress = None
self.system_stopped = None
# Parse out user ID
user_descriptor = punch_card_domain_model['employee'][
'personDescriptor']
self.user_id = int(
self.hash_key_service.decode_key_with_environment(user_descriptor))
# Parse card type
self.card_type = punch_card_domain_model.get('recordType')
# Parse all dates and times to objects
self.date = self.date_time_service.parse_date_time(
punch_card_domain_model['date'])
start_str = punch_card_domain_model.get('start')
if (start_str):
self.start = self.date_time_service.parse_date_time(start_str)
end_str = punch_card_domain_model.get('end')
if (end_str):
self.end = self.date_time_service.parse_date_time(end_str)
# Parse attributes
attributes = punch_card_domain_model.get('attributes')
if (attributes):
for attribute in attributes:
# For now only cares about state
if attribute['name'] == PUNCH_CARD_ATTRIBUTE_TYPE_STATE:
self.state = attribute['value']
break
in_progress_str = punch_card_domain_model.get('inProgress')
if (in_progress_str):
self.in_progress = bool(in_progress_str)
system_stopped_str = punch_card_domain_model.get('systemStopped')
if (system_stopped_str):
self.system_stopped = bool(system_stopped_str)
# Support lasy-evaluated validation
self._validation_issues = None
def get_punch_card_hours(self):
raw_hours = self.__get_raw_card_hours()
if self.card_type == PUNCH_CARD_TYPE_BREAK_TIME:
return -raw_hours
return raw_hours
def __get_raw_card_hours(self):
if (self.start is not None and self.end is not None):
card_hours = self.date_time_service.get_time_diff_in_hours(
self.start, self.end, 2)
return card_hours
return 0.0
def get_card_day_of_week_iso(self):
return self.date.isoweekday() % 7
@property
def validation_issues(self):
if (self._validation_issues is None):
self._validation_issues = self._validate()
return self._validation_issues
def is_valid(self):
issues = self.validation_issues
blocking_issue = next(
(issue for issue in issues
if issue.level > TimeCardValidationIssue.LEVEL_WARNING), None)
return blocking_issue is None
def _validate(self):
validation_issues = []
card_hours = self.__get_raw_card_hours()
# 1. Unclosed timecard (clocked in, but not out)
if ((self.start is not None and self.end is None)
or (self.in_progress)):
validation_issues.append(
TimeCardValidationIssue(
TimeCardValidationIssue.LEVEL_ERROR,
'[Unclosed Card] Clocked in, but not out, by midnight.'))
# 2. Negative hours
if (card_hours < 0.0):
validation_issues.append(
TimeCardValidationIssue(
TimeCardValidationIssue.LEVEL_ERROR,
'[Invalid Card Balance] Card with negative accounted hours.'
))
# 3. Long working hours, such as over 10 hours work
if (card_hours >= 10.0):
validation_issues.append(
TimeCardValidationIssue(
TimeCardValidationIssue.LEVEL_WARNING,
'[Unusual Card Balance] Card with more than 10 hours.'))
if (self.system_stopped):
validation_issues.append(
TimeCardValidationIssue(
TimeCardValidationIssue.LEVEL_ERROR,
'[System Closed Card] Card stopped accruing hours by system. Please validate!'
))
return validation_issues
def execute_creation(self, account_info, do_validation=True):
result = OperationResult(account_info)
account_result = None
# Do validation first, and short circuit if failed
if (do_validation):
account_result = self.validate(account_info)
else:
# directly construct the result, skipping validation
account_result = OperationResult(account_info)
# If the account creation info is not valid to begin with
# simply short circuit and return it
if (account_result.has_issue()):
return account_result
userManager = AuthUserManager()
# Create the actual user data
password = settings.DEFAULT_USER_PW
if account_info.password:
password = account_info.password
user = User.objects.create_user(account_info.email, password)
user.first_name = account_info.first_name
user.last_name = account_info.last_name
user.save()
# Create the company_user data
company_user = CompanyUser(
company_id=account_info.company_id,
user=user,
company_user_type=account_info.company_user_type)
if account_info.new_employee is not None:
company_user.new_employee = account_info.new_employee
company_user.save()
# Now create the person object
person_data = {
'first_name': account_info.first_name,
'last_name': account_info.last_name,
'user': user.id,
'relationship': SELF,
'person_type': 'primary_contact',
'email': user.email
}
person_serializer = PersonSimpleSerializer(data=person_data)
if person_serializer.is_valid():
person_serializer.save()
else:
raise Exception("Failed to create person record")
# Create the employee profile
key_service = HashKeyService()
person_id = key_service.decode_key(person_serializer.data['id'])
pin = account_info.pin
pinService = EmployeePinService()
if not pin:
pin = pinService.get_company_wide_unique_pin(
account_info.company_id, user.id)
profile_data = {
'person': person_id,
'company': account_info.company_id,
'start_date': account_info.start_date,
'benefit_start_date': account_info.benefit_start_date,
'pin': pin
}
if (account_info.compensation_info.annual_base_salary is not None):
profile_data[
'annual_base_salary'] = account_info.compensation_info.annual_base_salary
if (account_info.employment_type):
profile_data['employment_type'] = account_info.employment_type
if (account_info.manager_id):
profile_data['manager'] = account_info.manager_id
if (account_info.employee_number):
profile_data['employee_number'] = account_info.employee_number
profile_serializer = EmployeeProfilePostSerializer(data=profile_data)
if profile_serializer.is_valid():
profile_serializer.save()
else:
raise Exception("Failed to create employee profile record")
# Now check to see send email and create documents
if company_user.company_user_type == 'employee':
if account_info.send_email:
# now try to create the onboard email for this user.
try:
onboard_email(
"%s %s" % (user.first_name, user.last_name),
account_info.company_id,
[account_info.email, settings.SUPPORT_EMAIL_ADDRESS],
user.id)
except StandardError:
raise Exception("Failed to send email to employee")
if (account_info.create_docs):
# Let's create the documents for this new user
try:
doc_gen = UserDocumentGenerator(company_user.company, user)
doc_gen.generate_all_document(account_info.doc_fields)
except Exception:
raise Exception(
"Failed to generate documents for employee")
# Create the initial compensation record
compensation_data = {
'person': person_id,
'company': account_info.company_id,
'annual_base_salary':
account_info.compensation_info.annual_base_salary,
'projected_hour_per_month':
account_info.compensation_info.projected_hour_per_month,
'hourly_rate': account_info.compensation_info.hourly_rate,
'effective_date':
account_info.compensation_info.effective_date,
'increase_percentage': None
}
compensation_serializer = EmployeeCompensationPostSerializer(
data=compensation_data)
if (compensation_serializer.is_valid()):
compensation_serializer.save()
else:
raise Exception("Failed to create compensation record")
if account_info.group_id:
self._add_to_group(account_info.group_id, user.id)
elif account_info.group_name:
group_id = self._get_or_create_group(account_info.group_name,
account_info.company_id)
if group_id:
self._add_to_group(group_id, user.id)
else:
raise Exception(
"Cannot get group_id from group name {}".format(
account_info.group_name))
account_info.user_id = user.id
account_result.set_output_data(account_info)
# Now for the new employee being created, setup any information
# required for external parties (such as payroll and benefit service)
# providers.
self.company_integration_provider_data_service.generate_and_record_external_employee_number(
user.id)
return account_result
def from_native(self, data):
hash_key_service = HashKeyService()
return hash_key_service.decode_key(data)
class UserByCredentialView(APIView):
hash_key_service = HashKeyService()
'''
This is the view class to provide the API endpoint for getting user information
by providing the username and password of the user.
Note: The information got from this end point is simplified.
'''
authentication_classes = (CsrfExemptSessionAuthentication,
BasicAuthentication)
def post(self, request, format=None):
credential = request.DATA
email = credential.get('email')
password = credential.get('password')
if not email or not password:
return HttpResponse(status=401)
auth_result = AuthenticationService().login(email, password, request)
if auth_result.user:
# Authentication successful.
# Now get the user information
result = self._get_user_data(auth_result.user)
return Response(result)
else:
return HttpResponse(status=401)
def _get_user_data(self, user):
result = {}
# User info
user_info = {}
## Basic info
user_info['user_id'] = user.id
user_info[
'user_id_env_encode'] = self.hash_key_service.encode_key_with_environment(
user.id)
user_info['account_email'] = user.email
## Person and Compensation Info
persons = Person.objects.filter(user=user.id, relationship='self')
if (len(persons) > 0):
person_model = persons[0]
person_data = PersonInfo(person_model)
user_info['first_name'] = person_data.first_name
user_info['last_name'] = person_data.last_name
compensation_info = CompensationService(person_model=person_model)
hourly_rate = compensation_info.get_current_hourly_rate()
if (hourly_rate):
hourly_rate = round(hourly_rate, 2)
user_info['hourly_rate'] = hourly_rate
result['user_info'] = user_info
# Company Info
company_info = {}
company_users = CompanyUser.objects.filter(user=user.id)
company_id = None
if (len(company_users) > 0):
company_user = company_users[0]
company_id = company_user.company_id
company_info['company_id'] = company_id
company_info[
'company_id_env_encode'] = self.hash_key_service.encode_key_with_environment(
company_user.company_id)
if (company_user.company):
company_info['company_name'] = company_user.company.name
result['company_info'] = company_info
# Application Features
application_features = None
if (company_id):
application_feature_service = ApplicationFeatureService()
application_features = application_feature_service.get_complete_application_feature_status_by_company(
company_id)
result['app_features_info'] = application_features
# Projects
if (application_features
and application_features[APP_FEATURE_PROJECTMANAGEMENT]):
project_service = ProjectService()
result['project_list'] = project_service.get_projects_by_company(
company_id, active_only=True)
return result
def to_native(self, obj):
hash_key_service = HashKeyService()
return hash_key_service.encode_key(obj)
def _decode_value(self, value):
hash_key_service = HashKeyService()
return hash_key_service.decode_key(value)
class TimeOffRecord(object):
hash_key_service = HashKeyService()
date_time_service = DateTimeService()
def __init__(self, time_off_domain_model):
if (time_off_domain_model is None):
raise ValueError('Must pass valid time off domain model.')
# List out instance variables
self.requestor_user_id = None
self.requestor_user_info = None
self.approver_user_id = None
self.approver_user_info = None
self.start_date_time = None
self.duration = None
self.status = None
self.decision_timestamp = None
self.record_type = None
self.request_timestamp = None
# Parse requestor info
requestor_user_descriptor = time_off_domain_model['requestor'][
'personDescriptor']
self.requestor_user_id = int(
self.hash_key_service.decode_key_with_environment(
requestor_user_descriptor))
if (self.requestor_user_id):
user_model = User.objects.get(pk=self.requestor_user_id)
self.requestor_user_info = UserInfo(user_model)
# Parse approver info
if ('approver' in time_off_domain_model
and time_off_domain_model['approver']):
approver_user_descriptor = time_off_domain_model['approver'][
'personDescriptor']
self.approver_user_id = int(
self.hash_key_service.decode_key_with_environment(
approver_user_descriptor))
if (self.approver_user_id):
user_model = User.objects.get(pk=self.approver_user_id)
self.approver_user_info = UserInfo(user_model)
# Parse record type
self.record_type = time_off_domain_model['type']
# Parse Duration
self.duration = float(time_off_domain_model['duration'])
# Parse status
self.status = time_off_domain_model['status']
# Parse all dates and times to objects
self.start_date_time = self.date_time_service.parse_date_time(
time_off_domain_model['startDateTime'])
self.request_timestamp = self.date_time_service.parse_date_time(
time_off_domain_model['requestTimestamp'])
if ('decisionTimestamp' in time_off_domain_model):
decision_time_str = time_off_domain_model['decisionTimestamp']
self.decision_timestamp = self.date_time_service.parse_date_time(
decision_time_str)
@property
def requestor_full_name(self):
if (self.requestor_user_info is None):
return None
return self.requestor_user_info.full_name
@property
def approver_full_name(self):
if (self.approver_user_info is None):
return None
return self.approver_user_info.full_name
def _encode_value(self, value):
hash_key_service = HashKeyService()
if not hash_key_service.is_encoded(value):
return hash_key_service.encode_key(value)
return value
class CompanyEnrollmentSummaryView(APIView):
def __init__(self):
self.hash_service = HashKeyService()
def _retrieve_not_started_from_DB(self, company_id):
with connection.cursor() as cursor:
cursor.execute(
"""select distinct cu.user_id, COALESCE(p.first_name, u.first_name), COALESCE(p.last_name, u.last_name)
from app_companyuser cu
join app_authuser u on u.id = cu.user_id
join app_companygroupmember as cgm on cgm.user_id = cu.user_id
left join app_person p on p.user_id=cu.user_id and p.relationship='self'
left join app_companygroupbenefitplanoption as compgrouphealth on compgrouphealth.company_group_id = cgm.company_group_id
left join app_companybenefitplanoption as comphealth on comphealth.id = compgrouphealth.company_benefit_plan_option_id
left join app_usercompanybenefitplanoption as health on health.user_id = cu.user_id and comphealth.id = health.benefit_id
left join app_companygroupbasiclifeinsuranceplan as compbasic on compbasic.company_group_id = cgm.company_group_id
left join app_usercompanylifeinsuranceplan as basic on basic.user_id = cu.user_id
left join app_companygroupsuppllifeinsuranceplan as compsup on compsup.company_group_id = cgm.company_group_id
left join app_personcompsuppllifeinsuranceplan as sp on sp.person_id = p.id
left join app_companygroupltdinsuranceplan as compgltd on compgltd.company_group_id = cgm.company_group_id
left join app_usercompanyltdinsuranceplan as ltd on ltd.user_id = cu.user_id
left join app_companygroupstdinsuranceplan as compgstd on compgstd.company_group_id = cgm.company_group_id
left join app_usercompanystdinsuranceplan as std on std.user_id=cu.user_id
left join app_companygrouphraplan as comphra on comphra.company_group_id = cgm.company_group_id
left join app_personcompanyhraplan as hra on hra.person_id = p.id
left join app_companygroupfsaplan as compfsa on compfsa.company_group_id = cgm.company_group_id
left join app_fsa as fsa on fsa.user_id = cu.user_id
left join app_personcompanygrouphsaplan as hsa on hsa.person_id = p.id
left join app_companygrouphsaplan as comphsa on comphsa.company_group_id = cgm.company_group_id
left join app_usercompanywaivedbenefit as hwaive on hwaive.user_id = cu.user_id
where cu.company_id = %s
and cu.company_user_type = 'employee'
and (p.id is null
or
(
(
comphealth.id is not null or compbasic.id is not null or
compsup.id is not null or compgltd.id is not null or
compgstd.id is not null or comphra.id is not null or
compfsa.id is not null or comphsa.id is not null
)
and
(
health.id is null and sp.id is null and ltd.id is null and
std.id is null and hwaive.id is null and hra.id is null and
fsa.id is null and hsa.id is null and basic.id is null
)
))""", [company_id])
rows = cursor.fetchall()
return self._convert_db_rows_to_list(rows)
def _retrieve_started_from_DB(self, company_id):
with connection.cursor() as cursor:
cursor.execute(
"""select distinct cu.user_id, p.first_name, p.last_name
from app_companyuser cu
join app_person p on p.user_id=cu.user_id and p.relationship='self'
left join app_usercompanybenefitplanoption health on health.user_id = cu.user_id
left join app_usercompanylifeinsuranceplan basic on basic.user_id = cu.user_id
left join app_personcompsuppllifeinsuranceplan sp on sp.person_id = p.id
left join app_usercompanyltdinsuranceplan ltd on ltd.user_id = cu.user_id
left join app_usercompanystdinsuranceplan std on std.user_id=cu.user_id
left join app_usercompanywaivedbenefit hwaive on hwaive.user_id = cu.user_id
left join app_personcompanyhraplan hra on hra.person_id = p.id
left join app_fsa fsa on fsa.user_id = cu.user_id
left join app_personcompanygrouphsaplan hsa on hsa.person_id = p.id
where cu.company_id = %s
and cu.company_user_type = 'employee'
and (health.id is not null
or basic.id is not null
or sp.id is not null
or ltd.id is not null
or std.id is not null
or hwaive.id is not null
or hra.id is not null
or fsa.id is not null
or hsa.id is not null);""", [company_id])
rows = cursor.fetchall()
return self._convert_db_rows_to_list(rows)
def _retrieve_completed_from_DB(self, company_id):
with connection.cursor() as cursor:
cursor.execute(
"""select distinct cu.user_id, p.first_name, p.last_name
from app_companyuser as cu
join app_person as p on p.user_id=cu.user_id and p.relationship='self'
join app_companygroupmember as cgm on cgm.user_id = cu.user_id
left join app_companygroupbenefitplanoption as compgrouphealth on compgrouphealth.company_group_id = cgm.company_group_id
left join app_companybenefitplanoption as comphealth on comphealth.id = compgrouphealth.company_benefit_plan_option_id
left join app_usercompanybenefitplanoption as health on health.user_id = cu.user_id and comphealth.id = health.benefit_id
left join app_companygroupbasiclifeinsuranceplan as compbasic on compbasic.company_group_id = cgm.company_group_id
left join app_usercompanylifeinsuranceplan as basic on basic.user_id = cu.user_id
left join app_companygroupsuppllifeinsuranceplan as compsup on compsup.company_group_id = cgm.company_group_id
left join app_personcompsuppllifeinsuranceplan as sp on sp.person_id = p.id
left join app_companygroupltdinsuranceplan as compgltd on compgltd.company_group_id = cgm.company_group_id
left join app_usercompanyltdinsuranceplan as ltd on ltd.user_id = cu.user_id
left join app_companygroupstdinsuranceplan as compgstd on compgstd.company_group_id = cgm.company_group_id
left join app_usercompanystdinsuranceplan as std on std.user_id=cu.user_id
left join app_companygrouphraplan as comphra on comphra.company_group_id = cgm.company_group_id
left join app_personcompanyhraplan as hra on hra.person_id = p.id
left join app_companygroupfsaplan as compfsa on compfsa.company_group_id = cgm.company_group_id
left join app_fsa as fsa on fsa.user_id = cu.user_id
left join app_personcompanygrouphsaplan as hsa on hsa.person_id = p.id
left join app_companygrouphsaplan as comphsa on comphsa.company_group_id = cgm.company_group_id
left join app_usercompanywaivedbenefit as hwaive on hwaive.user_id = cu.user_id
where cu.company_id = %s
and cu.company_user_type = 'employee'
and (comphealth.id is null or health.id is not null or hwaive.id is not null)
and (compbasic.id is null or basic.id is not null)
and (compsup.id is null or sp.id is not null)
and (compgltd.id is null or ltd.id is not null)
and (compgstd.id is null or std.id is not null)
and (comphra.id is null or hra.id is not null)
and (compfsa.id is null or fsa.id is not null)
and (comphsa.id is null or hsa.id is not null);""", [company_id])
rows = cursor.fetchall()
return self._convert_db_rows_to_list(rows)
def _convert_db_rows_to_list(self, rows):
list = []
for row in rows:
list.append({
"id": self.hash_service.encode_key(row[0]),
"firstName": row[1],
"lastName": row[2]
})
return list
def get(self, request, comp_id, format=None):
if not Company.objects.filter(pk=comp_id).exists():
raise Http404
not_started = self._retrieve_not_started_from_DB(comp_id)
started = self._retrieve_started_from_DB(comp_id)
completed = self._retrieve_completed_from_DB(comp_id)
not_complete = []
for start_user in started:
if not start_user in completed:
not_complete.append(start_user)
totalCount = CompanyUser.objects.filter(
company=comp_id, company_user_type='employee').count()
response = {
"enrollmentNotStarted": not_started,
"enrollmentNotComplete": not_complete,
"enrollmentCompleted": completed,
"totalEmployeeCount": totalCount
}
return Response(response)