django: refactorisation

estimevent/contrib/django/estimevent/management/commands/estimsync.py

@@ -3,9 +3,13 @@
 from django.contrib.contenttypes.models import ContentType
 from django.core.management.base import BaseCommand
 from django.utils import timezone
+from django.utils.encoding import force_text
+from django.db import transaction
+from optparse import make_option
 from estimevent.contrib.django.estimevent.models import get_wrappers
 from estimevent.contrib.django.estimevent.models import EstimEvent
-from optparse import make_option
+from estimevent.api import EstimEventTemporaryError
+from estimevent.api import EstimEventPermanentError
 
 
 class Command(BaseCommand):
@@ -18,6 +22,103 @@ class Command(BaseCommand):
                     default=False,
                     help='Do not change anything'),
     )
+    def _info(self, message):
+        if self.verbosity > 1:
+            print message
+
+    def _notice(self, message):
+        if self.verbosity > 3:
+            print message
+
+    def _sync_event(self, wrapper, event, overrided_data):
+        with transaction.commit_on_success():
+            data = wrapper.properties(event, overrided_data)
+            errors = wrapper.validate(event, data)
+            if errors:
+                self._info('* INVALID: {} - {} - {}'.format(event.pk, data['date_debut'], event))
+                for error in errors:
+                    self._notice('  - {}'.format(error))
+                continue
+
+            if not wrapper.has_to_keep(event):
+                self._info('* NOT KEPT: {} - {} - {}'.format(event.pk, data['date_debut'], event))
+                continue
+
+            data_hash = EstimEvent.compute_hash(data)
+            estim_events = EstimEvent.objects.filter(
+                content_type=ContentType.objects.get_for_model(event),
+                object_id=event.id)
+
+            if data_hash in set(e.data_hash for e in estim_events if e.status == EstimEvent.STATUS_OK):
+                self._notice('* NOT CHANGED: {} - {} - {} [{}]'.format(event.pk, data['date_debut'], event, data_hash))
+                continue
+
+            key = wrapper.key(event, data)
+            json_key = EstimEvent.compute_json_key(key)
+
+            qs_estim_event = estim_events.filter(json_key=json_key)
+            new = False
+            if qs_estim_event.count() == 1:
+                estim_event = qs_estim_event.get()
+            elif qs_estim_event.count() == 0:
+                estim_event = EstimEvent(
+                    object_id=event.pk,
+                    content_type=ContentType.objects.get_for_model(event),
+                    json_key=json_key,
+                    data_hash=data_hash,
+                )
+                new = True
+                if not self.dry_run:
+                    estim_event.save()
+
+            if (
+                estim_event.status in [EstimEvent.STATUS_NEVER, EstimEvent.STATUS_TEMPORARY_ERROR]
+                or (data_hash != estim_event.data_hash)
+            ):
+                try:
+                    wrapper.get_api().save_event(data, production=not self.dry_run)
+                except EstimEventPermanentError, e:
+                    estim_event.status = EstimEvent.STATUS_PERMANENT_ERROR
+                    estim_event.message = force_text(e)
+                except EstimEventTemporaryError, e:
+                    estim_event.status = EstimEvent.STATUS_TEMPORARY_ERROR
+                    estim_event.message = force_text(e)
+                else:
+                    estim_event.status = EstimEvent.STATUS_OK
+                    estim_event.message = ''
+                    estim_event.data_hash = data_hash
+                    if new:
+                        self._info('* CREATION: {} - {} - {} [{}]'.format(event.pk, data['date_debut'], event, data_hash))
+                    else:
+                        self._info('* MODIFICATION: {} - {} - {} [{}]'.format(event.pk, data['date_debut'], event, data_hash))
+                finally:
+                    if not self.dry_run:
+                        estim_event.save()
+
+            elif estim_event.status in [EstimEvent.STATUS_OK]:
+                self._notice('* IDENTICAL: {} - {} - {} [{}]'.format(event.pk, data['date_debut'], event, data_hash))
+            elif estim_event.status in [EstimEvent.STATUS_PERMANENT_ERROR]:
+                self._info('* PERMANENT ERROR: {} - {} - {} [{}]'.format(event.pk, data['date_debut'], event, data_hash))
+                self._info('  %s' % estim_event.message)
+
+    def _delete_event(self, wrapper, estim_event, until):
+         if not hasattr(estim_event, 'event' or estim_event.event is None):
+             wrapper.remove(estim_event, production=not self.dry_run)
+             self._info('* DELETION (event not found) {} [{}]'.format(estim_event, estim_event.data_hash))
+             continue
+
+         event = getattr(estim_event, 'event', None)
+         if not wrapper.has_to_keep(estim_event.event):
+             wrapper.remove(estim_event, production=not self.dry_run)
+             self._info('* DELETION (not kept): {} - {} - {} [{}]'.format(event.pk, estim_event.key['date_debut'], event, estim_event.data_hash))
+             continue
+
+         if estim_event.data_hash not in wrapper.valid_hashes(estim_event.event, until):
+             wrapper.remove(estim_event, production=not self.dry_run)
+             self._info('* DELETION (modified event): {} - {} - {} [{}]'.format(event.pk, estim_event.key['date_debut'], event, estim_event.data_hash))
+             continue
+
+         self._notice('* KEPT: {} - {} - {} [{}]'.format(event.pk, estim_event.key['date_debut'], event, estim_event.data_hash))
 
     def handle(self, *args, **options):
 
@@ -29,80 +130,29 @@ class Command(BaseCommand):
 
             until = timezone.now() + timezone.timedelta(days=365.2425)
             dry_run = options['dry_run']
+            self.dry_run = dry_run
             if dry_run:
                 dry_run_label = '[DRY]: '
             else:
                 dry_run_label = ''
-            verbosity = int(options['verbosity'])
+
+            self.verbosity = int(options['verbosity'])
+
             # ajout / mise à jour
             events = [
                 (event, data)
                 for event, data in wrapper.events_to_sync(until)
                 if len(event_ids) == 0 or event.pk in event_ids
             ]
-            if verbosity > 1:
-                print '{}{} events to sync:'.format(dry_run_label, len(events))
-
+            self._info('{}{} events to check for sync:'.format(dry_run_label, len(events)))
             for (event, overrided_data) in events:
-                data = wrapper.properties(event, overrided_data)
-                errors = wrapper.validate(event, data)
-                if errors:
-                    if verbosity > 0:
-                        print '* INVALID: {} - {} - {}'.format(event.pk, data['date_debut'], event)
-                        if verbosity > 1:
-                            for error in errors:
-                                print '  - {}'.format(error)
-                    continue
-
-                if not wrapper.has_to_keep(event):
-                    if verbosity > 0:
-                        print '* NOT KEPT: {} - {} - {}'.format(event.pk, data['date_debut'], event)
-                    continue
-
-                data_hash = EstimEvent.compute_hash(data)
-                estim_events = EstimEvent.objects.filter(
-                    content_type=ContentType.objects.get_for_model(event),
-                    object_id=event.id)
-
-                if data_hash in set(e.data_hash for e in estim_events if e.status == EstimEvent.STATUS_OK):
-                    if verbosity > 2:
-                        print '* NOT CHANGED: {} - {} - {} [{}]'.format(event.pk, data['date_debut'], event, data_hash)
-                    continue
-
-                updated, created, data_hash = wrapper.create_or_update(event, data, production=not dry_run)
-                if verbosity > 0:
-                    if created:
-                        print '* CREATION: {} - {} - {} [{}]'.format(event.pk, data['date_debut'], event, data_hash)
-                    elif updated:
-                        print '* MODIFICATION: {} - {} - {} [{}]'.format(event.pk, data['date_debut'], event, data_hash)
+                self._sync_event(wrapper, event, overrided_data)
 
             # suppression des événements modifiés, dépubliés ou supprimés
             estim_events = EstimEvent.objects.all()
             if len(event_ids):
                 estim_events = estim_events.filter(object_id__in=event_ids)
-
-            if verbosity > 1:
-                print('{}{} estim events to check for deletion'.format(dry_run_label, len(estim_events)))
-
+            self._info('{}{} estim events to check for deletion'.format(dry_run_label, len(estim_events)))
             for estim_event in estim_events:
+                self._delete_event(wrapper, estim_event, until)
 
-                if not hasattr(estim_event, 'event' or estim_event.event is None):
-                    wrapper.remove(estim_event, production=not dry_run)
-                    if verbosity > 0:
-                        print '* DELETION (event not found) {} [{}]'.format(estim_event, estim_event.data_hash)
-                    continue
-
-                event = getattr(estim_event, 'event', None)
-                if not wrapper.has_to_keep(estim_event.event):
-                    if verbosity > 0:
-                        print '* DELETION (not kept): {} - {} - {} [{}]'.format(event.pk, estim_event.key['date_debut'], event, estim_event.data_hash)
-                    continue
-
-                if estim_event.data_hash not in wrapper.valid_hashes(estim_event.event, until):
-                    wrapper.remove(estim_event, production=not dry_run)
-                    if verbosity > 0:
-                        print '* DELETION (modified event): {} - {} - {} [{}]'.format(event.pk, estim_event.key['date_debut'], event, estim_event.data_hash)
-                    continue
-
-                if verbosity > 2:
-                    print '* KEPT: {} - {} - {} [{}]'.format(event.pk, estim_event.key['date_debut'], event, estim_event.data_hash)

estimevent/contrib/django/estimevent/models.py

@@ -9,10 +9,7 @@ from django.db import transaction
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.contenttypes.generic import GenericForeignKey
 from django.core.serializers.json import DjangoJSONEncoder
-from django.utils.encoding import force_text
 from estimevent.api import EstimEventError
-from estimevent.api import EstimEventTemporaryError
-from estimevent.api import EstimEventPermanentError
 from estimevent.api import EstimEventAPI
 from collections import OrderedDict
 
@@ -113,59 +110,6 @@ class EstimEventWrapperBase(object):
             hashes.add(data_hash)
         return hashes
 
-    @classmethod
-    def create_or_update(cls, event, data, production=True):
-        updated = True
-        created = True
-        with transaction.commit_on_success():
-            key = cls.key(event, data)
-            data_hash = EstimEvent.compute_hash(data)
-            json_key = EstimEvent.compute_json_key(key)
-
-            qs = EstimEvent.objects.filter(
-                object_id=event.pk,
-                content_type=ContentType.objects.get_for_model(event),
-                json_key=json_key,
-            )
-            if qs.count() == 1:
-                estim_event = qs.get()
-            elif qs.count() == 0:
-                estim_event = EstimEvent(
-                    object_id=event.pk,
-                    content_type=ContentType.objects.get_for_model(event),
-                    json_key=json_key,
-                    data_hash=data_hash,
-                )
-                created = True
-                if production:
-                    estim_event.save()
-
-            if (
-                estim_event.status in [EstimEvent.STATUS_NEVER, EstimEvent.STATUS_TEMPORARY_ERROR]
-                or (
-                    estim_event.status in [EstimEvent.STATUS_OK, EstimEvent.STATUS_PERMANENT_ERROR]
-                    and data_hash == estim_event.data_hash
-                )
-            ):
-
-                try:
-                    cls.get_api().save_event(data, production=production)
-                except EstimEventPermanentError, e:
-                    estim_event.status = EstimEvent.STATUS_PERMANENT_ERROR
-                    estim_event.message = force_text(e)
-                except EstimEventTemporaryError, e:
-                    estim_event.status = EstimEvent.STATUS_TEMPORARY_ERROR
-                    estim_event.message = force_text(e)
-                else:
-                    estim_event.status = EstimEvent.STATUS_OK
-                    estim_event.message = ''
-                    estim_event.data_hash = data_hash
-                finally:
-                    updated = True
-                    if production:
-                        estim_event.save()
-            return updated, created, data_hash
-
     @classmethod
     def remove(cls, estim_event, production=True):
         with transaction.commit_on_success():