0001-import_site-add-clean-if-empty-and-overwrite-options.patch

Benjamin Dauvergne, 03 mars 2017 21:42

Voir les différences: en ligne côte à côte

Subject: [PATCH] import_site: add --clean, --if-empty and --overwrite options

 passerelle/apps/csvdatasource/models.py            |  6 ++--
 passerelle/base/management/commands/import_site.py | 13 ++++++-
 passerelle/base/models.py                          | 27 +++++++++-----
 passerelle/utils/__init__.py                       | 29 +++++++++++++--
 tests/test_import_export.py                        | 42 ++++++++++++++++++----
 5 files changed, 96 insertions(+), 21 deletions(-)

             return d
         @classmethod
         def import_json_real(cls, d, **kwargs):
         def import_json_real(cls, overwrite, instance, d, **kwargs):
             queries = d.pop('queries', [])
             instance = super(CsvDataSource, cls).import_json_real(d, **kwargs)
             instance = super(CsvDataSource, cls).import_json_real(overwrite, instance, d, **kwargs)
             new = []
             if instance and overwrite:
                 Query.objects.filter(resource=instance).delete()
             for query in queries:
                 q = Query.import_json(query)
                 q.resource = instance

     from django.core.management.base import BaseCommand
     from passerelle.base.models import ApiUser, BaseResource
     from passerelle.utils import import_site
-...
         args = '<filename>'
         help = 'Import an exported site'
         option_list = BaseCommand.option_list + (
             make_option('--clean', action='store_true', default=False,
                         help='Clean site before importing'),
             make_option('--import-users', action='store_true', default=False,
                         help='Import users and access rights'),
             make_option('--if-empty', action='store_true', default=False,
                         help='Import only if passerelle is empty'),
             make_option('--overwrite', action='store_true', default=False,
                         help='Overwirte existing resources'),
+        )
         def handle(self, filename, **options):
             import_site(json.load(open(filename)), import_users=options['import_users'])
             import_site(json.load(open(filename)),
                         if_empty=options['if_empty'],
                         clean=options['clean'],
                         overwrite=options['overwrite'],
                         import_users=options['import_users'])

+            }
         @classmethod
         def import_json(self, d):
         def import_json(self, d, overwrite=False):
             if d.get('@type') != 'passerelle-user':
                 raise ValueError('not a passerelle user export')
             d = d.copy()
             d.pop('@type')
             return self.objects.get_or_create(username=d['username'],
                                               defaults=d)
             api_user, created = self.objects.get_or_create(username=d['username'], defaults=d)
             if overwrite and not created:
                 for key in d:
                     setattr(api_user, key, d[key])
                 api_user.save()
     class TemplateVar(models.Model):
-...
             return d
         @staticmethod
         def import_json(d, import_users=False):
         def import_json(d, import_users=False, overwrite=False):
             if d.get('@type') != 'passerelle-resource':
                 raise ValueError('not a passerelle resource export')
-...
             app_label, model_name = d['resource_type'].split('.')
             model = apps.get_model(app_label, model_name)
             try:
                 return model.objects.get(slug=d['slug'])
                 instance = model.objects.get(slug=d['slug'])
                 if not overwrite:
                     return
             except model.DoesNotExist:
                 pass
                 instance = None
             with transaction.atomic():
                 # prevent semi-creation of ressources
                 instance = model.import_json_real(d)
                 instance = model.import_json_real(overwrite, instance, d)
                 resource_type = ContentType.objects.get_for_model(instance)
                 # We can only connect AccessRight objects to the new Resource after its creation
                 if import_users:
-...
             return instance
         @classmethod
         def import_json_real(cls, d, **kwargs):
         def import_json_real(cls, overwrite, instance, d, **kwargs):
             init_kwargs = {
                 'title': d['title'],
                 'slug': d['slug'],
-...
                 'log_level': d['log_level'],
+            }
             init_kwargs.update(kwargs)
             instance = cls(**init_kwargs)
             if instance:
                 for key in init_kwargs:
                     setattr(instance, key, init_kwargs[key])
             else:
                 instance = cls(**init_kwargs)
             for field, model in cls._meta.get_concrete_fields_with_model():
                 if field.name == 'id':
                     continue

         return d
     def import_site(d, import_users=False):
     def import_site(d, if_empty=False, clean=False, overwrite=False, import_users=False):
         '''Load passerelle configuration (users, resources and ACLs) from a dictionnary loaded from
            JSON
         '''
         d = d.copy()
         def is_empty():
             if import_users:
                 if ApiUser.objects.count():
                     return False
             for subclass in BaseResource.__subclasses__():
                 if subclass._meta.abstract:
                     continue
                 if subclass.objects.count():
                     return False
             return True
         if if_empty and not is_empty():
             return
         if clean:
             for subclass in BaseResource.__subclasses__():
                 if subclass._meta.abstract:
                     continue
                 subclass.objects.all().delete()
             if import_users:
                 ApiUser.objects.all().delete()
         with transaction.atomic():
             if import_users:
                 for apiuser in d['apiusers']:
                     ApiUser.import_json(apiuser)
                     ApiUser.import_json(apiuser, overwrite=overwrite)
             for resource in d['resources']:
                 BaseResource.import_json(resource, import_users=import_users)
                 BaseResource.import_json(resource, overwrite=overwrite, import_users=import_users)

         return request.param
     def get_output_of_command(command, *args, **kwargs):
         old_stdout = sys.stdout
         output = sys.stdout = StringIO()
         call_command(command, *args, **kwargs)
         sys.stdout = old_stdout
         return output.getvalue()
     def test_export_csvdatasource(app, setup, filetype):
         def clear():
             Query.objects.all().delete()
-...
         second['resources'][0]['csv_file']['name'] = 'whocares'
         assert first == second
         old_stdout = sys.stdout
         output = sys.stdout = StringIO()
         call_command('export_site')
         sys.stdout = old_stdout
         output = output.getvalue()
         output = get_output_of_command('export_site')
         third = json.loads(output)
         third['resources'][0]['csv_file']['name'] = 'whocares'
         assert first == third
-...
         fourth = export_site()
         fourth['resources'][0]['csv_file']['name'] = 'whocares'
         assert first == fourth
         Query.objects.all().delete()
         with tempfile.NamedTemporaryFile() as f:
             f.write(output)
             f.flush()
             call_command('import_site', f.name, import_users=True)
         assert Query.objects.count() == 0
         with tempfile.NamedTemporaryFile() as f:
             f.write(output)
             f.flush()
             call_command('import_site', f.name, overwrite=True, import_users=True)
         assert Query.objects.count() == 1
         query = Query(slug='query-2_', resource=CsvDataSource.objects.get(), structure='array')
         query.projections = '\n'.join(['id:int(id)', 'prenom:prenom'])
         query.save()
         assert Query.objects.count() == 2
         with tempfile.NamedTemporaryFile() as f:
             f.write(output)
             f.flush()
             call_command('import_site', f.name, clean=True, overwrite=True, import_users=True)
         assert Query.objects.count() == 1
         assert Query.objects.filter(slug='query-1_').exists()
+    -

Projet

Général

Profil

Produits Entr'ouvert » Passerelle

0001-import_site-add-clean-if-empty-and-overwrite-options.patch