Example #1
0
    def detect_soft_applied(self, project_state, migration):
        """
        Tests whether a migration has been implicitly applied - that the
        tables or columns it would create exist. This is intended only for use
        on initial migrations (as it only looks for CreateModel and AddField).
        """
        if migration.initial is None:
            # Bail if the migration isn't the first one in its app
            if any(app == migration.app_label
                   for app, name in migration.dependencies):
                return False, project_state
        elif migration.initial is False:
            # Bail if it's NOT an initial migration
            return False, project_state

        if project_state is None:
            after_state = self.loader.project_state(
                (migration.app_label, migration.name), at_end=True)
        else:
            after_state = migration.mutate_state(project_state)
        apps = after_state.apps
        found_create_model_migration = False
        found_add_field_migration = False
        # Make sure all create model and add field operations are done
        for operation in migration.operations:
            if isinstance(operation, migrations.CreateModel):
                model = apps.get_model(migration.app_label, operation.name)
                if model._meta.swapped:
                    # We have to fetch the model to test with from the
                    # main app cache, as it's not a direct dependency.
                    model = global_apps.get_model(model._meta.swapped)
                if model._meta.proxy or not model._meta.managed:
                    continue
                if model._meta.db_table not in self.connection.introspection.table_names(
                        self.connection.cursor()):
                    return False, project_state
                found_create_model_migration = True
            elif isinstance(operation, migrations.AddField):
                model = apps.get_model(migration.app_label,
                                       operation.model_name)
                if model._meta.swapped:
                    # We have to fetch the model to test with from the
                    # main app cache, as it's not a direct dependency.
                    model = global_apps.get_model(model._meta.swapped)
                if model._meta.proxy or not model._meta.managed:
                    continue

                table = model._meta.db_table
                db_field = model._meta.get_field(operation.name).column
                fields = self.connection.introspection.get_table_description(
                    self.connection.cursor(), table)
                if db_field not in (f.name for f in fields):
                    return False, project_state
                found_add_field_migration = True
        # If we get this far and we found at least one CreateModel or AddField migration,
        # the migration is considered implicitly applied.
        return (found_create_model_migration
                or found_add_field_migration), after_state
Example #2
0
def get_relations(m1, m2):
    if isinstance(m1, string_types):
        m1 = apps.get_model(m1)
    if isinstance(m2, string_types):
        m2 = apps.get_model(m2)
    return [
        f for f in m1._meta.get_fields()
        if f.is_relation and f.related_model == m2
    ]
Example #3
0
    def detect_soft_applied(self, project_state, migration):
        """
        Tests whether a migration has been implicitly applied - that the
        tables or columns it would create exist. This is intended only for use
        on initial migrations (as it only looks for CreateModel and AddField).
        """
        if migration.initial is None:
            # Bail if the migration isn't the first one in its app
            if any(app == migration.app_label for app, name in migration.dependencies):
                return False, project_state
        elif migration.initial is False:
            # Bail if it's NOT an initial migration
            return False, project_state

        if project_state is None:
            after_state = self.loader.project_state((migration.app_label, migration.name), at_end=True)
        else:
            after_state = migration.mutate_state(project_state)
        apps = after_state.apps
        found_create_model_migration = False
        found_add_field_migration = False
        # Make sure all create model and add field operations are done
        for operation in migration.operations:
            if isinstance(operation, migrations.CreateModel):
                model = apps.get_model(migration.app_label, operation.name)
                if model._meta.swapped:
                    # We have to fetch the model to test with from the
                    # main app cache, as it's not a direct dependency.
                    model = global_apps.get_model(model._meta.swapped)
                if model._meta.proxy or not model._meta.managed:
                    continue
                if model._meta.db_table not in self.connection.introspection.table_names(self.connection.cursor()):
                    return False, project_state
                found_create_model_migration = True
            elif isinstance(operation, migrations.AddField):
                model = apps.get_model(migration.app_label, operation.model_name)
                if model._meta.swapped:
                    # We have to fetch the model to test with from the
                    # main app cache, as it's not a direct dependency.
                    model = global_apps.get_model(model._meta.swapped)
                if model._meta.proxy or not model._meta.managed:
                    continue

                table = model._meta.db_table
                db_field = model._meta.get_field(operation.name).column
                fields = self.connection.introspection.get_table_description(self.connection.cursor(), table)
                if db_field not in (f.name for f in fields):
                    return False, project_state
                found_add_field_migration = True
        # If we get this far and we found at least one CreateModel or AddField migration,
        # the migration is considered implicitly applied.
        return (found_create_model_migration or found_add_field_migration), after_state
Example #4
0
 def fillresponse(self, model='', objid=0):
     img = XferCompImage('img')
     img.set_value(self.icon_path())
     img.set_location(0, 0, 1, 6)
     self.add_component(img)
     self.model = apps.get_model(model)
     if objid != 0:
         self.item = self.model.objects.get(id=objid)
         fieldnames = []
         for fieldname in self.model.get_default_fields():
             if isinstance(fieldname, tuple):
                 fieldnames.append(fieldname[1])
             else:
                 fieldnames.append(fieldname)
         self.fill_from_model(1, 0, True, desc_fields=fieldnames)
         log_items = LucteriosLogEntry.objects.get_for_object(self.item)
     else:
         content_type = ContentType.objects.get_for_model(self.model)
         lbl = XferCompLabelForm('ModelName')
         lbl.set_value_as_header(six.text_type(content_type))
         lbl.description = _("content type")
         lbl.set_location(1, 0, 2)
         self.add_component(lbl)
         log_items = LucteriosLogEntry.objects.get_for_model(self.model)
     grid = XferCompGrid(self.field_id)
     grid.set_model(log_items, None, self)
     grid.set_location(1, self.get_max_row() + 1, 2)
     grid.set_size(200, 500)
     self.add_component(grid)
Example #5
0
 def detect_soft_applied(self, project_state, migration):
     """
     Tests whether a migration has been implicitly applied - that the
     tables it would create exist. This is intended only for use
     on initial migrations (as it only looks for CreateModel).
     """
     # Bail if the migration isn't the first one in its app
     if [name for app, name in migration.dependencies if app == migration.app_label]:
         return False, project_state
     if project_state is None:
         after_state = self.loader.project_state((migration.app_label, migration.name), at_end=True)
     else:
         after_state = migration.mutate_state(project_state)
     apps = after_state.apps
     found_create_migration = False
     # Make sure all create model are done
     for operation in migration.operations:
         if isinstance(operation, migrations.CreateModel):
             model = apps.get_model(migration.app_label, operation.name)
             if model._meta.swapped:
                 # We have to fetch the model to test with from the
                 # main app cache, as it's not a direct dependency.
                 model = global_apps.get_model(model._meta.swapped)
             if model._meta.db_table not in self.connection.introspection.table_names(self.connection.cursor()):
                 return False, project_state
             found_create_migration = True
     # If we get this far and we found at least one CreateModel migration,
     # the migration is considered implicitly applied.
     return found_create_migration, after_state
Example #6
0
    def run(self,
            module_name,
            class_name,
            trace,
            fields=None,
            extra_fields=None,
            exclude_fields=None,
            native=False,
            limits=(0, None)):
        model = apps.get_model(module_name, class_name)
        qs = model.objects.get_queryset()

        exclude_fields = list(exclude_fields or ())
        extra_fields = list(extra_fields or ())
        fields = list(fields or [])

        if extra_fields or exclude_fields or not fields:
            fields = self.get_fields(model)

        fields = [f for f in fields + extra_fields if f not in exclude_fields
                  ] or '__all__'

        qs = self.trace_queryset(qs, trace)
        if native:
            if isinstance(qs, QuerySet):
                return list(qs)
            return qs

        if tuple(limits) != (0, None):
            start, stop = limits
            qs = qs[slice(start, stop)]
        return self.serialize(qs,
                              model=model,
                              fields=fields,
                              extra_fields=extra_fields)
Example #7
0
def get_model_field_verbose_name_map(m):
    if isinstance(m, string_types):
        m = apps.get_model(m)
    r = {}
    for f in m._meta.get_fields():
        r[get_field_verbose_name(f)] = f
    return r
Example #8
0
 def detect_soft_applied(self, project_state, migration):
     """
     Tests whether a migration has been implicitly applied - that the
     tables it would create exist. This is intended only for use
     on initial migrations (as it only looks for CreateModel).
     """
     # Bail if the migration isn't the first one in its app
     if [
             name for app, name in migration.dependencies
             if app == migration.app_label
     ]:
         return False, project_state
     if project_state is None:
         after_state = self.loader.project_state(
             (migration.app_label, migration.name), at_end=True)
     else:
         after_state = migration.mutate_state(project_state)
     apps = after_state.apps
     found_create_migration = False
     # Make sure all create model are done
     for operation in migration.operations:
         if isinstance(operation, migrations.CreateModel):
             model = apps.get_model(migration.app_label, operation.name)
             if model._meta.swapped:
                 # We have to fetch the model to test with from the
                 # main app cache, as it's not a direct dependency.
                 model = global_apps.get_model(model._meta.swapped)
             if model._meta.db_table not in self.connection.introspection.table_names(
                     self.connection.cursor()):
                 return False, project_state
             found_create_migration = True
     # If we get this far and we found at least one CreateModel migration,
     # the migration is considered implicitly applied.
     return found_create_migration, after_state
Example #9
0
def get_subtitle():
    try:
        from django.apps.registry import apps
        legalentity = apps.get_model("contacts", "LegalEntity")
        our_detail = legalentity.objects.get(id=1)
        return our_detail.name
    except LookupError:
        return ugettext("Condominium application")
Example #10
0
 def fillresponse(self, modelname, field_id):
     if modelname is not None:
         self.model = apps.get_model(modelname)
     self.field_id = field_id
     XferListEditor.fillresponse(self)
     if WrapAction.is_permission(self.request, 'contacts.add_abstractcontact'):
         self.get_components(self.field_id).add_action(self.request, ObjectMerge.get_action(_("Merge"), "images/clone.png"),
                                                       close=CLOSE_NO, unique=SELECT_MULTI)
Example #11
0
 def fillresponse(self, modelname, field_id):
     if modelname is not None:
         self.model = apps.get_model(modelname)
     self.field_id = field_id
     XferListEditor.fillresponse(self)
     if WrapAction.is_permission(self.request, 'contacts.add_abstractcontact'):
         self.get_components(self.field_id).add_action(self.request, ObjectMerge.get_action(_("Merge"), "images/clone.png"),
                                                       close=CLOSE_NO, unique=SELECT_MULTI)
Example #12
0
def get_subtitle():
    try:
        from django.apps.registry import apps
        legalentity = apps.get_model("contacts", "LegalEntity")
        our_detail = legalentity.objects.get(id=1)
        return our_detail.name
    except LookupError:
        return ugettext("Condominium application")
Example #13
0
 def get_typeselection(cls):
     res = []
     for modelname in cls.objects.values_list('modelname',
                                              flat=True).distinct():
         model_item = apps.get_model(modelname)
         res.append(
             (modelname, six.text_type(model_item._meta.verbose_name)))
     return sorted(list(set(res)), key=lambda item: item[1])
Example #14
0
    def find(app_label, model_name):
        if not app_label:
            raise CommandError('Invalid app label "{}"'.format(app_label))

        if not model_name:
            raise CommandError('Invalid model name "{}"'.format(model_name))

        return apps.get_model(app_label, model_name)
Example #15
0
    def get(self, request, app, model):

        Model = apps.get_model(app, model)

        if self.has_export_permission(request.user, Model):
            return queryset_as_csv_response(Model.objects.all(),
                                            is_stream=True)
        else:
            raise PermissionDenied
Example #16
0
    def get_model(self, table_name):
        # Ensure the database connect and it's dummy app are registered
        self.register()
        model_name = table_name.lower().replace('_', '')

        # Is the model already registered with the dummy app?
        if model_name not in apps.all_models[self.label]:
            logger.info('Adding dynamic model: %s %s', self.label, table_name)

            # Use the "inspectdb" management command to get the structure of the table for us.
            file_obj = BufferWriter()
            kwargs = {
                'database': self.label,
                'table_name_filter': lambda t: t == table_name
            }
            if VERSION[0] >= 1 and VERSION[1] >= 10:
                kwargs['table'] = [table_name]
            Command(stdout=file_obj).handle(**kwargs)
            model_definition = file_obj.data

            # Make sure that we found the table and have a model definition
            loc = model_definition.find('(models.Model):')
            if loc != -1:
                # Ensure that the Model has a primary key.
                # Django doesn't support multiple column primary keys,
                # So we have to add a primary key if the inspect command didn't
                if model_definition.find('primary_key', loc) == -1:
                    loc = model_definition.find('(', loc + 14)
                    model_definition = '{}primary_key=True, {}'.format(
                        model_definition[:loc + 1], model_definition[loc + 1:])
                # Ensure that the model specifies what app_label it belongs to
                loc = model_definition.find(
                    'db_table = \'{}\''.format(table_name))
                if loc != -1:
                    model_definition = '{}app_label = \'{}\'\n        {}'.format(
                        model_definition[:loc], self.label,
                        model_definition[loc:])

                # Register the model with Django. Sad day when we use 'exec'
                exec(model_definition, globals(), locals())
                # exec model_definition in globals(), locals()
                # Update the list of models that the app
                # has to match what Django now has for this app
                apps.app_configs[self.label].models = apps.all_models[
                    self.label]
            else:
                logger.info('Could not find table: %s %s', self.label,
                            table_name)
        else:
            logger.info('Already added dynamic model: %s %s', self.label,
                        table_name)

        # If we have the connection, app and model. Return the model class
        if (self.label in connections._databases
                and self.label in apps.all_models
                and model_name in apps.all_models[self.label]):
            return apps.get_model(self.label, model_name)
Example #17
0
 def render(self, context):
     model = apps.get_model(*self.model.split('.'))
     if model is None:
         raise TemplateSyntaxError(
             _('tag_cloud_for_model tag was given an invalid model: %s') %
             self.model)
     context[self.context_var] = Tag.objects.cloud_for_model(
         model, **self.kwargs)
     return ''
Example #18
0
 def render(self, context):
     model = apps.get_model(*self.model.split('.'))
     if model is None:
         raise TemplateSyntaxError(
             _('tagged_objects tag was given an invalid model: %s') %
             self.model)
     context[self.context_var] = TaggedItem.objects.get_by_model(
         model, self.tag.resolve(context))
     return ''
Example #19
0
    def get_message(self):
        def get_new_line(action, dep_field, value):
            if hasattr(dep_field, 'verbose_name'):
                title = dep_field.verbose_name
            else:
                title = dep_field.name
            if action in (self.Action.CREATE,
                          self.Action.ADD) or (value[0] == value[1]):
                return '%s: "%s"' % (title,
                                     get_format_value(dep_field, value[1]))
            elif action == self.Action.UPDATE:
                return '%s: "%s" -> "%s"' % (
                    title, get_format_value(dep_field, value[0]),
                    get_format_value(dep_field, value[1]))
            else:
                return '%s: "%s"' % (title,
                                     get_format_value(dep_field, value[0]))

        changes = json.loads(self.changes)
        res = []
        for key, value in changes.items():
            dep_field = self.get_field(key)
            if (dep_field is None) or (not dep_field.editable
                                       or dep_field.primary_key):
                continue
            res.append(get_new_line(self.action, dep_field, value))
        if self.additional_data is not None:
            additional_data = json.loads(self.additional_data)
            for field_title, values in additional_data.items():
                for action_id, value_data in values.items():
                    action_id = int(action_id)
                    res_data = []
                    for value_item in value_data:
                        if isinstance(value_item, dict) and (
                                'modelname' in value_item) and ('changes'
                                                                in value_item):
                            sub_model = apps.get_model(value_item['modelname'])
                            for sub_fieldname, diff_value in value_item[
                                    'changes'].items():
                                sub_dep_field = sub_model._meta.get_field(
                                    sub_fieldname)
                                if (sub_dep_field is None) or (
                                        not sub_dep_field.editable
                                        or sub_dep_field.primary_key):
                                    continue
                                res_data.append(
                                    get_new_line(action_id, sub_dep_field,
                                                 diff_value))
                        else:
                            res_data.append(value_item)
                    res.append(
                        '%s: %s = "%s"' %
                        (field_title,
                         LucteriosLogEntry.Action.get_action_title(action_id),
                         '" "'.join(res_data)))
        return res
Example #20
0
    def get_model(self, table_name):
        # Ensure the database connect and it's dummy app are registered
        self.register()
        model_name = table_name.lower().replace('_', '')

        # Is the model already registered with the dummy app?
        if model_name not in apps.all_models[self.label]:
            logger.info('Adding dynamic model: %s %s', self.label, table_name)

            # Use the "inspectdb" management command to get the structure of the table for us.
            file_obj = BufferWriter()
            kwargs = {
                'database': self.label,
                'table_name_filter': lambda t: t == table_name
            }
            if VERSION[0] >= 1 and VERSION[1] >= 10:
                kwargs['table'] = [table_name]
            Command(stdout=file_obj).handle(**kwargs)
            model_definition = file_obj.data

            # Make sure that we found the table and have a model definition
            loc = model_definition.find('(models.Model):')
            if loc != -1:
                # Ensure that the Model has a primary key.
                # Django doesn't support multiple column primary keys,
                # So we have to add a primary key if the inspect command didn't
                if model_definition.find('primary_key', loc) == -1:
                    loc = model_definition.find('(', loc + 14)
                    model_definition = '{}primary_key=True, {}'.format(
                        model_definition[:loc + 1], model_definition[loc + 1:]
                    )
                # Ensure that the model specifies what app_label it belongs to
                loc = model_definition.find('db_table = \'{}\''.format(table_name))
                if loc != -1:
                    model_definition = '{}app_label = \'{}\'\n        {}'.format(
                        model_definition[:loc], self.label, model_definition[loc:]
                    )

                # Register the model with Django. Sad day when we use 'exec'
                exec(model_definition, globals(), locals())
                # exec model_definition in globals(), locals()
                # Update the list of models that the app
                # has to match what Django now has for this app
                apps.app_configs[self.label].models = apps.all_models[self.label]
            else:
                logger.info('Could not find table: %s %s', self.label, table_name)
        else:
            logger.info('Already added dynamic model: %s %s', self.label, table_name)

        # If we have the connection, app and model. Return the model class
        if (
                self.label in connections._databases and
                self.label in apps.all_models and
                model_name in apps.all_models[self.label]
        ):
            return apps.get_model(self.label, model_name)
Example #21
0
def get_model_list(class_list):
    """
    Receives a list of strings with app_name.model_name format
    and turns them into classes. If an item is already a class
    it ignores it.
    """
    for idx, item in enumerate(class_list):
        if isinstance(item, six.string_types):
            model_class = apps.get_model(item)
            class_list[idx] = model_class
Example #22
0
    def run(self, module_name, class_name, kwargs, update=False):
        model = apps.get_model(module_name, class_name)
        qs = model.objects.get_queryset()
        if update:
            obj, created = qs.update_or_create(**kwargs)
        else:
            obj, created = qs.get_or_create(**kwargs)

        data = self.serialize(obj, model=model)
        return data, created
Example #23
0
def get_model_list(class_list):
    """
    Receives a list of strings or arrays or classes.
    
    If an item is a string with app_name.model_name format,
    it is turned into classes.
   
    If an item is a list with (app_name, model_name,) format,
    it is turned into classes.
    
    If an item is already a class it ignores it.
    """
    for idx, item in enumerate(class_list):
        if isinstance(item, six.string_types):
            model_class = apps.get_model(item)
            class_list[idx] = model_class
        if isinstance(item, (list, tuple)):
            model_class = apps.get_model(item[0], item[1])
            class_list[idx] = model_class
Example #24
0
def get_models():
    from django.apps.registry import apps
    r = {}
    for a, b, c in router.registry:
        try:
            m = apps.get_model(a.replace('/', '.'))
            r[m._meta.label_lower] = m
        except:
            pass
    return r
Example #25
0
    def handle(self, *args, **kwargs):
        app_label, model_name = kwargs["model_label"].lower().rsplit(".")

        try:
            model = apps.get_model(app_label, model_name)
        except LookupError as e:
            raise CommandError(str(e))

        fixture_filepath = pathlib.Path(settings.BASE_DIR).joinpath(
            app_label, "fixtures", f"{model._meta.verbose_name_plural}.jsonl")
        self.atomically_loadlines(model, fixture_filepath)
Example #26
0
def get_or_create_concrete_model(model):
    """
    Returns the concrete version of argument model.

    Argument model may be a concrete model, in which case, it is returned as is.
    Otherwise a concrete model programmatically created from argument model is returned.
    """
    try:
        return apps.get_model(model._meta.label_lower)
    except LookupError:
        return ModelBase(model.__name__, (model,), {"__module__": model.__module__})
Example #27
0
 def display_name(self):
     if self.name:
         return self.name
     if self.page == "list":
         try:
             app_label, model_name = self.model.split("__", maxsplit=1)
             model = apps.get_model(app_label, model_name)
             return model._meta.verbose_name + "管理"
         except:
             pass
     return "未命名"
Example #28
0
 def display_name(self):
     if self.name:
         return self.name
     if self.page == 'list':
         try:
             app_label, model_name = self.model.split('__', maxsplit=1)
             model = apps.get_model(app_label, model_name)
             return model._meta.verbose_name + '管理'
         except:
             pass
     return '未命名'
Example #29
0
def get_model_viewsets():
    from django.apps.registry import apps
    r = {}
    for a, b, c in router.registry:
        try:
            mn = a.replace('/', '.')
            if hasattr(b, 'queryset'):
                m = b.queryset.model
            else:
                m = apps.get_model(mn)
            r[mn] = b
        except:
            pass
    return r
Example #30
0
 def run(self, module_name, class_name, trace, updates, single=False):
     model = apps.get_model(module_name, class_name)
     # noinspection PyProtectedMember
     pk_name = model._meta.pk.attname
     updates.pop(pk_name, None)
     qs = model.objects.get_queryset()
     qs = self.trace_queryset(qs, trace)
     if single:
         instance = qs.get()
         for k, v in updates.items():
             setattr(instance, k, v)
         instance.save(update_fields=list(updates.keys()))
         return 1
     return qs.update(**updates)
Example #31
0
def get_event_model():
    """
    Helper for getting event swappable model.

    :return: :class:`Event` model
    """

    model_path = settings.EVENT_MODEL
    swappable = apps.get_model(model_path)
    if not issubclass(swappable, AbstractBaseEvent):
        raise ImproperlyConfigured(
            "Given %s model isn't subclass of AbstractBaseUser" % model_path
        )
    return swappable
Example #32
0
 def get_queryset(self, pks):
     queryset = None
     if self.queryset is not None:
         queryset = self.queryset
         if hasattr(queryset, '_clone'):
             queryset = queryset._clone()
     elif self.model is not None:
         if isinstance(self.model, basestring):
             app, model_name = self.model.split('.')
             queryset = apps.get_model(app, model_name).objects
         else:
             queryset = self.model.objects
     else:
         raise self.Misconfigured('missing_model_queryset')
     filter = {'%s__in' % self.pk_field: pks}
     return queryset.filter(**filter)
Example #33
0
 def gen_relation_lookup_from_request(self, request):
     pms = request.query_params
     d = {}
     for k, v in pms.items():
         ps = k.split('.')
         if len(ps) != 3:
             continue
         mn = '.'.join(ps[:2])
         try:
             m = apps.get_model(mn)
             fn = ps[2]
             m._meta.get_field(fn)
             d.setdefault(mn, {})[fn] = v
         except:
             pass
     return d
Example #34
0
 def get_text_from_instance(self):
     try:
         from django.apps.registry import apps
         legalentity = apps.get_model("contacts", "LegalEntity")
         instance_name = legalentity.objects.get(id=1)
     except LookupError:
         from django.conf import settings
         instance_name = basename(dirname(settings.SETUP.__file__))
     xml_text = convert_to_html('text',
                                "{[b]}{[u]}%s{[/u]}{[/b]}" % instance_name,
                                text_align='center')
     xml_text.attrib['height'] = "%d.0" % 12
     xml_text.attrib['width'] = "%d.0" % self.content_width
     xml_text.attrib['top'] = "0.0"
     xml_text.attrib['left'] = "0.0"
     return xml_text
Example #35
0
def get_permissions_for_staff_user():
    """
    Returns all permissions that staff user possess. Staff user can create and edit
    all models from `MODELS_STAFF_USER_CAN_EDIT` list. By design he has no
    delete privileges --- as deleting questions could lead to bad user experience
    for students.

    :return: Iterable[django.contrib.auth.models.Permission]
    """
    from django.apps.registry import apps

    for app_label, model_name in MODELS_STAFF_USER_CAN_EDIT:
        model = apps.get_model(app_label, model_name)
        for action in ('add', 'change'):
            codename = get_permission_codename(action, model._meta)
            yield Permission.objects.get_by_natural_key(codename, app_label, model_name)
Example #36
0
File: views.py Project: povtux/core
 def fillresponse(self):
     if self.getparam("CONFIRME") is None:
         dlg = self.create_custom()
         img = XferCompImage('img')
         img.set_value(self.icon_path())
         img.set_location(0, 0)
         dlg.add_component(img)
         lbl = XferCompLabelForm('title')
         lbl.set_value_as_title(self.caption)
         lbl.set_location(1, 0, 2)
         dlg.add_component(lbl)
         lbl = XferCompLabelForm('lbl_record')
         lbl.set_value_as_name(_('record'))
         lbl.set_location(1, 1)
         dlg.add_component(lbl)
         lbl = XferCompLabelForm('record')
         lbl.set_value(six.text_type(self.item))
         lbl.set_location(2, 1)
         dlg.add_component(lbl)
         lbl = XferCompLabelForm('lbl_current')
         lbl.set_value_as_name(_('current model'))
         lbl.set_location(1, 2)
         dlg.add_component(lbl)
         lbl = XferCompLabelForm('current')
         lbl.set_value(self.item.__class__._meta.verbose_name)
         lbl.set_location(2, 2)
         dlg.add_component(lbl)
         lbl = XferCompLabelForm('lbl_newmodel')
         lbl.set_value_as_name(_('new model'))
         lbl.set_location(1, 3)
         dlg.add_component(lbl)
         lbl = XferCompSelect('newmodel')
         lbl.set_select(self.item.__class__.get_select_contact_type(False))
         lbl.set_location(2, 3)
         dlg.add_component(lbl)
         dlg.add_action(self.get_action(_('Ok'), "images/ok.png"),
                        {'close': CLOSE_YES, 'modal': FORMTYPE_MODAL, 'params': {'CONFIRME': 'YES'}})
         dlg.add_action(WrapAction(_("Cancel"), "images/cancel.png"), {})
     else:
         new_model = apps.get_model(self.getparam('newmodel'))
         field_id_name = "%s_ptr_id" % self.model.__name__.lower()
         new_object = new_model(**{field_id_name: self.item.pk})
         new_object.save()
         new_object.__dict__.update(self.item.__dict__)
         new_object.save()
         self.redirect_action(
             ActionsManage.get_act_changed(self.model.__name__, 'show', '', ''), {})
Example #37
0
 def get_field_by_param(self, param):
     field_args = param.param_type.split('.')
     if len(field_args) == 2:
         app_name = field_args[0]
         model_name = field_args[1]
         model = apps.get_model(app_name, model_name)
         field = serializers.PrimaryKeyRelatedField(
             queryset=model.objects.all(), many=bool(param.is_many))
     elif len(field_args) == 1:
         serializer_field_name = self.parameter_model.PARAMETERS_TYPES[
             param.param_type]['serializer_field_name']
         field = getattr(serializers, serializer_field_name)()
     else:
         raise serializers.ValidationError(
             f'''can't validate class for field"{param.code}"''')
     field.required = param.is_required
     return field
Example #38
0
 def fillresponse(self):
     if self.getparam("CONFIRME") is None:
         dlg = self.create_custom()
         img = XferCompImage('img')
         img.set_value(self.icon_path())
         img.set_location(0, 0)
         dlg.add_component(img)
         lbl = XferCompLabelForm('title')
         lbl.set_value_as_title(self.caption)
         lbl.set_location(1, 0, 2)
         dlg.add_component(lbl)
         lbl = XferCompLabelForm('lbl_record')
         lbl.set_value_as_name(_('record'))
         lbl.set_location(1, 1)
         dlg.add_component(lbl)
         lbl = XferCompLabelForm('record')
         lbl.set_value(six.text_type(self.item))
         lbl.set_location(2, 1)
         dlg.add_component(lbl)
         lbl = XferCompLabelForm('lbl_current')
         lbl.set_value_as_name(_('current model'))
         lbl.set_location(1, 2)
         dlg.add_component(lbl)
         lbl = XferCompLabelForm('current')
         lbl.set_value(self.item.__class__._meta.verbose_name)
         lbl.set_location(2, 2)
         dlg.add_component(lbl)
         lbl = XferCompLabelForm('lbl_newmodel')
         lbl.set_value_as_name(_('new model'))
         lbl.set_location(1, 3)
         dlg.add_component(lbl)
         lbl = XferCompSelect('newmodel')
         lbl.set_select(self.item.__class__.get_select_contact_type(False))
         lbl.set_location(2, 3)
         dlg.add_component(lbl)
         dlg.add_action(self.get_action(_('Ok'), "images/ok.png"), close=CLOSE_YES, modal=FORMTYPE_MODAL, params={'CONFIRME': 'YES'})
         dlg.add_action(WrapAction(_("Cancel"), "images/cancel.png"))
     else:
         new_model = apps.get_model(self.getparam('newmodel'))
         field_id_name = "%s_ptr_id" % self.model.__name__.lower()
         new_object = new_model(**{field_id_name: self.item.pk})
         new_object.save()
         new_object.__dict__.update(self.item.__dict__)
         new_object.save()
         self.redirect_action(ActionsManage.get_action_url(self.model.get_long_name(), 'Show', self))
Example #39
0
def create_empty_class(model, bases):
    '''
    Returns an empty class with the right metadata
    '''
    name = name_history_model(model.__name__)

    try:
        return apps.get_model(model._meta.app_label, name)

    except AppRegistryNotReady:

        class Meta:
            app_label = model._meta.app_label
            abstract = False
            verbose_name = _('%s change history') % model._meta.verbose_name
            verbose_name_plural = _('%s change histories') % model._meta.verbose_name

        attrs = {}
        attrs["Meta"] = Meta
        attrs["__module__"] = model.__module__
        return type(str(name), bases, attrs)
Example #40
0
 def detect_soft_applied(self, migration):
     """
     Tests whether a migration has been implicitly applied - that the
     tables it would create exist. This is intended only for use
     on initial migrations (as it only looks for CreateModel).
     """
     project_state = self.loader.project_state((migration.app_label, migration.name), at_end=True)
     apps = project_state.render()
     found_create_migration = False
     for operation in migration.operations:
         if isinstance(operation, migrations.CreateModel):
             model = apps.get_model(migration.app_label, operation.name)
             if model._meta.swapped:
                 # We have to fetch the model to test with from the
                 # main app cache, as it's not a direct dependency.
                 model = global_apps.get_model(model._meta.swapped)
             if model._meta.db_table not in self.connection.introspection.get_table_list(self.connection.cursor()):
                 return False
             found_create_migration = True
     # If we get this far and we found at least one CreateModel migration,
     # the migration is considered implicitly applied.
     return found_create_migration
Example #41
0
    def detect_soft_applied(self, project_state, migration):
        """
        Tests whether a migration has been implicitly applied - that the
        tables or columns it would create exist. This is intended only for use
        on initial migrations (as it only looks for CreateModel and AddField).
        """
        def should_skip_detecting_model(migration, model):
            """
            No need to detect tables for proxy models, unmanaged models, or
            models that can't be migrated on the current database.
            """
            return (
                model._meta.proxy or not model._meta.managed or not
                router.allow_migrate(
                    self.connection.alias, migration.app_label,
                    model_name=model._meta.model_name,
                )
            )

        if migration.initial is None:
            # Bail if the migration isn't the first one in its app
            if any(app == migration.app_label for app, name in migration.dependencies):
                return False, project_state
        elif migration.initial is False:
            # Bail if it's NOT an initial migration
            return False, project_state

        if project_state is None:
            after_state = self.loader.project_state((migration.app_label, migration.name), at_end=True)
        else:
            after_state = migration.mutate_state(project_state)
        apps = after_state.apps
        found_create_model_migration = False
        found_add_field_migration = False
        existing_table_names = self.connection.introspection.table_names(self.connection.cursor())
        # Make sure all create model and add field operations are done
        for operation in migration.operations:
            if isinstance(operation, migrations.CreateModel):
                model = apps.get_model(migration.app_label, operation.name)
                if model._meta.swapped:
                    # We have to fetch the model to test with from the
                    # main app cache, as it's not a direct dependency.
                    model = global_apps.get_model(model._meta.swapped)
                if should_skip_detecting_model(migration, model):
                    continue
                if model._meta.db_table not in existing_table_names:
                    return False, project_state
                found_create_model_migration = True
            elif isinstance(operation, migrations.AddField):
                model = apps.get_model(migration.app_label, operation.model_name)
                if model._meta.swapped:
                    # We have to fetch the model to test with from the
                    # main app cache, as it's not a direct dependency.
                    model = global_apps.get_model(model._meta.swapped)
                if should_skip_detecting_model(migration, model):
                    continue

                table = model._meta.db_table
                field = model._meta.get_field(operation.name)

                # Handle implicit many-to-many tables created by AddField.
                if field.many_to_many:
                    if field.remote_field.through._meta.db_table not in existing_table_names:
                        return False, project_state
                    else:
                        found_add_field_migration = True
                        continue

                column_names = [
                    column.name for column in
                    self.connection.introspection.get_table_description(self.connection.cursor(), table)
                ]
                if field.column not in column_names:
                    return False, project_state
                found_add_field_migration = True
        # If we get this far and we found at least one CreateModel or AddField migration,
        # the migration is considered implicitly applied.
        return (found_create_model_migration or found_add_field_migration), after_state
Example #42
0
File: views.py Project: povtux/core
 def _search_model(self):
     modelname = self.getparam('modelname')
     self.model = apps.get_model(modelname)
     XferContainerAcknowledge._search_model(self)
Example #43
0
File: views.py Project: povtux/core
 def _search_model(self):
     modelname = self.getparam('modelname')
     self.model = apps.get_model(modelname)
     self.field_id = self.getparam('field_id', modelname.lower())
     XferContainerAcknowledge._search_model(self)
Example #44
0
def get_model(model_label):
    return registered_apps.get_model(model_label)
    def orm_metadata(self, export_format):
        '''
        
        '''
        model = apps.get_model(self.module, self.name)
        model_opts = model._meta
        old_project_state = ProjectState()
        new_project_state = ProjectState()
#         new_project_state.add_model(model)
        autodetector = MigrationAutodetector(old_project_state, new_project_state)
        autodetector.generated_operations = {}

        # code from MigrationAutodetector.generate_created_models
        # Gather related fields
        related_fields = {}
        primary_key_rel = None
        for field in model_opts.local_fields:
            if field.rel:
                if field.rel.to:
                    if field.primary_key:
                        primary_key_rel = field.rel.to
                    elif not field.rel.parent_link:
                        related_fields[field.name] = field
                # through will be none on M2Ms on swapped-out models;
                # we can treat lack of through as auto_created=True, though.
                if getattr(field.rel, "through", None) and not field.rel.through._meta.auto_created:
                    related_fields[field.name] = field
        for field in model_opts.local_many_to_many:
            if field.rel.to:
                related_fields[field.name] = field
            if getattr(field.rel, "through", None) and not field.rel.through._meta.auto_created:
                related_fields[field.name] = field
        # Are there unique/index_together to defer?
#         unique_together = model_state.options.pop('unique_together', None)
#         index_together = model_state.options.pop('index_together', None)
#         order_with_respect_to = model_state.options.pop('order_with_respect_to', None)
        # Depend on the deletion of any possible proxy version of us
        dependencies = [
            (self.module, self.name, None, False),
        ]
        # Depend on all bases
#         for base in model_state.bases:
#             if isinstance(base, six.string_types) and "." in base:
#                 base_app_label, base_name = base.split(".", 1)
#                 dependencies.append((base_app_label, base_name, None, True))
        # Depend on the other end of the primary key if it's a relation
        if primary_key_rel:
            dependencies.append((
                primary_key_rel._meta.app_label,
                primary_key_rel._meta.object_name,
                None,
                True
            ))
        # Generate creation operation
        autodetector.add_operation(
            self.module,
            operations.CreateModel(
                name=self.name,
                fields=[d for d in model_opts.fields if d not in related_fields.values()],
                options=model_opts,
                bases=self.__class__.__bases__,
                managers=model_opts.managers,
            ),
            dependencies=dependencies,
            beginning=True,
        )
     
        # autodetector.generated_operations
        metadata = None
        fields = []
        if export_format == 'XML':
            metadata = "<Fields>"
        if export_format == 'JSON':
            metadata = '"Fields": ['
        if export_format == 'DICT':
            metadata = {}
        for field in autodetector.generated_operations[self.module][0].fields:
            if export_format == 'XML':
                sf = '<Field name="' + field.name + '">'
                sf += "</Field>"
            if export_format == 'JSON':
                sf = '{"name": "' + field.name + '", "type": "' + field.__class__.__name__ + '", "null": "' + str(field.null) + '"'
                if field.max_length != None:
                    sf += ', "max_length": "' + str(field.max_length) + '"'
                sf += ', "is_relation": "' + str(field.is_relation) + '", "column": "' + field.column + '"'
                if field.default not in {None, NOT_PROVIDED}:
                    sf += ', "default": "' + str(field.default) + '"'
                sf += '}'
            if export_format == 'DICT':
                sf = {"name": field.name}
            fields.append(sf)
            field.many_to_many
            field.many_to_one
        if export_format == 'XML':
            metadata += " ".join(fields) + "</Fields>"
        if export_format == 'JSON':
            metadata += ", ".join(fields) + "]"
        if export_format == 'DICT':
            metadata['Fields'] = fields
        return metadata
Example #46
0
from __future__ import unicode_literals
def post_comment_ajax(request, using=None):
    """
    Post a comment, via an Ajax call.
    """
    if not request.is_ajax():
        return HttpResponseBadRequest("Expecting Ajax call")

    # This is copied from django_comments.
    # Basically that view does too much, and doesn't offer a hook to change the rendering.
    # The request object is not passed to next_redirect for example.
    #
    # This is a separate view to integrate both features. Previously this used django-ajaxcomments
    # which is unfortunately not thread-safe (it it changes the comment view per request).

    # Fill out some initial data fields from an authenticated user, if present
    data = request.POST.copy()
    if request.user.is_authenticated():
        if not data.get('name', ''):
            data["name"] = request.user.get_full_name() or request.user.username
        if not data.get('email', ''):
            data["email"] = request.user.email

    # Look up the object we're trying to comment about
    ctype = data.get("content_type")
    object_pk = data.get("object_pk")
    if ctype is None or object_pk is None:
        return CommentPostBadRequest("Missing content_type or object_pk field.")
    try:
        object_pk = long(object_pk)
        try:
            from django.db import models
            model = models.get_model(*ctype.split(".", 1))
        except:
            from django.apps.registry import apps
            model = apps.get_model(*ctype.split(".", 1))
        target = model._default_manager.using(using).get(pk=object_pk)
    except ValueError:
        return CommentPostBadRequest("Invalid object_pk value: {0}".format(escape(object_pk)))
    except TypeError:
        return CommentPostBadRequest("Invalid content_type value: {0}".format(escape(ctype)))
    except AttributeError:
        return CommentPostBadRequest("The given content-type {0} does not resolve to a valid model.".format(escape(ctype)))
    except ObjectDoesNotExist:
        return CommentPostBadRequest("No object matching content-type {0} and object PK {1} exists.".format(escape(ctype), escape(object_pk)))
    except (ValueError, ValidationError) as e:
        return CommentPostBadRequest("Attempting go get content-type {0!r} and object PK {1!r} exists raised {2}".format(escape(ctype), escape(object_pk), e.__class__.__name__))

    # Do we want to preview the comment?
    preview = "preview" in data

    # Construct the comment form
    form = get_comments_form()(target, data=data)

    # Check security information
    if form.security_errors():
        return CommentPostBadRequest("The comment form failed security verification: {0}".format(form.security_errors()))

    # If there are errors or if we requested a preview show the comment
    if preview:
        comment = form.get_comment_object() if not form.errors else None
        return _ajax_result(request, form, "preview", comment, object_id=object_pk)
    if form.errors:
        return _ajax_result(request, form, "post", object_id=object_pk)

    # Otherwise create the comment
    comment = form.get_comment_object()
    comment.ip_address = request.META.get("REMOTE_ADDR", None)
    if request.user.is_authenticated():
        comment.user = request.user

    # Signal that the comment is about to be saved
    responses = signals.comment_will_be_posted.send(
        sender  = comment.__class__,
        comment = comment,
        request = request
    )

    for (receiver, response) in responses:
        if response is False:
            return CommentPostBadRequest("comment_will_be_posted receiver {0} killed the comment".format(receiver.__name__))

    # Save the comment and signal that it was saved
    comment.save()
    signals.comment_was_posted.send(
        sender  = comment.__class__,
        comment = comment,
        request = request
    )

    return _ajax_result(request, form, "post", comment, object_id=object_pk)