コード例 #1
0
 def resolve_and_update(cls, org_uuid, data, **kwargs):
     print("first in resolve and update ==============================")
     print(data)
     print("===========================================================")
     resolver = Resolver(
         pid_type=ORGANIZATION_PID_TYPE,
         object_type=ORGANIZATION_TYPE,
         getter=cls.get_record,
     )
     try:
         persistent_identifier, org = resolver.resolve(str(org_uuid))
         if org:
             print("{0}={1} found".format(ORGANIZATION_PID_TYPE, org_uuid))
             org.update(data)
             # .update(data, dbcommit=dbcommit, reindex=reindex)
             return org, 'updated'
     except Exception:
         pass
     if IDENTIFIERS_FIELD in data:  #Si no lo encontro por el uudi igual se intenta buscar desde cualquier otri pid
         for schema in identifiers_schemas:
             for identifier in data[IDENTIFIERS_FIELD]:
                 if schema == identifier[IDENTIFIERS_FIELD_TYPE]:
                     # print("identifier ------    ", identifier)
                     resolver.pid_type = schema
                     try:
                         persistent_identifier, org = resolver.resolve(
                             str(identifier[IDENTIFIERS_FIELD_VALUE]))
                         print('<<<<<<<<<<<<<<<<<<')
                         print('Org= ', org)
                         if org:
                             print("{0}={1} found".format(
                                 schema,
                                 str(identifier[IDENTIFIERS_FIELD_VALUE])))
                             org.update(data)
                             print('>>>>>>>>>>>>>>>>>>>>')
                             print('org updated: ', org)
                             return org, 'updated'
                     except PIDDoesNotExistError as pidno:
                         print("PIDDoesNotExistError:  {0} == {1}".format(
                             schema,
                             str(identifier[IDENTIFIERS_FIELD_VALUE])))
                     except (PIDDeletedError, NoResultFound) as ex:
                         cls.__delete_pids_without_object(
                             data[IDENTIFIERS_FIELD])
                     except Exception as e:
                         print('-------------------------------')
                         # print(str(e))
                         print(traceback.format_exc())
                         print('-------------------------------')
                         pass
コード例 #2
0
    def get_org_by_pid(cls, pid_value, with_deleted=False):
        resolver = Resolver(
            pid_type=ORGANIZATION_PID_TYPE,
            object_type=ORGANIZATION_TYPE,
            getter=cls.get_record,
        )
        try:
            return resolver.resolve(str(pid_value))
        except Exception:
            pass

        for pid_type in identifiers_schemas:
            try:
                resolver.pid_type = pid_type
                schemapid, org = resolver.resolve(pid_value)
                pid = PersistentIdentifier.get(ORGANIZATION_PID_TYPE,
                                               org['id'])
                return pid, org
            except Exception as e:
                pass
        return None, None
コード例 #3
0
def get_lower_organizations():
    db.session.rollback()
    try:
        for item in lower_organizations.values():
            count = 0
            datadir = current_app.config['CUOR_DATA_DIRECTORY']
            entrada = pd.read_excel(os.path.join(datadir, item["path"]),
                                    item["sheet"])
            dpa_full_path = os.path.join(datadir, dpa_path)
            for archivo in entrada['COD']:
                las_siglas = []
                siglas = str(entrada['SIGLAS'][count])
                #print('siglas: ', str(siglas))
                if not siglas.isalnum():
                    siglas = siglas.replace("-", "").strip()
                    #print("cambio: ", siglas)
                if len(siglas) > 0:
                    las_siglas.append(siglas)

                data = {
                    "name":
                    entrada['DESCC'][count],
                    "acronyms":
                    las_siglas,
                    "status":
                    "active",
                    "labels": [{
                        "label": entrada['DESCC'][count],
                        "iso639": "es",
                    }]
                }

                date_str = entrada['ALTA'][
                    count]  # puede ser d/m/A o puede ser Amd
                datetime_obj = None

                if isinstance(date_str, datetime.datetime):
                    datetime_obj = date_str
                else:
                    try:
                        format_str1 = '%d/%m/%Y'  # The format
                        format_str2 = '%Y%m%d'  # The format
                        print(date_str)
                        datetime_obj = datetime.datetime.strptime(
                            date_str, format_str1)
                    except:
                        try:
                            datetime_obj = datetime.datetime.strptime(
                                date_str, format_str2)
                        except Exception as e:
                            print(str(e))

                if datetime_obj:
                    data['established'] = datetime_obj.date().year

                ids = []
                ids.append({
                    'idtype': item["id_type"],
                    'value': str(item["id_type"]) + '.' + str(archivo)
                })
                data['identifiers'] = ids

                #Falta el DPA, hay que revisar la tabla de transferencia para ver conversion de codigos
                #entrada['DPA'][count],

                cod_dpa = entrada['DPA'][count]
                cod_dpa = str(cod_dpa)
                prov = cod_dpa[0:2]
                addresses = []
                with open(dpa_full_path) as f:
                    dpa = json.load(f)
                    one_address = {}
                    if prov != '40':
                        one_address["city"] = dpa[prov]["municipalities"][
                            cod_dpa]
                    else:
                        one_address["city"] = dpa[prov]["name"]
                    one_address["country"] = "Cuba"
                    one_address["country_code"] = "CU"
                    one_address["primary"] = True
                    one_address["state"] = dpa[prov]["name"]
                    one_address["state_code"] = dpa[prov]["iso"]

                    addresses.append(one_address)

                data['addresses'] = addresses

                #para las relationships debe hacerse algo parecido al resolver, ver que es
                relationships = []
                organism = None
                union = None

                resolver = Resolver(
                    pid_type=top_organizations["organismos"]["id_type"],
                    object_type=ORGANIZATION_TYPE,
                    getter=OrganizationRecord.get_record,
                )
                try:
                    pid_organism = top_organizations["organismos"][
                        "id_type"] + "." + str(entrada['ORGA'][count])
                    pid_organism, organism = resolver.resolve(pid_organism)
                    if organism:
                        #print("pid: ", pid_organism)
                        #print("organismo: ", organism)
                        nrel = {}
                        nrel["label"] = organism["name"]
                        nrel["type"] = "parent"
                        nrel["identifiers"] = organism["identifiers"]
                        relationships.append(nrel)
                        #print("nrel:  ")
                        #print(nrel)
                        #print(relationships)
                except Exception as eo:
                    print(str(eo))

                try:
                    if str(entrada['UNI'][count]) != '999':
                        resolver.pid_type = top_organizations["uniones"][
                            "id_type"]
                        pid_union = top_organizations["uniones"][
                            "id_type"] + "." + str(entrada['UNI'][count])
                        pid_union, union = resolver.resolve(pid_union)
                        if union:
                            #print("pid: ", pid_union)
                            #print("union: ", union)
                            nrel = dict()
                            nrel['label'] = union['name']
                            nrel['type'] = 'parent'
                            nrel['identifiers'] = union["identifiers"]
                            relationships.append(nrel)
                            #print("nrel:  ")
                            #print(nrel)
                            #print(relationships)
                except Exception as eu:
                    print(str(eu))

                data['relationships'] = relationships
                count = count + 1
                #print(data)
                insert_in_cuor(data, {})

    except Exception as e:
        print("*********************")
        print("Error adding lower organizations")
        print(str(e))
        print(traceback.format_exc())
        print("*********************")