def setUp(self):
logger = logging.getLogger(__name__)
createSession({})
#set sessoin start to tomorrow
session = Session.objects.first()
start_date = todaysDate()
session.parameterset.block_1_day_count = 3
session.parameterset.block_2_day_count = 3
session.parameterset.block_3_day_count = 5
session.parameterset.save()
session.calcEndDate()
session = Session.objects.get(id = session.id)
session.save()
data = {'action': 'updateSession', 'formData': [{'name': 'title', 'value': '*** New Session ***'}, {'name': 'start_date', 'value': start_date.date().strftime("%m/%d/%Y")}, {'name': 'treatment', 'value': 'A'}, {'name': 'consent_required', 'value': '1'}, {'name': 'questionnaire1_required', 'value': '1'}, {'name': 'questionnaire2_required', 'value': '1'},{'name': 'instruction_set', 'value': '1'},{'name':'auto_pay','value':'1'}]}
r = json.loads(updateSession(data,session.id).content.decode("UTF-8"))
self.assertEqual(r['status'],"success")
session = Session.objects.first()
logger.info(f"Session start date {session.start_date} end date {session.end_date}")
addSubject({},session.id)
addSubject({},session.id)
session = Session.objects.first()
self.session = session
#add in paylevels
start_value = 1.00
start_score = .14
for i in range(8):
ParametersetPaylevel.objects.create(parameterset=self.session.parameterset, value=start_value, score=start_score)
start_value += 0.5
start_score += 0.1
ParametersetPaylevel.objects.create(parameterset=self.session.parameterset, value=5, score=1.0)
for paylevel in ParametersetPaylevel.objects.all():
logger.info(f'Paylevels {paylevel.score} {paylevel.value}')
#store synced today
for subject in session.session_subjects.all():
subject.fitBitLastSynced = todaysDate()
subject.save()
def addNewSessionDays(self):
logger = logging.getLogger(__name__)
logger.info("Add new sessions: " + str(self.title))
#get today's date
d_start = todaysDate()
d_start = d_start.replace(day=self.start_date.day,
month=self.start_date.month,
year=self.start_date.year)
d_start += timedelta(days=1)
tempPeriod = 2
logger.info(d_start)
#logger.info(d_end)
#add days for block 1
for i in range(self.parameterset.block_1_day_count):
self.addSessionDay(d_start.date(), tempPeriod)
d_start += timedelta(days=1)
tempPeriod += 1
#add days for block 2
for i in range(self.parameterset.block_2_day_count):
self.addSessionDay(d_start.date(), tempPeriod)
d_start += timedelta(days=1)
tempPeriod += 1
#add days for block 3
for i in range(self.parameterset.block_3_day_count):
self.addSessionDay(d_start.date(), tempPeriod)
d_start += timedelta(days=1)
tempPeriod += 1
def test_block_1_payments_day_8(self):
'''
test that block 2 payments are calculated correctly
'''
logger = logging.getLogger(__name__)
session = self.session
session.start_date = todaysDate() - timedelta(days=7)
session.calcEndDate()
session = Session.objects.get(id=session.id)
r = json.loads(startSession({}, session.id).content.decode("UTF-8"))
self.assertEqual(r['status'], "success")
session = Session.objects.get(id=session.id)
start_sleep = 0.2
start_heart = 0.1
for session_subject in self.session.session_subjects.all():
for activity in session_subject.Session_day_subject_actvities.all(
).order_by('session_day__period_number'):
activity.heart_activity = start_heart
activity.immune_activity = start_sleep
activity.paypal_today = True
activity.save()
start_heart += 0.01
start_sleep += 0.01
start_sleep = 0.2
start_heart = 0.1
for session_subject in self.session.session_subjects.all():
for activity in session_subject.Session_day_subject_actvities.all(
).order_by('session_day__period_number'):
logger.info(
f"period {activity.session_day.period_number}, subject {activity.session_subject.id}, heart score {activity.heart_activity}, sleep score {activity.immune_activity}, pay pal today {activity.paypal_today}"
)
results = do_calc_a_b_c_treatments()
#logger.info(results)
for result in results["A B C Lumpsum Calculations"]:
for payment in result['payments']:
self.assertEqual(
payment['payment'],
round_half_away_from_zero(3 * (3 + 8 * .15 + 8 * .25), 2))
#check for none payment everywhere else
#check for correct payment on last block
for session_subject in self.session.session_subjects.all():
activity = session_subject.Session_day_subject_actvities.get(
session_day__period_number=7)
self.assertEqual(
float(activity.payment_today),
round_half_away_from_zero(3 * (3 + 8 * .15 + 8 * .25), 2))
def do_calc_a_b_c_treatments():
'''
check for A B C treatments for lumpsum payments.
'''
logger = logging.getLogger(__name__)
yesterdays_date = todaysDate() - timedelta(days=1)
#check for yesterday's sessions that fall on payday
yesterdays_sessions = Session_day.objects.filter(date=yesterdays_date.date()) \
.filter(payments_sent = False) \
.filter(session__started = True) \
.filter(session__soft_delete = False) \
.exclude(session__treatment = "I") \
.exclude(session__treatment = "Base")
payments_list = []
logger.info(f'do_calc_a_b_c_treatments {yesterdays_sessions}')
for session_d in yesterdays_sessions:
payments_list.append(session_d.calc_a_b_c_block_payments())
return {"A B C Lumpsum Calculations": payments_list}
def reCalcAllActvity(self):
logger = logging.getLogger(__name__)
d_today = todaysDate()
sada_set = self.Session_day_subject_actvities.filter(
session_day__date__lt=d_today.date()).order_by(
'session_day__period_number')
logger.info(f"reCalcAllActvity date {d_today.date()}")
previous_i = None
for i in sada_set:
if i.session_day.period_number == 1:
i.heart_activity = self.session.parameterset.heart_activity_inital
i.immune_activity = self.session.parameterset.immune_activity_inital
else:
logger.info(f"previous: {previous_i} current {i}")
i.saveHeartActivity(previous_i.heart_activity_minutes,
previous_i.heart_activity)
i.saveImmuneActivity(previous_i.immune_activity_minutes,
previous_i.immune_activity)
i.save()
previous_i = i
def backFillSleep(data):
logger = logging.getLogger(__name__)
logger.info("Back Fill Sleep")
logger.info(data)
errors = "Success"
try:
d_today = todaysDate() - timedelta(days=1)
session_id = data["backFillSleepSessionId"]
sda_qs = Session_day_subject_actvity.objects.filter(session_day__session__id = session_id)\
.filter(session_day__date__lte = d_today.date())\
.filter(fitbit_immune_time_series = "")
for i in sda_qs:
#self.fitbit_immune_time_series = self.session_subject.getFitbitSleep(self.session_day.date)
i.fitbit_immune_time_series = i.session_subject.getFitbitSleep(
i.session_day.date)
i.save()
except Exception as e:
logger.warning(e)
errors = str(e)
return JsonResponse({
"errors": errors,
}, safe=False)
def isBeforeStartDate(self):
logger = logging.getLogger(__name__)
if todaysDate().date() < self.start_date:
return True
else:
return False
def getCurrentSessionDay(self):
#logger = logging.getLogger(__name__)
d_today = todaysDate().date()
#logger.info(f"getCurrentSessionDay {d_today}")
return self.session_days.filter(date=d_today).first()
def test_block_1_payments_day_5_missed_day(self):
'''
test that block 1 payments are calculated correctly
'''
logger = logging.getLogger(__name__)
session = self.session
session.start_date = todaysDate() - timedelta(days=4)
logger.info(
f'test_block_1_payments_day_5 start date {session.start_date}')
session.calcEndDate()
session = Session.objects.get(id=session.id)
r = json.loads(startSession({}, session.id).content.decode("UTF-8"))
self.assertEqual(r['status'], "success")
session = Session.objects.get(id=session.id)
start_sleep = 0.2
start_heart = 0.1
for session_subject in self.session.session_subjects.all():
for activity in session_subject.Session_day_subject_actvities.all(
).order_by('session_day__period_number'):
activity.heart_activity = start_heart
activity.immune_activity = start_sleep
start_heart += 0.01
start_sleep += 0.01
activity.paypal_today = True
activity.save()
for session_subject in self.session.session_subjects.all():
activity = session_subject.Session_day_subject_actvities.get(
session_day__period_number=2)
activity.paypal_today = False
activity.save()
results = do_calc_a_b_c_treatments()
for result in results["A B C Lumpsum Calculations"]:
for payment in result['payments']:
self.assertEqual(payment['payment'], 9)
#check for correct payment on last block
for session_subject in self.session.session_subjects.all():
activity = session_subject.Session_day_subject_actvities.get(
session_day__period_number=4)
self.assertEqual(activity.payment_today, 9)
#check for none payment everywhere else
for session_subject in self.session.session_subjects.all():
for activity in session_subject.Session_day_subject_actvities.exclude(
session_day__period_number=4):
self.assertEqual(activity.payment_today, 0)
def test_auto_pay(self):
'''
test auto pay feature
'''
logger = logging.getLogger(__name__)
yesterday = todaysDate() - timedelta(days=1)
session = Session.objects.first()
session_day = session.session_days.get(date=yesterday.date())
logger.info(session_day)
#test no payments
session_day.payments_sent = False
session_day.save()
session.auto_pay = True
session.save()
r = do_paypal()
self.assertEqual([], r['Do Paypal Cron'])
#test payments
pay = 1.00
for activity in session_day.Session_day_subject_actvities_SD.all(
).order_by("id"):
activity.paypal_today = True
activity.payment_today = pay
activity.save()
pay += 1
session = Session.objects.first()
session_day = session.session_days.get(date=yesterday.date())
session_day.payments_sent = False
session_day.save()
session.auto_pay = True
session.save()
r = do_paypal()
self.assertNotEqual(2, len(r['Do Paypal Cron']))
#check no double sending
r = do_paypal()
self.assertEqual(0, len(r['Do Paypal Cron']))
#check auto pay off
session = Session.objects.first()
session_day = session.session_days.get(date=yesterday.date())
session_day.payments_sent = False
session_day.save()
session.auto_pay = False
session.save()
r = do_paypal()
logger.info(r)
self.assertEqual(0, len(r['Do Paypal Cron']))
def setUp(self):
logger = logging.getLogger(__name__)
createSession({})
#set sessoin start to tomorrow
session = Session.objects.first()
start_date = todaysDate()
session.parameterset.block_1_day_count = 3
session.parameterset.block_2_day_count = 3
session.parameterset.block_3_day_count = 5
session.parameterset.save()
session.calcEndDate()
session = Session.objects.get(id = session.id)
data = {'action': 'updateSession', 'formData': [{'name': 'title', 'value': '*** New Session ***'}, {'name': 'start_date', 'value': start_date.date().strftime("%m/%d/%Y")}, {'name': 'treatment', 'value': 'A'}, {'name': 'consent_required', 'value': '1'}, {'name': 'questionnaire1_required', 'value': '1'}, {'name': 'questionnaire2_required', 'value': '1'},{'name': 'instruction_set', 'value': '1'},{'name':'auto_pay','value':'1'}]}
r = json.loads(updateSession(data,session.id).content.decode("UTF-8"))
self.assertEqual(r['status'],"success")
session = Session.objects.first()
logger.info(f"Session start date {session.start_date} end date {session.end_date}")
addSubject({},session.id)
addSubject({},session.id)
addSubject({},session.id)
addSubject({},session.id)
addSubject({},session.id)
addSubject({},session.id)
r = json.loads(startSession({},session.id).content.decode("UTF-8"))
self.assertEqual(r['status'],"success")
session = Session.objects.first()
self.session = session
Session_day_subject_actvity.objects.filter(session_day__session = session).update(fitbit_on_wrist_minutes = session.parameterset.minimum_wrist_minutes)
#store synced today
for subject in session.session_subjects.all():
subject.fitBitLastSynced = todaysDate()
subject.save()
def calcEndDate(self):
d_end = todaysDate()
d_end = d_end.replace(day=self.start_date.day,month=self.start_date.month, year=self.start_date.year)
d_end += timedelta(days=self.numberOfDays()-1)
self.end_date=d_end.date()
self.save()
def getQuestionnaire2Required(self):
#p = Parameters.objects.first()
#check that questionnaire 2 is enabled
# if not p.questionnaire2Required:
# return False
#check that today is the last day of sessoin
if todaysDate().date() != self.session.end_date:
return False
return self.questionnaire2_required
def getYesterdaysSessionDay(self):
#logger = logging.getLogger(__name__)
d_yesterday = todaysDate() - timedelta(days=1)
#logger.info(f"getCurrentSessionDay {d_today}")
try:
return self.session_days.get(date=d_yesterday.date())
except ObjectDoesNotExist:
return None
return None
def createSession(data):
logger = logging.getLogger(__name__)
logger.info("Create Session")
logger.info(data)
p = Parameters.objects.first()
#create parameter set
ps = Parameterset()
ps.consent_form = Consent_forms.objects.all().last()
ps.save()
#create session
s = Session()
s.parameterset = ps
s.invitation_text = p.invitationText
s.invitation_text_subject = p.invitationTextSubject
s.cancelation_text = p.cancelationText
s.cancelation_text_subject = p.cancelationTextSubject
s.consent_required = p.consentFormRequired
s.questionnaire1_required = p.questionnaire1Required
s.questionnaire2_required = p.questionnaire2Required
s.instruction_set = InstructionSet.objects.first()
s.start_date = todaysDate().date()
s.calcEndDate()
s.save()
#setup first session day
sd = Session_day()
sd.session = s
sd.period_number = 1
sd.date = todaysDate().date()
sd.save()
return getSessions(data)
def fitbitSyncedToday(self):
logger = logging.getLogger(__name__)
d_today = todaysDate().date()
if not self.fitBitLastSynced:
return False
d_fitbit = self.fitBitLastSynced.date()
logger.info(
f'fitbitSyncedToday {self} Today:{d_today} Last Synced:{d_fitbit}')
if d_fitbit >= d_today:
return True
else:
return False
def test_block_length(self):
'''test block level counts '''
session = self.session
#check block length
self.assertEqual(4, session.parameterset.get_block_day_count(1))
self.assertEqual(4, session.parameterset.get_block_day_count(2))
self.assertEqual(4, session.parameterset.get_block_day_count(4))
self.assertEqual(3, session.parameterset.get_block_day_count(5))
self.assertEqual(3, session.parameterset.get_block_day_count(7))
self.assertEqual(5, session.parameterset.get_block_day_count(8))
self.assertEqual(5, session.parameterset.get_block_day_count(12))
#get first period
self.assertEqual(1, session.parameterset.get_block_first_period(1))
self.assertEqual(1, session.parameterset.get_block_first_period(2))
self.assertEqual(1, session.parameterset.get_block_first_period(4))
self.assertEqual(5, session.parameterset.get_block_first_period(5))
self.assertEqual(5, session.parameterset.get_block_first_period(7))
self.assertEqual(8, session.parameterset.get_block_first_period(8))
self.assertEqual(8, session.parameterset.get_block_first_period(9))
self.assertEqual(8, session.parameterset.get_block_first_period(12))
#get last period
self.assertEqual(4, session.parameterset.get_block_last_period(1))
self.assertEqual(4, session.parameterset.get_block_last_period(2))
self.assertEqual(4, session.parameterset.get_block_last_period(4))
self.assertEqual(7, session.parameterset.get_block_last_period(5))
self.assertEqual(7, session.parameterset.get_block_last_period(7))
self.assertEqual(12, session.parameterset.get_block_last_period(8))
self.assertEqual(12, session.parameterset.get_block_last_period(9))
self.assertEqual(12, session.parameterset.get_block_last_period(12))
#check pay date
self.assertEqual(todaysDate().date() + timedelta(days=4),
session.get_block_pay_date(2))
self.assertEqual(todaysDate().date() + timedelta(days=4),
session.get_block_pay_date(4))
self.assertEqual(todaysDate().date() + timedelta(days=7),
session.get_block_pay_date(5))
self.assertEqual(todaysDate().date() + timedelta(days=7),
session.get_block_pay_date(7))
self.assertEqual(todaysDate().date() + timedelta(days=12),
session.get_block_pay_date(8))
self.assertEqual(todaysDate().date() + timedelta(days=12),
session.get_block_pay_date(12))
#check on block 1 daily payments
session_subject = session.session_subjects.first()
self.assertEqual(session.parameterset.block_1_fixed_pay_per_day,
session_subject.get_daily_payment_A_B_C(1))
self.assertEqual(session.parameterset.block_1_fixed_pay_per_day,
session_subject.get_daily_payment_A_B_C(4))
def fitBitCatchUp(self):
logger = logging.getLogger(__name__)
logger.info(
f"fitBitCatchUp name {self.name} session {self.session.id}")
d_today = todaysDate()
sa_list = self.Session_day_subject_actvities.all().filter(
check_in_today=False, session_day__date__lt=d_today.date())
logger.info(
f'fitBitCatchUp date {d_today.date()} subject activities {sa_list}'
)
if not self.getFitBitAttached():
logger.warning(
f'fitBitCatchUp error not attached {d_today.date()} subject activities {sa_list}'
)
return
#pull in actvity for days not checked in
for s in sa_list:
#if s.session_day.date < d_today.date():
logger.info(f'fitBitCatchUp {s.id}')
previous_sa = s.getPreviousActivityDay()
if previous_sa:
fitbiterror = previous_sa.pullFitbitActvities()
if not fitbiterror:
previous_sa.pullFibitBitHeartRate(True)
s.check_in_today = True
s.save()
else:
logger.warning(
f'fitBitCatchUp error date {d_today.date()} subject activities {sa_list}'
)
break
#recalc activtivity scores
if sa_list:
self.reCalcAllActvity()
def getSubjectsAvailableToCopyJSON(id):
logger = logging.getLogger(__name__)
#list of emails in session
email_list = Session_subject.objects.filter(session__id = id) \
.values_list('contact_email', flat=True)
logger.info(f"Subjects available for copy: exclude emails {email_list}")
ss = Session_subject.objects.exclude(session__soft_delete = True) \
.filter(session__end_date__lt = todaysDate()) \
.exclude(soft_delete = True) \
.exclude(contact_email__in = email_list) \
.values('id','name','session__id','session__title') \
.order_by('session__title','name')
logger.info(f'Subjects available for copy: {ss}')
return [{"id" : i["id"],
"name" : i["name"],
"session_id" : i["session__id"],
"session_title" : i["session__title"] } for i in ss]
def fillWithTestData(self):
logger = logging.getLogger(__name__)
sada_set = self.Session_day_subject_actvities.order_by(
'session_day__period_number')
d_today = todaysDate()
heart_activity_minutes = random.randint(0, 90)
immune_activity_minutes = random.randint(240, 600)
previous_i = None
for i in sada_set:
if i.session_day.date == d_today.date():
break
if random.randrange(1, 100) == 1:
i.heart_activity_minutes = 0
i.immune_activity_minutes = 0
else:
i.heart_activity_minutes = heart_activity_minutes
i.immune_activity_minutes = immune_activity_minutes
heart_activity_minutes += random.randrange(-5, 5)
immune_activity_minutes += random.randrange(-10, 10)
if heart_activity_minutes < 0:
heart_activity_minutes = 0
if immune_activity_minutes < 0:
immune_activity_minutes = 0
i.check_in_today = True
if random.randrange(1, 50) == 1:
i.paypal_today = False
else:
i.paypal_today = True
i.save()
self.reCalcAllActvity()
#save earnings if treatment I or B
if self.session.treatment == "I" or self.session.treatment == "Base":
sada_set = self.Session_day_subject_actvities.order_by(
'session_day__period_number')
for i in sada_set:
if i.session_day.date == d_today.date():
break
i.paypal_today = True
i.storeTodaysTotalEarnings()
i.save()
#consent form
self.consent_required = False
self.consent_signature = self.name
self.save()
#questionnaires
#logger.info(f"fillWithTestData {self.Session_subject_questionnaire1}")
if not self.Session_subject_questionnaire1.all():
q1 = main.models.Session_subject_questionnaire1()
q1.session_subject = self
q1.save()
self.Session_subject_questionnaire1.first().fillWithTestData()
if todaysDate().date() > self.session.end_date:
if not self.Session_subject_questionnaire2.all():
q2 = main.models.Session_subject_questionnaire2()
q2.session_subject = self
q2.save()
self.Session_subject_questionnaire2.first().fillWithTestData()
def payMe(data,session_subject,session_day):
logger = logging.getLogger(__name__)
if session_day:
logger.info(f"Pay subject: subject {session_subject.name} id {session_subject.id} session day {session_day.id} date {session_day.date}")
else:
logger.info(f"Pay subject: subject {session_subject.id} session_day none")
logger.info(data)
p = Parameters.objects.first()
session_day_subject_actvity = Session_day_subject_actvity.objects.filter(session_subject = session_subject,session_day=session_day).first()
status = "success"
message = ""
#check that session is not complete
if not session_day:
status = "fail"
message = "Pay Error: Session day not found"
logger.warning(message)
#check that session is not started
if status == "success":
if not session_day.session.started:
status = "fail"
message = "Pay Error: Session not started"
logger.warning(message)
#check for consent form
if status == "success":
if session_subject.consent_required:
status = "fail"
message = "Pay Error: Consent required"
logger.warning(message)
#check that questionnaire one is done before payment
if status == "success":
if session_subject.questionnaire1_required:
status = "fail"
message = "Pay Error: Questionnaire 1 required"
logger.warning(message)
#check that session day activity exists
if status == "success":
if not session_day_subject_actvity:
status = "fail"
message = "Pay Error: Could not find session_day_subject_actvity"
logger.warning(message)
#check that it is the day of the specified session day
if status == "success":
if session_day_subject_actvity.session_day.date != todaysDate().date():
status = "fail"
message = "Pay Error: Session_day.date does not match today's date"
logger.warning(message)
#check that session is not complete
if status == "success":
if session_day.session.complete():
status = "fail"
message = "Pay Error: Session is already complete"
logger.warning(message)
#check that session is not canceled
if status == "success":
if session_day.session.canceled:
status = "fail"
message = "Pay Error: Session is canceled"
logger.warning(message)
#check that subject has not already been paid
if status == "success":
if session_day_subject_actvity.paypal_today:
status="fail"
message = "Pay Error: Double payment attempt"
logger.warning(message)
#check that questionnaire two is done before last payment
if status == "success":
if session_subject.getQuestionnaire2Required() :
status = "fail"
message = "Pay Error: Questionnaire 2 required"
logger.warning(message)
#check that subject has not be removed from session
if status == "success":
if session_subject.soft_delete:
status = "fail"
message = "Pay Error: Subject was removed from session"
logger.warning(message)
#check that subject has had the required wrist time
if status == "success":
# logger.info(f'{session_day.period_number }')
if session_day.period_number > 1:
pd = session_day_subject_actvity.getPreviousActivityDay()
# logger.info(f'{pd.fitbit_on_wrist_minutes} {session_day.period_number} {session_day.session.parameterset.minimum_wrist_minutes}')
if pd.fitbit_on_wrist_minutes < session_day.session.parameterset.minimum_wrist_minutes:
status = "fail"
message = "Pay Error: Wrist time too low."
logger.warning(message)
#check that fitbit has been synced today
if status == "success":
if not session_subject.fitbitSyncedToday():
status = "fail"
message = "Pay Error: No Fitbit sync today"
logger.warning(message)
if status == "success":
try:
session_day_subject_actvity.paypal_today=True
#store daily earnings of individual treatment
if session_day.session.treatment == "I":
session_day_subject_actvity.storeTodaysTotalEarnings()
session_day_subject_actvity.save()
except Exception as e:
logger.info(e)
status = "fail"
if status == "success":
logger.info("Do PayPal")
#add paypal code here
pass
treatment_a_b_c = {}
if status == "success":
treatment_a_b_c = get_treatment_a_b_c_json(session_day, session_subject,
session_day.period_number, session_day.session.parameterset)
return JsonResponse({"status":status,
"message":message,
"treatment_A_B_C" : treatment_a_b_c,
"session_complete":session_subject.sessionComplete(),
"session_day_subject_actvity" :session_day_subject_actvity.json() if session_day_subject_actvity else {}},safe=False)
def do_paypal():
'''
check for Induvidual treatments that need to be paid and send paypal payment.
'''
target_time = todaysDate().replace(hour=0, minute=5).time()
if todays_time() <= target_time:
return {"Do Paypal Cron": "Payment time not reached"}
parm = Parameters.objects.first()
logger = logging.getLogger(__name__)
yesterdays_date = todaysDate() - timedelta(days=1)
yesterdays_sessions = Session_day.objects.filter(date=yesterdays_date.date()) \
.filter(payments_sent = False) \
.filter(session__started = True) \
.filter(session__soft_delete = False) \
.filter(session__auto_pay = True) \
.prefetch_related("Session_day_subject_actvities_SD")
logger.info(f'do_paypal: {yesterdays_sessions}')
# build ppms request
result_list = []
for session_d in yesterdays_sessions:
#check if auto pay enabled
if session_d.session.auto_pay:
payments_list = []
for subject_activity in session_d.Session_day_subject_actvities_SD.all() \
.filter(session_subject__soft_delete = False) \
.select_related("session_subject") :
if subject_activity.payment_today > 0:
payments_list.append({
"email":
subject_activity.session_subject.contact_email,
"amount":
subject_activity.payment_today,
"note":
f'{subject_activity.session_subject.name}, {parm.paypal_email_body}',
"memo":
f'SD_ID: {session_d.id}, U_ID: {subject_activity.session_subject.id}'
})
if len(payments_list) > 0:
result = do_ppms(payments_list, session_d.id,
parm.paypal_email_subject)
session_d.payments_result_message = result["error_message"]
session_d.save()
result_list.append(result)
yesterdays_sessions.update(payments_sent=True)
return {"Do Paypal Cron": result_list}
def Staff_Session(request,id):
logger = logging.getLogger(__name__)
# logger.info("some info")
if request.method == 'POST':
f=""
try:
f = request.FILES['file']
except Exception as e:
logger.info(f'Staff_Session no file upload: {e}')
f = -1
#check for file upload
if f != -1:
return takeFileUpload(f,id)
else:
data = json.loads(request.body.decode('utf-8'))
if data["action"] == "getSession":
return getSession(data, id)
elif data["action"] == "deleteSubject":
return deleteSubject(data, id)
elif data["action"] == "addSubject":
return addSubject(data, id)
elif data["action"] == "updateParameters":
return updateParameters(data, id)
elif data["action"] == "updateSession":
return updateSession(data, id)
elif data["action"] == "updateSubject":
return updateSubject(data, id)
elif data["action"] == "showFitbitStatus":
return showFitbitStatus(data, id)
elif data["action"] == "importParameters":
return importParameters(data, id)
elif data["action"] == "backFillSessionDays":
return backFillSessionDays(data, id)
elif data["action"] == "startSession":
return startSession(data, id)
elif data["action"] == "sendInvitations":
return sendInvitations(data, id)
elif data["action"] == "downloadData":
return downloadData(data, id)
elif data["action"] == "sendCancelations":
return sendCancelations(data, id, True)
elif data["action"] == "refreshSubjectTable":
return refreshSubjectTable(data, id)
elif data["action"] == "downloadEarnings":
return downloadEarnings(data, id)
elif data["action"] == "downloadParameterset":
return downloadParameterset(data, id)
elif data["action"] == "getSubjectsAvailableToCopy":
return getSubjectsAvailableToCopy(id)
elif data["action"] == "sendCopySubject":
return takeCopySubject(data, id)
elif data["action"] == "addPayLevel":
return add_pay_level(data, id)
elif data["action"] == "removePayLevel":
return remove_pay_level(data, id)
elif data["action"] == "updatePaylevel":
return update_pay_level(data, id)
return JsonResponse({"response" : "fail"},safe=False)
else:
parameterset_form = Parameterset_form()
session_form = SessionForm()
subject_form = Subject_form()
import_parameters_form = Import_parameters_form()
parameterset_paylevel_form = ParametersetPaylevelForm()
p = Parameters.objects.first()
yesterdays_date = todaysDate() - timedelta(days=1)
#get list of form ids
subject_form_ids=[]
for i in subject_form:
subject_form_ids.append(i.html_name)
paylevel_form_ids=[]
for i in parameterset_paylevel_form:
paylevel_form_ids.append(i.html_name)
return render(request,'staff/session.html',{'id' : id,
'parameterset_form' : parameterset_form,
'session_form' : session_form,
'subject_form' : subject_form,
'help_text' : p.manualHelpText,
'import_parameters_form' : import_parameters_form,
'parameterset_paylevel_form' : parameterset_paylevel_form,
'subject_form_ids' : subject_form_ids,
'paylevel_form_ids' : paylevel_form_ids,
'yesterdays_date' : yesterdays_date.date().strftime("%Y-%m-%d")})
def test_c_payments_8_missed_day(self):
'''
test treatment c payments
'''
logger = logging.getLogger(__name__)
session = self.session
start_date = todaysDate() - timedelta(days=7)
data = {
'action':
'updateSession',
'formData': [{
'name': 'title',
'value': '*** New Session ***'
}, {
'name': 'start_date',
'value': start_date.date().strftime("%m/%d/%Y")
}, {
'name': 'treatment',
'value': 'C'
}, {
'name': 'consent_required',
'value': '1'
}, {
'name': 'questionnaire1_required',
'value': '1'
}, {
'name': 'questionnaire2_required',
'value': '1'
}, {
'name': 'instruction_set',
'value': '1'
}, {
'name': 'auto_pay',
'value': '1'
}]
}
r = json.loads(updateSession(data, session.id).content.decode("UTF-8"))
self.assertEqual(r['status'], "success")
r = json.loads(startSession({}, session.id).content.decode("UTF-8"))
self.assertEqual(r['status'], "success")
session = Session.objects.get(id=session.id)
session.parameterset.block_2_fixed_pay_per_day = 0
session.parameterset.save()
start_sleep = 0.2
start_heart = 0.1
for session_subject in self.session.session_subjects.all():
for activity in session_subject.Session_day_subject_actvities.all(
).order_by('session_day__period_number'):
activity.heart_activity = start_heart
activity.immune_activity = start_sleep
activity.paypal_today = True
activity.save()
start_heart += 0.01
start_sleep += 0.01
start_sleep = 0.2
start_heart = 0.1
for session_subject in self.session.session_subjects.all():
activity = session_subject.Session_day_subject_actvities.get(
session_day__period_number=5)
activity.paypal_today = False
activity.save()
for session_subject in self.session.session_subjects.all():
for activity in session_subject.Session_day_subject_actvities.all(
).order_by('session_day__period_number'):
logger.info(
f"period {activity.session_day.period_number}, subject {activity.session_subject.id}, heart score {activity.heart_activity}, sleep score {activity.immune_activity}, pay pal today {activity.paypal_today}"
)
results = do_calc_a_b_c_treatments()
#logger.info(results)
for result in results["A B C Lumpsum Calculations"]:
for payment in result['payments']:
self.assertEqual(
payment['payment'],
round_half_away_from_zero(2 * (1.5 * .16 + 2 * .26), 2))
#check for none payment everywhere else
#check for correct payment on last block
for session_subject in self.session.session_subjects.all():
activity = session_subject.Session_day_subject_actvities.get(
session_day__period_number=7)
self.assertEqual(
float(activity.payment_today),
round_half_away_from_zero(2 * (1.5 * .16 + 2 * .26), 2))
#check for zeros
for session_subject in self.session.session_subjects.all():
for activity in session_subject.Session_day_subject_actvities.exclude(
session_day__period_number=7):
self.assertEqual(activity.payment_today, 0)
def jsonTodayServerStats(self):
sada = self.Session_day_subject_actvities.filter(
session_day__date=todaysDate().date()).first()
check_in = False
pay_pal = False
earnings = "---"
heart_score = "---"
heart_time = "---"
heart_bpm = "---"
immune_score = "---"
immune_time = "---"
wrist_time = "---|---"
missed_days = "---"
if sada:
#sada_yesterday = self.Session_day_subject_actvities.filter(session_day__period_number = sada.session_day.period_number - 1).first()
sada_yesterday = sada.getPreviousActivityDay()
check_in = sada.check_in_today
pay_pal = sada.paypal_today
if self.session.treatment == "I" or self.session.treatment == "Base":
earnings = f'${sada.getTodaysTotalEarnings():0.2f}'
else:
earnings = f'${self.get_earnings_in_block_so_far(sada.session_day.period_number):0.2f}'
missed_days = self.get_missed_checkins(
sada.session_day.period_number)
if check_in:
heart_score = f'{sada.heart_activity:0.2f}'
heart_bpm = f'{sada.fitbit_min_heart_rate_zone_bpm}bpm'
immune_score = f'{sada.immune_activity:0.2f}'
else:
sada_yesterday = None
if sada_yesterday:
wrist_time = f'{sada_yesterday.getFormatedWristMinutes()} | {sada.getFormatedWristMinutes()}'
if sada_yesterday.heart_activity_minutes >= 0:
heart_time = f'{int(sada_yesterday.heart_activity_minutes)}mins'
if sada_yesterday.immune_activity_minutes >= 0:
immune_time = f'{math.floor(sada_yesterday.immune_activity_minutes/60)}hrs {sada_yesterday.immune_activity_minutes%60}mins'
elif sada:
wrist_time = f'---| {sada.getFormatedWristMinutes()}'
return {
"check_in": check_in,
"pay_pal": pay_pal,
"earnings": earnings,
"heart_score": heart_score,
"heart_time": heart_time,
"heart_bpm": heart_bpm,
"immune_score": immune_score,
"immune_time": immune_time,
"wrist_time": wrist_time,
"missed_days": missed_days,
}
def complete(self):
if todaysDate().date() > self.end_date:
return True
else:
return False
def setUp(self):
logger = logging.getLogger(__name__)
createSession({})
#set sessoin start to tomorrow
self.session = Session.objects.first()
start_date = todaysDate() - timedelta(days=1)
data = {
'action':
'updateSession',
'formData': [{
'name': 'title',
'value': '*** New Session ***'
}, {
'name': 'start_date',
'value': start_date.date().strftime("%m/%d/%Y")
}, {
'name': 'treatment',
'value': 'I'
}, {
'name': 'consent_required',
'value': '1'
}, {
'name': 'questionnaire1_required',
'value': '1'
}, {
'name': 'questionnaire2_required',
'value': '1'
}, {
'name': 'instruction_set',
'value': '2'
}, {
'name': 'auto_pay',
'value': '1'
}]
}
result = json.loads(
updateSession(data, self.session.id).content.decode("UTF-8"))
self.assertEqual(result['status'], "success")
addSubject({}, self.session.id)
addSubject({}, self.session.id)
self.session = Session.objects.get(id=self.session.id)
self.session.parameterset.block_1_fixed_pay_per_day = 3
self.session.parameterset.block_2_fixed_pay_per_day = 4
self.session.parameterset.block_3_fixed_pay_per_day = 5
self.session.parameterset.save()
r = json.loads(
startSession({}, self.session.id).content.decode("UTF-8"))
self.assertEqual(r['status'], "success")
self.session = Session.objects.first()
logger.info(
f"Session start date {self.session.start_date} end date {self.session.end_date}"
)
#store synced today
for subject in self.session.session_subjects.all():
subject.fitBitLastSynced = todaysDate()
subject.save()