Merge branch 'feature/backup' into development

.gitignore

@@ -1,7 +1,8 @@
 *.orig
 *.pyc
 *.pyo
-/*.sqlite
+*.sql
+*.sqlite
 /settings_local.py
 /celerybeat-schedule
 /document_storage/

apps/acls/__init__.py

@@ -5,7 +5,6 @@ from project_setup.api import register_setup
 
 from .classes import (AccessHolder, AccessObjectClass, ClassAccessHolder,
     AccessObject)
-
 from .links import (acl_detail, acl_grant, acl_revoke,
     acl_holder_new, acl_setup_valid_classes, acl_class_list,
     acl_class_acl_list, acl_class_acl_detail, acl_class_new_holder_for,
@@ -13,14 +12,9 @@ from .links import (acl_detail, acl_grant, acl_revoke,
 
 bind_links([AccessHolder], [acl_detail])
 register_multi_item_links(['acl_detail'], [acl_grant, acl_revoke])
-
 bind_links([AccessObject], [acl_holder_new], menu_name='sidebar')
-
 bind_links(['acl_setup_valid_classes', 'acl_class_acl_list', 'acl_class_new_holder_for', 'acl_class_acl_detail', 'acl_class_multiple_grant', 'acl_class_multiple_revoke'], [acl_class_list], menu_name='secondary_menu')
-
 bind_links([ClassAccessHolder], [acl_class_acl_detail])
-
 bind_links([AccessObjectClass], [acl_class_acl_list, acl_class_new_holder_for])
 register_multi_item_links(['acl_class_acl_detail'], [acl_class_grant, acl_class_revoke])
-
 register_setup(acl_setup_valid_classes)

apps/app_registry/__init__.py

@@ -0,0 +1,54 @@
+from __future__ import absolute_import
+
+from django.db import transaction, DatabaseError
+from django.utils.translation import ugettext_lazy as _
+
+from common.utils import encapsulate
+from icons.literals import APP, BACKUPS
+from job_processor.exceptions import JobQueuePushError
+from job_processor.models import JobQueue, JobType
+from project_tools.api import register_tool
+from project_setup.api import register_setup
+from navigation.api import bind_links, register_model_list_columns
+
+from .classes import AppBackup, ModelBackup
+from .links import (app_registry_tool_link, app_list, backup_tool_link, 
+    restore_tool_link, backup_job_list, backup_job_create, backup_job_edit,
+    backup_job_test)
+from .literals import BACKUP_JOB_QUEUE_NAME
+from .models import App, BackupJob
+
+
+@transaction.commit_on_success
+def create_backups_job_queue():
+    global backups_job_queue
+    try:
+        backups_job_queue, created = JobQueue.objects.get_or_create(name=BACKUP_JOB_QUEUE_NAME, defaults={'label': _('Backups'), 'unique_jobs': True})
+    except DatabaseError:
+        transaction.rollback()
+
+
+register_tool(app_registry_tool_link)
+bind_links(['app_list'], [app_list], menu_name='secondary_menu')
+
+create_backups_job_queue()
+#backup_job_type = JobType('remote_backup', _(u'Remove backup'), do_backup)
+
+register_setup(backup_tool_link)
+register_tool(restore_tool_link)
+bind_links([BackupJob, 'backup_job_list', 'backup_job_create'], [backup_job_list], menu_name='secondary_menu')
+bind_links([BackupJob, 'backup_job_list', 'backup_job_create'], [backup_job_create], menu_name='sidebar')
+bind_links([BackupJob], [backup_job_edit, backup_job_test])
+
+register_model_list_columns(BackupJob, [
+    {'name':_(u'begin date time'), 'attribute': 'begin_datetime'},
+    {'name':_(u'storage module'), 'attribute': 'storage_module.label'},
+    {'name':_(u'apps'), 'attribute': encapsulate(lambda x: u', '.join([unicode(app) for app in x.apps.all()]))},
+])
+
+try:
+    app = App.register('app_registry', label=_(u'App registry'), icon=APP, description=_(u'Holds the app registry and backups functions.'))
+except App.UnableToRegister:
+    pass
+else:
+    app.set_backup([ModelBackup()])

apps/app_registry/classes.py

@@ -0,0 +1,300 @@
+import logging
+import os
+
+from django.core.files.base import ContentFile
+from django.core.files.storage import FileSystemStorage
+from django.core.management.commands.dumpdata import Command
+from django.db import router, DEFAULT_DB_ALIAS
+from django.utils.translation import ugettext_lazy as _
+from django.utils.translation import ugettext
+
+logger = logging.getLogger(__name__)
+
+
+# Data types
+class ElementDataBase(object):
+    """
+    The basic unit of a backup, a data type
+    it is produced or consumed by the ElementBackup classes
+    """
+    def make_filename(self, id):
+        return '%s-%s' % (self.model_backup.app_backup.app.name, id)
+    
+    def save(self):
+        """
+        Must return a file like object
+        """
+        raise NotImplemented
+
+    def load(self, file_object):
+        """
+        Must read a file like object and store content
+        """
+        raise NotImplemented        
+
+
+class Fixture(ElementDataBase):
+    name = 'fixture'
+    
+    def __init__(self, model_backup, content):
+        self.model_backup = model_backup
+        self.content = content
+    
+    @property
+    def filename(self):
+        return self.make_filename(self.__class__.name)
+    
+    def save(self):
+        return ContentFile(name=self.filename, content=self.content)
+
+    #def load(self):
+
+
+# Element backup
+class ElementBackupBase(object):
+    """
+    Sub classes must provide at least:
+        info()
+        backup()
+        restore()
+    """
+
+    label = _(u'Base backup manager')
+
+    def info(self):
+        """
+        Must return at least None
+        """
+        return None
+
+    def link(self, app_backup):
+        self.app_backup = app_backup
+        return self
+
+    def __unicode__(self):
+        return unicode(self.__class__.label)
+
+
+class ModelBackup(ElementBackupBase):
+    label = _(u'Model fixtures')
+
+    def __init__(self, models=None):
+        self.model_list = models or []
+    
+    def info(self):
+        return _(u'models: %s') % (u', '.join(self.model_list) if self.model_list else _(u'All'))
+
+    def backup(self):
+        """
+        """
+        #TODO: turn into a generator
+
+        command = Command()
+        if not self.model_list:
+            result = [self.app_backup.app.name]
+        else:
+            result = [u'%s.%s' (self.app_backup.app.name, model) for model in self.model_list]
+        
+        #TODO: a single Fixture or a list of Fixtures for each model?
+        #Can't return multiple Fixture until a way to find all of an app's models is found
+        return [Fixture(
+            model_backup=self,
+            content=command.handle(u' '.join(result), format='json', indent=4, using=DEFAULT_DB_ALIAS, exclude=[], user_base_manager=False, use_natural_keys=False)
+        )]
+
+
+class FileBackup(ElementBackupBase):
+    label = _(u'File copy')
+
+    def __init__(self, storage_class, filepath=None):
+        self.storage_class = storage_class
+        self.filepath = filepath
+    
+    def info(self):
+        return _(u'%s from %s') % (self.filepath or _(u'all files'), self.storage_class)
+
+    def backup(self):
+        """
+        Fetch a file specified by filepath from the Django storage class
+        and return a file like object
+        """
+        return None
+        
+
+# App config
+class AppBackup(object):
+    _registry = {}
+ 
+    STATE_BACKING_UP = 'backing_up'
+    STATE_RESTORING = 'restoring'
+    STATE_IDLE = 'idle'
+    
+    STATE_CHOICES = (
+        (STATE_BACKING_UP, _(u'backing up')),
+        (STATE_RESTORING, _(u'restoring')),
+        (STATE_IDLE, _(u'idle')),
+    )
+
+    @classmethod
+    def get(cls, name):
+        return cls._registry[name]
+
+    @classmethod
+    def get_all(cls):
+        return cls._registry.values()
+
+    def __init__(self, app, backup_managers):
+        # app = App instance from app_registry app
+        self.app = app
+        self.backup_managers = [manager.link(self) for manager in backup_managers]
+        self.state = self.__class__.STATE_IDLE
+        self.__class__._registry[app] = self
+
+    def info(self):
+        results = []
+        for manager in self.backup_managers:
+            results.append(u'%s - %s' % (manager, manager.info() or _(u'Nothing')))
+        return u', '.join(results)
+
+    def backup(self, storage_module, dry_run=False):
+        logger.debug('starting')
+
+        self.state = self.__class__.STATE_BACKING_UP
+        for manager in self.backup_managers:
+            result = manager.backup()
+            storage_module.backup(result, dry_run=dry_run)
+        self.state = self.__class__.STATE_IDLE
+
+    def restore(self, storage_module=None):
+        logger.debug('starting')
+        self.state = self.__class__.STATE_RESTORING
+        for manager in self.backup_managers:
+            manager.restore(storage_module.restore())
+        self.state = self.__class__.STATE_IDLE
+
+    def __unicode__(self):
+        return unicode(self.app)
+        
+
+#Storage
+class StorageModuleBase(object):
+    _registry = {}
+    
+    # Local modules depend on hardware on a node and execute in the Scheduler
+    # of a particular node
+    REALM_LOCAL = 'local'
+    
+    # Remote modules can be execute by any node in a cluster and are placed
+    # in the JobQueue
+    REALM_REMOTE = 'remote'
+    
+    REALM_CHOICES = (
+        (REALM_LOCAL, _(u'local')),
+        (REALM_REMOTE, _(u'remote')),
+    )
+    
+    class UnknownStorageModule(Exception):
+        pass
+    
+    @classmethod
+    def register(cls, klass):
+        """
+        Register a subclass of StorageModuleBase to make it available to the
+        UI
+        """
+        cls._registry[klass.name] = klass
+
+    @classmethod
+    def get_all(cls):
+        return cls._registry.values()
+
+    @classmethod
+    def get(cls, name):
+        try:
+            return cls._registry[name]
+        except KeyError:
+            raise cls.UnknownStorageModule
+
+    @classmethod
+    def get_as_choices(cls):
+        return [(name, unicode(klass.label)) for name, klass in cls._registry.items()]
+
+    def get_arguments(self):
+        return []
+
+    def is_local_realm(self):
+        return self.realm == REALM_LOCAL
+
+    def is_remote_realm(self):
+        return self.realm == REALM_REMOTE
+
+    def backup(self, data, dry_run):
+        raise NotImplemented
+        
+    def restore(self):
+        """
+        Must return data or a file like object
+        """
+        raise NotImplemented
+    
+    def __unicode__(self):
+        return unicode(self.label)
+
+
+class TestStorage(StorageModuleBase):
+    name = 'test_storage'
+    label = _(u'Test storage module')
+    realm = StorageModuleBase.REALM_LOCAL
+
+    def __init__(self, *args, **kwargs):
+        self.backup_path = kwargs.pop('backup_path', None)
+        self.restore_path = kwargs.pop('restore_path', None)
+
+    def get_arguments(self):
+        return ['backup_path', 'restore_path']
+    
+    def backup(self, elements, dry_run):
+        logger.debug('self.backup_path: %s' % self.backup_path)
+
+        for element in elements:
+            content_file = element.save()
+            logger.debug('element.filename: %s' % element.filename)
+            logger.debug('element.content: %s' % element.content)
+    
+    def restore(self):
+        print 'restore from path: %s' % self.restore_path
+        return 'sample_data'
+
+
+class LocalFileSystemStorage(FileSystemStorage):
+    """
+    Simple wrapper for the stock Django FileSystemStorage class
+    """
+    name = 'local_filesystem_storage'
+    label = _(u'Local filesystem')
+    realm = StorageModuleBase.REALM_LOCAL
+
+    separator = os.path.sep
+
+    def get_arguments(self):
+        return ['backup_path', 'restore_path']
+    
+    def backup(self, elements, dry_run):
+        logger.debug('self.backup_path: %s' % self.backup_path)
+        for element in elements:
+            content_file = element.save()
+            path = self.storage.save(content_file.name, content_file)
+            logger.debug('element.filename: %s' % element.filename)
+            logger.debug('element.content: %s' % element.content)
+
+    def restore(self):
+        print 'restore from path: %s' % self.restore_path
+        return 'sample_data'
+
+    def __init__(self, *args, **kwargs):
+        self.backup_path = kwargs.pop('backup_path', None)
+        self.storage = FileSystemStorage(location=self.backup_path)
+
+
+StorageModuleBase.register(LocalFileSystemStorage)
+StorageModuleBase.register(TestStorage)

apps/app_registry/forms.py

@@ -0,0 +1,20 @@
+from __future__ import absolute_import
+
+from django import forms
+
+from common.widgets import ScrollableCheckboxSelectMultiple
+
+from .classes import AppBackup
+from .models import App, BackupJob
+
+
+def valid_app_choices():
+    # Return app that exist in the app registry and that have been registered for backup
+    return App.live.filter(pk__in=[appbackup.app.pk for appbackup in AppBackup.get_all()])
+
+
+class BackupJobForm(forms.ModelForm):
+    apps = forms.ModelMultipleChoiceField(queryset=valid_app_choices(), widget=ScrollableCheckboxSelectMultiple())
+
+    class Meta:
+        model = BackupJob

apps/app_registry/links.py

@@ -0,0 +1,21 @@
+from __future__ import absolute_import
+
+from django.utils.translation import ugettext_lazy as _
+
+from navigation.api import Link
+from icons.api import get_icon_name, get_sprite_name
+from icons.literals import APP
+
+from .permissions import PERMISSION_BACKUP_JOB_VIEW, PERMISSION_BACKUP_JOB_CREATE, PERMISSION_BACKUP_JOB_EDIT, PERMISSION_BACKUP_JOB_DELETE
+
+app_registry_tool_link = Link(text=_(u'Apps'), view='app_list', icon=get_icon_name(APP))#, permissions=[PERMISSION_BACKUP_JOB_VIEW])
+app_list = Link(text=_(u'app list'), view='app_list', sprite=get_sprite_name(APP))#, permissions=[PERMISSION_BACKUP_JOB_VIEW])
+
+backup_tool_link = Link(text=_(u'backups'), view='backup_job_list', icon='cd_burn.png', permissions=[PERMISSION_BACKUP_JOB_VIEW])
+backup_job_list = Link(text=_(u'backup job list'), view='backup_job_list', sprite='cd_burn', permissions=[PERMISSION_BACKUP_JOB_VIEW])
+backup_job_create = Link(text=_(u'create'), view='backup_job_create', sprite='cd_add', permissions=[PERMISSION_BACKUP_JOB_CREATE])
+backup_job_edit = Link(text=_(u'edit'), view='backup_job_edit', args='object.pk', sprite='cd_edit', permissions=[PERMISSION_BACKUP_JOB_EDIT])
+backup_job_test = Link(text=_(u'test'), view='backup_job_test', args='object.pk', sprite='cd_go')#, permissions=[PERMISSION_BACKUP_JOB_TEST])
+backup_job_delete = Link(text=_(u'delete'), view='backup_job_delete', args='object.pk', sprite='cd_delete', permissions=[PERMISSION_BACKUP_JOB_DELETE])
+
+restore_tool_link = Link(text=_(u'restore'), view='restore_view', icon='cd_eject.png')#, permissions=[])

apps/app_registry/literals.py

@@ -0,0 +1 @@
+BACKUP_JOB_QUEUE_NAME = 'backups_queue'

apps/app_registry/migrations/0001_initial.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding model 'App'
+        db.create_table('app_registry_app', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('name', self.gf('django.db.models.fields.CharField')(max_length=64)),
+        ))
+        db.send_create_signal('app_registry', ['App'])
+
+
+    def backwards(self, orm):
+        # Deleting model 'App'
+        db.delete_table('app_registry_app')
+
+
+    models = {
+        'app_registry.app': {
+            'Meta': {'ordering': "('name',)", 'object_name': 'App'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '64'})
+        }
+    }
+
+    complete_apps = ['app_registry']

apps/app_registry/migrations/0002_auto__add_field_app_icon__add_unique_app_name.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding field 'App.icon'
+        db.add_column('app_registry_app', 'icon',
+                      self.gf('django.db.models.fields.CharField')(default='', max_length=64, blank=True),
+                      keep_default=False)
+
+        # Adding unique constraint on 'App', fields ['name']
+        db.create_unique('app_registry_app', ['name'])
+
+
+    def backwards(self, orm):
+        # Removing unique constraint on 'App', fields ['name']
+        db.delete_unique('app_registry_app', ['name'])
+
+        # Deleting field 'App.icon'
+        db.delete_column('app_registry_app', 'icon')
+
+
+    models = {
+        'app_registry.app': {
+            'Meta': {'ordering': "('name',)", 'object_name': 'App'},
+            'icon': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '64'})
+        }
+    }
+
+    complete_apps = ['app_registry']

apps/app_registry/migrations/0003_auto__add_backupjob.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding model 'BackupJob'
+        db.create_table('app_registry_backupjob', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('name', self.gf('django.db.models.fields.CharField')(max_length=64)),
+            ('enabled', self.gf('django.db.models.fields.BooleanField')(default=True)),
+            ('begin_datetime', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime(2012, 8, 18, 0, 0))),
+            ('storage_module_name', self.gf('django.db.models.fields.CharField')(max_length=32)),
+            ('storage_arguments_json', self.gf('django.db.models.fields.TextField')(blank=True)),
+        ))
+        db.send_create_signal('app_registry', ['BackupJob'])
+
+        # Adding M2M table for field apps on 'BackupJob'
+        db.create_table('app_registry_backupjob_apps', (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('backupjob', models.ForeignKey(orm['app_registry.backupjob'], null=False)),
+            ('app', models.ForeignKey(orm['app_registry.app'], null=False))
+        ))
+        db.create_unique('app_registry_backupjob_apps', ['backupjob_id', 'app_id'])
+
+
+    def backwards(self, orm):
+        # Deleting model 'BackupJob'
+        db.delete_table('app_registry_backupjob')
+
+        # Removing M2M table for field apps on 'BackupJob'
+        db.delete_table('app_registry_backupjob_apps')
+
+
+    models = {
+        'app_registry.app': {
+            'Meta': {'ordering': "('name',)", 'object_name': 'App'},
+            'icon': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '64'})
+        },
+        'app_registry.backupjob': {
+            'Meta': {'object_name': 'BackupJob'},
+            'apps': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['app_registry.App']", 'symmetrical': 'False'}),
+            'begin_datetime': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2012, 8, 18, 0, 0)'}),
+            'enabled': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '64'}),
+            'storage_arguments_json': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'storage_module_name': ('django.db.models.fields.CharField', [], {'max_length': '32'})
+        }
+    }
+
+    complete_apps = ['app_registry']

apps/app_registry/migrations/0004_auto.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding M2M table for field dependencies on 'App'
+        db.create_table('app_registry_app_dependencies', (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('from_app', models.ForeignKey(orm['app_registry.app'], null=False)),
+            ('to_app', models.ForeignKey(orm['app_registry.app'], null=False))
+        ))
+        db.create_unique('app_registry_app_dependencies', ['from_app_id', 'to_app_id'])
+
+
+    def backwards(self, orm):
+        # Removing M2M table for field dependencies on 'App'
+        db.delete_table('app_registry_app_dependencies')
+
+
+    models = {
+        'app_registry.app': {
+            'Meta': {'ordering': "('name',)", 'object_name': 'App'},
+            'dependencies': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'dependencies_rel_+'", 'null': 'True', 'to': "orm['app_registry.App']"}),
+            'icon': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '64'})
+        },
+        'app_registry.backupjob': {
+            'Meta': {'object_name': 'BackupJob'},
+            'apps': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['app_registry.App']", 'symmetrical': 'False'}),
+            'begin_datetime': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2012, 8, 18, 0, 0)'}),
+            'enabled': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '64'}),
+            'storage_arguments_json': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'storage_module_name': ('django.db.models.fields.CharField', [], {'max_length': '32'})
+        }
+    }
+
+    complete_apps = ['app_registry']

apps/app_registry/migrations/0005_auto.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Removing M2M table for field dependencies on 'App'
+        db.delete_table('app_registry_app_dependencies')
+
+
+    def backwards(self, orm):
+        # Adding M2M table for field dependencies on 'App'
+        db.create_table('app_registry_app_dependencies', (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('from_app', models.ForeignKey(orm['app_registry.app'], null=False)),
+            ('to_app', models.ForeignKey(orm['app_registry.app'], null=False))
+        ))
+        db.create_unique('app_registry_app_dependencies', ['from_app_id', 'to_app_id'])
+
+
+    models = {
+        'app_registry.app': {
+            'Meta': {'ordering': "('name',)", 'object_name': 'App'},
+            'icon': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '64'})
+        },
+        'app_registry.backupjob': {
+            'Meta': {'object_name': 'BackupJob'},
+            'apps': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['app_registry.App']", 'symmetrical': 'False'}),
+            'begin_datetime': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2012, 8, 18, 0, 0)'}),
+            'enabled': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '64'}),
+            'storage_arguments_json': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'storage_module_name': ('django.db.models.fields.CharField', [], {'max_length': '32'})
+        }
+    }
+
+    complete_apps = ['app_registry']

apps/app_registry/migrations/0006_auto.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding M2M table for field dependencies on 'App'
+        db.create_table('app_registry_app_dependencies', (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('from_app', models.ForeignKey(orm['app_registry.app'], null=False)),
+            ('to_app', models.ForeignKey(orm['app_registry.app'], null=False))
+        ))
+        db.create_unique('app_registry_app_dependencies', ['from_app_id', 'to_app_id'])
+
+
+    def backwards(self, orm):
+        # Removing M2M table for field dependencies on 'App'
+        db.delete_table('app_registry_app_dependencies')
+
+
+    models = {
+        'app_registry.app': {
+            'Meta': {'ordering': "('name',)", 'object_name': 'App'},
+            'dependencies': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['app_registry.App']", 'null': 'True', 'blank': 'True'}),
+            'icon': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '64'})
+        },
+        'app_registry.backupjob': {
+            'Meta': {'object_name': 'BackupJob'},
+            'apps': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['app_registry.App']", 'symmetrical': 'False'}),
+            'begin_datetime': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2012, 8, 18, 0, 0)'}),
+            'enabled': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '64'}),
+            'storage_arguments_json': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'storage_module_name': ('django.db.models.fields.CharField', [], {'max_length': '32'})
+        }
+    }
+
+    complete_apps = ['app_registry']

apps/app_registry/models.py

@@ -0,0 +1,119 @@
+from __future__ import absolute_import
+
+import datetime
+import logging
+
+from django.db import models
+from django.db import DatabaseError, transaction
+from django.utils.translation import ugettext_lazy as _
+from django.utils.translation import ugettext
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.contenttypes import generic
+
+from common.models import TranslatableLabelMixin, LiveObjectMixin
+
+from .classes import AppBackup, StorageModuleBase
+
+logger = logging.getLogger(__name__)
+
+
+class App(TranslatableLabelMixin, LiveObjectMixin, models.Model):
+    translatables = ['label', 'description']
+
+    class UnableToRegister(Exception):
+        pass
+    
+    name = models.CharField(max_length=64, verbose_name=_(u'name'), unique=True)
+    icon = models.CharField(max_length=64, verbose_name=_(u'icon'), blank=True)
+    dependencies = models.ManyToManyField('self', verbose_name=_(u'dependencies'), symmetrical=False, blank=True, null=True)
+    #version
+    #top_urls
+    #namespace
+
+    @classmethod
+    @transaction.commit_on_success
+    def register(cls, name, label, icon=None, description=None):
+        try:
+            app, created = App.objects.get_or_create(name=name)
+        except DatabaseError:
+            transaction.rollback()
+            raise cls.UnableToRegister
+        else:
+            app.label = label
+            if icon:
+                app.icon = icon
+            if description:
+                app.description = description
+            app.dependencies.clear()
+            app.save()
+            return app    
+    
+    def set_dependencies(self, app_names):
+        for app_name in app_names:
+            app = App.objects.get(name=app_name)
+            self.dependencies.add(app)
+            
+    def set_backup(self, *args, **kwargs):
+        return AppBackup(self, *args, **kwargs)
+        
+    def __unicode__(self):
+        return unicode(self.label)
+
+    class Meta:
+        ordering = ('name', )
+        verbose_name = _(u'app')
+        verbose_name_plural = _(u'apps')
+
+
+class BackupJob(models.Model):
+    name = models.CharField(max_length=64, verbose_name=_(u'name'))
+    enabled = models.BooleanField(default=True, verbose_name=_(u'enabled'))
+    apps = models.ManyToManyField(App)
+    begin_datetime = models.DateTimeField(verbose_name=_(u'begin date and time'), default=lambda: datetime.datetime.now())
+
+    # * repetition = 
+    #   day - 1 days
+    #    weekly - days of week checkbox
+    #   month - day of month, day of week
+    # * repetition option field
+    # * ends
+    #   - never
+    #   - After # ocurrences
+    #   - On date
+    # * end option field
+    # * type
+    #    - Full
+    #    - Incremental
+    storage_module_name = models.CharField(max_length=32, choices=StorageModuleBase.get_as_choices(), verbose_name=_(u'storage module'))
+    storage_arguments_json = models.TextField(verbose_name=_(u'storage module arguments (in JSON)'), blank=True)
+
+    def __unicode__(self):
+        return self.name
+
+    @property
+    def storage_module(self):
+        return StorageModuleBase.get(self.storage_module_name)
+
+    def backup(self, dry_run=False):
+        logger.debug('starting: %s', self)
+        logger.debug('dry_run: %s' % dry_run)
+        storage_module = self.storage_module
+        #TODO: loads
+        for app in self.apps.all():
+            app_backup = AppBackup.get(app)
+            app_backup.backup(storage_module(backup_path='/tmp'), dry_run=dry_run)
+
+    def save(self, *args, **kwargs):
+        #dump
+        super(BackupJob, self).save(*args, **kwargs)
+
+    @models.permalink
+    def get_absolute_url(self):
+        return ('checkout_info', [self.document.pk])
+
+    class Meta:
+        verbose_name = _(u'document checkout')
+        verbose_name_plural = _(u'document checkouts')
+
+
+#class BackupJobLog

apps/app_registry/permissions.py

@@ -0,0 +1,12 @@
+from __future__ import absolute_import
+
+from django.utils.translation import ugettext_lazy as _
+
+from permissions.models import PermissionNamespace, Permission
+
+namespace = PermissionNamespace('backups', _(u'Backups'))
+
+PERMISSION_BACKUP_JOB_VIEW = Permission.objects.register(namespace, 'backup_job_view', _(u'View a backup job'))
+PERMISSION_BACKUP_JOB_CREATE = Permission.objects.register(namespace, 'backup_job_view', _(u'Create backup jobs'))
+PERMISSION_BACKUP_JOB_EDIT = Permission.objects.register(namespace, 'backup_job_edit', _(u'Edit an existing backup jobs'))
+PERMISSION_BACKUP_JOB_DELETE = Permission.objects.register(namespace, 'backup_job_delete', _(u'Delete an existing backup jobs'))

apps/app_registry/urls.py

@@ -0,0 +1,10 @@
+from django.conf.urls.defaults import patterns, url
+
+urlpatterns = patterns('app_registry.views',
+    url(r'^list/$', 'app_list', (), 'app_list'),
+    url(r'^jobs/list/$', 'backup_job_list', (), 'backup_job_list'),
+    url(r'^jobs/create/$', 'backup_job_create', (), 'backup_job_create'),
+    url(r'^jobs/(?P<backup_job_pk>\d+)/edit/$', 'backup_job_edit', (), 'backup_job_edit'),
+    url(r'^jobs/(?P<backup_job_pk>\d+)/test/$', 'backup_job_test', (), 'backup_job_test'),
+    #url(r'^jobs/(?P<backup_job_pk>\d+)/delete/$', 'backup_job_delete', (), 'backup_job_delete'),
+)

apps/app_registry/views.py

@@ -0,0 +1,144 @@
+from __future__ import absolute_import
+
+from django.conf import settings
+from django.contrib import messages
+from django.core.urlresolvers import reverse
+from django.http import HttpResponseRedirect
+from django.shortcuts import render_to_response, get_object_or_404
+from django.template import RequestContext
+from django.utils.translation import ugettext as _
+
+from common.utils import encapsulate
+from icons.widgets import icon_widget
+from icons.literals import APP
+from permissions.models import Permission
+
+from .classes import AppBackup
+from .forms import BackupJobForm
+from .models import App, BackupJob
+from .permissions import PERMISSION_BACKUP_JOB_VIEW, PERMISSION_BACKUP_JOB_CREATE, PERMISSION_BACKUP_JOB_EDIT
+
+
+def app_list(request):
+    #order =  [i for i,f in sorted(smart_modules.items(), key=lambda k: 'dependencies' in k[1] and k[1]['dependencies'])]
+
+    return render_to_response('generic_list.html', {
+        'object_list' : App.live.all(),
+        'hide_object': True,
+        'extra_columns': [
+            {'name': _(u'icon'), 'attribute': 'icon'},
+            {'name':_(u'icon'), 'attribute': encapsulate(lambda x: icon_widget(x.icon or APP))},
+            {'name': _(u'label'), 'attribute': 'label'},
+            {'name':_(u'description'), 'attribute': 'description'},
+            {'name':_(u'dependencies'), 'attribute': encapsulate(lambda x: u', '.join([unicode(dependency) for dependency in x.dependencies.all()]))},
+        ],
+    }, context_instance=RequestContext(request))
+
+
+def backup_job_list(request):
+    pre_object_list = BackupJob.objects.all()
+
+    try:
+        Permission.objects.check_permissions(request.user, [PERMISSION_BACKUP_JOB_VIEW])
+    except PermissionDenied:
+        # If user doesn't have global permission, get a list of backup jobs
+        # for which he/she does have access use it to filter the
+        # provided object_list
+        final_object_list = AccessEntry.objects.filter_objects_by_access(PERMISSION_BACKUP_JOB_VIEW, request.user, pre_object_list)
+    else:
+        final_object_list = pre_object_list
+
+    context = {
+        'object_list': final_object_list,
+        'title': _(u'backup jobs'),
+        'hide_link': True,
+        #'extra_columns': [
+        #    {'name': _(u'info'), 'attribute': 'info'},
+        #],
+    }
+    return render_to_response('generic_list.html', context,
+        context_instance=RequestContext(request))
+
+
+def backup_job_create(request):
+    Permission.objects.check_permissions(request.user, [PERMISSION_BACKUP_JOB_CREATE])
+
+    if request.method == 'POST':
+        form = BackupJobForm(data=request.POST)
+        if form.is_valid():
+            try:
+                backup_job = form.save()
+            except Exception, exc:
+                messages.error(request, _(u'Error creating backup job; %s') % exc)
+            else:
+                messages.success(request, _(u'Backup job "%s" created successfully.') % backup_job)
+                return HttpResponseRedirect(reverse('backup_job_list'))
+    else:
+        form = BackupJobForm()
+
+    return render_to_response('generic_form.html', {
+        'form': form,
+        'title': _(u'Create backup job')
+    }, context_instance=RequestContext(request))
+    
+
+def backup_job_edit(request, backup_job_pk):
+    backup_job = get_object_or_404(BackupJob, pk=backup_job_pk)
+    try:
+        Permission.objects.check_permissions(request.user, [PERMISSION_BACKUP_JOB_EDIT])
+    except PermissionDenied:
+        AccessEntry.objects.check_access(PERMISSION_BACKUP_JOB_EDIT, request.user, backup_job)
+
+    if request.method == 'POST':
+        form = BackupJobForm(data=request.POST, instance=backup_job)
+        if form.is_valid():
+            try:
+                backup_job = form.save()
+            except Exception, exc:
+                messages.error(request, _(u'Error editing backup job; %s') % exc)
+            else:
+                messages.success(request, _(u'Backup job "%s" edited successfully.') % backup_job)
+                return HttpResponseRedirect(reverse('backup_job_list'))
+    else:
+        form = BackupJobForm(instance=backup_job)
+
+    return render_to_response('generic_form.html', {
+        'form': form,
+        'object': backup_job,
+        'title': _(u'Edit backup job: %s') % backup_job
+    }, context_instance=RequestContext(request))
+
+
+def backup_job_test(request, backup_job_pk):
+    backup_job = get_object_or_404(BackupJob, pk=backup_job_pk)
+    #try:
+    #    Permission.objects.check_permissions(request.user, [PERMISSION_BACKUP_JOB_EDIT])
+    #except PermissionDenied:
+    #    AccessEntry.objects.check_access(PERMISSION_BACKUP_JOB_EDIT, request.user, backup_job)
+
+    try:
+        backup_job.backup(dry_run=True)
+    except Exception, exc:
+        if settings.DEBUG:
+            raise
+        else:
+            messages.error(request, _(u'Error testing backup job; %s') % exc)
+            return HttpResponseRedirect(reverse('backup_job_list'))
+    else:
+        messages.success(request, _(u'Test for backup job "%s" finished successfully.') % backup_job)
+        return HttpResponseRedirect(reverse('backup_job_list'))
+
+
+def backup_view(request):
+    #Permission.objects.check_permissions(request.user, [])
+
+    context = {
+        'object_list': AppBackup.get_all(),
+        'title': _(u'registered apps for backup'),
+        'hide_link': True,
+        'extra_columns': [
+            {'name': _(u'info'), 'attribute': 'info'},
+        ],
+    }
+    return render_to_response('generic_list.html', context,
+        context_instance=RequestContext(request))

apps/bootstrap/__init__.py

@@ -1,7 +1,10 @@
 from __future__ import absolute_import
 
-from project_setup.api import register_setup
+from django.utils.translation import ugettext_lazy as _
+
 from navigation.api import bind_links
+from project_setup.api import register_setup
+from app_registry.models import App
 
 from .links import database_bootstrap, bootstrap_execute, erase_database_link
 from .api import BootstrapSimple, BootstrapPermit
@@ -10,3 +13,10 @@ register_setup(database_bootstrap)
 register_setup(erase_database_link)
 bind_links([BootstrapSimple], [bootstrap_execute])
 bind_links([BootstrapPermit], [bootstrap_execute])
+
+try:
+    app = App.register('bootstrap', _(u'Database bootstrap'))
+except App.UnableToRegister:
+    pass
+else:
+    app.set_dependencies(['app_registry'])

apps/checkouts/__init__.py

@@ -2,12 +2,12 @@ from __future__ import absolute_import
 
 from django.utils.translation import ugettext_lazy as _
 
+from acls.api import class_permissions
+from app_registry.models import App
+from documents.models import Document
 from navigation.api import bind_links, register_top_menu
 from scheduler.api import LocalScheduler
 
-from documents.models import Document
-from acls.api import class_permissions
-
 from .permissions import (PERMISSION_DOCUMENT_CHECKOUT,
     PERMISSION_DOCUMENT_CHECKIN, PERMISSION_DOCUMENT_CHECKIN_OVERRIDE,
     PERMISSION_DOCUMENT_RESTRICTIONS_OVERRIDE)
@@ -40,3 +40,11 @@ checkouts_scheduler.add_interval_job('task_check_expired_check_outs', _(u'Check
 checkouts_scheduler.start()
 
 initialize_document_checkout_extra_methods()
+
+try:
+    app = App.register('checkouts', _(u'Checkouts'))
+except App.UnableToRegister:
+    pass
+else:
+    app.set_dependencies(['app_registry'])
+#    AppBackup(app, [ModelBackup()])    

apps/common/models.py

@@ -60,3 +60,56 @@ class AutoAdminSingleton(Singleton):
 
     class Meta:
         verbose_name = verbose_name_plural = _(u'auto admin properties')
+
+
+class TranslatableLabelMixin(models.Model):
+    _translatable_registry = {}
+    
+    class NotConfigured(Exception):
+        pass
+    
+    def __getattr__(self, attr):
+        if attr in self.__class__.translatables:
+            try:
+                return self.__class__._translatable_registry[self.pk][attr]
+            except KeyError:
+                return u''
+        else:
+            raise AttributeError('\'%s\' object has no attribute \'%s\'' % (self.__class__, attr))
+
+    def __setattr__(self, attr, value):
+        if not hasattr(self.__class__, 'translatables'):
+            raise self.__class__.NotConfigured('Must specify a list of translatable class attributes')
+            
+        if attr in self.__class__.translatables:
+            self.__class__._translatable_registry.setdefault(self.pk, {})
+            self.__class__._translatable_registry[self.pk][attr] = value
+        else:
+            return super(TranslatableLabelMixin, self).__setattr__(attr, value)
+
+    def __init__(self, *args, **kwargs):
+        super(TranslatableLabelMixin, self).__init__(*args, **kwargs)
+        self.__class__._translatable_registry.setdefault(self.pk, {})
+        
+    class Meta:
+        abstract = True
+
+
+class LiveObjectsManager(models.Manager):
+    def get_query_set(self):
+        return super(LiveObjectsManager, self).get_query_set().filter(pk__in=(entry.pk for entry in self.model._registry))
+
+
+class LiveObjectMixin(models.Model):
+    _registry = []
+   
+    def save(self, *args, **kwargs):
+        super(LiveObjectMixin, self).save(*args, **kwargs)
+        self.__class__._registry.append(self)
+        return self
+
+    live = LiveObjectsManager()
+    objects = models.Manager()
+    
+    class Meta:
+        abstract = True

apps/common/utils.py

@@ -433,3 +433,25 @@ def copyfile(source, destination, buffer_size=1024 * 1024):
 
     source_descriptor.close()
     destination_descriptor.close()
+
+
+
+#From: http://tomforb.es/using-python-metaclasses-to-make-awesome-django-model-field-choices?pid=0&utm_source=agiliq&utm_medium=agiliq
+import inspect
+
+class Choice(object):
+    class __metaclass__(type):
+        def __init__(self, name, type, other):
+            self._data = []
+            for name, value in inspect.getmembers(self):
+                if not name.startswith('_') and not inspect.isfunction(value):
+                    if isinstance(value,tuple) and len(value) > 1:
+                        data = value
+                    else:
+                        data = (value, ' '.join([x.capitalize() for x in name.split('_')]),)
+                    self._data.append(data)
+                    setattr(self, name, data[0])
+
+        def __iter__(self):
+            for value, data in self._data:
+                yield value, data

apps/document_indexing/__init__.py

@@ -2,25 +2,25 @@ from __future__ import absolute_import
 
 import logging
 
+from django.db.models.signals import post_save, pre_delete, post_delete
 from django.dispatch import receiver
 from django.utils.translation import ugettext_lazy as _
-from django.db.models.signals import post_save, pre_delete, post_delete
 
+from app_registry.models import App
+from documents.models import Document
+from maintenance.api import MaintenanceNamespace
+from metadata.models import DocumentMetadata
 from navigation.api import (register_top_menu, register_sidebar_template,
     bind_links, Link)
-
-from maintenance.api import MaintenanceNamespace
-from documents.models import Document
-from metadata.models import DocumentMetadata
 from project_setup.api import register_setup
 
-from .models import (Index, IndexTemplateNode, IndexInstanceNode)
 from .api import update_indexes, delete_indexes
 from .links import (index_setup, index_setup_list, index_setup_create,
     index_setup_edit, index_setup_delete, index_setup_view,
     template_node_create, template_node_edit, template_node_delete,
     index_parent, document_index_list, rebuild_index_instances,
     index_setup_document_types)
+from .models import (Index, IndexTemplateNode, IndexInstanceNode)
 
 logger = logging.getLogger(__name__)
 
@@ -70,3 +70,12 @@ def document_metadata_index_delete(sender, **kwargs):
 def document_metadata_index_post_delete(sender, **kwargs):
     # TODO: save result in index log
     update_indexes(kwargs['instance'].document)
+
+try:
+    app = App.register('document_indexing', _(u'Document indexing'))
+except App.UnableToRegister:
+    pass
+else:
+    app.set_dependencies(['app_registry', 'documents'])
+#aelse:
+#    AppBackup(app, [ModelBackup()])

apps/document_indexing/forms.py

@@ -11,6 +11,7 @@ class IndexForm(forms.ModelForm):
     """
     class Meta:
         model = Index
+        exclude = ('document_types',)
 
 
 class IndexTemplateNodeForm(forms.ModelForm):

apps/documents/__init__.py

@@ -4,15 +4,16 @@ import tempfile
 
 from django.utils.translation import ugettext_lazy as _
 
+from acls.api import class_permissions
+from app_registry.models import App
 from common.utils import validate_path, encapsulate
+from diagnostics.api import DiagnosticNamespace
+from history.permissions import PERMISSION_HISTORY_VIEW
+from maintenance.api import MaintenanceNamespace
 from navigation.api import (bind_links, register_top_menu,
     register_model_list_columns,
     register_sidebar_template, Link, register_multi_item_links)
-from diagnostics.api import DiagnosticNamespace
-from maintenance.api import MaintenanceNamespace
-from history.permissions import PERMISSION_HISTORY_VIEW
 from project_setup.api import register_setup
-from acls.api import class_permissions
 from statistics.api import register_statistics
 
 from .models import (Document, DocumentPage,
@@ -136,3 +137,11 @@ class_permissions(Document, [
 ])
 
 register_statistics(get_statistics)
+
+try:
+    app = App.register('documents', _(u'Documents'))
+except App.UnableToRegister:
+    pass
+else:
+    app.set_dependencies(['app_registry'])
+    #AppBackup(app, [ModelBackup(), FileBackup(document_settings.STORAGE_BACKEND)])

apps/documents/statistics.py

@@ -61,7 +61,7 @@ def get_statistics():
     paragraphs.extend(
         [
             _(u'Document pages in database: %d') % DocumentPage.objects.only('pk',).count(),
-            _(u'Minimum amount of pages per document: %d') % (document_stats['page_count__max'] or 0),
+            _(u'Minimum amount of pages per document: %d') % (document_stats['page_count__min'] or 0),
             _(u'Maximum amount of pages per document: %d') % (document_stats['page_count__max'] or 0),
             _(u'Average amount of pages per document: %f') % (document_stats['page_count__avg'] or 0),
         ]

apps/folders/__init__.py

@@ -2,33 +2,29 @@ from __future__ import absolute_import
 
 from django.utils.translation import ugettext_lazy as _
 
-from navigation.api import (bind_links, register_top_menu,
-    register_multi_item_links, register_sidebar_template, Link)
-from documents.models import Document
 from acls.api import class_permissions
 from acls.permissions import ACLS_EDIT_ACL, ACLS_VIEW_ACL
+#from app_registry import register_app, UnableToRegister
+#from backups.api import AppBackup, ModelBackup
+from documents.models import Document
+from navigation.api import (bind_links, register_top_menu,
+    register_multi_item_links, register_sidebar_template, Link)
 
-from .models import Folder
 from .links import (folder_list, folder_create, folder_edit,
     folder_delete, folder_document_multiple_remove, folder_view,
     folder_add_document, document_folder_list, folder_acl_list)
+from .models import Folder
 from .permissions import (PERMISSION_FOLDER_EDIT, PERMISSION_FOLDER_DELETE,
     PERMISSION_FOLDER_REMOVE_DOCUMENT, PERMISSION_FOLDER_VIEW,
     PERMISSION_FOLDER_ADD_DOCUMENT)
 
-register_multi_item_links(['folder_view'], [folder_document_multiple_remove])
-
-bind_links([Folder], [folder_view, folder_edit, folder_delete, folder_acl_list])
-
-bind_links([Folder, 'folder_list', 'folder_create'], [folder_list, folder_create], menu_name='secondary_menu')
-
 register_top_menu(name='folders', link=Link(text=_('folders'), sprite='folder_user', view='folder_list', children_views=['folder_list', 'folder_create', 'folder_edit', 'folder_delete', 'folder_view', 'folder_document_multiple_remove']))
-
+register_multi_item_links(['folder_view'], [folder_document_multiple_remove])
+bind_links([Folder], [folder_view, folder_edit, folder_delete, folder_acl_list])
+bind_links([Folder, 'folder_list', 'folder_create'], [folder_list, folder_create], menu_name='secondary_menu')
 bind_links([Document], [document_folder_list], menu_name='form_header')
-
-register_sidebar_template(['folder_list'], 'folders_help.html')
-
 bind_links(['document_folder_list', 'folder_add_document'], [folder_add_document], menu_name="sidebar")
+register_sidebar_template(['folder_list'], 'folders_help.html')
 
 class_permissions(Folder, [
     PERMISSION_FOLDER_EDIT,
@@ -42,3 +38,10 @@ class_permissions(Document, [
     PERMISSION_FOLDER_ADD_DOCUMENT,
     PERMISSION_FOLDER_REMOVE_DOCUMENT,
 ])
+
+#try:
+#    app = register_app('folders', _(u'Folders'))
+#except UnableToRegister:
+#    pass
+#else:
+#    AppBackup(app, [ModelBackup()])

apps/history/__init__.py

@@ -2,9 +2,11 @@ from __future__ import absolute_import
 
 from django.utils.translation import ugettext_lazy as _
 
-from project_tools.api import register_tool
-from navigation.api import bind_links, register_model_list_columns
+from app_registry.models import App
+from app_registry.classes import ModelBackup
 from common.utils import encapsulate
+from navigation.api import bind_links, register_model_list_columns
+from project_tools.api import register_tool
 
 from .models import History
 from .widgets import history_entry_type_link
@@ -28,3 +30,11 @@ register_model_list_columns(History, [
 ])
 
 bind_links([History], [history_details])
+
+try:
+    app = App.register('history', _(u'History'))
+except App.UnableToRegister:
+    pass
+else:
+    app.set_backup([ModelBackup()])
+    app.set_dependencies(['app_registry'])

apps/icons/__init__.py

@@ -0,0 +1,10 @@
+from django.utils.translation import ugettext_lazy as _
+
+from app_registry.models import App
+
+try:
+    app = App.register('icons', _(u'Icons'))
+except App.UnableToRegister:
+    pass
+else:
+    app.set_dependencies(['app_registry'])

apps/icons/api.py

@@ -0,0 +1,22 @@
+from __future__ import absolute_import
+
+from .conf import settings
+from .sets import ICON_THEMES
+from .literals import ERROR
+
+
+def get_icon_name(icon):
+    try:
+        return ICON_THEMES[settings.ICON_SET][icon]
+    except KeyError:
+        return ICON_THEMES[settings.ICON_SET][ERROR]
+    except AttributeError:
+        pass
+
+def get_sprite_name(sprite):
+    try:
+        return ICON_THEMES[settings.ICON_SET][sprite]
+    except KeyError:
+        return ICON_THEMES[settings.ICON_SET][ERROR]
+    except AttributeError:
+        pass

apps/icons/conf/settings.py

@@ -0,0 +1,24 @@
+"""
+Configuration options for the documents app
+"""
+from __future__ import absolute_import
+
+from django.utils.translation import ugettext_lazy as _
+from django.conf import settings
+
+from storage.backends.filebasedstorage import FileBasedStorage
+from smart_settings.api import Setting, SettingNamespace
+from ..literals import DEFAULT_ICON_SET
+
+from .. import app
+print '__file__', __file__
+namespace = SettingNamespace(app.name, app.label, module='icons.conf.settings', sprite='page')
+
+# Saving
+
+Setting(
+    namespace=namespace,
+    name='ICON_SET',
+    global_name='ICONS_ICON_SET',
+    default=DEFAULT_ICON_SET,
+)

apps/icons/literals.py

@@ -0,0 +1,10 @@
+#from icons.sets import fat_cow, famfamfam
+
+#DEFAULT_ICON_SET = fat_cow.ID
+DEFAULT_ICON_SET = 'fat_cow'
+
+APP = 'app'
+BACKUPS = 'backups'
+ERROR = 'error'
+ICONS = 'icons'
+

apps/icons/models.py

@@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.

apps/icons/sets/__init__.py

@@ -0,0 +1,39 @@
+from __future__ import absolute_import
+
+from django.utils.translation import ugettext_lazy as _
+
+from icons.sets import fat_cow, famfamfam
+
+
+SET_CHOICES = (
+    (fat_cow.ID, fat_cow.LABEL),
+    (famfamfam.ID, famfamfam.LABEL),
+)
+
+ICON_THEMES = {
+    fat_cow.ID: fat_cow.DICTIONARY,
+    famfamfam.ID: famfamfam.DICTIONARY
+}
+
+
+"""
+THEME_DEFAULT = 'default'
+
+SET_CHOICES = (
+    (fat_cow.ID, fat_cow.LABEL),
+    (famfamfam.ID, famfamfam.LABEL),
+)
+
+THEME_ICONSETS = {
+    THEME_DEFAULT: {
+        'icons': fat_cow.DICTIONARY,
+        'sprites': famfamfam.DICTIONARY
+    }
+}
+
+THEMES_CHOICES = {
+    THEME_DEFAULT: _(u'Default theme (using Fat cow for icons and FamFamFam for sprites)')
+}
+
+DEFAULT_THEME = THEME_DEFAULT
+"""

apps/icons/sets/famfamfam.py

@@ -0,0 +1,11 @@
+from django.utils.translation import ugettext_lazy as _
+
+from icons.literals import *
+
+ID = 'famfamfam'
+LABEL = _(u'FamFamFam')
+
+DICTIONARY = {
+    APP: 'plugin',
+    BACKUPS: 'cd_burn',
+}

apps/icons/sets/fat_cow.py

@@ -0,0 +1,16 @@
+import os
+
+from django.utils.translation import ugettext_lazy as _
+
+from icons.literals import *
+
+PATH = os.path.join('Fat Cow', '32x32')
+ID = 'fat_cow'
+LABEL = _(u'Fat cow')
+
+DICTIONARY = {
+    APP: 'plugin.png',
+    BACKUPS: 'cd_burn.png',
+    ERROR: 'error.png',
+    ICONS: 'application_view_icons.png',
+}