def print_medication_stock_labels(modeladmin, request, queryset):
zpl_data = []
label = Label(
label_template_name="medication_stock_label.lbl",
static_files_path="edc_pharmacy/label_templates",
)
for obj in queryset:
for i in range(1, obj.qty):
stock_identifier = uuid4().hex
context = dict(
protocol=Protocol().protocol,
protocol_title=Protocol().protocol_title,
stock_identifier=stock_identifier,
barcode_value=stock_identifier,
medication_name=obj.medication_product.formulation.medication.display_name,
medication_strength=obj.medication_product.formulation.strength,
medication_units=obj.medication_product.formulation.units,
)
# keys = [k for k in context]
# for fld in obj._meta.get_fields():
# if fld.name not in keys and fld.name != "assignment":
# context.update({fld.name: getattr(obj, fld.name)})
zpl_data.append(
str(label.render_as_zpl_data(copies=1, context=context, encoding=False))
.strip("\n")
.replace("\n", "")
)
request.session["zpl_data"] = "|".join(zpl_data)
url = reverse("edc_label:browser_print_labels_url")
return HttpResponseRedirect(url)
def setUp(self):
site_consents.registry = {}
self.study_open_datetime = Protocol().study_open_datetime
self.study_close_datetime = Protocol().study_close_datetime
site_visit_schedules._registry = {}
site_visit_schedules.register(visit_schedule)
self.subject_identifier = "12345"
super().setUp()
def setUp(self):
v1_consent = Consent(
"visit_schedule_app.subjectconsent",
version="1",
start=Protocol().study_open_datetime,
end=Protocol().study_close_datetime,
age_min=18,
age_is_adult=18,
age_max=64,
gender=[MALE, FEMALE],
)
import_holidays()
site_consents.registry = {}
site_consents.register(v1_consent)
self.visit_schedule = VisitSchedule(
name="visit_schedule",
verbose_name="Visit Schedule",
offstudy_model="visit_schedule_app.subjectoffstudy",
death_report_model="visit_schedule_app.deathreport",
)
self.schedule = Schedule(
name="schedule",
onschedule_model="visit_schedule_app.onschedule",
offschedule_model="visit_schedule_app.offschedule",
appointment_model="edc_appointment.appointment",
consent_model="visit_schedule_app.subjectconsent",
)
visit = Visit(
code="1000",
rbase=relativedelta(days=0),
rlower=relativedelta(days=0),
rupper=relativedelta(days=6),
timepoint=1,
)
self.schedule.add_visit(visit)
self.visit_schedule.add_schedule(self.schedule)
site_visit_schedules._registry = {}
site_visit_schedules.register(self.visit_schedule)
site_reference_configs.registry = {}
site_reference_configs.register_from_visit_schedule(visit_models={
"edc_appointment.appointment":
"visit_schedule_app.subjectvisit"
})
self.subject_consent = SubjectConsent.objects.create(
subject_identifier="12345",
consent_datetime=get_utcnow() - relativedelta(seconds=1),
dob=date(1995, 1, 1),
identity="11111",
confirm_identity="11111",
)
self.subject_identifier = self.subject_consent.subject_identifier
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
self.subject_identifier = self.kwargs.get("subject_identifier")
if self.subject_identifier:
if not re.match(Protocol().subject_identifier_pattern,
self.subject_identifier):
raise RegisteredSubjectError(
f"Invalid subject identifier format. "
f"Valid pattern is `{Protocol().subject_identifier_pattern}`. "
f"See `edc_protocol.Protocol().subject_identifier_pattern`. "
f"Got `{self.subject_identifier}`.")
try:
obj = RegisteredSubject.objects.get(
subject_identifier=self.subject_identifier)
except ObjectDoesNotExist:
raise RegisteredSubjectError(
f"Unknown subject identifier. "
f"Got `{self.subject_identifier}`.")
context.update(
subject_identifier=obj.subject_identifier,
gender=obj.gender,
dob=obj.dob,
initials=obj.initials,
identity=obj.identity,
firstname=obj.first_name,
lastname=obj.last_name,
registered_subject=obj,
registered_subject_pk=str(obj.pk),
)
return context
def label_context(self):
tz = pytz.timezone(settings.TIME_ZONE)
local = Arrow.fromdatetime(self.requisition.drawn_datetime
or self.requisition.created).to(tz)
formatted_date = local.format("YYYY-MM-DD HH:mm")
printed = "PRINTED: " if not self.requisition.drawn_datetime else "DRAWN: "
drawn_datetime = f"{printed}{formatted_date}"
try:
clinician_initials = self.requisition.user_created[0:2].upper()
except IndexError:
clinician_initials = "??"
return {
"requisition_identifier": self.requisition.requisition_identifier,
"item": self.item,
"item_count": self.requisition.item_count or 1,
"primary": "<P>",
"barcode_value": self.requisition.requisition_identifier,
"protocol": Protocol().protocol,
"site": str(self.requisition.site.id),
"site_name": str(self.requisition.site.name),
"site_title": str(self.requisition.site.siteprofile.title),
"clinician_initials": clinician_initials,
"drawn_datetime": drawn_datetime,
"subject_identifier": self.registered_subject.subject_identifier,
"gender": self.registered_subject.gender,
"dob": self.registered_subject.dob,
"initials": self.registered_subject.initials,
"identity": self.registered_subject.identity,
"alpha_code": self.requisition.panel_object.alpha_code,
"panel": self.requisition.panel_object.abbreviation,
"panel_name": self.requisition.panel.display_name,
}
def __init__(
self,
identifier_type: Optional[str] = None,
template: Optional[str] = None,
device_id: Optional[str] = None,
protocol_number: Optional[str] = None,
site: Site = None,
requesting_model: Optional[str] = None,
identifier: Optional[str] = None,
) -> None:
self._identifier = None
self.requesting_model = requesting_model
if not self.requesting_model:
raise IdentifierError("Invalid requesting_model. Got None")
self.identifier_type = identifier_type or self.identifier_type
if not self.identifier_type:
raise IdentifierError("Invalid identifier_type. Got None")
self.template = template or self.template
app_config = django_apps.get_app_config("edc_device")
self.device_id = device_id or app_config.device_id
self.protocol_number = protocol_number or Protocol().protocol_number
self.site = site or Site.objects.get_current()
if identifier:
# load an existing identifier
self.identifier_model = self.identifier_model_cls.objects.get(
identifier=identifier
)
self._identifier = self.identifier_model.identifier
self.subject_type = self.identifier_model.subject_type
self.site = self.identifier_model.site
self.get_identifier()
def get_template_options(self, instance=None, test_message=None, **kwargs):
"""Returns a dictionary of message template options.
Extend using `extra_template_options`.
"""
test_message = test_message or self.test_message
template_options = dict(
name=self.name,
protocol_name=Protocol().protocol_name,
display_name=self.get_display_name(instance=instance,
test_message=test_message,
**kwargs),
email_from=self.email_from,
test_subject_line=(self.email_test_subject_line
if test_message else "").strip(),
test_body_line=self.email_test_body_line if test_message else "",
test_line=self.sms_test_line if test_message else "",
message_datetime=get_utcnow(),
message_reference="",
)
if "subject_identifier" not in template_options:
try:
template_options.update(
subject_identifier=instance.subject_identifier)
except AttributeError:
pass
if "site_name" not in template_options:
try:
template_options.update(
site_name=instance.site.name.replace("_", " ").title())
except AttributeError:
pass
return template_options
def get_protocol_number(self):
"""Returns the protocol number from the field or
AppConfig.
"""
protocol_number = self.protocol_number
if not self.protocol_number:
protocol_number = Protocol().protocol_number
return protocol_number
def setUp(self):
self.subject_identifier = "12345"
site_visit_schedules._registry = {}
site_visit_schedules.register(visit_schedule=visit_schedule3)
self.helper = self.helper_cls(
subject_identifier=self.subject_identifier,
now=Protocol().study_open_datetime,
)
def setUp(self):
import_holidays()
v1_consent = Consent(
"visit_schedule_app.subjectconsent",
version="1",
start=Protocol().study_open_datetime,
end=Protocol().study_close_datetime,
age_min=18,
age_is_adult=18,
age_max=64,
gender=[MALE, FEMALE],
)
site_consents.registry = {}
site_consents.register(v1_consent)
self.visit_schedule = VisitSchedule(
name="visit_schedule",
verbose_name="Visit Schedule",
offstudy_model="visit_schedule_app.subjectoffstudy",
death_report_model="visit_schedule_app.deathreport",
)
self.schedule = Schedule(
name="schedule",
onschedule_model="visit_schedule_app.onschedule",
offschedule_model="visit_schedule_app.offschedule",
appointment_model="edc_appointment.appointment",
consent_model="visit_schedule_app.subjectconsent",
)
self.schedule2 = Schedule(
name="schedule_two",
onschedule_model="visit_schedule_app.onscheduletwo",
offschedule_model="visit_schedule_app.offscheduletwo",
appointment_model="edc_appointment.appointment",
consent_model="visit_schedule_app.subjectconsent",
)
self.schedule3 = Schedule(
name="schedule_three",
onschedule_model="visit_schedule_app.onschedulethree",
offschedule_model="visit_schedule_app.offschedulethree",
appointment_model="edc_appointment.appointment",
consent_model="visit_schedule_app.subjectconsent",
)
def get_institution_extra_context(extra_context):
protocol = Protocol()
extra_context.update({
"institution": protocol.institution,
"copyright": protocol.copyright,
"license": protocol.license or "",
"disclaimer": protocol.disclaimer,
})
return extra_context
def setUp(self):
super().setUp()
v1_consent = Consent(
"visit_schedule_app.subjectconsent",
version="1",
start=Protocol().study_open_datetime,
end=Protocol().study_close_datetime,
age_min=18,
age_is_adult=18,
age_max=64,
gender=[MALE, FEMALE],
)
import_holidays()
site_reference_configs.register_from_visit_schedule(visit_models={
"edc_appointment.appointment":
"visit_schedule_app.subjectvisit"
})
site_consents.registry = {}
site_consents.register(v1_consent)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
protocol = Protocol()
context.update({
"protocol": protocol.protocol,
"protocol_number": protocol.protocol_number,
"protocol_name": protocol.protocol_name,
"protocol_title": protocol.protocol_title,
})
return context
def label_context(self) -> dict:
context = {
"protocol": Protocol().protocol,
"subject_identifier": self.registered_subject.subject_identifier,
"gender": self.registered_subject.gender,
"dob": self.registered_subject.dob,
"initials": self.registered_subject.initials,
"identity": self.registered_subject.identity,
}
context.update(self.site_context)
return context
def setUp(self):
super().setUp()
site_consents.registry = {}
self.study_open_datetime = Protocol().study_open_datetime
self.study_close_datetime = Protocol().study_close_datetime
consent_object_factory(start=self.study_open_datetime,
end=self.study_close_datetime)
self.request = HttpRequest()
user = User.objects.create(username="******")
self.request.user = user
for _ in range(3):
first_name = fake.first_name()
last_name = fake.last_name()
initials = first_name[0] + choice(
string.ascii_uppercase) + last_name[0]
baker.make_recipe(
"edc_consent.subjectconsent",
consent_datetime=self.study_open_datetime +
relativedelta(days=1),
initials=initials.upper(),
)
def setUp(self):
site_visit_schedules.loaded = False
site_visit_schedules._registry = {}
site_visit_schedules.register(visit_schedule)
site_reference_configs.register_from_visit_schedule(visit_models={
"edc_appointment.appointment":
"visit_schedule_app.subjectvisit"
})
v1_consent = Consent(
"visit_schedule_app.subjectconsent",
version="1",
start=Protocol().study_open_datetime,
end=Protocol().study_close_datetime,
age_min=18,
age_is_adult=18,
age_max=64,
gender=[MALE, FEMALE],
)
self.subject_identifier = "1234"
site_consents.registry = {}
site_consents.register(v1_consent)
def label_context(self):
return {
"barcode_value": self.model_obj.box_identifier,
"box_identifier": self.model_obj.human_readable_identifier,
"box_name": self.model_obj.name,
"protocol": Protocol().protocol,
"site": str(self.model_obj.site.id),
"box_datetime": self.model_obj.box_datetime.strftime("%Y-%m-%d %H:%M"),
"category": self.model_obj.get_category_display().upper(),
"specimen_types": self.model_obj.specimen_types,
"site_name": str(self.model_obj.site.siteprofile.title),
}
def setUp(self):
self.study_open_datetime = Protocol().study_open_datetime
self.study_close_datetime = Protocol().study_close_datetime
site_consents.registry = {}
consent_factory(
start=self.study_open_datetime,
end=self.study_open_datetime + timedelta(days=50),
version="1.0",
)
consent_factory(
start=self.study_open_datetime + timedelta(days=51),
end=self.study_open_datetime + timedelta(days=100),
version="2.0",
)
consent_factory(
start=self.study_open_datetime + timedelta(days=101),
end=self.study_open_datetime + timedelta(days=150),
version="3.0",
updates_versions="1.0, 2.0",
)
self.dob = self.study_open_datetime - relativedelta(years=25)
def __init__(self,
page=None,
header_line=None,
filename=None,
request=None,
**kwargs):
self._styles = None
self.request = request
self.page = page or self.default_page
self.report_filename = filename or f"{uuid4()}.pdf"
if not header_line:
header_line = Protocol().institution
self.header_line = header_line
class UrlRequestContextMixin(ContextMixin):
urlconfig_getattr = "dashboard_urls"
urlconfig_identifier_label = "subject_identifier"
urlconfig_identifier_pattern = Protocol().subject_identifier_pattern
urlconfig_label = None
url_name = None
@classmethod
def get_urlname(cls):
return cls.url_name
@classmethod
def urls(cls,
namespace=None,
label=None,
identifier_label=None,
identifier_pattern=None):
label = (label or cls.urlconfig_label or convert_from_camel(
cls.__name__.replace("view", "")).lower())
urlconfig = UrlConfig(
url_name=cls.get_urlname(),
namespace=namespace,
view_class=cls,
label=label,
identifier_label=identifier_label
or cls.urlconfig_identifier_label,
identifier_pattern=identifier_pattern
or cls.urlconfig_identifier_pattern,
)
return getattr(urlconfig, cls.urlconfig_getattr)
@staticmethod
def add_url_to_context(new_key=None, existing_key=None, context=None):
"""Add a url as new_key to the context using the value
of the existing_key from request.context_data.
"""
try:
context.update({new_key: url_names.get(existing_key)})
except InvalidUrlName as e:
raise UrlRequestContextError(
f"Url name not defined in url_names. "
f"Expected one of {url_names.registry}. Got {e}. "
f"Hint: check if dashboard middleware is loaded.")
return context
def extra_context(self):
protocol = Protocol()
try:
live_system = settings.LIVE_SYSTEM
except AttributeError:
live_system = None
return {
"DEBUG": settings.DEBUG,
"copyright": protocol.copyright,
"disclaimer": protocol.disclaimer,
"institution": protocol.institution,
"license": protocol.license,
"revision": site_revision.tag,
"project_name": protocol.project_name,
"live_system": live_system,
"INDEX_PAGE": getattr(settings, "INDEX_PAGE", None),
"INDEX_PAGE_LABEL": getattr(settings, "INDEX_PAGE_LABEL", None),
}
def on_first_page(self, canvas, doc):
super().on_first_page(canvas, doc)
width, height = A4
if self.draw_logo and self.logo:
canvas.drawImage(self.logo,
35,
height - 50,
*self.logo_data["first_page"],
mask="auto")
else:
canvas.setFontSize(10)
canvas.drawString(48, height - 40, Protocol().protocol_name)
if self.confidential:
canvas.setFontSize(10)
canvas.drawString(48, height - 50, "CONFIDENTIAL")
canvas.drawRightString(width - 35, height - 50, "CONFIDENTIAL")
canvas.setFontSize(10)
canvas.drawRightString(width - 35, height - 40, self.title)
def label_context(self):
registered_subject = django_apps.get_model(
self.registered_subject_model).objects.get(
subject_identifier=self.requisition.subject_identifier)
return {
"aliquot_identifier":
self.model_obj.human_readable_identifier,
"aliquot_count":
1 if self.model_obj.is_primary else self.model_obj.count,
"children_count":
1 if self.model_obj.is_primary else self.children_count,
"primary":
"<P>" if self.model_obj.is_primary else "",
"barcode_value":
self.model_obj.aliquot_identifier,
"protocol":
Protocol().protocol,
"site":
str(self.requisition.site.id),
"site_name":
str(self.requisition.site.name),
"site_title":
str(self.requisition.site.siteprofile.title),
"clinician_initials":
self.requisition.user_created[0:2].upper(),
"drawn_datetime":
self.requisition.drawn_datetime.strftime("%Y-%m-%d %H:%M"),
"subject_identifier":
registered_subject.subject_identifier,
"gender":
registered_subject.gender,
"dob":
registered_subject.dob.strftime("%Y-%m-%d"),
"initials":
registered_subject.initials,
"alpha_code":
self.model_obj.alpha_code,
"panel":
self.requisition.panel_object.abbreviation,
"panel_name":
self.requisition.panel.display_name,
}
def check_consent_period_within_study_period(new_consent=None):
"""Raises if the start or end date of the consent period
it not within the opening and closing dates of the protocol.
"""
protocol = Protocol()
study_open_datetime = protocol.study_open_datetime
study_close_datetime = protocol.study_close_datetime
for index, dt in enumerate([new_consent.start, new_consent.end]):
if not (study_open_datetime <= dt <= study_close_datetime):
dt_label = "start" if index == 0 else "end"
formatted_study_open_datetime = study_open_datetime.strftime(
convert_php_dateformat(settings.SHORT_DATE_FORMAT))
formatted_study_close_datetime = study_close_datetime.strftime(
convert_php_dateformat(settings.SHORT_DATE_FORMAT))
formatted_dt = dt.strftime(
convert_php_dateformat(settings.SHORT_DATE_FORMAT))
raise ConsentPeriodError(
f"Invalid consent. Consent period for {new_consent.name} "
"must be within study opening/closing dates of "
f"{formatted_study_open_datetime} - "
f"{formatted_study_close_datetime}. "
f"Got {dt_label}={formatted_dt}.")
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
try:
edc_device_app_config = django_apps.get_app_config(
self.edc_device_app)
except LookupError as e:
edc_device_app_config = None
warnings.warn(str(e))
live_system = getattr(settings, "LIVE_SYSTEM", "TEST")
sentry_dsn = getattr(settings, "SENTRY_DSN", "sentry_dsn?")
protocol = Protocol()
context.update({
"copyright":
getattr(protocol, "copyright", "copyright?"),
"device_id":
getattr(edc_device_app_config, "device_id", "device_id?"),
"device_role":
getattr(edc_device_app_config, "device_role", "device_role?"),
"disclaimer":
getattr(protocol, "disclaimer", "disclaimer?"),
"institution":
getattr(protocol, "institution", "institution?"),
"license":
getattr(protocol, "license", "license?"),
"project_name":
getattr(protocol, "project_name", "project_name?"),
"project_repo":
getattr(protocol, "project_repo", "project_repo?"),
"live_system":
live_system,
"sentry_dsn":
sentry_dsn,
})
self.check_for_warning_messages(live_system=live_system)
return context
def extra_context(self):
protocol = Protocol()
try:
live_system = settings.LIVE_SYSTEM
except AttributeError:
live_system = None
try:
allow_password_reset = settings.ALLOW_PASSWORD_RESET
except AttributeError:
allow_password_reset = None
return {
"edc_base_template":
get_template_path_with_bootstrap("edc_dashboard/base.html"),
"DEBUG":
settings.DEBUG,
"ALLOW_PASSWORD_RESET":
allow_password_reset,
"copyright":
protocol.copyright,
"disclaimer":
protocol.disclaimer,
"institution":
protocol.institution,
"license":
protocol.license,
"revision":
site_revision.tag,
"project_name":
protocol.project_name,
"live_system":
live_system,
"INDEX_PAGE":
getattr(settings, "INDEX_PAGE", None),
"INDEX_PAGE_LABEL":
getattr(settings, "INDEX_PAGE_LABEL", None),
}
from edc_consent.consent import Consent
from edc_consent.site_consents import site_consents
from edc_constants.constants import FEMALE, MALE
from edc_protocol import Protocol
v1 = Consent(
"data_manager_app.subjectconsent",
version="1",
start=Protocol().study_open_datetime,
end=Protocol().study_close_datetime,
age_min=18,
age_is_adult=18,
age_max=110,
gender=[MALE, FEMALE],
)
site_consents.register(v1)
def test_protocol(self):
self.assertEqual(Protocol().study_open_datetime.date(), opendte.date())
self.assertEqual(Protocol().study_close_datetime.date(),
closedte.date())
def __init__(
self,
username: str = None,
first_name: str = None,
last_name: str = None,
job_title: str = None,
email: str = None,
alternate_email: str = None,
mobile: str = None,
site_names: List[str] = None,
role_names: List[str] = None,
is_active: bool = None,
is_staff: bool = None,
resource_name: str = None,
created_email_template: Optional[Template] = None,
updated_email_template: Optional[Template] = None,
send_email_to_user: Optional[Any] = None,
test_email_address: Optional[Any] = None,
resend_as_new: Optional[Any] = None,
nwords: Optional[int] = None,
**kwargs,
):
self._messages: List[str] = []
self._user = None
self.created = False
self.password = None
try:
self.email, self.alternate_email = email.split(",")
except (ValueError, AttributeError):
self.email = email
self.alternate_email = alternate_email
self.first_name = first_name
self.job_title = job_title or "staff member"
self.last_name = last_name
self.mobile = mobile
self.is_active = is_active or False
self.is_staff = is_staff or False
self.password_generator = PasswordGenerator(nwords=nwords
or self.password_nwords,
**kwargs)
self.resource_name = resource_name or self.resource_name
self.resend_as_newly_created = resend_as_new
self.test_email_address = test_email_address
self.username = username or self.get_username()
self.created_email_template = (created_email_template
or self.created_email_template)
self.updated_email_template = (updated_email_template
or self.updated_email_template)
self.validate_username()
if ACCOUNT_MANAGER_ROLE in role_names:
site_names = [s.name for s in Site.objects.all()]
self.update_user_sites(site_names or [])
self.update_user_roles(role_names or [STAFF_ROLE])
self.user.save()
self.user.userprofile.job_title = self.job_title
self.user.userprofile.mobile = self.mobile
self.user.userprofile.alternate_email = self.alternate_email
self.user.userprofile.save()
self.site_names = (
"\n - ".join([s.name for s in self.user.userprofile.sites.all()])
or "(You have not been granted access to any sites)")
self.role_names = "\n - ".join(
[g.display_name for g in self.user.userprofile.roles.all()])
self.project_name = Protocol().protocol_name
if send_email_to_user:
try:
self.email_message.send(fail_silently=False)
except ConnectionRefusedError:
print(self.email_message.body)
from .patterns import screening_identifier
from .views import (
AeListboardView,
DeathReportListboardView,
ScreeningListboardView,
SubjectDashboardView,
SubjectListboardView,
)
app_name = "meta_dashboard"
urlpatterns = SubjectListboardView.urls(
namespace=app_name,
label="subject_listboard",
identifier_pattern=Protocol().subject_identifier_pattern,
)
urlpatterns += ScreeningListboardView.urls(
namespace=app_name,
label="screening_listboard",
identifier_label="screening_identifier",
identifier_pattern=screening_identifier,
)
urlpatterns += SubjectDashboardView.urls(
namespace=app_name,
label="subject_dashboard",
identifier_pattern=Protocol().subject_identifier_pattern,
)
urlpatterns += SubjectReviewListboardView.urls(
namespace=app_name,
