def run(request): """Run analysis, return URL of the analysis status page Needs re-factoring """ logger.debug("analysis_manager.views.run called") if not request.is_ajax(): return HttpResponseBadRequest() # 400 allowed_methods = ['POST'] if request.method not in allowed_methods: return HttpResponseNotAllowed(allowed_methods) # 405 analysis_config = simplejson.loads(request.body) try: workflow_uuid = analysis_config['workflowUuid'] study_uuid = analysis_config['studyUuid'] node_set_uuid = analysis_config['nodeSetUuid'] node_relationship_uuid = analysis_config['nodeRelationshipUuid'] except KeyError: return HttpResponseBadRequest() # 400 # must provide workflow and study UUIDs, # and either node set UUID or node relationship UUID if not (workflow_uuid and study_uuid and (node_set_uuid or node_relationship_uuid)): return HttpResponseBadRequest() # 400 # single-input workflow if node_set_uuid: #TODO: handle DoesNotExist exception curr_node_set = NodeSet.objects.get(uuid=node_set_uuid) curr_node_dict = curr_node_set.solr_query_components curr_node_dict = simplejson.loads(curr_node_dict) # solr results solr_uuids = get_solr_results( curr_node_set.solr_query, only_uuids=True, selected_mode=curr_node_dict['documentSelectionBlacklistMode'], selected_nodes=curr_node_dict['documentSelection']) # retrieving workflow based on input workflow_uuid #TODO: handle DoesNotExist exception curr_workflow = Workflow.objects.filter(uuid=workflow_uuid)[0] # TODO: catch if study or data set don't exist study = Study.objects.get(uuid=study_uuid) data_set = InvestigationLink.objects.filter( investigation__uuid=study.investigation.uuid).order_by( "version").reverse()[0].data_set logger.info("Associating analysis with data set %s (%s)" % (data_set, data_set.uuid)) ######### ANALYSIS MODEL ######## # How to create a simple analysis object temp_name = curr_workflow.name + " " + datetime.now().strftime( "%Y-%m-%d @ %H:%M:%S") summary_name = "None provided." analysis = Analysis( summary=summary_name, name=temp_name, project=request.user.get_profile().catch_all_project, data_set=data_set, workflow=curr_workflow, time_start=datetime.now()) analysis.save() analysis.set_owner(request.user) # gets galaxy internal id for specified workflow workflow_galaxy_id = curr_workflow.internal_id # getting distinct workflow inputs workflow_data_inputs = curr_workflow.data_inputs.all()[0] # NEED TO GET LIST OF FILE_UUIDS from solr query count = 0 for file_uuid in solr_uuids: count += 1 temp_input = WorkflowDataInputMap( workflow_data_input_name=workflow_data_inputs.name, data_uuid=file_uuid, pair_id=count) temp_input.save() analysis.workflow_data_input_maps.add(temp_input) analysis.save() # dual-input workflow if node_relationship_uuid: # Input list for running analysis ret_list = [] # retrieving workflow based on input workflow_uuid curr_workflow = Workflow.objects.get(uuid=workflow_uuid) # TODO: catch if study or data set don't exist study = Study.objects.get(uuid=study_uuid) data_set = InvestigationLink.objects.filter( investigation__uuid=study.investigation.uuid).order_by( "version").reverse()[0].data_set # Get node relationship model curr_relationship = NodeRelationship.objects.get( uuid=node_relationship_uuid) # Iterating over node pairs input_keys = [] base_input = {} # defining inputs used for analysis for workflow_inputs in curr_workflow.input_relationships.all(): base_input[workflow_inputs.set1] = {} base_input[workflow_inputs.set2] = {} input_keys.append(workflow_inputs.set1) input_keys.append(workflow_inputs.set2) # creating instance of instance of input data pairing for analysis, # i.e. [{u'exp_file': {'node_uuid': u'3d061699-6bc8-11e2-9b55-406c8f1d5108', 'pair_id': 1}, u'input_file': {'node_uuid': u'3d180d11-6bc8-11e2-9bc7-406c8f1d5108', 'pair_id': 1}}] count = 1 for curr_pair in curr_relationship.node_pairs.all(): temp_pair = copy.deepcopy(base_input) print "curr_pair" print temp_pair print curr_pair #temp_pair = {} if curr_pair.node2: #print curr_pair.node2.uuid temp_pair[input_keys[0]]['node_uuid'] = curr_pair.node1.uuid temp_pair[input_keys[0]]['pair_id'] = count temp_pair[input_keys[1]]['node_uuid'] = curr_pair.node2.uuid temp_pair[input_keys[1]]['pair_id'] = count ret_list.append(temp_pair) print temp_pair count += 1 logger.info("Associating analysis with data set %s (%s)" % (data_set, data_set.uuid)) ######### ANALYSIS MODEL ######## # How to create a simple analysis object temp_name = curr_workflow.name + " " + str(datetime.now()) summary_name = "None provided." analysis = Analysis( summary=summary_name, name=temp_name, project=request.user.get_profile().catch_all_project, data_set=data_set, workflow=curr_workflow, time_start=datetime.now()) analysis.save() analysis.set_owner(request.user) # gets galaxy internal id for specified workflow workflow_galaxy_id = curr_workflow.internal_id # getting distinct workflow inputs workflow_data_inputs = curr_workflow.data_inputs.all() logger.debug("ret_list") logger.debug(simplejson.dumps(ret_list, indent=4)) ######### ANALYSIS MODEL # Updating Refinery Models for updated workflow input (galaxy worfkflow input id & node_uuid count = 0 for samp in ret_list: count += 1 for k, v in samp.items(): temp_input = WorkflowDataInputMap( workflow_data_input_name=k, data_uuid=samp[k]["node_uuid"], pair_id=count) temp_input.save() analysis.workflow_data_input_maps.add(temp_input) analysis.save() # keeping new reference to analysis_status analysis_status = AnalysisStatus.objects.create(analysis=analysis) analysis_status.save() # call function via analysis_manager run_analysis.delay(analysis) redirect_url = reverse('analysis_manager.views.analysis_status', args=(analysis.uuid, )) return HttpResponse(redirect_url)
def create_noderelationship(request): """ ajax function for creating noderelationships based on multiple node sets """ logger.debug("analysis_manager.views create_noderelationship called") logger.debug(simplejson.dumps(request.POST, indent=4)) if request.is_ajax(): #print "is ajax" nr_name = request.POST.getlist('name')[0] nr_description = request.POST.getlist('description')[0] # getting nodeset uuids node_set_uuid1 = request.POST.getlist('node_set_uuid1')[0] node_set_uuid2 = request.POST.getlist('node_set_uuid2')[0] # getting instances of current nodeset curr_node_set1 = NodeSet.objects.get(uuid=node_set_uuid1) curr_node_set2 = NodeSet.objects.get(uuid=node_set_uuid2) # fields to match on diff_fields = request.POST.getlist('fields[]') if len(diff_fields) < 1: logger.error( 'create_noderelationship: failed b/c no field selected for defining Node Relationships' ) # get study uuid assay_uuid = request.POST.getlist('assay_uuid')[0] study_uuid = request.POST.getlist('study_uuid')[0] study = Study.objects.get(uuid=study_uuid) # TODO: catch if study or data set don't exist study = Study.objects.get(uuid=study_uuid) assay = Assay.objects.get(uuid=assay_uuid) # Need to deal w/ limits on current solr queries # solr results #print "curr_node_set1.solr_query_components" curr_node_dict1 = curr_node_set1.solr_query_components curr_node_dict1 = simplejson.loads(curr_node_dict1) curr_node_dict2 = curr_node_set2.solr_query_components curr_node_dict2 = simplejson.loads(curr_node_dict2) # getting list of node uuids based on input solr query node_set_solr1 = get_solr_results( curr_node_set1.solr_query, selected_mode=curr_node_dict1['documentSelectionBlacklistMode'], selected_nodes=curr_node_dict1['documentSelection']) node_set_solr2 = get_solr_results( curr_node_set2.solr_query, selected_mode=curr_node_dict2['documentSelectionBlacklistMode'], selected_nodes=curr_node_dict2['documentSelection']) # all fields from the first solr query all_fields = node_set_solr1['responseHeader']['params']['fl'] # actual documents retreived from solr response node_set_results1 = node_set_solr1['response']['docs'] node_set_results2 = node_set_solr2['response']['docs'] # match between 2 nodesets for a given column nodes_set_match, match_info = match_nodesets(node_set_results1, node_set_results2, diff_fields, all_fields) logger.debug("MAKING RELATIONSHIPS NOW") logger.debug(simplejson.dumps(nodes_set_match, indent=4)) logger.debug(nodes_set_match) # TODO: need to include names, descriptions, summary if (nr_name.strip() == ''): nr_name = curr_node_set1.name + " - " + curr_node_set2.name + " " + str( datetime.now()) if (nr_description.strip() == ''): nr_description = curr_node_set1.name + " - " + curr_node_set2.name + " " + str( datetime.now()) new_relationship = NodeRelationship(node_set_1=curr_node_set1, node_set_2=curr_node_set2, study=study, assay=assay, name=nr_name, summary=nr_description) new_relationship.save() for i in range(len(nodes_set_match)): #print "### i =" + str(i) node1 = Node.objects.get(uuid=nodes_set_match[i]['uuid_1']) node2 = Node.objects.get(uuid=nodes_set_match[i]['uuid_2']) new_pair = NodePair(node1=node1, node2=node2, group=i + 1) new_pair.save() new_relationship.node_pairs.add(new_pair) #print "node_set_solr1" #print simplejson.dumps(node_set_solr1, indent=4) #print "node_set_solr2" #print simplejson.dumps(node_set_solr2, indent=4) return HttpResponse(simplejson.dumps(match_info, indent=4), mimetype='application/json')
def repository_run(request): logger.debug("analysis_manager.views.repository_run called") if request.method == 'POST': print(simplejson.dumps(request.POST, indent=4)) # attributes associated with node selection from interface node_selection_blacklist_mode = request.POST[ 'node_selection_blacklist_mode'] if node_selection_blacklist_mode == 'true': node_selection_blacklist_mode = True else: node_selection_blacklist_mode = False node_selection = request.POST.getlist('node_selection[]') # solr results solr_query = request.POST["query"] solr_uuids = get_solr_results( solr_query, only_uuids=True, selected_mode=node_selection_blacklist_mode, selected_nodes=node_selection) # gets workflow_uuid workflow_uuid = request.POST['workflow_choice'] # get study uuid study_uuid = request.POST['study_uuid'] # retrieving workflow based on input workflow_uuid curr_workflow = Workflow.objects.filter(uuid=workflow_uuid)[0] # TODO: catch if study or data set don't exist study = Study.objects.get(uuid=study_uuid) data_set = InvestigationLink.objects.filter( investigation__uuid=study.investigation.uuid).order_by( "version").reverse()[0].data_set logger.info("Associating analysis with data set %s (%s)" % (data_set, data_set.uuid)) ######### ANALYSIS MODEL ######## # How to create a simple analysis object temp_name = curr_workflow.name + " " + datetime.now().strftime( "%Y-%m-%d @ %H:%M:%S") summary_name = "None provided." analysis = Analysis( summary=summary_name, name=temp_name, project=request.user.get_profile().catch_all_project, data_set=data_set, workflow=curr_workflow, time_start=datetime.now()) analysis.save() #setting the owner analysis.set_owner(request.user) # gets galaxy internal id for specified workflow workflow_galaxy_id = curr_workflow.internal_id # getting distinct workflow inputs workflow_data_inputs = curr_workflow.data_inputs.all()[0] # NEED TO GET LIST OF FILE_UUIDS from solr query count = 0 for file_uuid in solr_uuids: count += 1 temp_input = WorkflowDataInputMap( workflow_data_input_name=workflow_data_inputs.name, data_uuid=file_uuid, pair_id=count) temp_input.save() analysis.workflow_data_input_maps.add(temp_input) analysis.save() # keeping new reference to analysis_status analysis_status = AnalysisStatus.objects.create(analysis=analysis) analysis_status.save() # call function via analysis_manager run_analysis.delay(analysis) #import pdb; pdb.set_trace() logger.debug( request.build_absolute_uri( reverse('analysis_manager.views.analysis_status', args=(analysis.uuid, )))) ret_url = request.build_absolute_uri( reverse('analysis_manager.views.analysis_status', args=(analysis.uuid, ))) return HttpResponse(simplejson.dumps(ret_url), mimetype='application/json')
def create_noderelationship(request): """ ajax function for creating noderelationships based on multiple node sets """ logger.debug("analysis_manager.views create_noderelationship called") logger.debug( simplejson.dumps(request.POST, indent=4) ) if request.is_ajax(): #print "is ajax" nr_name = request.POST.getlist('name')[0] nr_description = request.POST.getlist('description')[0] # getting nodeset uuids node_set_uuid1 = request.POST.getlist('node_set_uuid1')[0] node_set_uuid2 = request.POST.getlist('node_set_uuid2')[0] # getting instances of current nodeset curr_node_set1 = NodeSet.objects.get(uuid=node_set_uuid1) curr_node_set2 = NodeSet.objects.get(uuid=node_set_uuid2) # fields to match on diff_fields = request.POST.getlist('fields[]') if len(diff_fields) < 1: logger.error('create_noderelationship: failed b/c no field selected for defining Node Relationships') # get study uuid assay_uuid = request.POST.getlist('assay_uuid')[0] study_uuid = request.POST.getlist('study_uuid')[0] study = Study.objects.get( uuid=study_uuid ); # TODO: catch if study or data set don't exist study = Study.objects.get( uuid=study_uuid ); assay = Assay.objects.get( uuid=assay_uuid ); # Need to deal w/ limits on current solr queries # solr results #print "curr_node_set1.solr_query_components" curr_node_dict1 = curr_node_set1.solr_query_components curr_node_dict1 = simplejson.loads(curr_node_dict1) curr_node_dict2 = curr_node_set2.solr_query_components curr_node_dict2 = simplejson.loads(curr_node_dict2) # getting list of node uuids based on input solr query node_set_solr1 = get_solr_results(curr_node_set1.solr_query, selected_mode=curr_node_dict1['documentSelectionBlacklistMode'], selected_nodes=curr_node_dict1['documentSelection']) node_set_solr2 = get_solr_results(curr_node_set2.solr_query, selected_mode=curr_node_dict2['documentSelectionBlacklistMode'], selected_nodes=curr_node_dict2['documentSelection']) # all fields from the first solr query all_fields = node_set_solr1['responseHeader']['params']['fl'] # actual documents retreived from solr response node_set_results1 = node_set_solr1['response']['docs'] node_set_results2 = node_set_solr2['response']['docs'] # match between 2 nodesets for a given column nodes_set_match, match_info = match_nodesets(node_set_results1, node_set_results2, diff_fields, all_fields) logger.debug("MAKING RELATIONSHIPS NOW") logger.debug(simplejson.dumps(nodes_set_match, indent=4)) logger.debug(nodes_set_match) # TODO: need to include names, descriptions, summary if (nr_name.strip() == ''): nr_name = curr_node_set1.name + " - " + curr_node_set2.name + " " + str( datetime.now() ) if (nr_description.strip() == ''): nr_description = curr_node_set1.name + " - " + curr_node_set2.name + " " + str( datetime.now() ) new_relationship = NodeRelationship(node_set_1=curr_node_set1, node_set_2=curr_node_set2, study=study, assay=assay, name=nr_name, summary=nr_description) new_relationship.save() for i in range(len(nodes_set_match)): #print "### i =" + str(i) node1 = Node.objects.get(uuid=nodes_set_match[i]['uuid_1']) node2 = Node.objects.get(uuid=nodes_set_match[i]['uuid_2']) new_pair = NodePair(node1=node1, node2=node2, group=i+1) new_pair.save() new_relationship.node_pairs.add(new_pair) #print "node_set_solr1" #print simplejson.dumps(node_set_solr1, indent=4) #print "node_set_solr2" #print simplejson.dumps(node_set_solr2, indent=4) return HttpResponse(simplejson.dumps(match_info, indent=4), mimetype='application/json')
def run(request): """Run analysis, return URL of the analysis status page Needs re-factoring """ logger.debug("analysis_manager.views.run called") if not request.is_ajax(): return HttpResponseBadRequest() # 400 allowed_methods = ['POST'] if request.method not in allowed_methods: return HttpResponseNotAllowed(allowed_methods) # 405 analysis_config = simplejson.loads(request.body) try: workflow_uuid = analysis_config['workflowUuid'] study_uuid = analysis_config['studyUuid'] node_set_uuid = analysis_config['nodeSetUuid'] node_relationship_uuid = analysis_config['nodeRelationshipUuid'] except KeyError: return HttpResponseBadRequest() # 400 # must provide workflow and study UUIDs, # and either node set UUID or node relationship UUID if not (workflow_uuid and study_uuid and (node_set_uuid or node_relationship_uuid)): return HttpResponseBadRequest() # 400 # single-input workflow if node_set_uuid: #TODO: handle DoesNotExist exception curr_node_set = NodeSet.objects.get(uuid=node_set_uuid) curr_node_dict = curr_node_set.solr_query_components curr_node_dict = simplejson.loads(curr_node_dict) # solr results solr_uuids = get_solr_results( curr_node_set.solr_query, only_uuids=True, selected_mode=curr_node_dict['documentSelectionBlacklistMode'], selected_nodes=curr_node_dict['documentSelection'] ) # retrieving workflow based on input workflow_uuid #TODO: handle DoesNotExist exception curr_workflow = Workflow.objects.filter(uuid=workflow_uuid)[0] # TODO: catch if study or data set don't exist study = Study.objects.get(uuid=study_uuid); data_set = InvestigationLink.objects.filter( investigation__uuid=study.investigation.uuid).order_by( "version").reverse()[0].data_set; logger.info("Associating analysis with data set %s (%s)" % (data_set, data_set.uuid)) ######### ANALYSIS MODEL ######## # How to create a simple analysis object temp_name = curr_workflow.name + " " + datetime.now().strftime("%Y-%m-%d @ %H:%M:%S") summary_name = "None provided." analysis = Analysis(summary=summary_name, name=temp_name, project=request.user.get_profile().catch_all_project, data_set=data_set, workflow=curr_workflow, time_start=datetime.now()) analysis.save() analysis.set_owner(request.user) # gets galaxy internal id for specified workflow workflow_galaxy_id = curr_workflow.internal_id # getting distinct workflow inputs workflow_data_inputs = curr_workflow.data_inputs.all()[0] # NEED TO GET LIST OF FILE_UUIDS from solr query count = 0; for file_uuid in solr_uuids: count += 1 temp_input = WorkflowDataInputMap( workflow_data_input_name=workflow_data_inputs.name, data_uuid=file_uuid, pair_id=count ) temp_input.save() analysis.workflow_data_input_maps.add(temp_input) analysis.save() # dual-input workflow if node_relationship_uuid: # Input list for running analysis ret_list = [] # retrieving workflow based on input workflow_uuid curr_workflow = Workflow.objects.get(uuid=workflow_uuid) # TODO: catch if study or data set don't exist study = Study.objects.get(uuid=study_uuid); data_set = InvestigationLink.objects.filter( investigation__uuid=study.investigation.uuid).order_by( "version").reverse()[0].data_set; # Get node relationship model curr_relationship = NodeRelationship.objects.get(uuid=node_relationship_uuid) # Iterating over node pairs input_keys = [] base_input = {} # defining inputs used for analysis for workflow_inputs in curr_workflow.input_relationships.all(): base_input[workflow_inputs.set1] = {} base_input[workflow_inputs.set2] = {} input_keys.append(workflow_inputs.set1) input_keys.append(workflow_inputs.set2) # creating instance of instance of input data pairing for analysis, # i.e. [{u'exp_file': {'node_uuid': u'3d061699-6bc8-11e2-9b55-406c8f1d5108', 'pair_id': 1}, u'input_file': {'node_uuid': u'3d180d11-6bc8-11e2-9bc7-406c8f1d5108', 'pair_id': 1}}] count = 1 for curr_pair in curr_relationship.node_pairs.all(): temp_pair = copy.deepcopy(base_input) print "curr_pair" print temp_pair print curr_pair #temp_pair = {} if curr_pair.node2: #print curr_pair.node2.uuid temp_pair[input_keys[0]]['node_uuid'] = curr_pair.node1.uuid temp_pair[input_keys[0]]['pair_id'] = count temp_pair[input_keys[1]]['node_uuid'] = curr_pair.node2.uuid temp_pair[input_keys[1]]['pair_id'] = count ret_list.append(temp_pair) print temp_pair count += 1 logger.info("Associating analysis with data set %s (%s)" % (data_set, data_set.uuid)) ######### ANALYSIS MODEL ######## # How to create a simple analysis object temp_name = curr_workflow.name + " " + str(datetime.now()) summary_name = "None provided." analysis = Analysis(summary=summary_name, name=temp_name, project=request.user.get_profile().catch_all_project, data_set=data_set, workflow=curr_workflow, time_start=datetime.now()) analysis.save() analysis.set_owner(request.user) # gets galaxy internal id for specified workflow workflow_galaxy_id = curr_workflow.internal_id # getting distinct workflow inputs workflow_data_inputs = curr_workflow.data_inputs.all() logger.debug("ret_list") logger.debug(simplejson.dumps(ret_list, indent=4)) ######### ANALYSIS MODEL # Updating Refinery Models for updated workflow input (galaxy worfkflow input id & node_uuid count = 0 for samp in ret_list: count += 1 for k,v in samp.items(): temp_input = WorkflowDataInputMap( workflow_data_input_name=k, data_uuid=samp[k]["node_uuid"], pair_id=count) temp_input.save() analysis.workflow_data_input_maps.add(temp_input) analysis.save() # keeping new reference to analysis_status analysis_status = AnalysisStatus.objects.create(analysis=analysis) analysis_status.save() # call function via analysis_manager run_analysis.delay(analysis) redirect_url = reverse('analysis_manager.views.analysis_status', args=(analysis.uuid,)) return HttpResponse(redirect_url)
def repository_run(request): logger.debug( "analysis_manager.views.repository_run called") if request.method == 'POST': print( simplejson.dumps(request.POST, indent=4) ) # attributes associated with node selection from interface node_selection_blacklist_mode = request.POST['node_selection_blacklist_mode'] if node_selection_blacklist_mode == 'true': node_selection_blacklist_mode = True else: node_selection_blacklist_mode = False node_selection = request.POST.getlist('node_selection[]') # solr results solr_query = request.POST["query"] solr_uuids = get_solr_results(solr_query, only_uuids=True, selected_mode=node_selection_blacklist_mode, selected_nodes=node_selection) # gets workflow_uuid workflow_uuid = request.POST['workflow_choice'] # get study uuid study_uuid = request.POST['study_uuid'] # retrieving workflow based on input workflow_uuid curr_workflow = Workflow.objects.filter(uuid=workflow_uuid)[0] # TODO: catch if study or data set don't exist study = Study.objects.get( uuid=study_uuid ); data_set = InvestigationLink.objects.filter( investigation__uuid=study.investigation.uuid ).order_by( "version" ).reverse()[0].data_set; logger.info( "Associating analysis with data set %s (%s)" % ( data_set, data_set.uuid ) ) ######### ANALYSIS MODEL ######## # How to create a simple analysis object temp_name = curr_workflow.name + " " + datetime.now().strftime("%Y-%m-%d @ %H:%M:%S") summary_name = "None provided." analysis = Analysis( summary=summary_name, name=temp_name, project=request.user.get_profile().catch_all_project, data_set=data_set, workflow=curr_workflow, time_start=datetime.now() ) analysis.save() #setting the owner analysis.set_owner(request.user) # gets galaxy internal id for specified workflow workflow_galaxy_id = curr_workflow.internal_id # getting distinct workflow inputs workflow_data_inputs = curr_workflow.data_inputs.all()[0] # NEED TO GET LIST OF FILE_UUIDS from solr query count = 0; for file_uuid in solr_uuids: count += 1 temp_input = WorkflowDataInputMap( workflow_data_input_name=workflow_data_inputs.name, data_uuid=file_uuid, pair_id=count) temp_input.save() analysis.workflow_data_input_maps.add( temp_input ) analysis.save() # keeping new reference to analysis_status analysis_status = AnalysisStatus.objects.create(analysis=analysis) analysis_status.save() # call function via analysis_manager run_analysis.delay(analysis) #import pdb; pdb.set_trace() logger.debug(request.build_absolute_uri(reverse('analysis_manager.views.analysis_status', args=(analysis.uuid,)) )) ret_url = request.build_absolute_uri(reverse('analysis_manager.views.analysis_status', args=(analysis.uuid,)) ) return HttpResponse(simplejson.dumps(ret_url), mimetype='application/json')
def run(request): """Run analysis, return URL of the analysis status page Needs re-factoring """ logger.debug("Received request to start analysis") if not request.is_ajax(): return HttpResponseBadRequest() # 400 allowed_methods = ['POST'] if request.method not in allowed_methods: return HttpResponseNotAllowed(allowed_methods) # 405 analysis_config = json.loads(request.body) try: workflow_uuid = analysis_config['workflowUuid'] study_uuid = analysis_config['studyUuid'] node_set_uuid = analysis_config['nodeSetUuid'] node_group_uuid = analysis_config['nodeGroupUuid'] node_relationship_uuid = analysis_config['nodeRelationshipUuid'] custom_name = analysis_config['name'] except KeyError: return HttpResponseBadRequest() # 400 # must provide workflow and study UUIDs, # and either node set UUID or node relationship UUID if not (workflow_uuid and study_uuid and (node_set_uuid or node_relationship_uuid or node_group_uuid)): return HttpResponseBadRequest() # 400 # single-input workflow based node group if node_group_uuid: try: curr_node_group = NodeGroup.objects.get(uuid=node_group_uuid) except NodeGroup.DoesNotExist: logger.error("Node Group with UUID '{}' does not exist".format( node_group_uuid)) return HttpResponse(status='404') except NodeGroup.MultipleObjectsReturned: logger.error("Node Group with UUID '{}' returned multiple " "objects".format(node_group_uuid)) return HttpResponse(status='500') try: curr_workflow = Workflow.objects.get(uuid=workflow_uuid) except Workflow.DoesNotExist: logger.error("WorkFlow with UUID '{}' does not exist".format( workflow_uuid)) return HttpResponse(status='404') except Workflow.MultipleObjectsReturned: logger.error("WorkFlow with UUID '{}' returns multiple objects" .format(workflow_uuid)) return HttpResponse(status='500') try: study = Study.objects.get(uuid=study_uuid) except Study.DoesNotExist: logger.error("Study with UUID '{}' does not exist".format( study_uuid)) return HttpResponse(status='404') except Study.MultipleObjectsReturned: logger.error("Study with UUID '{}' returns multiple objects" .format(study_uuid)) return HttpResponse(status='500') investigation_links = InvestigationLink.objects.filter( investigation__uuid=study.investigation.uuid).order_by( "version") if not investigation_links: logger.error("InvestigationLink with UUID '{}' with does not " "exist".format(study.investigation.uuid)) return HttpResponse(status='404') data_set = investigation_links.reverse()[0].data_set logger.info("Associating analysis with data set %s (%s)", data_set, data_set.uuid) # ANALYSIS MODEL # How to create a simple analysis object if not custom_name: temp_name = curr_workflow.name + " " + get_aware_local_time()\ .strftime("%Y-%m-%d @ %H:%M:%S") else: temp_name = custom_name summary_name = "None provided." analysis = Analysis.objects.create( summary=summary_name, name=temp_name, project=request.user.get_profile().catch_all_project, data_set=data_set, workflow=curr_workflow, time_start=timezone.now() ) analysis.set_owner(request.user) # getting distinct workflow inputs try: workflow_data_inputs = curr_workflow.data_inputs.all()[0] except IndexError: logger.error("Workflow with UUID '{}' has an index " "error with inputs".format(workflow_uuid.uuid)) return HttpResponse(status='500') # NEED TO GET LIST OF FILE_UUIDS from node_group_uuid fields count = 0 for node_file in curr_node_group.nodes.all(): count += 1 temp_input = WorkflowDataInputMap.objects.create( workflow_data_input_name=workflow_data_inputs.name, data_uuid=node_file.uuid, pair_id=count ) analysis.workflow_data_input_maps.add(temp_input) analysis.save() # single-input workflow if node_set_uuid: # TODO: handle DoesNotExist exception curr_node_set = NodeSet.objects.get(uuid=node_set_uuid) curr_node_dict = curr_node_set.solr_query_components curr_node_dict = json.loads(curr_node_dict) # solr results solr_uuids = get_solr_results( curr_node_set.solr_query, only_uuids=True, selected_mode=curr_node_dict['documentSelectionBlacklistMode'], selected_nodes=curr_node_dict['documentSelection'] ) # retrieving workflow based on input workflow_uuid # TODO: handle DoesNotExist exception curr_workflow = Workflow.objects.filter(uuid=workflow_uuid)[0] # TODO: catch if study or data set don't exist study = Study.objects.get(uuid=study_uuid) data_set = InvestigationLink.objects.filter( investigation__uuid=study.investigation.uuid).order_by( "version").reverse()[0].data_set logger.info("Associating analysis with data set %s (%s)", data_set, data_set.uuid) # ANALYSIS MODEL # How to create a simple analysis object if not custom_name: temp_name = curr_workflow.name + " " + get_aware_local_time()\ .strftime("%Y-%m-%d @ %H:%M:%S") else: temp_name = custom_name summary_name = "None provided." analysis = Analysis.objects.create( summary=summary_name, name=temp_name, project=request.user.get_profile().catch_all_project, data_set=data_set, workflow=curr_workflow, time_start=timezone.now() ) analysis.set_owner(request.user) # getting distinct workflow inputs workflow_data_inputs = curr_workflow.data_inputs.all()[0] # NEED TO GET LIST OF FILE_UUIDS from solr query count = 0 for file_uuid in solr_uuids: count += 1 temp_input = WorkflowDataInputMap.objects.create( workflow_data_input_name=workflow_data_inputs.name, data_uuid=file_uuid, pair_id=count ) analysis.workflow_data_input_maps.add(temp_input) analysis.save() # dual-input workflow if node_relationship_uuid: # Input list for running analysis ret_list = [] # retrieving workflow based on input workflow_uuid curr_workflow = Workflow.objects.get(uuid=workflow_uuid) # TODO: catch if study or data set don't exist study = Study.objects.get(uuid=study_uuid) data_set = InvestigationLink.objects.filter( investigation__uuid=study.investigation.uuid).order_by( "version").reverse()[0].data_set # Get node relationship model curr_relationship = NodeRelationship.objects.get( uuid=node_relationship_uuid) # Iterating over node pairs input_keys = [] base_input = {} # defining inputs used for analysis for workflow_inputs in curr_workflow.input_relationships.all(): base_input[workflow_inputs.set1] = {} base_input[workflow_inputs.set2] = {} input_keys.append(workflow_inputs.set1) input_keys.append(workflow_inputs.set2) # creating instance of instance of input data pairing for analysis, # i.e. [{u'exp_file': # {'node_uuid': u'3d061699-6bc8-11e2-9b55-406c8f1d5108', 'pair_id': 1}, # u'input_file': # {'node_uuid': u'3d180d11-6bc8-11e2-9bc7-406c8f1d5108', 'pair_id': 1}} # ] count = 1 for curr_pair in curr_relationship.node_pairs.all(): temp_pair = copy.deepcopy(base_input) logger.debug("Temp Pair: %s", temp_pair) logger.debug("Current Pair: %s", curr_pair) if curr_pair.node2: temp_pair[input_keys[0]]['node_uuid'] = curr_pair.node1.uuid temp_pair[input_keys[0]]['pair_id'] = count temp_pair[input_keys[1]]['node_uuid'] = curr_pair.node2.uuid temp_pair[input_keys[1]]['pair_id'] = count ret_list.append(temp_pair) logger.debug("Temp Pair: %s", temp_pair) count += 1 logger.info("Associating analysis with data set %s (%s)", data_set, data_set.uuid) # ANALYSIS MODEL # How to create a simple analysis object if not custom_name: temp_name = curr_workflow.name + " " + get_aware_local_time()\ .strftime("%Y-%m-%d @ %H:%M:%S") else: temp_name = custom_name summary_name = "None provided." analysis = Analysis.objects.create( summary=summary_name, name=temp_name, project=request.user.get_profile().catch_all_project, data_set=data_set, workflow=curr_workflow, time_start=timezone.now() ) analysis.set_owner(request.user) # getting distinct workflow inputs workflow_data_inputs = curr_workflow.data_inputs.all() logger.debug("ret_list") logger.debug(json.dumps(ret_list, indent=4)) # ANALYSIS MODEL # Updating Refinery Models for updated workflow input # (galaxy worfkflow input id & node_uuid) count = 0 for samp in ret_list: count += 1 for k, v in samp.items(): temp_input = WorkflowDataInputMap.objects.create( workflow_data_input_name=k, data_uuid=samp[k]["node_uuid"], pair_id=count) analysis.workflow_data_input_maps.add(temp_input) analysis.save() # keeping new reference to analysis_status analysis_status = AnalysisStatus.objects.create(analysis=analysis) analysis_status.save() # call function via analysis_manager run_analysis.delay(analysis.uuid) return HttpResponse(reverse('analysis-status', args=(analysis.uuid,)))