rattail/people

   rattail/problems/index

   rattail/products

   rattail/tailbone

   rattail/time

   rattail/trainwreck/index

import tempfile

import warnings

import logging

import humanize

from mako.template import Template

from rattail.util import (load_object, load_entry_points,

                          pretty_quantity, pretty_hours,

                          NOTSET)

from rattail.files import temp_path, resource_path

                self.config, **kwargs)

        return self.problem_report_handler

    def get_tailbone_handler(self, **kwargs):

        """

        Get the configured "tailbone" handler.

Please note this is different from the Customer Order Handler.

"""

import re

import decimal

import sqlalchemy as sa

from rattail.db import model

from rattail.batch import BatchHandler

from rattail.time import localtime

        """

        contact = self.get_contact(batch)

        if contact:

        pending = batch.pending_customer

        if pending:

    def get_contact_phones(self, batch):

        """

        vendor = product.cost.vendor if product.cost else None

        info = {

            'uuid': product.uuid,

            'item_id': product.item_id,

            'scancode': product.scancode,

            'upc_pretty': product.upc.pretty(),

                sale_ends = sale_price.ends

                if sale_ends:

                    sale_ends = localtime(self.config, sale_ends, from_utc=True).date()

                    info['sale_ends_display'] = self.app.render_date(sale_ends)

        case_price = None

                unit_price = sale_price.price

            case_price = (case_size or 1) * unit_price

            case_price = case_price.quantize(decimal.Decimal('0.01'))

        info['case_price_display'] = self.app.render_currency(case_price)

        key = self.config.product_key()

            row.product_upc = product.upc

            row.product_item_id = product.item_id

            row.product_scancode = product.scancode

            row.product_description = product.description

            row.product_size = product.size

            row.product_weighed = product.weighed

        row.product_upc = pending.upc

        row.product_item_id = pending.item_id

        row.product_scancode = pending.scancode

        row.product_description = pending.description

        row.product_size = pending.size

        # TODO: is this even important?  pending does not have it

Console Commands

"""

import os

import sys

import json

    def run(self, args):

        from sqlalchemy import create_engine, orm

        classes = args.classes

        assert classes

Installer Commands

"""

import os

import stat

import subprocess

import sys

from mako.lookup import TemplateLookup

from rattail.commands.core import Subcommand

from rattail.files import resource_path

class InstallSubcommand(Subcommand):

    def run(self, args):

            resource_path('{}:templates/installer'.format(self.app_package)),

            resource_path('rattail:templates/installer'),

        ])

                       database=dbname)

    def test_db_connection(self, url):

        engine = create_engine(url)

        # check for random table; does not matter if it exists, we

        # just need to test interaction and this is a neutral way

        try:

        except Exception as error:

            return str(error)

            self.rprint("\t[blue]bin/pserve file+ini:app/web.conf[/blue]")

Application Configuration

"""

import os

import re

import sys

import logging

import logging.config

from rattail.exceptions import WindowsExtensionsNotInstalled, ConfigurationError

from rattail.files import temp_path

from rattail.logging import TimeConverter

        """

        kwargs.setdefault('usedb', False)

        spec = self.get('rattail', 'enum', default='rattail.enum', **kwargs)

    def get_model(self):

        """

        :mod:`rattail.db.model`.

        """

        spec = self.get('rattail', 'model', default='rattail.db.model', usedb=False)

    def get_trainwreck_model(self):

        """

        be configured.

        """

        spec = self.require('rattail.trainwreck', 'model', usedb=False)

    def product_key(self, default='upc'):

        """

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

Cache Helpers

"""

import logging

from sqlalchemy.orm import joinedload

from rattail.core import Object

from rattail.db import model

log = logging.getLogger(__name__)

    def get_key(self, instance, normalized):

        if callable(self.key):

            return self.key(instance, normalized)

            return getattr(instance, self.key)

        return tuple(getattr(instance, k) for k in self.key)

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

Database Configuration

"""

import logging

from rattail.exceptions import SQLAlchemyNotInstalled

from rattail.config import parse_list, parse_bool

import socket

import logging

import sqlalchemy as sa

import sqlalchemy_continuum as continuum

from sqlalchemy_continuum.plugins import Plugin

from sqlalchemy_utils.functions import get_primary_keys

# TODO: Deprecate/remove this import.

from rattail.db.config import configure_versioning

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

   from the SIL specification.

"""

BATCH_ACTION_ADD                = 'ADD'

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

CSV -> Rattail data import

"""

import os

import csv

import datetime

import sqlalchemy as sa

from sqlalchemy import orm

from sqlalchemy_utils.functions import get_primary_keys

from rattail.importing.handlers import FromFileHandler

from rattail.importing.files import FromFile

from rattail.db.util import make_topo_sortkey

from rattail.config import parse_bool

        fields = list(mapper.columns.keys())

        pkeys = get_primary_keys(cls)

        name = '{}Importer'.format(name)

        return type(name, (FromCSV, self.ToParent), {

            'model_class': cls,

            'supported_fields': fields,

        return '{}.csv'.format(self.model_name)

    def open_input_file(self):

    def close_input_file(self):

        self.input_file.close()

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

Rattail Data Exporters

"""

import os

import csv

from sqlalchemy import orm

from sqlalchemy_utils.functions import get_primary_keys

from rattail.db.util import make_topo_sortkey

from rattail.importing import Importer

from rattail.importing.rattail import FromRattailHandler, FromRattail

        fields = list(mapper.columns.keys())

        pkeys = get_primary_keys(cls)

        name = '{}Importer'.format(name)

        return type(name, (self.FromParent, ToCSV), {

            'model_class': cls,

            'supported_fields': fields,

    empty_local_data = True

    def open_output_file(self):

        self.write_output_header()

    def write_output_header(self):

                value = ''

            else:

            coerced[field] = value

        return coerced

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

Import Handlers

"""

import os

import sys

import shutil

import tempfile

import logging

import humanize

import sqlalchemy as sa

from rattail.core import get_uuid

from rattail.time import make_utc

from rattail.mail import send_email

        def delete(key, i):

            cached = importer.cached_local_data.pop(key)

            local_data = cached['data']

            sequence = batch.rowcount + 1

            self.make_batch_row(session, importer, row_table, sequence, None, local_data,

                                status_code=self.enum.IMPORTER_BATCH_ROW_STATUS_DELETE)

            if '_object_str' in host_data:

                values['object_str'] = host_data['_object_str']

            elif '_host_object' in host_data:

        elif local_data:

            if '_object_str' in local_data:

                values['object_str'] = local_data['_object_str']

            elif '_object' in local_data:

            values['object_key'] = ','.join([local_data[f] for f in importer.key])

        for field in importer.fields:

        return label(record)

    def label(self, record):

    def get_url(self, record):

        """

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

IFPS -> Rattail data import

"""

import datetime

import logging

import sqlalchemy as sa

from rattail import importing

from rattail.importing.handlers import FromFileHandler

from rattail.importing.files import FromExcelFile

from rattail.time import localtime, make_utc

from rattail.db.util import maxlen

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

Data Importers

"""

import datetime

import logging

from rattail.db import cache

from rattail.db.util import QuerySequence

from rattail.time import make_utc

from rattail.csvutil import UnicodeDictReader

            self.exclude_fields(*exclude_fields)

        self.fuzzy_fields = fuzzy_fields or []

        self.fuzz_factor = fuzz_factor

            self.key = (self.key,)

        if self.key:

            for field in self.key:

                self.source_data_path = self.args.source_csv

    def get_host_objects(self):

        objects = list(reader)

        source_csv_file.close()

        return objects

"""

import logging

import sqlalchemy as sa

from rattail.importing import model

from rattail.importing.handlers import FromSQLAlchemyHandler, ToSQLAlchemyHandler

from rattail.importing.sqlalchemy import FromSQLAlchemySameToSame

log = logging.getLogger(__name__)

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

Rattail -> Rattail bulk data import

"""

from rattail import importing

from rattail.importing.rattail import FromRattailToRattailImport, FromRattail

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

#

#  Rattail -- Retail Software Framework

#

#  This file is part of Rattail.

#

Sample -> Rattail data import

"""

import csv

import os

import datetime

import decimal

import logging