def generate_unique_items(component=str(), profile_id=str(), elem_id=str(), record_id=str(), **kwargs): da_object = DAComponent(component=component, profile_id=profile_id) action_type = kwargs.get("action_type", str()) component_records = list() all_records = da_object.get_all_records() if action_type == "cloning": component_records = [x[elem_id] for x in all_records if elem_id in x] else: component_records = [x[elem_id] for x in all_records if elem_id in x and not str(x["_id"]) == record_id] return component_records
def generate_component_records(component=str(), profile_id=str()): da_object = DAComponent(component=component, profile_id=profile_id) component_records = list() for record in da_object.get_all_records(): rec_dict = dict(_id=str(record["_id"])) for f in da_object.get_schema().get("schema_dict"): if f.get("show_in_form", True): key_split = f["id"].split(".")[-1] rec_dict[key_split] = record.get(key_split, d_utils.default_jsontype(f.get("type", str()))) component_records.append(rec_dict) return component_records
def generate_component_records(component=str(), profile_id=str(), label_key=str(), **kwargs): da_object = DAComponent(component=component, profile_id=profile_id) if component in da_dict: da_object = da_dict[component](profile_id) component_records = list() schema = da_object.get_component_schema(**kwargs) # if label_key is not provided, we will assume the first element in the schema to be the label_key if not label_key: label_key = schema[0]["id"].split(".")[-1] if schema else '' for record in da_object.get_all_records(**kwargs): option = dict(value=str(record["_id"]), label=record.get(label_key, "N/A")) component_records.append(option) return component_records
class BrokerDA: def __init__(self, **kwargs): self.param_dict = kwargs self.context = self.param_dict.get("context", dict()) self.component = self.param_dict.get("component", str()) self.visualize = self.param_dict.get("visualize", str()) self.profile_id = self.param_dict.get("profile_id", str()) self.auto_fields = self.param_dict.get("auto_fields", dict()) if self.auto_fields and isinstance(self.auto_fields, str): self.auto_fields = json.loads(self.auto_fields) self.broker_visuals = BrokerVisuals(**kwargs) self.da_object = DAComponent(self.profile_id, self.component) da_dict = dict(publication=Publication, person=Person, sample=Sample, source=Source, profile=Profile, datafile=DataFile, submission=Submission, annotation=Annotation, cgcore=CGCore, metadata_template=MetadataTemplate) if self.component in da_dict: self.da_object = da_dict[self.component](self.profile_id) def set_extra_params(self, extra_param): for k, v in extra_param.items(): self.param_dict[k] = v def do_form_control_schemas(self): """ function returns object type control schemas used in building form controls :return: """ copo_schemas = dict() for k, v in d_utils.object_type_control_map().items(): copo_schemas[k] = d_utils.get_copo_schema(v) self.context["copo_schemas"] = copo_schemas return self.context def do_save_edit(self): kwargs = dict() kwargs["target_id"] = self.param_dict.get("target_id", str()) # set report parameter status = "success" # 'success', 'warning', 'info', 'danger' - modelled after bootstrap alert classes action_type = "add" report_metadata = dict() if self.param_dict.get("target_id", str()): action_type = "edit" record_object = self.da_object.save_record(self.auto_fields, **kwargs) if not record_object: status = "danger" if action_type == "add": report_metadata[ "message"] = "New " + self.component + " record created!" if status != "success": report_metadata[ "message"] = "There was a problem creating the " + self.component + " record!" elif action_type == "edit": report_metadata["message"] = "Record updated!" if status != "success": report_metadata[ "message"] = "There was a problem updating the " + self.component + " record!" report_metadata["status"] = status self.context["action_feedback"] = report_metadata # process visualisation context, # set extra parameters which will be passed along to the visualize object self.broker_visuals.set_extra_params( dict(record_object=record_object, data_source=self.param_dict.get("data_source", str()))) # build dictionary of executable tasks/functions visualize_dict = dict( profiles_counts=self.broker_visuals.do_profiles_counts, created_component_json=self.broker_visuals. get_created_component_json, last_record=self.broker_visuals.get_last_record, get_profile_count=self.broker_visuals.get_profile_count) if self.visualize in visualize_dict: self.context = visualize_dict[self.visualize]() elif self.param_dict.get("target_id", str()): self.context = self.broker_visuals.do_table_data() else: self.context = self.broker_visuals.do_row_data() return self.context def do_delete(self): target_ids = [ObjectId(i) for i in self.param_dict.get("target_ids")] # if ever it was needed to re-implement 'soft' delete uncomment the following lines and # comment out the 'hard' delete query # soft delete # self.da_object.get_collection_handle().update_many( # {"_id": {"$in": target_ids}}, {"$set": {"deleted": d_utils.get_deleted_flag()}} # ) # hard delete self.da_object.get_collection_handle().remove( {'_id': { '$in': target_ids }}) self.context = self.broker_visuals.do_table_data() return self.context def do_form(self): target_id = self.param_dict.get("target_id") component_dict = self.param_dict.get("component_dict", dict()) message_dict = self.param_dict.get("message_dict", dict()) kwargs = dict() kwargs["referenced_field"] = self.param_dict.get( "referenced_field", str()) kwargs["referenced_type"] = self.param_dict.get( "referenced_type", str()) self.context["form"] = htags.generate_copo_form( self.component, target_id, component_dict, message_dict, self.profile_id, **kwargs) self.context["form"]["visualize"] = self.param_dict.get("visualize") return self.context def do_form_and_component_records(self): # generates form, and in addition returns records of the form component, this could, for instance, be # used for cloning of a record kwargs = dict() kwargs["referenced_field"] = self.param_dict.get( "referenced_field", str()) kwargs["referenced_type"] = self.param_dict.get( "referenced_type", str()) self.context = self.do_form() self.context["component_records"] = htags.generate_component_records( self.component, self.profile_id, **kwargs) return self.context def do_doi(self): id_handle = self.param_dict.get("id_handle") id_type = self.param_dict.get("id_type") doi_resolve = DOI2Metadata(id_handle, id_type).get_resolve(self.component) self.set_extra_params( dict(target_id=str(), component_dict=doi_resolve.get("component_dict", dict()), message_dict=doi_resolve.get("message_dict", dict()))) return self.do_form() def do_initiate_submission(self): kwarg = dict(datafile_ids=self.param_dict.get("datafile_ids", list())) self.context["submission_token"] = str( self.da_object.save_record(dict(), **kwarg).get("_id", str())) return self.context def do_user_email(self): user_id = self.param_dict.get("user_id", str()) user_email = self.param_dict.get("user_email", str()) user = User.objects.get(pk=int(user_id)) user.email = user_email user.save() return self.context def do_component_record(self): self.context["component_record"] = self.da_object.get_record( self.param_dict.get("target_id")) return self.context def component_form_record(self): target_id = self.param_dict.get("target_id") component_dict = self.param_dict.get("component_dict", dict()) message_dict = self.param_dict.get("message_dict", dict()) kwargs = dict() kwargs["referenced_field"] = self.param_dict.get( "referenced_field", str()) kwargs["referenced_type"] = self.param_dict.get( "referenced_type", str()) kwargs["action_type"] = self.param_dict.get("action_type", str()) form_value = htags.generate_copo_form(self.component, target_id, component_dict, message_dict, self.profile_id, **kwargs) self.context["component_record"] = form_value["form_value"] self.context["component_schema"] = form_value["form_schema"] return self.context def do_sanitise_submissions(self): records = self.da_object.get_all_records() for submission in records: if "bundle_meta" not in submission: bundle_meta = list() for file_id in submission.get("bundle", list()): datafile = DataFile().get_record(file_id) if datafile: upload_status = False if str(submission.get("complete", False)).lower() == 'true': upload_status = True bundle_meta.append( dict(file_id=file_id, file_path=datafile.get( "file_location", str()), upload_status=upload_status)) submission["bundle_meta"] = bundle_meta submission['target_id'] = str(submission.pop('_id')) self.da_object.save_record(dict(), **submission) self.context["sanitise_status"] = True return self.context def do_clone_description_bundle(self): """ function creates a new description by cloning an existing (specified) bundle :return: """ target_id = self.param_dict.get("target_id", str()) bundle_name = self.param_dict.get("bundle_name", str()) result = dict(status="success", message="") if Description().get_description_handle().find({ "name": { '$regex': "^" + bundle_name + "$", "$options": 'i' } }).count() >= 1: result["status"] = "error" result["message"] = "Bundle name must be unique" self.context["result"] = result return self.context # retrieve clone target description = Description().GET(target_id) # new bundle being created try: bundle = Description().create_description( profile_id=self.profile_id, component=self.component, name=bundle_name, stages=description.get('stages', list()), attributes=description.get('attributes', dict()), meta=description.get('meta', dict())) result["data"] = dict(id=str(bundle["_id"]), name=bundle["name"]) except Exception as e: message = "Couldn't create bundle: " + bundle_name + " " + str(e) result["status"] = "error" result["message"] = message self.context["result"] = result return self.context def create_rename_description_bundle(self): """ function creates a new description bundle or renames an existing one :return: """ target_id = self.param_dict.get("target_id", str()) bundle_name = self.param_dict.get("bundle_name", str()) result = dict(status="success", message="") if Description().get_description_handle().find({ "name": { '$regex': "^" + bundle_name + "$", "$options": 'i' } }).count() >= 1: result["status"] = "error" result["message"] = "Bundle name must be unique" elif target_id: # updating existing bundle Description().edit_description(target_id, {"name": bundle_name}) try: Description().edit_description(target_id, {"name": bundle_name}) except Exception as e: message = "Couldn't update bundle: " + bundle_name + " " + str( e) result["status"] = "error" result["message"] = message else: # new bundle being created try: bundle = Description().create_description( profile_id=self.profile_id, component=self.component, name=bundle_name) result["data"] = dict(id=str(bundle["_id"]), name=bundle["name"]) except Exception as e: message = "Couldn't create bundle: " + bundle_name + " " + str( e) result["status"] = "error" result["message"] = message self.context["result"] = result return self.context
def generate_copo_table_data(profile_id=str(), component=str()): # This method generates the 'json' for building an UI table # instantiate data access object da_object = DAComponent(profile_id, component) # get records records = da_object.get_all_records() columns = list() dataSet = list() displayable_fields = list() # headers for f in da_object.get_schema().get("schema_dict"): if f.get("show_in_table", True): displayable_fields.append(f) columns.append(dict(title=f["label"])) columns.append(dict(title=str())) # extra 'blank' header for record actions column # data for rec in records: row = list() for df in displayable_fields: row.append(resolve_control_output(rec, df)) row.append(str(rec["_id"])) # last element in a row exposes the id of the record dataSet.append(row) # define action buttons button_templates = d_utils.get_button_templates() common_btn_dict = dict(row_btns=[button_templates['edit_row'], button_templates['delete_row']], global_btns=[button_templates['delete_global']]) sample_info = copy.deepcopy(button_templates['info_row']) sample_info["text"] = "Sample Attributes" buttons_dict = dict(publication=common_btn_dict, person=common_btn_dict, sample=dict(row_btns=[sample_info, button_templates['edit_row'], button_templates['delete_row']], global_btns=[button_templates['add_new_samples_global'], button_templates['delete_global']]), source=common_btn_dict, profile=common_btn_dict, annotation=common_btn_dict, metadata_template=common_btn_dict, datafile=dict( row_btns=[button_templates['info_row'], button_templates['describe_row'], button_templates['delete_row']], global_btns=[button_templates['describe_global'], button_templates['undescribe_global']]) ) action_buttons = dict(row_btns=buttons_dict.get(component).get("row_btns"), global_btns=buttons_dict.get(component).get("global_btns") ) return_dict = dict(columns=columns, dataSet=dataSet, table_id=table_id_dict.get(component, str()), action_buttons=action_buttons ) return return_dict
def generate_copo_table_data(profile_id=str(), component=str()): # This method generates the 'json' for building an UI table # instantiate data access object da_object = DAComponent(profile_id, component) # get records records = da_object.get_all_records() columns = list() dataSet = list() # headers for f in da_object.get_schema().get("schema_dict"): if f.get("show_in_table", True): columns.append(dict(title=f["label"])) columns.append(dict(title=str())) # extra 'blank' header for record actions column # data for rec in records: row = list() for f in da_object.get_schema().get("schema_dict"): if f.get("show_in_table", True): row.append(resolve_control_output(rec, f)) row.append(str(rec["_id"])) # last element in a row exposes the id of the record dataSet.append(row) # define action buttons button_templates = d_utils.get_button_templates() common_btn_dict = dict(row_btns=[button_templates['edit_row'], button_templates['delete_row']], global_btns=[button_templates['delete_global']]) sample_info = copy.deepcopy(button_templates['info_row']) sample_info["text"] = "Sample Attributes" buttons_dict = dict(publication=common_btn_dict, person=common_btn_dict, sample=dict(row_btns=[sample_info, button_templates['edit_row'], button_templates['delete_row']], global_btns=[button_templates['add_new_samples_global'], button_templates['delete_global']]), source=common_btn_dict, profile=common_btn_dict, annotation=common_btn_dict, datafile=dict( row_btns=[button_templates['info_row'], button_templates['describe_row'], button_templates['delete_row']], global_btns=[button_templates['describe_global'], button_templates['undescribe_global']]) ) action_buttons = dict(row_btns=buttons_dict.get(component).get("row_btns"), global_btns=buttons_dict.get(component).get("global_btns") ) return_dict = dict(columns=columns, dataSet=dataSet, table_id=table_id_dict.get(component, str()), action_buttons=action_buttons ) return return_dict