def handle_abort_element(self, req_post):
session = self.session
claim_id = req_post['claim']
assert claim_id == self.ref_id, "claim_id {0}, ref_id {1}".format(claim_id, self.ref_id)
claim = session.query(Claim).filter_by(ref_id=claim_id).one()
self.set_claim_form(claim)
parts, part_links, _ = get_participants(session, claim_id)
participant_id = req_post['participant']
participant = session.query(Participant).filter_by(ref_id=participant_id).first()
pform = ParticipantEdit(req_post)
self.participant_form = self.finish_participant_form(pform, parts)
element_id = req_post['element']
if element_id == NOELEMENT:
head_element = get_head_element(session, participant)
if head_element:
self.set_element_form(head_element,
element_choices(session, participant))
self.set_hidden_fields(claim_id, participant_id, str(head_element.element_id))
else:
self.set_hidden_fields(claim_id, participant_id, NOELEMENT)
else:
element = session.query(ParticipantElement).filter_by(element_id=element_id).one()
self.set_element_form(element,
element_choices(session, participant))
self.set_hidden_fields(claim_id, participant_id, element_id)
def handle_update_claim(self, req_post):
logging.info("Hit 'update_claim'")
claim_id = req_post['claim']
assert claim_id == self.ref_id, "claim_id {0}, ref_id {1}".format(claim_id, self.ref_id)
session = self.session
claim = session.query(Claim).filter_by(ref_id=claim_id).first()
scf = self.set_claim_form_choices(ClaimEdit(req_post))
self.claim_form = scf
if scf.validate():
logging.info("Validated claim form")
claim.publication = expand_curie(scf.publication.data)
if scf.narrative.data == "None":
claim.narrative = None
else:
claim.narrative = expand_curie(scf.narrative.data)
claim.behavior_term = expand_curie(scf.behavior_term.data)
claim.publication_behavior = scf.publication_behavior.data
claim.evidence = expand_curie(scf.evidence.data)
parts, part_links, _ = get_participants(session, claim_id)
participant_id = req_post['participant']
participant = get_participant(session, participant_id)
element_id = req_post['element']
element = get_pelement(session, element_id)
self.set_participant_form(participant, parts)
self.set_element_form(element, element_choices(session, participant))
if part_links:
self.update_graph(claim, parts, part_links)
self.set_hidden_fields(claim_id, participant_id, element_id)
def handle_update_element(self, part_links, parts, req_post):
claim_id = req_post['claim']
element_id = req_post['element']
old_participant_id = req_post['participant']
assert self.ref_id == claim_id
session = self.session
claim = session.query(Claim).filter_by(ref_id=claim_id).first()
form = ElementEdit(req_post)
element = get_pelement(session, element_id)
participant = element.participant
assert old_participant_id == participant.ref_id, "{0} != {1}".format(old_participant_id, participant.ref_id)
form.element_choice.choices = element_choices(session, participant)
self.element_form = self.set_element_form_choices(form)
form.validate()
if form.element_choice in form.errors:
logging.info("Choice was {0}".format(form.element_choice.data))
parts, part_links, active = get_participants(session, claim_id)
self.set_claim_form(claim)
self.set_participant_form(active, parts)
else:
logging.info("element_choice: {0}".format(element_id))
logging.info("Errors were: {0}".format(form.errors))
self.set_claim_form(claim)
self.set_participant_form(participant, parts)
# self.choose_element_form(req_post, element, choices)
if part_links:
self.update_graph(claim, parts, part_links)
self.set_hidden_fields(claim_id, participant.ref_id, element_id)
def handle_update_participant(self, req_post):
logging.info("Hit 'update_participant'")
claim_id = req_post['claim']
assert claim_id == self.ref_id, "claim_id {0}, ref_id {1}".format(claim_id, self.ref_id)
session = self.session
claim = session.query(Claim).filter_by(ref_id=claim_id).one()
self.set_claim_form(claim)
participant_id = req_post['participant_choice']
participant = get_participant(session, participant_id)
parts, part_links, _ = get_participants(session, claim_id)
form = ParticipantEdit(req_post)
form.ref_id = participant_id
form = self.finish_participant_form(form, parts)
form.validate()
if form.errors:
active_element = get_head_element(session, participant)
self.choose_element_form(req_post,
active_element,
element_choices(session, participant))
else:
logging.info("participant_choice: {0}".format(participant_id))
participant.type = form.type.data
participant.label = form.label.data
participant.publication_taxon = form.publication_taxon.data
participant.publication_anatomy = form.publication_anatomy.data
participant.publication_substrate = form.publication_substrate.data
participant.publication_text = form.publication_text.data
participant.participation_property = expand_curie(form.participation_property.data)
self.participant_form = form
element_id = req_post['element']
element = get_pelement(session, element_id)
self.set_element_form(element, element_choices(session, participant))
self.update_graph(claim, parts, part_links)
self.set_hidden_fields(claim_id, participant_id, element_id)
def handle_commit_participant(self, req_post):
logging.info("Hit 'commit_participant'")
ref_id = self.ref_id
session = self.session
assert req_post['claim'] == ref_id
claim = session.query(Claim).filter_by(ref_id=ref_id).first()
claim_id = claim.ref_id
self.set_claim_form(claim)
form = ParticipantCreate(req_post)
self.set_participant_form_no_navigator_choices(form)
form.participant_choice.data = "None"
form.participant_choice.choices = [("None", "None")]
form.validate()
if form.errors:
logging.warning("Participant Create Errors: {0}".format(repr(form.errors)))
self.participant_form = form
self.element_form = InactiveElementEdit(None)
self.set_hidden_fields(claim_id, req_post['participant'], NOELEMENT)
else:
form = ParticipantEdit(self.request.POST)
participant = Participant()
new_ref_id = request_uid(self.session)
transaction.commit() # maybe not needed
participant.ref_id = new_ref_id
participant.type = form.type.data
participant.label = form.label.data
participant.publication_taxon = form.publication_taxon.data
participant.publication_anatomy = form.publication_anatomy.data
participant.publication_substrate = form.publication_substrate.data
participant.publication_text = form.publication_text.data
participant.participation_property = expand_curie(form.participation_property.data)
participant.claim_id = ref_id
parts, part_links, _ = get_participants(self.session, ref_id)
parts[participant.ref_id] = participant
self.participant_form = form
property_key = expand_curie(form.participation_property.data)
property_term = session.query(Property).filter_by(ref_id=property_key).one()
part_links[participant.ref_id] = property_term
self.set_participant_form(participant, parts)
self.set_participant_form(participant, parts)
self.element_form = ElementCreateOnly()
self.element_form.expression_type.data = "None"
self.element_form.expression_type.choices = expression_type_choice(session)
session.add(participant)
transaction.commit()
self.update_graph(claim, parts, part_links)
self.set_hidden_fields(claim_id, new_ref_id, NOELEMENT)
logging.info("Exiting commit participant")
def handle_create_participant(self):
ref_id = self.ref_id
session = self.session
claim = session.query(Claim).filter_by(ref_id=ref_id).first()
assert isinstance(claim, Claim)
self.set_claim_form(claim)
self.set_claim_form_choices(self.claim_form)
form = ParticipantCreate(None)
self.element_form = InactiveElementEdit(None)
if claim.narrative:
form.type.data = "individual"
else:
form.type.data = "class"
form.ref_id = 'UNASSIGNED'
parts, part_links, active = get_participants(self.session, ref_id)
self.participant_form = self.finish_participant_form(form, parts) # ?
self.update_graph(claim, parts, part_links)
self.set_hidden_fields(claim.ref_id, NOPARTICIPANT, NOELEMENT)
def handle_element_form(self, req_post):
parts, part_links, active = get_participants(self.session, self.ref_id)
if 'choose_element' in req_post:
self.handle_choose_element(part_links, parts, req_post)
elif 'update_element' in req_post:
self.handle_update_element(part_links, parts, req_post)
elif 'create_element' in req_post:
logging.info("Calling Element create {0}".format(repr(req_post)))
self.handle_create_element(part_links, parts, req_post)
elif 'commit_element' in req_post:
self.handle_commit_element(part_links, parts, req_post)
elif 'abort_element' in req_post:
self.handle_abort_element(req_post)
elif 'up' in req_post:
self.handle_element_up_button(part_links, parts, req_post)
elif 'down' in req_post:
self.handle_element_down_button(part_links, parts, req_post)
elif 'sibling' in req_post:
self.handle_element_sibling_button(part_links, parts, req_post)
else:
logging.info("Fell through all navigator buttons, post is {0}".format(repr(req_post)))
def handle_choose_participant(self, req_post):
claim_id = req_post['claim']
assert claim_id == self.ref_id, "claim_id {0}, ref_id {1}".format(claim_id, self.ref_id)
session = self.session
claim = session.query(Claim).filter_by(ref_id=claim_id).first()
participant_id = req_post['participant_choice'] # not participant
participant = get_participant(session, participant_id)
head_element = get_head_element(session, participant)
parts, part_links, active = get_participants(self.session, claim_id)
self.set_claim_form(claim)
self.choose_participant_form(participant, req_post, parts)
if head_element:
self.set_element_form(head_element,
element_choices(self.session, participant))
element_id = str(head_element.element_id)
else:
self.element_form = ElementCreateOnly(None)
self.element_form.expression_type.data = "None"
self.element_form.expression_type.choices = expression_type_choice(session)
element_id = NOELEMENT
self.update_graph(claim, parts, part_links)
self.set_hidden_fields(claim_id, participant_id, element_id)
def handle_commit_claim(self, req_post):
logging.info("Hit 'commit_claim'")
scf = ClaimCreate(req_post)
self.set_claim_form_choices(scf)
if scf.validate():
scf = ClaimEdit(req_post)
self.set_claim_form_choices(scf)
claim = Claim()
new_ref_id = request_uid(self.session)
claim.ref_id = new_ref_id
claim.publication = expand_curie(scf.publication.data)
if scf.narrative.data == "None":
claim.narrative = None
else:
claim.narrative = expand_curie(scf.narrative.data)
claim.behavior_term = expand_curie(scf.behavior_term.data)
claim.publication_behavior = scf.publication_behavior.data
claim.evidence = expand_curie(scf.evidence.data)
transaction.commit() # make sure the ref_id is committed first
self.session.add(claim)
# commit so HTTPFound 'exception' doesn't drop transaction (TODO - is there a better way)
transaction.commit()
logging.info("About to redirect to {0}".format(generate_route_id(self.request, 'claim_edit', new_ref_id)))
# TODO - can this setup forms and return normally?
# self.set_hidden_fields("test claim", "test participant", "test element")
return HTTPFound(location=generate_route_id(self.request, 'claim_edit', new_ref_id))
else:
session = self.session
old_claim_id = req_post['claim']
old_participant_id = req_post['participant']
old_element_id = req_post['element']
parts, part_links, _ = get_participants(session, old_claim_id)
self.claim_form = scf
participant = parts[old_participant_id]
self.set_participant_form(participant, parts)
element = session.query(ParticipantElement).filter_by(element_id=old_element_id).one()
self.set_element_form(element, element_choices(session, participant))
self.set_hidden_fields(old_claim_id, old_participant_id, old_element_id)
return self.render()
def handle_abort_participant(self, req_post):
session = self.session
claim_id = req_post['claim']
assert claim_id == self.ref_id, "claim_id {0}, ref_id {1}".format(claim_id, self.ref_id)
claim = self.session.query(Claim).filter_by(ref_id=claim_id).one()
self.set_claim_form(claim)
parts, part_links, _ = get_participants(session, claim_id)
participant_id = req_post['participant']
participant = self.session.query(Participant).filter_by(ref_id=participant_id).first()
form = ParticipantEdit(req_post)
form.ref_id = participant_id
self.participant_form = self.finish_participant_form(form, parts)
if participant:
head_element = get_head_element(session, participant)
self.set_element_form(head_element,
element_choices(session, participant))
if head_element:
self.set_hidden_fields(claim_id, participant_id, head_element.id)
else:
self.set_hidden_fields(claim_id, participant_id, NOELEMENT)
else:
self.element_form = InactiveElementEdit()
self.set_hidden_fields(claim_id, NOPARTICIPANT, NOELEMENT)
def handle_form_g_e_t_request(self):
ref_id = self.ref_id
logging.info("GET request")
if ref_id:
claim = self.session.query(Claim).filter_by(ref_id=ref_id).one()
self.set_claim_form(claim)
parts, part_links, active = get_participants(self.session, ref_id)
if parts:
active_element = get_head_element(self.session, active)
self.set_participant_form(active, parts)
if active_element:
choices = element_choices(self.session, active)
self.set_element_form(active_element, choices)
self.set_hidden_fields(claim.ref_id, active.ref_id, str(active_element.element_id))
else:
self.element_form = InactiveElementEdit(None)
self.set_hidden_fields(claim.ref_id, active.ref_id, NOELEMENT)
if part_links:
self.update_graph(claim, parts, part_links)
else:
form = ParticipantCreate(None)
form.ref_id = 'UNASSIGNED'
if active:
form.type.data = active.type
else:
form.type.data = 'UNASSIGNED' # should guess from claim
self.participant_form = self.finish_participant_form(form, parts) # ?
self.element_form = InactiveElementEdit(None)
self.set_hidden_fields(claim.ref_id, NOPARTICIPANT, NOELEMENT)
else: # GET for claim edit w/o ref_id means create a new claim
self.claim_form = ClaimCreate(None)
self.set_claim_form_choices(self.claim_form)
inactive_participant_form = InactiveParticipantEdit(None)
inactive_element_form = InactiveElementEdit(None)
self.participant_form = inactive_participant_form
self.element_form = inactive_element_form
self.set_hidden_fields(NOCLAIM, NOPARTICIPANT, NOELEMENT)
