Beispiel #1
0
def object_is_reversion_ready(obj):
    """
    Returns True if the object's model
    is registered with Django reversion.
    """
    cls = obj.__class__
    return default_revision_manager.is_registered(cls)
Beispiel #2
0
def object_is_reversion_ready(obj):
    """
    Returns True if the object's model
    is registered with Django reversion.
    """
    cls = obj.__class__
    return default_revision_manager.is_registered(cls)
    def create_initial_revisions(self, app, model_class, comment, batch_size, verbosity=2, database=None, **kwargs):
        """Creates the set of initial revisions for the given model."""
        # Import the relevant admin module.
        try:
            import_module("%s.admin" % app.__name__.rsplit(".", 1)[0])
        except ImportError:
            pass
        # Check all models for empty revisions.
        if default_revision_manager.is_registered(model_class):
            if verbosity >= 2:
                print("Creating initial revision(s) for model %s ..."  % (force_text(model_class._meta.verbose_name)))
            created_count = 0
            content_type = ContentType.objects.db_manager(database).get_for_model(model_class)
            versioned_pk_queryset = Version.objects.using(database).filter(content_type=content_type).all()
            live_objs = model_class._default_manager.using(database).all()
            if has_int_pk(model_class):
                # We can do this as a fast database join!
                live_objs = live_objs.exclude(
                    pk__in = versioned_pk_queryset.values_list("object_id_int", flat=True)
                )
            else:
                # This join has to be done as two separate queries.
                live_objs = live_objs.exclude(
                    pk__in = list(versioned_pk_queryset.values_list("object_id", flat=True).iterator())
                )
            # Save all the versions.
            ids = list(live_objs.values_list(model_class._meta.pk.name, flat=True))
            total = len(ids)
            for i in range(0, total, batch_size):
                chunked_ids = ids[i:i+batch_size]
                objects = live_objs.in_bulk(chunked_ids)
                for id, obj in objects.items():
                    try:
                        default_revision_manager.save_revision((obj,), comment=comment, db=database)
                    except:
                        print("ERROR: Could not save initial version for %s %s." % (model_class.__name__, obj.pk))
                        raise
                    created_count += 1
                reset_queries()
                if verbosity >= 2:
                    print("Created %s of %s." % (created_count, total))

            # Print out a message, if feeling verbose.
            if verbosity >= 2:
                print("Created %s initial revision(s) for model %s." % (created_count, force_text(model_class._meta.verbose_name)))
        else:
            if verbosity >= 2:
                print("Model %s is not registered."  % (force_text(model_class._meta.verbose_name)))
Beispiel #4
0
def monitoring_parameter_import(request, monitoring_pk):
    """
    Импорт параметров из CSV.

    """
    must_register = False
    if revision.is_registered(Parameter):
        revision.unregister(Parameter)
        must_register = True

    monitoring = get_object_or_404(Monitoring, pk=monitoring_pk)
    if not request.user.has_perm('exmo2010.edit_monitoring', monitoring):
        raise PermissionDenied
    if 'paramfile' not in request.FILES:
        return HttpResponseRedirect(reverse('exmo2010:monitorings_list'))
    reader = UnicodeReader(request.FILES['paramfile'])
    errors = []
    rowOKCount = 0
    row_num = 0
    try:
        for row_num, row in enumerate(reader, start=1):
            if row[0].startswith('#'):
                errors.append("row %d. Starts with '#'. Skipped" % row_num)
                continue
            if row[0] == '':
                errors.append("row %d (csv). Empty code" % row_num)
                continue
            if row[1] == '':
                errors.append("row %d (csv). Empty name" % row_num)
                continue
            try:
                code = row[0]
                name = row[1]
                parameter = Parameter.objects.get(monitoring=monitoring, code=code, name=name)
            except Parameter.DoesNotExist:
                parameter = Parameter()
            except Exception, e:
                errors.append("row %d. %s" % (row_num, e))
                continue
            try:
                parameter.monitoring = monitoring
                parameter.code = code
                parameter.name = name
                # Присваиваем пустую строку, а не None.
                parameter.grounds = row[2] or ''
                parameter.rating_procedure = row[3] or ''
                parameter.notes = row[4] or ''
                parameter.complete = bool(int(row[5]))
                parameter.topical = bool(int(row[6]))
                parameter.accessible = bool(int(row[7]))
                parameter.hypertext = bool(int(row[8]))
                parameter.document = bool(int(row[9]))
                parameter.image = bool(int(row[10]))
                parameter.weight = row[11]
                parameter.full_clean()
                parameter.save()
            except ValidationError, e:
                errors.append("row %d (validation). %s" % (
                    row_num,
                    '; '.join(['%s: %s' % (i[0], ', '.join(i[1])) for i in e.message_dict.items()])))
            except Exception, e:
                errors.append("row %d. %s" % (row_num, e))
Beispiel #5
0
def monitoring_organization_import(request, monitoring_pk):
    """
    Импорт организаций из CSV.

    """
    must_register = False
    if revision.is_registered(Organization):
        revision.unregister(Organization)
        must_register = True

    monitoring = get_object_or_404(Monitoring, pk=monitoring_pk)
    if not request.user.has_perm('exmo2010.edit_monitoring', monitoring):
        raise PermissionDenied
    if 'orgfile' not in request.FILES:
        return HttpResponseRedirect(reverse('exmo2010:monitorings_list'))
    reader = UnicodeReader(request.FILES['orgfile'])
    errors = []
    indexes = {}
    rowOKCount = 0
    row_num = 0
    try:
        for row_num, row in enumerate(reader, start=1):
            if row[0] and row[0].startswith('#'):
                for key in ['name', 'url', 'email', 'phone', 'recommendations_hidden']:
                    for item in row:
                        if item and key in item.lower():
                            indexes[key] = row.index(item)
                errors.append("row %d. Starts with '#'. Skipped" % row_num)
                continue

            if 'name' not in indexes:
                errors.append("header row (csv). Field 'Name' does not exist")
                break

            if row[indexes['name']] == '':
                errors.append("row %d (csv). Empty organization name" % row_num)
                continue
            try:
                organization = Organization.objects.get(monitoring=monitoring, name=row[indexes['name']])
            except Organization.DoesNotExist:
                organization = Organization(name=row[indexes['name']])
                organization.monitoring = monitoring
            except Exception, e:
                errors.append("row %d. %s" % (row_num, e))
                continue
            try:
                if row[indexes['email']]:
                    organization.email = replace_string(row[indexes['email']]).strip()
                if row[indexes['phone']]:
                    organization.phone = replace_string(row[indexes['phone']]).strip()
                if row[indexes['url']]:
                    organization.url = row[indexes['url']].strip()
                if row[indexes['recommendations_hidden']] == 'False':
                    organization.recommendations_hidden = False
                if row[indexes['recommendations_hidden']] == 'True':
                    organization.recommendations_hidden = True

                organization.inv_code = generate_inv_code(6)
                organization.full_clean()
                organization.save()
            except ValidationError, e:
                errors.append("row %d (validation). %s" % (
                    row_num,
                    '; '.join(['%s: %s' % (i[0], ', '.join(i[1])) for i in e.message_dict.items()])))
            except Exception, e:
                errors.append("row %d. %s" % (row_num, e))
Beispiel #6
0
    def create_initial_revisions(self,
                                 app,
                                 model_class,
                                 comment,
                                 batch_size,
                                 verbosity=2,
                                 database=None,
                                 **kwargs):
        """Creates the set of initial revisions for the given model."""
        # Import the relevant admin module.
        try:
            import_module("%s.admin" % app.__name__.rsplit(".", 1)[0])
        except ImportError:
            pass
        # Check all models for empty revisions.
        if default_revision_manager.is_registered(model_class):
            if verbosity >= 2:
                print("Creating initial revision(s) for model %s ..." %
                      (force_text(model_class._meta.verbose_name)))
            created_count = 0
            content_type = ContentType.objects.db_manager(
                database).get_for_model(model_class)
            versioned_pk_queryset = Version.objects.using(database).filter(
                content_type=content_type).all()
            live_objs = model_class._default_manager.using(database).all()
            if has_int_pk(model_class):
                # We can do this as a fast database join!
                live_objs = live_objs.exclude(
                    pk__in=versioned_pk_queryset.values_list("object_id_int",
                                                             flat=True))
            else:
                # This join has to be done as two separate queries.
                live_objs = live_objs.exclude(pk__in=list(
                    versioned_pk_queryset.values_list("object_id",
                                                      flat=True).iterator()))
            # Save all the versions.
            ids = list(
                live_objs.values_list(model_class._meta.pk.name, flat=True))
            total = len(ids)
            for i in range(0, total, batch_size):
                chunked_ids = ids[i:i + batch_size]
                objects = live_objs.in_bulk(chunked_ids)
                for id, obj in objects.items():
                    try:
                        default_revision_manager.save_revision((obj, ),
                                                               comment=comment,
                                                               db=database)
                    except:
                        print(
                            "ERROR: Could not save initial version for %s %s."
                            % (model_class.__name__, obj.pk))
                        raise
                    created_count += 1
                reset_queries()
                if verbosity >= 2:
                    print("Created %s of %s." % (created_count, total))

            # Print out a message, if feeling verbose.
            if verbosity >= 2:
                print("Created %s initial revision(s) for model %s." %
                      (created_count, force_text(
                          model_class._meta.verbose_name)))
        else:
            if verbosity >= 2:
                print("Model %s is not registered." %
                      (force_text(model_class._meta.verbose_name)))