def register(self, front_end_str):
cf = common_functions.Common_functions()
appl = applicant.Applicant()
error = []
message = ''
none = 0
return_front_end_dict = ''
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data'][0]
error.append(appl.setUserId(front_end_data['user_id']))
error.append(appl.setCampTimeSlots(front_end_data['camp_time_slots']))
error.append(
appl.setApplicantFirstName(front_end_data['applicant_first_name']))
error.append(
appl.setApplicantLastName(front_end_data['applicant_last_name']))
error.append(appl.setApplicantAge(front_end_data['applicant_age']))
error.append(
appl.setApplicantGender(front_end_data['applicant_gender']))
error.append(
appl.setApplicantAddress(front_end_data['applicant_address']))
error.append(
appl.setGuardianFirstName(front_end_data['guardian_first_name']))
error.append(
appl.setGuardianLastName(front_end_data['guardian_last_name']))
error.append(
appl.setGuardianContactNumber(
front_end_data['guardian_contact_number']))
error.append(
appl.setGuardianAddress(front_end_data['guardian_address']))
error.append(appl.setApplicationDate(str(datetime.datetime.now())))
error.append(
appl.setEmergencyContact(front_end_data['emergency_contact']))
error.append(appl.setPayment(front_end_data['payment']))
error.append(appl.setGuardianSsn(front_end_data['guardian_ssn']))
#print(front_end_str)
#print(error)
for i in range(0, len(error)):
if error[i] != None:
if message == '':
message = error[i]
else:
message = message + '|' + error[i]
if message == '':
cf.insertIntoCsv('applicant.csv', appl)
emp_appl = applicant.Applicant()
return_front_end_dict = '{ "data": [' + json.dumps(
emp_appl.__dict__
) + '], "status":"success", "message":"REGISTRATION COMPLETE" }'
else:
return_front_end_dict = '{ "data": [' + json.dumps(
appl.__dict__
) + '], "status":"error", "message":"' + message + '" }'
return return_front_end_dict
def insertIntoCsv(self, filename, object_name):
""" Insert into .csv from objects """
cf = common_functions.Common_functions()
dict = object_name
list_data = cf.csvToListOfList(
'Testing/Test_data_user_stories/Registration/' + filename)
last_row = [list_data[0]]
if len(list_data) != 1:
last_row.append(list_data[len(list_data) - 1])
last_row_dict = cf.convertListToDict(last_row)
output_list = []
relations = cf.csvToListOfList('relations.csv')
relations_dict = cf.convertListToDict(relations)
for i in range(0, len(list_data[0])):
for j in range(0, len(relations_dict)):
if relations_dict[j]['filename'] == filename:
if len(list_data) != 1:
dict[relations_dict[j]['column']] = int(
last_row_dict[0][relations_dict[j]['column']]) + 1
else:
dict[relations_dict[j]['column']] = 1
output_list.append(str(dict[list_data[0][i]]))
writer = csv.writer(open(
'Testing/Test_data_user_stories/Registration/' + filename, 'a'),
quoting=csv.QUOTE_ALL,
lineterminator='\n')
writer.writerow(output_list)
def getCheckInStatus(self,front_end_str):
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data'][0]
cf = common_functions.Common_functions()
data = cf.getFromCsv('applicant.csv',front_end_data)
apps = application_status.Application_status()
new_data = apps.getApplicationStatus(front_end_str)
new_data_check = ast.literal_eval(new_data)
data_accepted = new_data_check['data']
accepted_applicant_id = []
for i in range(0,len(data_accepted)):
if data_accepted[i]['application_status'] == 1:
accepted_applicant_id.append(data_accepted[i]['applicant_id'])
return_data = []
for i in range(0,len(data)):
if data[i]['applicant_id'] in accepted_applicant_id:
return_data.append(data[i])
if len(data) == 0:
return_front_end_dict = '{ "data": [], "status":"success", "message":"No applicants registered" }'
else:
return_front_end_dict = '{ "data": ' + json.dumps(return_data) + ', "status":"success", "message":"All applicant''s information retrieved" }'
return return_front_end_dict
def updateCheckInStatus(self,front_end_str):
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data']
cf = common_functions.Common_functions()
app_dict = []
for i in range(0,len(front_end_data)):
where_applicant_id = {}
where_applicant_id['applicant_id'] = front_end_data[i]['applicant_id']
data = cf.getFromCsv('applicant.csv',where_applicant_id)
data[0]['medical_form'] = front_end_data[i]['medical_form']
data[0]['legal_form'] = front_end_data[i]['legal_form']
data[0]['emergency_contact'] = front_end_data[i]['emergency_contact']
data[0]['helmet'] = front_end_data[i]['helmet']
data[0]['boot'] = front_end_data[i]['boot']
data[0]['sleeping_bag'] = front_end_data[i]['sleeping_bag']
data[0]['water_bottle'] = front_end_data[i]['water_bottle']
data[0]['sunscreen'] = front_end_data[i]['sunscreen']
data[0]['bugs_spray'] = front_end_data[i]['bugs_spray']
data[0]['check_in_status'] = front_end_data[i]['check_in_status']
app_dict.append(data[0])
cf.updateManyRowIntoCsv('applicant.csv',app_dict,'applicant_id')
return_front_end_dict = '{ "data": "", "status":"success", "message":"All applicant''s information updated" }'
return return_front_end_dict
def isApplicationDateNotInRange(self, application_date, camp_date):
""" checks whether the application date has surpassed or not """
cf = common_functions.Common_functions()
camp_date_minus_2_month = cf.monthdelta(camp_date, -2)
camp_date_minus_8_month = cf.monthdelta(camp_date, -8)
if application_date >= camp_date_minus_8_month and application_date <= camp_date_minus_2_month:
return False
else:
return True
def getCheckInStatus(self,front_end_str):
cf = common_functions.Common_functions()
data = cf.getAcceptedApplicants(front_end_str)
if len(data) == 0:
return_front_end_dict = '{ "data": [], "status":"success", "message":"No applicants registered" }'
else:
return_front_end_dict = '{ "data": ' + json.dumps(data) + ', "status":"success", "message":"All applicant''s information retrieved" }'
return return_front_end_dict
def getId(self, front_end_str):
""" Get Id for selected Name """
front_end_dict = ast.literal_eval(front_end_str)
together_flag = 1
try:
applicant_name = front_end_dict['data'][0][
'applicant_name_together_with']
except:
applicant_name = front_end_dict['data'][0][
'applicant_name_not_together_with']
together_flag = 0
cf = common_functions.Common_functions()
data = cf.getFromCsv('applicant.csv', {})
if data == []:
return_front_end_dict = '{ "data": [], "status":"success", "message":"No applicants registered"}'
else:
new_data = [{}]
list_of_id = []
#print("applicant_name : ",applicant_name)
if applicant_name != 'NONE':
for i in range(0, len(data)):
name = data[i]['applicant_last_name'] + ', ' + data[i][
'applicant_first_name']
if name == applicant_name:
id = data[i]['applicant_id']
if id not in list_of_id:
list_of_id.append(data[i]['applicant_id'])
else:
list_of_id = ['NONE']
if together_flag == 1:
new_data[0]['applicant_id_together_with'] = list_of_id
else:
new_data[0]['applicant_id_not_together_with'] = list_of_id
if len(list_of_id) <= 1:
return_front_end_dict = '{ "data": ' + json.dumps(
new_data) + ', "status":"success", "message":"" }'
else:
return_front_end_dict = '{ "data": ' + json.dumps(
new_data
) + ', "status":"success", "message":"There are more than 1 Application Id\'s.| Please choose one of them from the dropdown" }'
#print("new_data : ",new_data)
return return_front_end_dict
def readBunkhouseData(self,front_end_str):
""" read data for Bunkhouse """
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data'][0]
where = [{'camp_time_slots':str(front_end_data['camp_time_slots'])}]
total_no_of_bunkhouses = int(front_end_data['no_of_bunkhouses'])
no_of_male_bunkhouses = total_no_of_bunkhouses/2
no_of_female_bunkhouses = total_no_of_bunkhouses
cf = common_functions.Common_functions()
data = cf.getCheckedInApplicants('{ "data": ' + json.dumps(where) + '}')
if len(data) == 0:
return_front_end_dict = '{ "data": [], "status":"success", "message":"No applicants registered" }'
else:
male_data = []
female_data = []
for i in range(0,len(data)):
if data[i]['applicant_gender'] == 'MALE':
male_data.append(data[i])
elif data[i]['applicant_gender'] == 'FEMALE':
female_data.append(data[i])
male_data_with_bunkhouses = cf.sortData(male_data,'applicant_age')
female_data_with_bunkhouses = cf.sortData(female_data,'applicant_age')
bunkhouse_id = 1
for k in range(0,len(male_data_with_bunkhouses)):
male_data_with_bunkhouses[k]['bunkhouse_id'] = bunkhouse_id
bunkhouse_id += 1
if bunkhouse_id == no_of_male_bunkhouses + 1:
bunkhouse_id = 1
bunkhouse_id = no_of_male_bunkhouses + 1
for l in range(0,len(female_data_with_bunkhouses)):
female_data_with_bunkhouses[l]['bunkhouse_id'] = bunkhouse_id
bunkhouse_id += 1
if bunkhouse_id == no_of_female_bunkhouses + 1:
bunkhouse_id = no_of_male_bunkhouses + 1
all_data = male_data_with_bunkhouses + female_data_with_bunkhouses
cf.updateManyRowIntoCsv('applicant.csv',all_data,'applicant_id')
all_data_rows = cf.sortData(all_data,'bunkhouse_id')
return_front_end_dict = '{ "data": ' + json.dumps(all_data_rows) + ', "status":"success", "message":"All applicant''s information retrieved" }'
return return_front_end_dict
def readTribesData(self, front_end_str):
""" read data for Tribes """
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data'][0]
where = [{'camp_time_slots': str(front_end_data['camp_time_slots'])}]
total_no_of_tribes = int(front_end_data['no_of_tribes'])
cf = common_functions.Common_functions()
data = cf.getCheckedInApplicants('{ "data": ' + json.dumps(where) +
'}')
if len(data) == 0:
return_front_end_dict = '{ "data": [], "status":"success", "message":"No applicants registered" }'
else:
male_data = []
female_data = []
for i in range(0, len(data)):
if data[i]['applicant_gender'] == 'MALE':
male_data.append(data[i])
elif data[i]['applicant_gender'] == 'FEMALE':
female_data.append(data[i])
male_data_with_tribes = cf.sortData(male_data, 'applicant_age')
female_data_with_tribes = cf.sortData(female_data, 'applicant_age')
tribe_id = 1
for k in range(0, len(male_data_with_tribes)):
male_data_with_tribes[k]['tribe_id'] = tribe_id
tribe_id += 1
if tribe_id == total_no_of_tribes + 1:
tribe_id = 1
for l in range(0, len(female_data_with_tribes)):
female_data_with_tribes[l]['tribe_id'] = tribe_id
tribe_id += 1
if tribe_id == total_no_of_tribes + 1:
tribe_id = 1
all_data = male_data_with_tribes + female_data_with_tribes
all_data_rows = cf.sortData(all_data, 'tribe_id')
return_front_end_dict = '{ "data": ' + json.dumps(
all_data_rows
) + ', "status":"success", "message":"All applicant' 's information retrieved" }'
return return_front_end_dict
def setManyCancelFlag(self,front_end_str):
""" set cancel at csv """
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data']
cf = common_functions.Common_functions()
data = cf.getFromCsv('applicant.csv',{})
applicant_ids = []
new = []
current_date_time = str(datetime.datetime.now())
for i in range(0,len(front_end_data)):
applicant_ids.append(front_end_data[i]['applicant_id'])
#print(applicant_ids)
for j in range(0,len(data)):
if data[j]['applicant_id'] in applicant_ids:
new.append(data[j])
for k in range(0,len(new)):
for i in range(0,len(front_end_data)):
if new[k]["applicant_id"] == front_end_data[i]["applicant_id"]:
new[k]["cancel_flag"] = front_end_data[i]["cancel_flag"]
if new[k]["cancel_flag"] == '1':
new[k]["application_status"] = '2'
elif new[k]["cancel_flag"] == '0':
new[k]["application_status"] = '1'
for l in range(0,len(new)):
if new[l]["cancel_flag"] == '1':
if new[l]["cancel_date"] == '':
new[l]["cancel_date"] = current_date_time
print('new[l]["cancel_date"]:',new[l]["cancel_date"])
#getRefund(new[l]["payment"],new[l]["mailing_date"],new[l]["cancel_date"])
new[l]["refund"] = self.getRefund(new[l]["payment"],new[l]["mailing_date"],new[l]["cancel_date"])
print(new[l]["refund"])
else:
new[l]["cancel_date"] = ""
new[l]["refund"] = ""
cf.updateManyRowIntoCsv('applicant.csv',new,'applicant_id')
return_front_end_dict = '{ "data": ' + json.dumps(new) + ', "status":"success", "message":"Application has been updated" }'
return return_front_end_dict
def updateApplicationStatus(self, front_end_str):
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data']
cf = common_functions.Common_functions()
app_dict = []
for i in range(0, len(front_end_data)):
where_applicant_id = {}
where_applicant_id['applicant_id'] = front_end_data[i][
'applicant_id']
data = cf.getFromCsv('applicant.csv', where_applicant_id)
print(data)
if front_end_data[i]['application_status'][0] == "A":
data[0]['application_status'] = "1"
elif front_end_data[i]['application_status'][0] == "R":
data[0]['application_status'] = "0"
elif front_end_data[i]['application_status'][0] == "C":
data[0]['application_status'] = "2"
if front_end_data[i]['acceptance_packet'] == "1":
data[0]['acceptance_packet'] = front_end_data[i][
'acceptance_packet']
if data[0]['mailing_date'] == "":
data[0]['mailing_date'] = str(datetime.datetime.now())
elif data[0]['application_status'] == "2":
pass
elif front_end_data[i]['acceptance_packet'] == "0":
data[0]['acceptance_packet'] = ""
data[0]['mailing_date'] = ""
data[0]['rejected_reason'] = front_end_data[i]['rejected_reason']
app_dict.append(data[0])
cf.updateManyRowIntoCsv('applicant.csv', app_dict, 'applicant_id')
return_front_end_dict = '{ "data": "", "status":"success", "message":"All applicant' 's information updated" }'
return return_front_end_dict
def create_volume(request):
c = {}
c.update(csrf(request))
data = request.POST["vol_name"]
print("data" + data)
print(type(data))
data_dict = ast.literal_eval(data)
print(data_dict["password"])
k = common_functions.Common_functions()
ur = user.User()
ur.setUserId(data_dict["user_id"])
ur.setUserName(data_dict["user_name"])
ur.setUserType(data_dict["user_type"])
if ur.setPassword(data_dict["password"]
) == "Password should be more than 5 characters":
return false
else:
ur.setPassword(data_dict["password"])
k.insertIntoCsv("user.csv", ur)
return HttpResponse("success", content_type="application/type")
def setCancelFlag(self,front_end_str):
""" set cancel at csv """
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data'][0]
where = {'applicant_id': str(front_end_data['applicant_id'])}
cf = common_functions.Common_functions()
data = cf.getFromCsv('applicant.csv',where)
if len(data) == 0:
return_front_end_dict = '{ "data": "", "status":"error", "message":"Something went wrong" }'
else:
data[0]['cancel_flag'] = '0'
cf.updateManyRowIntoCsv('applicant.csv',data,'applicant_id')
return_front_end_dict = '{ "data": ' + json.dumps(data) + ', "status":"success", "message":"Applicantion has been cancelled" }'
#print('return_front_end_dict;',return_front_end_dict)
return return_front_end_dict
def viewRegisteredApplicant(self, front_end_str):
""" View Registered Applicant based on Application Id """
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data'][0]
applicant_id_dict = {'applicant_id': front_end_data['applicant_id']}
cf = common_functions.Common_functions()
data = cf.getFromCsv('applicant.csv', applicant_id_dict)
if data != []:
if data[0]['camp_time_slots'] != front_end_data['camp_time_slots']:
data = []
if len(data) != 0:
return_front_end_dict = '{ "data": [' + json.dumps(
data) + '], "status":"success", "message":"DATA RETRIEVED" }'
else:
return_front_end_dict = '{ "data": [' + json.dumps(
data
) + '], "status":"error", "message":"APPLICANT ID NOT FOUND FOR THIS CAMP TIME SLOT" }'
return return_front_end_dict
def alreadySsn(self, front_end_str):
""" Showing data if already present for an SSN """
cf = common_functions.Common_functions()
appl = {
'guardian_ssn': '',
'guardian_first_name': '',
'applicant_last_name': '',
'guardian_contact_number': '',
'emergency_contact': ''
}
error = []
message = ''
none = 0
return_front_end_dict = ''
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data'][0]
ssn_data = cf.getFromCsv('applicant.csv', front_end_data)
if ssn_data == []:
return_front_end_dict = '{ "data": [], "status":"error", "message":"" }'
else:
key = len(ssn_data) - 1
appl['guardian_ssn'] = ssn_data[key]['guardian_ssn']
appl['guardian_first_name'] = ssn_data[key]['guardian_first_name']
appl['guardian_last_name'] = ssn_data[key]['guardian_last_name']
appl['guardian_address'] = ssn_data[key]['guardian_address']
appl['guardian_contact_number'] = ssn_data[key][
'guardian_contact_number']
appl['emergency_contact'] = ssn_data[key]['emergency_contact']
return_front_end_dict = '{ "data": [' + json.dumps(
appl
) + '], "status":"success", "message":"WE ALREADY HAVE DATA FOR SSN : ' + ssn_data[
0]['guardian_ssn'] + '|DO YOU WANT TO USE IT?"}'
return return_front_end_dict
def getFromCsv(self, filename, where):
""" Read to csv file """
cf = common_functions.Common_functions()
# Reading csv and storing data in List of List
list_data = cf.csvToListOfList(
'Testing/Test_data_user_stories/Registration/' + filename)
# Converting List of List to List of Dictionary
list_dict_data = cf.convertListToDict(list_data)
list_dict_data_where = []
if where == {}:
# return all the data if there is no where clause defined
list_dict_data_where = list_dict_data
else:
# find rows that match the where
for i in range(0, len(list_dict_data)):
dict = {}
for columns in where:
if list_dict_data[i][columns] == where[columns]:
list_dict_data_where.append(list_dict_data[i])
return list_dict_data_where
def getRefund(self,payment,mailing_date,cancel_date):
"""Set Refund at csv"""
cf = common_functions.Common_functions()
mail = cf.str_to_date(mailing_date)
print('cancel_date:',cancel_date)
cancel = cf.str_to_date(cancel_date)
#print(mail)
#print(cancel_date)
#if week_difference
week_difference = (cancel - mail).days/7
print('week_difference:',week_difference)
if int(payment)<=1000:
if week_difference <= 3:
refund = float(payment)*0.9
return refund
elif week_difference >= 3 and week_difference <= 6:
refund = float(payment)*0.45
return refund
else:
return "0"
elif int(payment)>1000:
payment_extra = int(payment)-1000
if week_difference <= 3:
refund = float(1000)*0.9
return refund+payment_extra
elif week_difference >= 3 and week_difference <= 6:
refund = float(1000)*0.45
return refund+payment_extra
else:
return "0"
def getApplicationStatus(self, front_end_str):
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data'][0]
cf = common_functions.Common_functions()
data = cf.getFromCsv('applicant.csv', front_end_data)
if len(data) == 0:
return_front_end_dict = '{ "data": [], "status":"success", "message":"No applicants registered" }'
else:
new_data = []
accepted_count = {'MALE': 0, 'FEMALE': 0}
for i in range(0, len(data)):
dict = {}
violations = []
slot = 36
applicant_status = 0
# data about the applicant
camp_date = datetime.datetime.strptime(
data[i]['camp_time_slots'], "%Y-%m-%d %H:%M:%S.%f")
application_date = datetime.datetime.strptime(
data[i]['application_date'], "%Y-%m-%d %H:%M:%S.%f")
gender = data[i]['applicant_gender']
age = int(data[i]['applicant_age'])
payment = int(data[i]['payment'])
cancel_flag = data[i]['cancel_flag']
if self.isApplicationCancelled(cancel_flag):
violations.append('APPLICATION HAS BEEN CANCELLED')
if self.isApplicationDateNotInRange(application_date,
camp_date):
violations.append(
'DATE OF REGISTRATION HAS NOT YET STARTED OR HAS SURPASSED'
)
if self.isSlotNotAvailable(accepted_count, gender):
violations.append(gender + ' SLOTS ARE FULL')
if self.isAgeNotInRange(age):
violations.append('AGE IS NOT BETWEEN 8 AND 19')
if self.isPaymentNotCorrect(payment):
violations.append(str(payment) + '$ IS LESS THAN 1000$')
if len(violations) == 0:
accepted_count[gender] += 1
applicant_status = 1
violations.append('NO VIOLATIONS')
if self.isApplicationCancelled(cancel_flag):
applicant_status = 2
dict['applicant_id'] = data[i]['applicant_id']
dict['applicant_first_name'] = data[i]['applicant_first_name']
dict['applicant_last_name'] = data[i]['applicant_last_name']
dict['application_status'] = applicant_status
dict['acceptance_packet'] = data[i]['acceptance_packet']
dict['violations'] = violations
new_data.append(dict)
data[i]['rejected_reason'] = new_data[i]['violations'][0]
cf.updateManyRowIntoCsv('applicant.csv', data, 'applicant_id')
return_front_end_dict = '{ "data": ' + json.dumps(
new_data
) + ', "status":"success", "message":"All applicant' 's information retrieved" }'
return return_front_end_dict
import sys
sys.path.append("Python")
sys.path.append("Python/Entities")
import common_functions
import user
ur = user.User()
ur.setUserName('Karthik-Yana')
cf = common_functions.Common_functions()
cf.insertIntoCsv('user.csv', ur)
def chooseDate(self):
return_front_end_dict = ''
cf = common_functions.Common_functions()
dt = date.Date()
date1 = {"date_id": "1"}
date2 = {"date_id": "2"}
date3 = {"date_id": "3"}
data1 = cf.getFromCsv('date.csv', date1)
data2 = cf.getFromCsv('date.csv', date2)
data3 = cf.getFromCsv('date.csv', date3)
if len(data1) == 0:
return_front_end_dict = '{ "data": [], "status":"error", "message":"No Date in ' 'date.csv' '" }'
elif len(data2) == 0:
return_front_end_dict = '{ "data": [], "status":"error", "message":"No Date in ' 'date.csv' '" }'
elif len(data3) == 0:
return_front_end_dict = '{ "data": [], "status":"error", "message":"No Date in ' 'date.csv' '" }'
else:
start_date1 = self.returnSecondSunday(int(data1[0]['year']),
int(data1[0]['month']))
start_date2 = self.returnSecondSunday(int(data2[0]['year']),
int(data2[0]['month']))
start_date3 = self.returnSecondSunday(int(data3[0]['year']),
int(data3[0]['month']))
new_data = [{}]
new_data[0]['camp_time_slots1'] = str(
start_date1) + " 00:00:00.000000"
new_data[0]['camp_time_slots2'] = str(
start_date2) + " 00:00:00.000000"
new_data[0]['camp_time_slots3'] = str(
start_date3) + " 00:00:00.000000"
end_date1 = start_date1 + datetime.timedelta(days=13)
end_date2 = start_date2 + datetime.timedelta(days=13)
end_date3 = start_date3 + datetime.timedelta(days=13)
display_date1 = str(start_date1.day) + self.suffix(
start_date1.day) + '-' + str(end_date1.day) + self.suffix(
end_date1.day) + " " + start_date1.strftime(
"%B") + " " + str(end_date1.year)
display_date2 = str(start_date2.day) + self.suffix(
start_date2.day) + '-' + str(end_date2.day) + self.suffix(
end_date2.day) + " " + start_date2.strftime(
"%B") + " " + str(end_date2.year)
display_date3 = str(start_date3.day) + self.suffix(
start_date3.day) + '-' + str(end_date3.day) + self.suffix(
end_date3.day) + " " + start_date3.strftime(
"%B") + " " + str(end_date3.year)
new_data[0]['display_date1'] = display_date1
new_data[0]['display_date2'] = display_date2
new_data[0]['display_date3'] = display_date3
return_front_end_dict = '{ "data": ' + json.dumps(
new_data) + ', "status":"success", "message":"" }'
return return_front_end_dict
def updateCustomerPriorities(self, front_end_str):
""" Updating priorities in applicant.csv """
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data']
cf = common_functions.Common_functions()
data = cf.getFromCsv('applicant.csv', {})
if len(data) == 0:
return_front_end_dict = '{ "data": ' + json.dumps(
data
) + ', "status":"error", "message":"Something went wrong" }'
else:
update_flag = 1
applicant_id_same = ''
applicant_id_same_applicant = ''
for k in range(0, len(front_end_data)):
if front_end_data[k]['applicant_name_together_with'] != 'NONE':
if front_end_data[k][
'applicant_id_together_with'] == front_end_data[k][
'applicant_id_not_together_with']:
update_flag = 2
if applicant_id_same == '':
applicant_id_same = front_end_data[k][
'applicant_id']
else:
applicant_id_same = applicant_id_same + ', ' + front_end_data[
k]['applicant_id']
for l in range(0, len(front_end_data)):
if front_end_data[l][
'applicant_id_together_with'] == front_end_data[l][
'applicant_id'] or front_end_data[l][
'applicant_id_not_together_with'] == front_end_data[
l]['applicant_id']:
update_flag = 3
if applicant_id_same_applicant == '':
applicant_id_same_applicant = front_end_data[l][
'applicant_id']
else:
applicant_id_same_applicant = applicant_id_same_applicant + ', ' + front_end_data[
l]['applicant_id']
if update_flag == 1:
for i in range(0, len(data)):
for j in range(0, len(front_end_data)):
if data[i]['applicant_id'] == front_end_data[j][
'applicant_id']:
data[i][
'applicant_name_together_with'] = front_end_data[
j]['applicant_name_together_with']
data[i][
'applicant_id_together_with'] = front_end_data[
j]['applicant_id_together_with']
data[i][
'applicant_name_not_together_with'] = front_end_data[
j]['applicant_name_not_together_with']
data[i][
'applicant_id_not_together_with'] = front_end_data[
j]['applicant_id_not_together_with']
if update_flag == 1:
cf.updateManyRowIntoCsv('applicant.csv', data, 'applicant_id')
return_front_end_dict = '{ "data": ' + json.dumps(
data
) + ', "status":"success", "message":"All applicant\'s data updated" }'
elif update_flag == 2:
return_front_end_dict = '{ "data": ' + json.dumps(
data
) + ', "status":"success", "message":"You can\'t enter same names in both together and not together. Check following applicant id\'s : ' + applicant_id_same + '" }'
elif update_flag == 3:
return_front_end_dict = '{ "data": ' + json.dumps(
data
) + ', "status":"success", "message":"You can\'t enter same name as applicant in together or not together. Check following applicant id\'s : ' + applicant_id_same_applicant + '" }'
return return_front_end_dict
def updateRegisteredApplicantData(self, front_end_str):
""" View Registered Applicant based on Application Id """
cf = common_functions.Common_functions()
appl = applicant.Applicant()
error = []
message = ''
none = 0
return_front_end_dict = ''
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data'][0]
print("front_end_data :", front_end_data)
error.append(appl.setApplicantId(front_end_data['applicant_id']))
error.append(appl.setUserId(front_end_data['user_id']))
error.append(appl.setCampTimeSlots(front_end_data['camp_time_slots']))
error.append(
appl.setApplicantFirstName(front_end_data['applicant_first_name']))
error.append(
appl.setApplicantLastName(front_end_data['applicant_last_name']))
error.append(appl.setApplicantAge(front_end_data['applicant_age']))
error.append(
appl.setApplicantGender(front_end_data['applicant_gender']))
error.append(
appl.setApplicantAddress(front_end_data['applicant_address']))
error.append(
appl.setGuardianFirstName(front_end_data['guardian_first_name']))
error.append(
appl.setGuardianLastName(front_end_data['guardian_last_name']))
error.append(
appl.setGuardianContactNumber(
front_end_data['guardian_contact_number']))
error.append(
appl.setGuardianAddress(front_end_data['guardian_address']))
error.append(
appl.setEmergencyContact(front_end_data['emergency_contact']))
error.append(appl.setPayment(front_end_data['payment']))
error.append(appl.setGuardianSsn(front_end_data['guardian_ssn']))
error.append(
appl.setApplicationDate(front_end_data['application_date']))
#print(front_end_str)
#print(error)
for i in range(0, len(error)):
if error[i] != None:
if message == '':
message = error[i]
else:
message = message + '|' + error[i]
if message == '':
cf.updateManyRowIntoCsv('applicant.csv', [appl.__dict__],
'applicant_id')
return_front_end_dict = '{ "data": [' + json.dumps(
appl.__dict__
) + '], "status":"success", "message":"APPLICANT DATA UPDATED" }'
else:
return_front_end_dict = '{ "data": [' + json.dumps(
appl.__dict__
) + '], "status":"error", "message":"' + message + '" }'
return return_front_end_dict
def getCustomerPriorities(self, front_end_str):
""" get data for priorities from Customer """
cf = common_functions.Common_functions()
appl = applicant.Applicant()
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data'][0]
data = cf.getFromCsv('applicant.csv', front_end_data)
if data == []:
return_front_end_dict = '{ "data": [], "status":"success", "message":"No applicants registered"}'
else:
new_data = []
list_of_names = ["NONE"]
list_of_id = ["NONE"]
for i in range(0, len(data)):
name = data[i]['applicant_last_name'] + ', ' + data[i][
'applicant_first_name']
if name not in list_of_names:
list_of_names.append(data[i]['applicant_last_name'] +
', ' +
data[i]['applicant_first_name'])
for j in range(0, len(data)):
backup_list_of_names = copy.deepcopy(list_of_names)
backup_list_of_id = copy.deepcopy(list_of_id)
new_dict = {}
new_dict['applicant_id'] = data[j]['applicant_id']
new_dict['applicant_name'] = data[j][
'applicant_last_name'] + ', ' + data[j][
'applicant_first_name']
new_dict[
'applicant_name_together_with'] = self.getCorrectSequence(
data[j]['applicant_name_together_with'],
backup_list_of_names)
check_list_of_id1 = ['NONE']
if data[j]['applicant_id_together_with'] != '':
dict_applicant_name = [{
'applicant_name_together_with':
data[j]['applicant_name_together_with']
}]
check_list_of_id1_str = self.getId(
'{ "data": ' + json.dumps(dict_applicant_name) + '}')
check_list_of_id1_dict = ast.literal_eval(
check_list_of_id1_str)
check_list_of_id1 = check_list_of_id1_dict['data'][0][
'applicant_id_together_with']
#print("check_list_of_id1 :",check_list_of_id1)
if len(check_list_of_id1
) > 1 and check_list_of_id1[0] != 'NONE':
check_list_of_id1 = self.getCorrectSequence(
data[j]['applicant_id_together_with'],
check_list_of_id1)
new_dict['applicant_id_together_with'] = check_list_of_id1
new_dict[
'applicant_name_not_together_with'] = self.getCorrectSequence(
data[j]['applicant_name_not_together_with'],
backup_list_of_names)
check_list_of_id2 = ['NONE']
print("data[j]['applicant_id_not_together_with'] :",
data[j]['applicant_id_not_together_with'])
if data[j]['applicant_id_not_together_with'] != '':
dict_applicant_name = [{
'applicant_name_not_together_with':
data[j]['applicant_name_not_together_with']
}]
check_list_of_id2_str = self.getId(
'{ "data": ' + json.dumps(dict_applicant_name) + '}')
check_list_of_id2_dict = ast.literal_eval(
check_list_of_id2_str)
check_list_of_id2 = check_list_of_id2_dict['data'][0][
'applicant_id_not_together_with']
#print("check_list_of_id1 :",check_list_of_id2)
if len(check_list_of_id2
) > 1 and check_list_of_id2[0] != 'NONE':
check_list_of_id2 = self.getCorrectSequence(
data[j]['applicant_id_not_together_with'],
check_list_of_id2)
new_dict['applicant_id_not_together_with'] = check_list_of_id2
new_data.append(new_dict)
return_front_end_dict = '{ "data": ' + json.dumps(
new_data
) + ', "status":"success", "message":"All applicant' 's information retrieved" }'
return return_front_end_dict
def printAcceptanceRejection(self, front_end_str):
front_end_dict = ast.literal_eval(front_end_str)
front_end_data = front_end_dict['data'][0]
#print('front_end_data :',front_end_data)
cf = common_functions.Common_functions()
data = cf.getFromCsv('applicant.csv', front_end_data)
#print(data)
app = application_status.Application_status()
data1 = app.getApplicationStatus(front_end_str)
data2 = ast.literal_eval(data1)
data3 = data2['data']
#print("data2 :",data2)
#print(data)
#print("data3[0]['violations'] :",data3[0]["violations"])
data[0]["violations"] = data3[0]["violations"]
data[0]["application_status"] = data3[0]["application_status"]
#print
data[0]["camp_time_slots"] = data[0]["camp_time_slots"][:10]
if data[0]["violations"][0] == "NO VIOLATIONS":
file_print = "Textfiles/Templates/a_template.txt"
path_name = "acception_letter"
else:
file_print = "Textfiles/Templates/r_template.txt"
path_name = "rejection_letter"
with open(file_print, "r") as myfile:
template = myfile.readlines()
temp = ''.join(template)
k = 1
Str = ''
for j in range(0, len(data)):
t = temp
for i in data[j].keys():
if ('*' + i + '*' in temp):
try:
t = t.replace('*' + i + '*', data[j][i])
except:
pass
#print("--------------------------------")
Str = ''
for m in range(0, len(data[j]['violations'])):
if m == 0:
Str = str(m + 1) + '. ' + data[j]['violations'][m]
else:
Str = Str + '\n' + str(m +
1) + '. ' + data[j]['violations'][m]
#print(type(Str))
t = t.replace("*violations*", Str)
#print ("yes")
#print(t)
user = getpass.getuser()
save_path = 'C:/Users/' + user + '/Documents/Gila_Breath_Camp'
if not os.path.exists(save_path):
os.makedirs(save_path)
name_of_file = data[0]["applicant_first_name"] + "_" + data[0][
"applicant_last_name"] + "_" + data[0][
"applicant_id"] + "_" + path_name
completeName = os.path.join(save_path, name_of_file + ".txt")
text_file = open(completeName, "w")
text_file.write(t)
text_file.close()
print(t)
return (t)
