Beispiel #1
0
    def setUp(self):
        """
        Este metodo se encarga de preparar los datos para las pruebas
        """
        # Create namespace
        name = NameSpace(namespace="Test",
                         url="http://test.com/",
                         short_name="test")
        name.save()

        # Create two entities
        ent1 = Entidad(nombre="father",
                       namespace=name,
                       descripcion="descripcion de un elemento de prueba 1",
                       etiqueta="etiqueta de prueba 1")
        ent1.save()

        ent2 = Entidad(nombre="son",
                       namespace=name,
                       descripcion="descripcion de un elemento de prueba 2",
                       etiqueta="etiqueta de prueba 2")
        ent2.save()

        # Create some properties
        prop1 = Propiedad(nombre="proptest1",
                          simple=True,
                          descripcion="desc test 1",
                          etiqueta="prop test 1",
                          namespace=name)

        prop1.save()
        prop1.entidades.add(ent1)

        prop2 = Propiedad(nombre="proptest2",
                          simple=True,
                          descripcion="desc test 2",
                          etiqueta="prop test 2",
                          namespace=name)

        prop2.save()
        prop2.entidades.add(ent1)

        prop3 = Propiedad(nombre="proptest3",
                          simple=True,
                          descripcion="desc test 3",
                          etiqueta="prop test 3",
                          namespace=name)
        prop3.save()
        prop3.entidades.add(ent2)
        prop3.tipo.add(ent2)
        prop3.save()

        mod = Modelo(nombre="Propiedad", aplicacion="easydata",
                     visibilidad='V', entidad=ent2)
        mod.save()

        atri = Atributo(nombre="nombre", modelo=mod, visibilidad='V',
                        propiedad=prop3, tipo_field="CharField")
        atri.save()
Beispiel #2
0
    def handle(self, *args, **options):
        modelos = list()
        if len(args) != 0:
            #Load only the models of the specified app
            try:
                aplicacion = get_app(app_label=args[0])
                modelos = get_models(aplicacion)
            except ImproperlyConfigured:
                print "The application doesn't exist"
        else:
            aplicaciones = get_apps()

            #Load the models of the apps except of EasyData app
            for app in aplicaciones:
                if not app.__name__.startswith('easydata.'):
                    modelos += get_models(app)

        #Iterate over the models
        for mod in modelos:
            modelo_instance = Modelo(nombre=mod.__name__,
                                     aplicacion=mod._meta.app_label)

            #Save the model instance
            try:
                modelo_instance.save()
            except IntegrityError:
                print "El modelo %s ya esta incluido y no se \
salva" % mod.__name__

        #Delete the models and fields that don't exist on the project
        self.elimina_modelos()
        self.elimina_fields()

        #Iterate one more time over the models, to add the fields
        for mod in modelos:
            modelo_instance = Modelo.objects.all()
            modelo_instance = modelo_instance.filter(nombre=mod.__name__)
            modelo_instance = modelo_instance.filter(
                              aplicacion=mod._meta.app_label).get()

            #Load the fiel list
            lista_fields = mod._meta.fields

            # Store the many relations if not are stored
            for many in mod._meta.many_to_many:
                if not many in lista_fields:
                    lista_fields.append(many)

            fields_texto = list()

            for atributo in lista_fields:
                #Case: Relation
                if not getattr(atributo, 'related', None) is None:
                    #Take the related model
                    mod_class = atributo.rel.to

                    #Search this model
                    try:
                        mod_rel = Modelo.objects.all()
                        mod_rel = mod_rel.filter(nombre=mod_class.__name__)
                        mod_rel = mod_rel.filter(
                                  aplicacion=mod_class._meta.app_label)
                        mod_rel = mod_rel.get()
                    except Modelo.DoesNotExist:
                        mod_rel = Modelo(nombre=mod_class.__name__,
                                         aplicacion=mod_class._meta.app_label)

                        #Save the model instance
                        try:
                            mod_rel.save()
                            mod_class_rel = get_model(
                                            model_name=mod_class.__name__,
                                            app_label=mod_class._meta
                                            .app_label)
                            modelos.append(mod_class_rel)
                        except IntegrityError:
                            print "El modelo %s ya esta incluido y no se \
salva" % mod_class.__name__

                    #Get the relation type
                    tipo_relacion = self.get_relation_type(atributo.__class__)

                    #Si se encuentra el tipo de relacion, continuamos
                    if not tipo_relacion is None:
                        #Relation in one direction
                        field_instance = Relacion(nombre=atributo.name,
                                                  modelo=modelo_instance,
                                                  tipo_relacion=tipo_relacion,
                                                  modelo_relacionado=mod_rel)

                        #Save the field
                        try:
                            field_instance.save()
                        except IntegrityError:
                            print "El field %s del modelo %s ya existe y no se\
 salva" % (atributo.name, modelo_instance)

                            #Get the relation to update
                            field_instance = Relacion.objects.all()
                            field_instance = field_instance.filter(
                                             nombre=atributo.name)
                            field_instance = field_instance.filter(
                                             modelo=modelo_instance)

                            if field_instance.count() == 1:
                                field_instance = field_instance.get()

                                #Update the relation
                                field_instance.tipo_relacion = tipo_relacion
                                field_instance.modelo_relacionado = mod_rel
                                field_instance.save()

                            else:
                                field_instance = Relacion.objects.all()
                                field_instance = field_instance.filter(
                                                 nombre=atributo.name)
                                field_instance = field_instance.filter(
                                                 modelo=modelo_instance)

                                if field_instance.count() == 1:
                                    field_instance.delete()

                                    field_instance = Relacion(
                                                   nombre=atributo.name,
                                                   modelo=modelo_instance,
                                                   tipo_relacion=tipo_relacion,
                                                   modelo_relacionado=mod_rel)
                                    field_instance.save()

                        if tipo_relacion == "FO":
                            tipo_relacion = "OF"

                        #If doesn't have accessor name
                        #I can't access in the other direction
                        if not atributo.related.get_accessor_name() is None \
                           and mod == atributo.model:
                            #In the other direction
                            field_instance_related = Relacion(
                                            nombre=atributo.related
                                            .get_accessor_name(),
                                            modelo=mod_rel,
                                            tipo_relacion=tipo_relacion,
                                            inversa=field_instance,
                                            modelo_relacionado=modelo_instance)

                            #Save the field
                            try:
                                field_instance_related.save()
                            except IntegrityError:
                                print "El field %s del modelo %s ya existe y \
no se salva" % (atributo.related.get_accessor_name(), mod_rel.nombre)

                                #Get the relation to update
                                field_instance = Relacion.objects.all()
                                field_instance = field_instance.filter(
                                                 nombre=atributo.related
                                                 .get_accessor_name())
                                field_instance = field_instance.filter(
                                                  modelo=mod_rel)

                                if field_instance.count() == 1:
                                    field_instance = field_instance.get()

                                    #Update the relation
                                    field_instance.tipo_relacion = \
                                                                tipo_relacion
                                    field_instance.modelo_relacionado = \
                                                                modelo_instance
                                    field_instance.save()
                                else:
                                    field_instance = Atributo.objects.all()
                                    field_instance = field_instance.filter(
                                   nombre=atributo.related.get_accessor_name())
                                    field_instance = field_instance.filter(
                                                     modelo=mod_rel)

                                    if field_instance.count() == 1:
                                        field_instance.delete()

                                        field_instance_related = Relacion(
                                   nombre=atributo.related.get_accessor_name(),
                                   modelo=mod_rel,
                                   tipo_relacion=tipo_relacion,
                                   modelo_relacionado=modelo_instance)
                                        field_instance_related.save()

                else:  # Case: normal field
                    field_instance = Atributo(
                                     nombre=atributo.name,
                                     modelo=modelo_instance,
                                     tipo_field=atributo.__class__.__name__)

                    #Save the field
                    try:
                        field_instance.save()
                    except IntegrityError:
                        print "El field %s del modelo %s ya existe y no se \
salva" % (atributo.name, modelo_instance)

                        field_instance = Atributo.objects.all()
                        field_instance = field_instance.filter(
                                         nombre=atributo.name)
                        field_instance = field_instance.filter(
                                          modelo=modelo_instance)

                        if field_instance.count() == 1:
                            field_instance = field_instance.get()

                            #If exists, update the fields
                            field_instance.tipo_field = \
                                                    atributo.__class__.__name__
                            field_instance.save()
                        else:
                            field_instance = Relacion.objects.all()
                            field_instance = field_instance.filter(
                                             nombre=atributo.name)
                            field_instance = field_instance.filter(
                                             modelo=modelo_instance)

                            if field_instance.count() == 1:
                                field_instance.delete()

                                field_instance = Atributo(
                                                 nombre=atributo.name,
                                                 modelo=modelo_instance,
                                                 tipo_field=atributo.__class__
                                                 .__name__)
                                field_instance.save()

                #Add the field to the list
                fields_texto.append(atributo.name)

        print ">> The load has finished succesfully <<"
Beispiel #3
0
    def setUp(self):
        """
        Este metodo se encarga de preparar los datos para las pruebas
        """
        # Create namespace
        name = NameSpace(namespace="Test",
                         url="http://test.com/",
                         short_name="test")
        name.save()

        # Create two entities
        ent1 = Entidad(nombre="father",
                      namespace=name,
                      descripcion="descripcion de un elemento de prueba 1",
                      etiqueta="etiqueta de prueba 1")
        ent1.save()

        ent2 = Entidad(nombre="son",
                      namespace=name,
                      descripcion="descripcion de un elemento de prueba 2",
                      etiqueta="etiqueta de prueba 2")
        ent2.save()

        # Create some properties
        prop1 = Propiedad(nombre="proptest1",
                         simple=True,
                         descripcion="desc test 1",
                         etiqueta="prop test 1",
                         namespace=name)

        prop1.save()
        prop1.entidades.add(ent1)

        prop2 = Propiedad(nombre="proptest2",
                         simple=True,
                         descripcion="desc test 2",
                         etiqueta="prop test 2",
                         namespace=name)

        prop2.save()
        prop2.entidades.add(ent1)

        prop3 = Propiedad(nombre="proptest3",
                         simple=True,
                         descripcion="desc test 3",
                         etiqueta="prop test 3",
                         namespace=name)
        prop3.save()
        prop3.entidades.add(ent2)
        prop3.tipo.add(ent2)
        prop3.save()

        mod1 = Modelo(nombre="Propiedad", aplicacion="easydata",
                     visibilidad='V', entidad=ent2)

        mod2 = Modelo(nombre="Entidad", aplicacion="easydata",
                     visibilidad='V', entidad=ent2)

        mod1.save()
        mod2.save()

        rel1 = Relacion(nombre="entidades", modelo=mod1,
                        modelo_relacionado=mod2, visibilidad="V",
                        tipo_relacion="M")
        rel2 = Relacion(nombre="propiedades", modelo=mod2,
                        modelo_relacionado=mod1, visibilidad="V",
                        tipo_relacion="M")

        rel1.save()
        rel2.save()