def status_json(context, request):
"""
Returns the current exports statuses.
"""
exports_query = query_exports(request)
exports_count = exports_query.count()
pagination = Pagination(request.GET.get('page', 1), 5, exports_count)
exports_query = exports_query.offset(pagination.offset).limit(5)
locale = negotiate_locale_name(request)
localizer = get_localizer(request)
redis = request.redis
def export2json(export):
# TODO: This doesn't actually work, I can't figure out how to get
# the corect data out of redis
if export.status != 'complete':
data = redis.hgetall(export.redis_key)
else:
data = {}
log.debug('info: {}'.format(str(data)))
count = len(export.contents)
return {
'id': export.id,
'title': localizer.pluralize(
_(u'Export containing ${count} item'),
_(u'Export containing ${count} items'),
count, 'occams_studies', mapping={'count': count}),
'name': export.name,
'status': export.status,
'use_choice_labels': export.use_choice_labels,
'expand_collections': export.expand_collections,
'contents': sorted(export.contents, key=lambda v: v['title']),
'count': data.get('count'),
'total': data.get('total'),
'file_size': (naturalsize(export.file_size)
if export.file_size else None),
'download_url': request.route_path('studies.export_download',
export=export.id),
'delete_url': request.route_path('studies.export',
export=export.id),
'create_date': format_datetime(export.create_date, locale=locale),
'expire_date': format_datetime(export.expire_date, locale=locale)
}
return {
'csrf_token': request.session.get_csrf_token(),
'pager': pagination.serialize(),
'exports': [export2json(e) for e in exports_query]
}
def visits_cycle(context, request):
"""
This view displays summary statistics about visits that are related to
this cycle, as well as a listing of those visits for reference.
"""
db_session = request.db_session
cycle = (db_session.query(models.Cycle).filter_by(
study=context, name=request.matchdict['cycle']).first())
if not cycle:
raise HTTPNotFound()
states = db_session.query(datastore.State).order_by('id').all()
data = {
'states': states,
'visit_count': cycle.visits.count(),
'data_summary': {},
'visits_summary': {}
}
by_state = (request.GET.get('by_state') or '').strip()
by_state = next((state for state in states if state.name == by_state),
None)
for state in states:
data['visits_summary'][state.name] = (cycle.visits.filter(
models.Visit.entities.any(state=state)).count())
data['data_summary'][state.name] = (db_session.query(
datastore.Entity).join(datastore.Entity.contexts).join(
models.Visit, (datastore.Context.external == 'visit')
& (models.Visit.id == datastore.Context.key)).filter(
models.Visit.cycles.any(id=cycle.id)).filter(
datastore.Entity.state == state).count())
def count_state_exp(name):
return sa.func.count(
sa.sql.case([(datastore.State.name == name, sa.true())],
else_=sa.null()))
site_ids = [
site.id for site in db_session.query(models.Site)
if request.has_permission('view', site)
]
if site_ids:
visits_query = (db_session.query(
models.Patient.pid,
models.Visit.visit_date).select_from(models.Visit).filter(
models.Visit.cycles.
any(id=cycle.id)).join(models.Visit.patient).join(
datastore.Context, (datastore.Context.external
== sa.sql.literal_column(u"'visit'"))
& (datastore.Context.key == models.Visit.id)).join(
datastore.Context.entity).join(
datastore.Entity.state).add_columns(*[
count_state_exp(state.name).label(state.name)
for state in states
]).filter(
models.Patient.site.has(
models.Site.id.in_(site_ids))).group_by(
models.Patient.pid,
models.Visit.visit_date).order_by(
models.Visit.visit_date.desc()))
if by_state:
visits_query = visits_query.having(
count_state_exp(by_state.name) > 0)
total_visits = visits_query.count()
else:
total_visits = 0
try:
page = int((request.GET.get('page') or '').strip())
except ValueError:
page = 1
pagination = Pagination(page, 25, total_visits)
if site_ids:
visits = (visits_query.offset(pagination.offset).limit(
pagination.per_page).all())
else:
visits = []
def make_page_url(page):
return request.current_route_path(_query={
'state': by_state and by_state.name,
'page': page
})
data.update({
'cycle': cycle,
'by_state': by_state,
'offset_start': pagination.offset + 1,
'offset_end': pagination.offset + len(visits),
'total_visits': total_visits,
'make_page_url': make_page_url,
'pagination': pagination,
'visits': visits
})
return data
def enrollments(context, request):
"""
Displays enrollment summary and allows the user to filter by date.
"""
db_session = request.db_session
statuses = {
'active': models.Enrollment.termination_date == sa.null(),
'terminated': models.Enrollment.termination_date != sa.null(),
}
class FilterForm(Form):
page = wtforms.IntegerField()
status = wtforms.StringField(validators=[
wtforms.validators.Optional(),
wtforms.validators.AnyOf(statuses)
])
start = DateField()
end = DateField()
form = FilterForm(request.GET)
form.validate()
sites_query = db_session.query(models.Site)
site_ids = [s.id for s in sites_query if request.has_permission('view', s)]
if site_ids:
enrollments_query = (db_session.query(
models.Patient.pid, models.Enrollment.reference_number,
models.Enrollment.consent_date,
models.Enrollment.latest_consent_date,
models.Enrollment.termination_date).add_columns(
*[expr.label(name)
for name, expr in statuses.items()]).select_from(
models.Enrollment).join(models.Enrollment.patient).join(
models.Enrollment.study).filter(
models.Enrollment.study == context).order_by(
models.Enrollment.consent_date.desc()))
if form.start.data:
enrollments_query = enrollments_query.filter(
models.Enrollment.consent_date >= form.start.data)
if form.end.data:
enrollments_query = enrollments_query.filter(
models.Enrollment.consent_date <= form.end.data)
if form.status.data:
enrollments_query = enrollments_query.filter(
statuses[form.status.data])
total_enrollments = enrollments_query.count()
else:
total_enrollments = 0
pagination = Pagination(form.page.data, 25, total_enrollments)
if site_ids:
enrollments = (enrollments_query.offset(pagination.offset).limit(
pagination.per_page).all())
else:
enrollments = []
def make_page_url(page):
_query = form.data
_query['page'] = page
return request.current_route_path(_query=_query)
return {
'params':
form.data,
'total_active':
(context.enrollments.filter(statuses['active']).count()),
'total_terminated':
(context.enrollments.filter(statuses['terminated']).count()),
'make_page_url':
make_page_url,
'offset_start':
pagination.offset + 1,
'offset_end':
pagination.offset + len(enrollments),
'enrollments':
enrollments,
'pagination':
pagination
}
def filter_aliquot(context, request, state, page_key='page', omit=None):
db_session = request.db_session
omit = set(omit or [])
types_query = db_session.query(models.AliquotType).order_by('title')
available_types = [(t.id, t.title) for t in types_query]
states_query = db_session.query(models.AliquotState).order_by('title')
available_states = [(s.id, s.title) for s in states_query]
cycles_query = db_session.query(studies.Cycle).order_by('title')
available_cycles = [(s.id, s.title) for s in cycles_query]
class FilterForm(wtforms.Form):
pid = wtforms.StringField(_(u'PID'),
validators=[wtforms.validators.Optional()])
aliquot_types = wtforms.SelectMultipleField(
_(u'Aliquot Types'),
choices=available_types,
coerce=int,
validators=[wtforms.validators.Optional()])
aliquot_states = wtforms.SelectMultipleField(
_(u'Aliquot States'),
choices=available_states,
coerce=int,
validators=[wtforms.validators.Optional()])
visit_cycles = wtforms.SelectMultipleField(
_(u'Visit Cycles'),
choices=available_cycles,
coerce=int,
validators=[wtforms.validators.Optional()])
from_ = DateField(_(u'From Date'),
validators=[
wtforms.validators.Optional(),
DateRange(min=date(1900, 1, 1))
])
to = DateField(_(u'To Date'),
validators=[
wtforms.validators.Optional(),
DateRange(min=date(1900, 1, 1))
])
freezer = wtforms.StringField(
_(u'Freezer'), validators=[wtforms.validators.Optional()])
rack = wtforms.StringField(_(u'Rack'),
validators=[wtforms.validators.Optional()])
box = wtforms.StringField(_(u'Box'),
validators=[wtforms.validators.Optional()])
filter_form = FilterForm(request.GET)
for name in omit:
del filter_form[name]
# TODO: There is a possibility that the listing might get
# updated between requests, we need to make sure the same
# listing is repeatable...
query = (db_session.query(models.Aliquot).join(
models.Aliquot.specimen).join(models.Specimen.patient).join(
models.Aliquot.aliquot_type).join(models.Aliquot.state).filter(
(models.Aliquot.location == context)
| (models.Aliquot.previous_location == context)).order_by(
studies.Patient.pid, models.AliquotType.title,
models.Aliquot.id))
if 'pid' not in omit and filter_form.pid.data:
query = query.filter(
studies.Patient.pid.ilike('%s%%' % filter_form.pid.data))
if 'aliquot_types' not in omit and filter_form.aliquot_types.data:
query = query.filter(
models.Aliquot.aliquot_type_id.in_(filter_form.aliquot_types.data))
if 'aliquot_states' not in omit and filter_form.aliquot_states.data:
query = query.filter(
models.Aliquot.state_id.in_(filter_form.aliquot_states.data))
else:
query = query.filter(models.AliquotState.name == state)
if 'visit_cycles' not in omit and filter_form.visit_cycles.data:
query = query.filter(
models.Aliquot.specimen.has(
models.Specimen.cycle_id.in_(filter_form.visit_cycles.data)))
if 'from_' not in omit and filter_form.from_.data:
query = query.filter(
(models.Aliquot.collect_date >= filter_form.from_.data)
| (models.Aliquot.inventory_date >= filter_form.from_.data))
if 'to' not in omit and filter_form.to.data:
query = query.filter(
(models.Aliquot.collect_date <= filter_form.to.data)
| (models.Aliquot.inventory_date <= filter_form.to.data))
if 'freezer' not in omit and filter_form.freezer.data:
query = query.filter(
models.Aliquot.freezer == filter_form.freezer.data)
if 'rack' not in omit and filter_form.rack.data:
query = query.filter(models.Aliquot.rack == filter_form.rack.data)
if 'box' not in omit and filter_form.box.data:
query = query.filter(models.Aliquot.box == filter_form.box.data)
total_count = query.count()
pager = Pagination(request.GET.get(page_key), 20, total_count)
aliquot = query.offset(pager.offset).limit(pager.per_page).all()
return {
'filter_form': filter_form,
'full_query': query,
'aliquot': aliquot,
'has_aliquot': len(aliquot) > 0,
'pager': pager,
}
def filter_specimen(context, request, state, page_key='page', omit=None):
db_session = request.db_session
omit = set(omit or [])
types_query = db_session.query(models.SpecimenType).order_by('title')
available_types = [(t.id, t.title) for t in types_query]
states_query = db_session.query(models.SpecimenState).order_by('title')
available_states = [(s.id, s.title) for s in states_query]
cycles_query = db_session.query(studies.Cycle).order_by('title')
available_cycles = [(s.id, s.title) for s in cycles_query]
class FilterForm(wtforms.Form):
pid = wtforms.StringField(
_(u'PID'),
validators=[wtforms.validators.Optional()])
specimen_types = wtforms.SelectMultipleField(
_(u'Specimen Types'),
choices=available_types,
coerce=int,
validators=[wtforms.validators.Optional()])
specimen_states = wtforms.SelectMultipleField(
_(u'Specimen States'),
choices=available_states,
coerce=int,
validators=[wtforms.validators.Optional()])
visit_cycles = wtforms.SelectMultipleField(
_(u'Visit Cycles'),
choices=available_cycles,
coerce=int,
validators=[wtforms.validators.Optional()])
from_ = DateField(
_(u'From Date'),
validators=[
wtforms.validators.Optional(),
DateRange(min=date(1900, 1, 1))
])
to = DateField(
_(u'To Date'),
validators=[
wtforms.validators.Optional(),
DateRange(min=date(1900, 1, 1))
])
filter_form = FilterForm(request.GET)
for name in omit:
del filter_form[name]
# TODO: There is a possibility that the listing might get
# updated between requests, we need to make sure the same
# listing is repeatable...
query = (
db_session.query(models.Specimen)
.filter(
(models.Specimen.location == context)
| (models.Specimen.previous_location == context))
.order_by(
models.Specimen.collect_date.desc().nullsfirst(),
models.Specimen.patient_id,
models.Specimen.specimen_type_id,
models.Specimen.id))
if 'pid' not in omit and filter_form.pid.data:
query = query.filter(models.Specimen.patient.has(
studies.Patient.pid.ilike('%s%%' % filter_form.pid.data)))
if 'specimen_types' not in omit and filter_form.specimen_types.data:
query = query.filter(models.Specimen.specimen_type.has(
models.SpecimenType.id.in_(filter_form.specimen_types.data)))
if 'specimen_states' not in omit and filter_form.specimen_states.data:
query = query.filter(models.Specimen.state.has(
models.SpecimenState.id.in_(filter_form.specimen_states.data)))
else:
query = query.filter(models.Specimen.state.has(name=state))
if 'visit_cycles' not in omit and filter_form.visit_cycles.data:
query = query.filter(
models.Specimen.cycle_id.in_(filter_form.visit_cycles.data))
if 'from_' not in omit and filter_form.from_.data:
query = query.filter(
models.Specimen.collect_date >= filter_form.from_.data)
if 'to' not in omit and filter_form.to.data:
query = query.filter(
models.Specimen.collect_date <= filter_form.to.data)
total_count = query.count()
pager = Pagination(request.GET.get(page_key), 10, total_count)
specimen = query.offset(pager.offset).limit(pager.per_page).all()
return {
'filter_form': filter_form,
'specimen': specimen,
'has_specimen': len(specimen) > 0,
'pager': pager,
}
def status_json(context, request):
"""
Returns the current exports statuses.
"""
exports_query = query_exports(request)
exports_count = exports_query.count()
pagination = Pagination(request.GET.get('page', 1), 5, exports_count)
exports_query = exports_query.offset(pagination.offset).limit(5)
locale = negotiate_locale_name(request)
localizer = get_localizer(request)
redis = request.redis
def export2json(export):
# TODO: This doesn't actually work, I can't figure out how to get
# the corect data out of redis
if export.status != 'complete':
data = redis.hgetall(export.redis_key)
else:
data = {}
log.debug('info: {}'.format(str(data)))
count = len(export.contents)
return {
'id':
export.id,
'title':
localizer.pluralize(_(u'Export containing ${count} item'),
_(u'Export containing ${count} items'),
count,
'occams_studies',
mapping={'count': count}),
'name':
export.name,
'status':
export.status,
'use_choice_labels':
export.use_choice_labels,
'expand_collections':
export.expand_collections,
'contents':
sorted(export.contents, key=lambda v: v['title']),
'count':
data.get('count'),
'total':
data.get('total'),
'file_size':
(naturalsize(export.file_size) if export.file_size else None),
'download_url':
request.route_path('studies.export_download', export=export.id),
'delete_url':
request.route_path('studies.export', export=export.id),
'create_date':
format_datetime(export.create_date, locale=locale),
'expire_date':
format_datetime(export.expire_date, locale=locale)
}
return {
'csrf_token': request.session.get_csrf_token(),
'pager': pagination.serialize(),
'exports': [export2json(e) for e in exports_query]
}