from rattail.util import load_entry_points, load_object

from rattail.mail import send_email

        handler = self.get_handler()

                            help="Which models to import.  If none are specified, all models will "

                            "be imported.  Or, specify only those you wish to import.  Supported "

                            "models are: {0}".format(', '.join(handler.get_importer_keys())))

    def get_handler_factory(self):

        """

        This method must return a factory, which will in turn generate a

        handler instance to be used by the command.  Note that you *must*

        override this method.

        """

        raise NotImplementedError

    def get_handler(self, **kwargs):

        """

        Returns a handler instance to be used by the command.

        """

        factory = self.get_handler_factory()

        return factory(getattr(self, 'config', None), **kwargs)

        Perform a data import, with the given arguments and database session.

        """

        handler = self.get_handler(session=session)

        models = args.models or handler.get_importer_keys()

        updates = handler.import_data(models, max_updates=args.max_updates,

                                      progress=self.progress)

        if args.warnings and updates:

            key = '{0}_{1}_updates'.format(self.parent.name, self.name)

            key = key.replace('-', '_')

            send_email(self.config, key, fallback_key='rattail_import_updates', data={

                'command': '{0} {1}'.format(self.parent.name, self.name),

                'models': models,

                'dry_run': args.dry_run,

                'updates': updates,

                'render_record': self.get_record_renderer()})

    def get_record_renderer(self):

        """

        Get the record renderer for email notifications.  Note that config may

        override the default.

        spec = self.config.get('{0}.{1}'.format(self.parent.name, self.name), 'record_renderer',

                               default='rattail.db.importing:RecordRenderer')

        return load_object(spec)(self.config)

from .core import Importer, make_importer, RecordRenderer

from .handlers import ImportHandler

        created = []

        updated = []

                    updated.append(instance)

                created.append(instance)

        return created, updated

class RecordRenderer(object):

    """

    Record renderer for email notifications sent from data import jobs.

    """

    def __init__(self, config):

        self.config = config

    def __call__(self, record):

        return self.render(record)

    def render(self, record):

        """

        Render the given record.  Default is to attempt.

        """

        key = record.__class__.__name__.lower()

        renderer = getattr(self, 'render_{0}'.format(key), None)

        if renderer:

            return renderer(record)

        label = self.get_label(record)

        url = self.get_url(record)

        if url:

            return '<a href="{0}">{1}</a>'.format(url, label)

        return label

    def get_label(self, record):

        key = record.__class__.__name__.lower()

        label = getattr(self, 'label_{0}'.format(key), self.label)

        return label(record)

    def label(self, record):

        return unicode(record)

    def get_url(self, record):

        """

        Fetch / generate a URL for the given data record.  You should *not*

        override this method, but do :meth:`url()` instead.

        """

        key = record.__class__.__name__.lower()

        url = getattr(self, 'url_{0}'.format(key), self.url)

        return url(record)

    def url(self, record):

        """

        Fetch / generate a URL for the given data record.

        """

        url = self.config.get('tailbone', 'url')

        if url:

            url = url.rstrip('/')

            name = '{0}s'.format(record.__class__.__name__.lower())

            if name == 'persons': # FIXME, obviously this is a hack

                name = 'people'

            url = '{0}/{1}/{{uuid}}'.format(url, name)

            return url.format(uuid=record.uuid)

# -*- coding: utf-8 -*-

################################################################################

#

#  Rattail -- Retail Software Framework

#  Copyright © 2010-2015 Lance Edgar

#

#  This file is part of Rattail.

#

#  Rattail is free software: you can redistribute it and/or modify it under the

#  terms of the GNU Affero General Public License as published by the Free

#  Software Foundation, either version 3 of the License, or (at your option)

#  any later version.

#

#  Rattail is distributed in the hope that it will be useful, but WITHOUT ANY

#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

#  FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for

#  more details.

#

#  You should have received a copy of the GNU Affero General Public License

#  along with Rattail.  If not, see <http://www.gnu.org/licenses/>.

#

################################################################################

"""

Import Handlers

"""

from __future__ import unicode_literals

import logging

from rattail.util import OrderedDict

log = logging.getLogger(__name__)

class ImportHandler(object):

    """

    Base class for all import handlers.

    """

    def __init__(self, config=None, session=None):

        self.config = config

        self.session = session

        self.importers = self.get_importers()

    def get_importers(self):

        """

        Returns a dict of all available importers, where the values are

        importer factories.  All subclasses will want to override this.  Note

        that if you return an ``OrderedDict`` instance, you can affect the

        ordering of keys in the command line help system, etc.

        """

        return {}

    def get_importer_keys(self):

        """

        Returns a list of keys corresponding to the available importers.

        """

        return list(self.importers.iterkeys())

    def get_importer(self, key):

        """

        Returns an importer instance corresponding to the given key.

        """

        return self.importers[key](self.config, self.session,

                                   **self.get_importer_kwargs(key))

    def get_importer_kwargs(self, key):

        """

        Return a dict of kwargs to be used when construcing an importer with

        the given key.

        """

        return {}

    def import_data(self, keys, max_updates=None, progress=None):

        """

        Import all data for the given importer keys.

        """

        self.before_import()

        updates = OrderedDict()

        for key in keys:

            provider = self.get_importer(key)

            if not provider:

                log.warning("unknown importer; skipping: {0}".format(repr(key)))

                continue

            data = provider.get_data(progress=progress)

            created, updated = provider.importer.import_data(

                data, provider.supported_fields, provider.key,

                max_updates=max_updates, progress=progress)

            if hasattr(provider, 'process_deletions'):

                deleted = provider.process_deletions(data, progress=progress)

            else:

                deleted = 0

            log.info("added {0}, updated {1}, deleted {2} {3} records".format(

                len(created), len(updated), deleted, key))

            if created or updated or deleted:

                updates[key] = created, updated, deleted

        self.after_import()

        return updates

    def before_import(self):

        return 

    def after_import(self):

        return 

<html>

  <body>

    <h3>Data Import Warnings (<code>${command}</code>)</h3>

    % if dry_run:

        <p>

          <em><strong>NOTE:</strong>&nbsp; This was a dry run only; no data was harmed

          in the making of this email.</em>

        </p>

    % endif

    <p>

      Generally the periodic data import is expected to be a precaution only, in order

      to detect and fix Rattail data which falls out of sync from the data authority,

      e.g. your POS.  It is normally expected that proper real-time operation

      <em>should</em> be enough to keep things in sync; therefore any actual changes

      which occur as part of the import process are considered "warnings".

    </p>

    <p>

      The following is a list of changes which occurred during the latest

      import run.  Please investigate at your convenience.

    </p>

    <ul>

      % for model, (created, updated, deleted) in updates.iteritems():

          <li>

            <a href="#${model}">${model}</a>

            - ${len(created)} created, ${len(updated)} updated, ${deleted} deleted

          </li>

      % endfor

    </ul>

    % for model, (created, updated, deleted) in updates.iteritems():

        <h4><a name="${model}">${model}</a></h4>

        % for label, records in (('created', created), ('updated', updated)):

            % if records:

                % if len(records) == 1:

                    <p>1 record was <strong>${label}:</strong></p>

                % else:

                    <p>${len(records)} records were <strong>${label}:</strong></p>

                % endif

                <ul>

                  % for record in records:

                      <li>${render_record(record)}</li>

                  % endfor

                </ul>

            % endif

        % endfor

        % if deleted == 1:

            <p>1 record was <strong>deleted</strong></p>

        % elif deleted:

            <p>${deleted} records were <strong>deleted</strong></p>

        % endif

    % endfor

  </body>

</html>