def _call_fut(self, *args, **kw): from occams_forms.renderers import apply_data return apply_data(*args, **kw)
def form(context, request): """ XXX: Cannot merge into single view because of the way patient forms are handled """ db_session = request.db_session patient = context.__parent__.__parent__ schema = context.schema (is_phi, ) = (db_session.query( db_session.query(models.patient_schema_table).filter_by( schema_id=schema.id).exists()).one()) if not is_phi: previous_url = request.current_route_path( _route_name='studies.patient_forms') show_metadata = True # We cannot determine which study this form will be applied to # so just use any version from active studies available_schemata = (db_session.query(datastore.Schema).join( models.study_schema_table).join(models.Study).filter( datastore.Schema.name == context.schema.name).filter( datastore.Schema.publish_date != sa.null()).filter( datastore.Schema.retract_date == sa.null())) allowed_versions = sorted( set(s.publish_date for s in available_schemata)) else: previous_url = request.current_route_path( _route_name='studies.patient') show_metadata = False allowed_versions = None if request.has_permission('retract'): transition = modes.ALL elif request.has_permission('transition'): transition = modes.AVAILABLE else: transition = modes.AUTO Form = make_form( db_session, context.schema, entity=context, show_metadata=show_metadata, transition=transition, allowed_versions=allowed_versions, ) form = Form(request.POST, data=entity_data(context)) if request.method == 'POST': if not request.has_permission('edit', context): raise HTTPForbidden() if form.validate(): upload_dir = request.registry.settings['studies.blob.dir'] apply_data(db_session, context, form.data, upload_dir) db_session.flush() request.session.flash( _(u'Changes saved to: %s' % context.schema.title), 'success') return HTTPFound(location=previous_url) return { 'phi': get_phi_entities(patient, request), 'patient': view_json(patient, request), 'form': render_form(form, disabled=not request.has_permission('edit'), cancel_url=previous_url, attr={ 'method': 'POST', 'action': request.current_route_path(), 'role': 'form' }), }
def _call_fut(self, *args, **kw): from occams_forms.renderers import apply_data return apply_data(*args, **kw)
def terminate_ajax(context, request): db_session = request.db_session try: entity = ( db_session.query(datastore.Entity) .join(datastore.Entity.schema) .filter(datastore.Schema.name.in_( # Only search for forms being used as temrination forms db_session.query(datastore.Schema.name) .join(models.Study.termination_schema) .subquery())) .join(datastore.Context) .filter_by(external='enrollment', key=context.id) .one()) except orm.exc.MultipleResultsFound: raise Exception('Should only have one...') except orm.exc.NoResultFound: schema = context.study.termination_schema entity = datastore.Entity(schema=schema) # XXX: This is really bad form as we're applying # side-effects to a GET request, but there is no time # to make this look prety... # If you remove this line you will be creating random termination # entries... context.entities.add(entity) else: schema = entity.schema if not entity.state: entity.state = ( db_session.query(datastore.State) .filter_by(name='pending-entry') .one()) if 'termination_date' not in schema.attributes: msg = 'There is no "termination_date" configured on: {}' log.warn(msg.format(schema.name)) if request.has_permission('retract'): transition = modes.ALL elif request.has_permission('transition'): transition = modes.AVAILABLE else: transition = modes.AUTO Form = make_form( db_session, schema, entity=entity, transition=transition, show_metadata=False) form = Form(request.POST, data=entity_data(entity)) def validate_termination_date(form, field): if not (field.data >= context.latest_consent_date): raise wtforms.ValidationError(request.localizer.translate( _(u'Termination must be on or after latest consent (${date})'), mapping={'date': context.latest_consent_date} )) # Inject a validator into the termination form so that we # ensure that the termination date provided is valid form.termination_date.validators.append(validate_termination_date) if request.method == 'POST': check_csrf_token(request) if form.validate(): if not entity.id: # changing termination version *should* not be # allowed, just assign the schema that's already being used context.entities.add(entity) upload_dir = request.registry.settings['studies.blob.dir'] apply_data(db_session, entity, form.data, upload_dir) context.termination_date = form.termination_date.data db_session.flush() return HTTPOk(json=view_json(context, request)) else: return HTTPBadRequest(json={'errors': wtferrors(form)}) return render_form( form, cancel_url=request.current_route_path(_route_name='studies.patient'), attr={ 'method': 'POST', 'action': request.current_route_path(), 'role': 'form', 'data-bind': 'formentry: {}, submit: $root.terminateEnrollment' } )
def apply_direct_mappings(task): # get all the direct mappings for processing mappings = ( Session.query(models.Mapping) .filter_by(type=u'direct').all() ) default_state = ( Session.query(datastore.State) .filter_by(name='pending-entry') .one() ) redis = app.redis total_mappings = len(mappings) count = 0 mappings_id = six.text_type(str(uuid.uuid4())) redis.hmset(mappings_id, { 'count': count, 'total': total_mappings }) for mapping in mappings: source_schema_name = mapping.logic['source_schema'] source_schema_publish_date = mapping.logic['source_schema_publish_date'] source_variable = mapping.logic['source_variable'] target_schema_name = mapping.logic['target_schema'] target_schema_publish_date = mapping.logic['target_schema_publish_date'] target_variable = mapping.logic['target_variable'] # get records that have a matching schema for source schema records = ( Session.query(models.SiteData) .filter( models.SiteData.data['form_name'].astext == source_schema_name ) .filter( models.SiteData.data['form_publish_date'].astext == source_schema_publish_date ).all() ) for record in records: pid = record.data['pid'] collect_date = record.data['collect_date'] patient = ( Session.query(studies.Patient) .filter_by(pid=pid) .one() ) target_schema = ( Session.query(datastore.Schema) .filter_by(name=target_schema_name) .filter_by(publish_date=target_schema_publish_date) ).one() # if the target schema already exists we want to add data # to the schema rather than creating a new entity entity_exists = False for item in patient.entities: if item.schema.name == target_schema_name and \ item.schema.publish_date.isoformat() == \ target_schema_publish_date: entity = item entity_exists = True break if not entity_exists: entity = datastore.Entity( schema=target_schema, collect_date=collect_date, state=default_state ) patient.entities.add(entity) if mapping.logic['choices_mapping']: # add handling if there is no value to map source_key = record.data.get(source_variable) payload = {target_variable: source_key} upload_dir = tempfile.mkdtemp() apply_data(Session, entity, payload, upload_dir) shutil.rmtree(upload_dir) else: # non-choices processing source_key = record.data.get(source_variable) payload = {target_variable: source_key} upload_dir = tempfile.mkdtemp() apply_data(Session, entity, payload, upload_dir) shutil.rmtree(upload_dir) redis.hincrby(mappings_id, 'count') data = redis.hgetall(mappings_id) # redis-py returns everything as string, so we need to clean it for key in ('count', 'total'): data[key] = int(data[key]) redis.publish('direct', json.dumps(data))
def populate_project( db_session, project_name, consolidated_frame, pid_column=DEFAULT_PID_COLUMN, visit_column=DEFAULT_VISIT_COLUMN, collect_date_column=DEFAULT_COLLECT_DATE_COLUMN, ): """ Processes a final dataframe (i.e. a frame after mappings have been applied) and creates entities for the target project. :param db_session: Current database transaction session :type db_session: sqlalchemy.orm.session.Session :param project_name: study where entities will be applied :type project_name: str :param consolidated_frame: dataframe populated with mapped variables :type consolidated_frame: pandas.DataFrame :returns: none """ site = db_session.query(studies.Site).filter_by(name=project_name).one() project = (db_session.query( studies.Study).filter_by(name=project_name).one()) default_state = (db_session.query( datastore.State).filter_by(name='pending-entry').one()) for index, row in consolidated_frame.iterrows(): pid = row['pid'] try: patient = (db_session.query( studies.Patient).filter_by(pid=pid).one()) except orm.exc.NoResultFound: patient = studies.Patient(site=site, pid=pid) db_session.add(patient) db_session.flush() for schema in project.schemata: payload = {} for attribute in schema.iterleafs(): column_name = '_'.join( [project.name, schema.name, attribute.name]) if column_name not in row: continue value = row[column_name] if isinstance(value, numbers.Number) and math.isnan(value): continue payload[attribute.name] = value # Avoid creating empty records if not payload: continue calculated_collect_date_column = '_'.join( [project.name, schema.name, collect_date_column]) collect_date = row[calculated_collect_date_column] entity = datastore.Entity(schema=schema, collect_date=collect_date, state=default_state) patient.entities.add(entity) upload_dir = tempfile.mkdtemp() apply_data(db_session, entity, payload, upload_dir) shutil.rmtree(upload_dir) db_session.flush()
def form(context, request): """ XXX: Cannot merge into single view because of the way patient forms are handled """ db_session = request.db_session patient = context.__parent__.__parent__ schema = context.schema (is_phi,) = ( db_session.query( db_session.query(models.patient_schema_table) .filter_by(schema_id=schema.id) .exists()) .one()) if not is_phi: previous_url = request.current_route_path( _route_name='studies.patient_forms') show_metadata = True # We cannot determine which study this form will be applied to # so just use any version from active studies available_schemata = ( db_session.query(datastore.Schema) .join(models.study_schema_table) .join(models.Study) .filter(datastore.Schema.name == context.schema.name) .filter(datastore.Schema.publish_date != sa.null()) .filter(datastore.Schema.retract_date == sa.null())) allowed_versions = sorted(set( s.publish_date for s in available_schemata)) else: previous_url = request.current_route_path( _route_name='studies.patient') show_metadata = False allowed_versions = None if request.has_permission('retract'): transition = modes.ALL elif request.has_permission('transition'): transition = modes.AVAILABLE else: transition = modes.AUTO Form = make_form( db_session, context.schema, entity=context, show_metadata=show_metadata, transition=transition, allowed_versions=allowed_versions, ) form = Form(request.POST, data=entity_data(context)) if request.method == 'POST': if not request.has_permission('edit', context): raise HTTPForbidden() if form.validate(): upload_dir = request.registry.settings['studies.blob.dir'] apply_data(db_session, context, form.data, upload_dir) db_session.flush() request.session.flash( _(u'Changes saved to: %s' % context.schema.title), 'success') return HTTPFound(location=previous_url) return { 'phi': get_phi_entities(patient, request), 'patient': view_json(patient, request), 'form': render_form( form, disabled=not request.has_permission('edit'), cancel_url=previous_url, attr={ 'method': 'POST', 'action': request.current_route_path(), 'role': 'form' } ), }
def populate_project( db_session, project_name, consolidated_frame, pid_column=DEFAULT_PID_COLUMN, visit_column=DEFAULT_VISIT_COLUMN, collect_date_column=DEFAULT_COLLECT_DATE_COLUMN, ): """ Processes a final dataframe (i.e. a frame after mappings have been applied) and creates entities for the target project. :param db_session: Current database transaction session :type db_session: sqlalchemy.orm.session.Session :param project_name: study where entities will be applied :type project_name: str :param consolidated_frame: dataframe populated with mapped variables :type consolidated_frame: pandas.DataFrame :returns: none """ site = db_session.query(studies.Site).filter_by(name=project_name).one() project = ( db_session.query(studies.Study) .filter_by(name=project_name) .one() ) default_state = ( db_session.query(datastore.State) .filter_by(name='pending-entry') .one() ) for index, row in consolidated_frame.iterrows(): pid = row['pid'] try: patient = ( db_session.query(studies.Patient) .filter_by(pid=pid) .one() ) except orm.exc.NoResultFound: patient = studies.Patient(site=site, pid=pid) db_session.add(patient) db_session.flush() for schema in project.schemata: payload = {} for attribute in schema.iterleafs(): column_name = '_'.join([ project.name, schema.name, attribute.name ]) if column_name not in row: continue value = row[column_name] if isinstance(value, numbers.Number) and math.isnan(value): continue payload[attribute.name] = value # Avoid creating empty records if not payload: continue calculated_collect_date_column = '_'.join([ project.name, schema.name, collect_date_column ]) collect_date = row[calculated_collect_date_column] entity = datastore.Entity( schema=schema, collect_date=collect_date, state=default_state ) patient.entities.add(entity) upload_dir = tempfile.mkdtemp() apply_data(db_session, entity, payload, upload_dir) shutil.rmtree(upload_dir) db_session.flush()
def form(context, request): """ XXX: Cannot merge into single view because of the way patient forms are handled """ db_session = request.db_session visit = context.__parent__.__parent__ allowed_schemata = (db_session.query(datastore.Schema).join( models.study_schema_table).join(models.Study).join( models.Cycle).filter( datastore.Schema.name == context.schema.name).filter( models.Cycle.id.in_([cycle.id for cycle in visit.cycles]))) allowed_versions = [s.publish_date for s in allowed_schemata] if request.has_permission('retract'): transition = modes.ALL elif request.has_permission('transition'): transition = modes.AVAILABLE else: transition = modes.AUTO Form = make_form( db_session, context.schema, entity=context, show_metadata=True, transition=transition, allowed_versions=allowed_versions, ) form = Form(request.POST, data=entity_data(context)) if request.method == 'POST': if not request.has_permission('edit', context): raise HTTPForbidden() if form.validate(): upload_dir = request.registry.settings['studies.blob.dir'] apply_data(db_session, context, form.data, upload_dir) db_session.flush() request.session.flash( _(u'Changes saved for: ${form}', mapping={'form': context.schema.title}), 'success') return HTTPFound(location=request.current_route_path( _route_name='studies.visit')) return { 'visit': view_json(visit, request), 'form': render_form( form, disabled=not request.has_permission('edit'), cancel_url=request.current_route_path(_route_name='studies.visit'), attr={ 'method': 'POST', 'action': request.current_route_path(), 'role': 'form' }), }
def terminate_ajax(context, request): db_session = request.db_session try: entity = ( db_session.query(datastore.Entity).join( datastore.Entity.schema).filter( datastore.Schema.name.in_( # Only search for forms being used as temrination forms db_session.query(datastore.Schema.name).join( models.Study.termination_schema ).subquery())).join(datastore.Context).filter_by( external='enrollment', key=context.id).one()) except orm.exc.MultipleResultsFound: raise Exception('Should only have one...') except orm.exc.NoResultFound: schema = context.study.termination_schema entity = datastore.Entity(schema=schema) # XXX: This is really bad form as we're applying # side-effects to a GET request, but there is no time # to make this look prety... # If you remove this line you will be creating random termination # entries... context.entities.add(entity) context.patient.entities.add(entity) else: schema = entity.schema if not entity.state: entity.state = (db_session.query( datastore.State).filter_by(name='pending-entry').one()) if 'termination_date' not in schema.attributes: msg = 'There is no "termination_date" configured on: {}' log.warn(msg.format(schema.name)) if request.has_permission('retract'): transition = modes.ALL elif request.has_permission('transition'): transition = modes.AVAILABLE else: transition = modes.AUTO Form = make_form(db_session, schema, entity=entity, transition=transition, show_metadata=False) form = Form(request.POST, data=entity_data(entity)) def validate_termination_date(form, field): if not (field.data >= context.latest_consent_date): raise wtforms.ValidationError( request.localizer.translate(_( u'Termination must be on or after latest consent (${date})' ), mapping={ 'date': context.latest_consent_date })) # Inject a validator into the termination form so that we # ensure that the termination date provided is valid form.termination_date.validators.append(validate_termination_date) if request.method == 'POST': check_csrf_token(request) if form.validate(): if not entity.id: # changing termination version *should* not be # allowed, just assign the schema that's already being used context.entities.add(entity) upload_dir = request.registry.settings['studies.blob.dir'] apply_data(db_session, entity, form.data, upload_dir) context.termination_date = form.termination_date.data db_session.flush() return HTTPOk(json=view_json(context, request)) else: return HTTPBadRequest(json={'errors': wtferrors(form)}) return render_form( form, cancel_url=request.current_route_path(_route_name='studies.patient'), attr={ 'method': 'POST', 'action': request.current_route_path(), 'role': 'form', 'data-bind': 'formentry: {}, submit: $root.terminateEnrollment' })
def form(context, request): """ XXX: Cannot merge into single view because of the way patient forms are handled """ db_session = request.db_session visit = context.__parent__.__parent__ allowed_schemata = ( db_session.query(datastore.Schema) .join(models.study_schema_table) .join(models.Study) .join(models.Cycle) .filter(models.Cycle.id.in_([cycle.id for cycle in visit.cycles]))) allowed_versions = [s.publish_date for s in allowed_schemata] if request.has_permission('retract'): transition = modes.ALL elif request.has_permission('transition'): transition = modes.AVAILABLE else: transition = modes.AUTO Form = make_form( db_session, context.schema, entity=context, show_metadata=True, transition=transition, allowed_versions=allowed_versions, ) form = Form(request.POST, data=entity_data(context)) if request.method == 'POST': if not request.has_permission('edit', context): raise HTTPForbidden() if form.validate(): upload_dir = request.registry.settings['studies.blob.dir'] apply_data(db_session, context, form.data, upload_dir) db_session.flush() request.session.flash( _(u'Changes saved for: ${form}', mapping={ 'form': context.schema.title}), 'success') return HTTPFound(location=request.current_route_path( _route_name='studies.visit')) return { 'visit': view_json(visit, request), 'form': render_form( form, disabled=not request.has_permission('edit'), cancel_url=request.current_route_path(_route_name='studies.visit'), attr={ 'method': 'POST', 'action': request.current_route_path(), 'role': 'form' } ), }