def reset_password(request, forgot_hash): # REFACTOR
try:
user = User.objects.get(
patient_profile__forgot_key=forgot_hash,
patient_profile__forgot_key_updated__gt=(utcnow() -
timedelta(days=1)))
except User.DoesNotExist:
try:
user = User.objects.get(
professional_profile__forgot_key=forgot_hash,
professional_profile__forgot_key_updated__gt=(
utcnow() - timedelta(days=1)))
except User.DoesNotExist:
return HttpResponseNotFound()
if request.method == "POST":
form = ResetPasswordForm(request.POST, user=user)
if form.is_valid():
user.set_password(form.cleaned_data["password"])
user.forgot_key = None
user.forgot_key_updated = None
user.save()
return HttpResponseRedirect('/accounts/reset/thanks/')
else:
form = ResetPasswordForm(user=user)
return render(request, "accounts/reset.html", {"form": form})
def schedule(self) -> None:
if self.check_schedule_ok():
return
glucose_reading_times = []
if (self.glucose_reading_interval ==
DemoPatientProfile.GLUCOSE_READING_INTERVAL_WEEKLY):
glucose_reading_times.append(utcnow() + timedelta(
seconds=random.randint(0, 60 * 60 * 24 * 7)))
elif (self.glucose_reading_interval ==
DemoPatientProfile.GLUCOSE_READING_INTERVAL_ONCE_DAILY):
for i in range(7):
glucose_reading_times.append(
utcnow() + timedelta(days=i) +
timedelta(seconds=random.randint(0, 60 * 60 * 24)))
elif self.glucose_reading_interval in (
DemoPatientProfile.GLUCOSE_READING_INTERVAL_THREE_TIMES_DAILY,
DemoPatientProfile.GLUCOSE_READING_INTERVAL_FIVE_TIMES_DAILY):
if (self.glucose_reading_interval == DemoPatientProfile.
GLUCOSE_READING_INTERVAL_THREE_TIMES_DAILY):
day_segments = 3
else:
day_segments = 5
day_portion = 60 * 60 * 24 / day_segments
for i in range(7):
for j in range(day_segments):
glucose_reading_times.append(
utcnow() + timedelta(days=i) +
timedelta(seconds=((j * day_portion) +
random.randint(0, day_portion))))
for grt in glucose_reading_times:
DemoScheduledReading.generate_scheduled_reading(
self.user, grt, random.choice([True, False]))
self.last_scheduled = utcnow()
self.save()
def __init__(self, *args, **kwargs):
self.patient = kwargs.pop('patient', None)
self.requester = kwargs.pop('requester', None)
super(DisplayLogbookForm, self).__init__(*args, **kwargs)
if self.patient:
self.fields['patient'].queryset = PatientProfile.myghr_patients.get_users().filter(pk=self.patient.id)
self.fields['patient'].initial = self.patient
self.fields['start_date'].initial = \
utcnow().astimezone(
self.patient.patient_profile.timezone) - timedelta(days=14)
self.fields['end_date'].initial = \
utcnow().astimezone(self.patient.patient_profile.timezone)
def render(self, name, value, attrs=None, renderer=None):
year_range = range(
(utcnow() - timedelta(days=100 * 365)).year, utcnow().year)
years = [(i, i) for i in year_range]
years = sorted(years, key=lambda x: x[0], reverse=True)
months = []
for i in range(1, 13):
months.append(
(i, datetime(day=1, month=i, year=2000).strftime('%B')))
days = [(i, i) for i in range(1, 32)]
return render_to_string(
'utils/birthday_widget.html',
{'widget': self, 'name': name, 'value': value,
'attrs': attrs, 'years': years, 'months': months, 'days': days,
'required': self.attrs.get('required', False)})
def save(self, *args, **kwargs):
user = User.objects.get(username=self.cleaned_data['username'])
profile = user.get_profile()
while True:
hash_ = sha_constructor(str(random.random())).hexdigest()[8:16]
try:
if user.is_patient():
PatientProfile.objects.get(forgot_key=hash_)
else:
ProfessionalProfile.objects.get(forgot_key=hash_)
except profile.DoesNotExist:
profile.forgot_key = hash_
profile.forgot_key_updated = utcnow()
profile.save()
break
ctx_dict = {
'reset_link': 'http://%s/dashboard/public/#/accounts/reset/%s/' % (
settings.SITE_URL, profile.forgot_key)}
subject = render_to_string(
'accounts/lost_password/email_subject.txt', ctx_dict)
message = render_to_string(
'accounts/lost_password/email_message.txt', ctx_dict)
user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL)
return user
def trigger_if_ready(self):
"""Note that this will only work on the "scheduled"/"regular" triggers.
E.g. it will not work on reading received alerts."""
if self.type in (
ProfessionalAlert.READING_RECEIVED,
ProfessionalAlert.GLUCOSE_DANGER_RANGE):
raise Exception(
'trigger_if_ready should not be called on reading received '
'or danger range alerts.')
# Only proceed if triggered is empty orwas more than a weak ago.
if (self.last_triggered is not None and
self.last_triggered + timedelta(days=7) > utcnow()):
return
patient_name = self.patient.first_name
healthinformation = self.patient.healthinformation
if self.type == ProfessionalAlert.OUT_OF_TARGET_COMPLIANCE:
compliance_goal = self.patient.healthinformation.compliance_goal
if (self.patient.patient_profile.get_average_daily_readings() <
compliance_goal):
self.trigger(
compliance_target=healthinformation.compliance_goal,
patient=patient_name)
elif self.type == ProfessionalAlert.OUT_OF_MINIMUM_COMPLIANCE:
if (self.patient.patient_profile.get_average_daily_readings() <
healthinformation.minimum_compliance):
self.trigger(
compliance_target=healthinformation.minimum_compliance,
patient=patient_name)
elif self.type == ProfessionalAlert.GLUCOSE_OUT_OF_RANGE:
avg = self.patient.patient_profile.get_average_glucose_level()
if (avg < healthinformation.premeal_glucose_goal_minimum or
avg > healthinformation.postmeal_glucose_goal_maximum):
self.trigger(
value=avg,
patient=patient_name)
def compliance_data(request, user_id):
try:
patient = request.user.professional_profile.get_patients().get(
pk=user_id)
except User.DoesNotExist as e:
return debug_response(e)
today = utcnow().astimezone(request.user.professional_profile.timezone)
readings = []
labels = []
for i in range(7, 0, -1):
timezone = request.user.professional_profile.timezone
cur_datetime = convert_date_to_utc_datetime(today - timedelta(days=i),
timezone)
end_datetime = cur_datetime + timedelta(days=1)
readings.append(
patient.glucose_readings.filter(
reading_datetime_utc__range=(cur_datetime,
end_datetime)).count())
labels.append(cur_datetime.strftime('%a'))
data = {
'labels': labels,
'readings': readings,
'patient_name': patient.get_full_name(),
'professional_name': request.user.get_full_name()
}
data['date_range'] = '%s - %s' % (
(today - timedelta(days=7)).strftime('%m/%d/%y'),
(today - timedelta(days=1)).strftime('%m/%d/%y'))
return HttpResponse(json.dumps(data), content_type="application/json")
def process_request(self, request):
try:
profile = request.user.get_profile()
except (Exception, AttributeError):
pass
else:
profile.last_touched = utcnow()
profile.save()
def process(self, force: bool = False) -> None:
if (self.fired or (self.reading_datetime > utcnow() and not force)
or not self.patient.patient_profile.get_device()):
return
self.patient.patient_profile.send_http_reading()
self.response = ''
self.fired = True
self.save()
def get_logged_in_users(cls) -> 'QuerySet[User]':
login_records = LoginRecord.objects.filter(
datetime__gt=(
utcnow() - timedelta(seconds=settings.LOGGED_IN_TIME)))
# Get profiles first so we're not included users
# without this kind of profile.
profiles = cls.objects.filter(
user__pk__in=login_records.values_list('user'))
users = User.objects.filter(pk__in=profiles.values_list('user'))
return users
def save(self, *args, **kwargs):
# Override save method to have it send register updates.
if not self.assigned_at and self.patient:
self.assigned_at = utcnow()
if not self.last_assigned_patient and self.patient:
self.last_assigned_patient = self.patient
if self.group is None and self.patient and\
self.patient.patient_profile.get_group():
self.group = self.patient.patient_profile.get_group()
super(GDrive, self).save(*args, **kwargs)
def patient_home(request):
c = {}
last_three_readings = request.user.glucose_readings.order_by(
'-reading_datetime_utc')
if last_three_readings.count() > 3:
last_three_readings = last_three_readings[:3]
c['last_three_readings'] = last_three_readings
last_fourteen_day_readings = request.user.glucose_readings.filter(
reading_datetime_utc__gte=utcnow() - timedelta(days=14))
c['aggregates'] = aggregate_readings(
request.user, last_fourteen_day_readings, days=14)
last_reading = request.user.patient_profile.get_last_reading()
if not last_reading:
c['reading_status'] = 'no_readings'
elif (last_reading.reading_datetime_utc + timedelta(days=14)) < utcnow():
c['reading_status'] = 'outdated'
else:
c['reading_status'] = 'ok'
c['number_of_logins_last_six_months'] = request.user.patient_profile\
.logins_since(utcnow() - relativedelta(months=6)).count()
return render(request, 'dashboard/patient_home.html', c)
def generate_raw_reading(cls, patient, **kwargs):
"""Generates an encrypted, raw reading that can be sent to the reading
server."""
device = patient.patient_profile.get_device()
if not device:
raise Exception(
'generate_raw_reading will not work for a patient without a'
' device.')
# Create random / default data if user has not specified.
glucose_value = kwargs.get('glucose_value', random.randint(40, 160))
measure_type = kwargs.get('measure_type', random.randint(0, 2))
reading_datetime = kwargs.get('reading_datetime', utcnow()).astimezone(
patient.patient_profile.timezone)
if 'offset' in kwargs:
offset = kwargs['offset']
else:
# Figure out offset from timezone.
offset = reading_datetime.strftime('%z')[:-2]
# It will give it to us as +0100 (e.g.). trim off last two digits.
hour = "%s,%s" % (reading_datetime.hour, offset)
c = {
'gateway_type': '4123',
'gateway_id': '0000000000000001',
'device_type': '4123',
'serial_number': device.device_id,
'meid': device.meid,
'extension_id': '1',
'year': reading_datetime.year,
'month': reading_datetime.month,
'day': reading_datetime.day,
'hour': hour,
'minute': reading_datetime.minute,
'second': reading_datetime.second,
'data_type': '1',
'value_1': glucose_value,
'value_2': '0',
'value_3': '0',
'value_4': measure_type,
'value_5': '0',
'value_6': '0'
}
return cls.raw_reading_from_dict(c), c
def check_schedule_ok(self) -> bool:
return (self.last_scheduled is not None
and (utcnow() - self.last_scheduled <
(timedelta(days=7) - timedelta(hours=1))))
def cron_process(self) -> None:
self.schedule()
for sdr in self.user.scheduled_demo_readings.filter(
fired=False, reading_datetime__lt=utcnow()):
if self.user.patient_profile.get_device():
sdr.process()
def trigger_delayed(self, commit=True, **details):
self.send_texts(**details)
self.send_emails(**details)
self.last_triggered = utcnow()
if commit:
self.save()
def send_glucose_reading(self, attempt_or_reading):
from genesishealth.apps.readings.models import GlucoseReading
if isinstance(attempt_or_reading, GlucoseReading):
reading = attempt_or_reading
attempt, _ = APIReadingForwardAttempt.objects.get_or_create(
reading=reading, partner=self)
elif isinstance(attempt_or_reading, APIReadingForwardAttempt):
attempt = attempt_or_reading
else:
raise ValueError("Unknown type for attempt_or_reading")
if (attempt.committed
or attempt.attempts >= self.maximum_send_attempts):
return
if self not in attempt.reading.patient.patient_profile.partners.all():
raise Exception('Attempting to send reading to wrong partner.')
log = APILogRecord(is_inbound=False,
datetime=utcnow(),
url=self.get_url('push_data'),
action_type='push_data',
for_partner=self,
reading=attempt.reading)
reading_data = self.generate_reading_data(attempt.reading)
encoded_data = json.dumps(reading_data)
log.data = encoded_data
# Send the reading
from genesishealth.apps.gdrives.models import \
GDriveTransmissionLogEntry
try:
attempt.reading.log_entry
except GDriveTransmissionLogEntry.DoesNotExist:
pass
else:
attempt.reading.log_entry.sent_to_api = True
attempt.reading.log_entry.save()
attempt.attempts += 1
push_location = self.get_url('push_data')
request = Request(push_location)
if self.api_version == "2.1":
request.add_header("x-api-key", self.outgoing_api_key)
base64string = base64.standard_b64encode(
"%s:%s" % (self.outgoing_username, self.outgoing_password))
request.add_header("Authorization", "Basic %s" % base64string)
request.add_header("Content-type", "application/json")
context = ssl._create_unverified_context()
try:
response = urlopen(request, encoded_data, 10, context=context)
except HTTPError as e:
log.status = 'connection_error'
log.response = str(e.read())
except URLError as e:
log.status = 'connection_error'
log.response = e.reason
except Exception as e:
log.status = 'connection_error'
log.response = str(e)
else:
response_contents = response.read()
log.response = response_contents
# Interpret response
try:
decoded_response = json.loads(response_contents)
except ValueError:
log.status = 'json_error'
else:
if decoded_response.get('success'):
log.status = 'complete'
attempt.committed = True
try:
attempt.reading.log_entry
except GDriveTransmissionLogEntry.DoesNotExist:
pass
else:
attempt.reading.log_entry.received_by_api = True
attempt.reading.log_entry.save()
else:
log.status = 'returned_error'
attempt.save()
log.save()
def touch(self, commit: bool = True) -> None:
self.last_touched = utcnow()
if commit:
self.save()
def is_logged_in(self) -> bool:
idle_timedelta = utcnow() - self.last_touched
idle_time = idle_timedelta.total_seconds()
return idle_time < settings.LOGGED_IN_TIME