def get_class_prefix(self, default=None):

        """

        Returns the "class prefix" for the app, used when naming model

        classes etc.

        """

        prefix = self.config.get('rattail', 'app_class_prefix',

                                 default=default)

        if prefix:

            return prefix

        title = self.get_title(default="Rattail")

        prefix = title.replace(' ', '')

        return prefix

    def get_table_prefix(self, default=None):

        """

        Returns the "table prefix" for the app, used when naming

        tables etc.

        """

        prefix = self.config.get('rattail', 'app_table_prefix',

                                 default=default)

        if prefix:

            return prefix

        title = self.get_title(default="Rattail")

        prefix = title.lower()\

                      .replace(' ', '_')

        return prefix

    def get_db_handler(self, **kwargs):

        """

        Get the configured "database" handler.

        :returns: The :class:`~rattail.db.handler.DatabaseHandler`

           instance for the app.

        """

        if not hasattr(self, 'db_handler'):

            spec = self.config.get('rattail.db', 'handler',

                                   default='rattail.db.handler:DatabaseHandler')

            Handler = self.load_object(spec)

            self.db_handler = Handler(self.config)

        return self.db_handler

    def require_prompt_toolkit(self):

        try:

            import prompt_toolkit

        except ImportError:

            value = input("\nprompt_toolkit is not installed.  shall i install it? [Yn] ")

            value = value.strip()

            if value and not self.config.parse_bool(value):

                self.stderr.write("prompt_toolkit is required; aborting\n")

                sys.exit(1)

            subprocess.check_call(['pip', 'install', 'prompt_toolkit'])

    def require_rich(self):

        try:

            import rich

        except ImportError:

            value = input("\nrich is not installed.  shall i install it? [Yn] ")

            value = value.strip()

            if value and not self.config.parse_bool(value):

                self.stderr.write("rich is required; aborting\n")

                sys.exit(1)

            subprocess.check_call(['pip', 'install', 'rich'])

    def rprint(self, *args, **kwargs):

        self.require_rich()

        from rich import print as rprint

        return rprint(*args, **kwargs)

    def basic_prompt(self, info, default=None, is_password=False, is_bool=False,

                     required=False):

        self.require_prompt_toolkit()

        from prompt_toolkit import prompt

        from prompt_toolkit.styles import Style

        # message formatting styles

        style = Style.from_dict({

            '': '',

            'bold': 'bold',

        })

        # build prompt message

        message = [

            ('', '\n'),

            ('class:bold', info),

        ]

        if default is not None:

            if is_bool:

                message.append(('', ' [{}]: '.format('Y' if default else 'N')))

            else:

                message.append(('', ' [{}]: '.format(default)))

        else:

            message.append(('', ': '))

        # prompt user for input

        try:

            text = prompt(message, style=style, is_password=is_password)

        except (KeyboardInterrupt, EOFError):

            self.rprint("\n\t[bold yellow]operation canceled by user[/bold yellow]\n",

                        file=self.stderr)

            sys.exit(2)

        if is_bool:

            if text == '':

                return default

            elif text.upper() == 'Y':

                return True

            elif text.upper() == 'N':

                return False

            self.rprint("\n\t[bold yellow]ambiguous, please try again[/bold yellow]\n")

            return self.basic_prompt(info, default, is_bool=True)

        if required and not text and not default:

            return self.basic_prompt(info, default, is_password=is_password,

                                     required=True)

        return text or default

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

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

#

#  Rattail -- Retail Software Framework

#  Copyright © 2010-2022 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 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 General Public License for more

#  details.

#

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

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

#

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

"""

Project Commands

"""

from __future__ import unicode_literals, absolute_import

import os

import subprocess

import sys

from rattail.commands.core import Subcommand

from rattail.projects.handler import RattailProjectHandler

class MakeProject(Subcommand):

    """

    Make a new app project

    """

    name = 'make-project'

    description = __doc__.strip()

    def add_parser_args(self, parser):

        parser.add_argument('path',

                            help="Path to project folder")

    def run(self, args):

        path = os.path.abspath(args.path)

        if os.path.exists(path):

            self.stderr.write("path already exists: {}\n".format(path))

            sys.exit(1)

        # nb. technically these would be required and auto-installed

        # as needed (later), but seems better to do this explicitly

        # up-front before any other command output

        self.require_prompt_toolkit()

        self.require_rich()

        # welcome, continue?

        self.rprint("\n\t[blue]Welcome to Rattail[/blue]")

        self.rprint("\n\tThis tool will generate source code for a new project.")

        if not self.basic_prompt("continue?", True, is_bool=True):

            self.rprint()

            sys.exit(0)

        # name

        name = os.path.basename(path)

        # app_table_prefix

        prefix = name

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

        prefix = prefix.replace(' ', '_')

        app_table_prefix = self.basic_prompt('app_table_prefix',

                                             default=prefix)

        app_table_prefix = app_table_prefix.rstrip('_')

        # app_class_prefix

        prefix = name

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

        prefix = prefix.replace('_', ' ')

        app_class_prefix = ''.join([w.capitalize() for w in prefix.split()])

        app_class_prefix = self.basic_prompt('app_class_prefix',

                                             default=app_class_prefix)

        # org_name

        org_name = self.basic_prompt('org_name', required=True)

        # pypi_name

        pypi_name = name

        pypi_name = pypi_name.replace('_', ' ')

        pypi_name = pypi_name.replace('-', ' ')

        pypi_name = '-'.join([w.capitalize()

                              for w in org_name.split() + pypi_name.split()])

        pypi_name = self.basic_prompt('pypi_name', default=pypi_name)

        # app_title

        app_title = name

        app_title = app_title.replace('-', ' ')

        app_title = app_title.replace('_', ' ')

        app_title = ' '.join([w.capitalize() for w in app_title.split()])

        # generate project

        project_handler = RattailProjectHandler(self.config)

        options = {

            'name': app_title,

            'slug': name,

            'organization': org_name,

            'python_project_name': pypi_name,

            'python_name': app_table_prefix,

            'has_db': True,

            'extends_db': True,

            'has_web': True,

            # TODO: these should not be needed..?

            'has_web_api': False,

            'has_datasync': False,

            'integrates_catapult': False,

            'integrates_corepos': False,

            'integrates_locsms': False,

            'uses_fabric': False,

        }

        project_handler.generate_project('rattail', name, options, path=path)

        self.rprint("\n\tproject created at:  [bold green]{}[/bold green]".format(

            path))

        # install pkg

        if self.basic_prompt("install project package?", is_bool=True, default=True):

            subprocess.check_call(['pip', 'install', '-e', path])

            self.rprint("\n\tpackage installed:  [bold green]{}[/bold green]".format(

                pypi_name))

            self.rprint("\n\tinstall and configure the app with:")

            self.rprint("\n\t[blue]{} -n install[/blue]".format(name))

        self.rprint()

# TODO: you may want exclog only in production, not dev.

# also you may want debugtoolbar in dev

pyramid.includes =

        pyramid_exclog

        # pyramid_debugtoolbar

trusted_proxy = 127.0.0.1

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

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

#

#  Rattail -- Retail Software Framework

#  Copyright © 2010-2022 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 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 General Public License for more

#  details.

#

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

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

#

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

"""

Database Handler

"""

from __future__ import unicode_literals, absolute_import

from alembic.config import Config as AlembicConfig

from alembic.script import ScriptDirectory

from rattail.app import GenericHandler

class DatabaseHandler(GenericHandler):

    """

    Base class and default implementation for the DB handler.

    """

    def get_alembic_branch_names(self, **kwargs):

        """

        Returns a list of Alembic branch names present in the default

        database schema.

        """

        alembic_config = AlembicConfig()

        alembic_config.set_main_option(

            'script_location',

            self.config.get('alembic', 'script_location', usedb=False))

        alembic_config.set_main_option(

            'version_locations',

            self.config.get('alembic', 'version_locations', usedb=False))

        script = ScriptDirectory.from_config(alembic_config)

        branches = set()

        for rev in script.get_revisions(script.get_heads()):

            branches.update(rev.branch_labels)

        return sorted(branches)

import re

        from alembic.config import Config as AlembicConfig

        from alembic.command import revision as alembic_revision

            # make alembic config, aware of new project versions folder

            alembic_config = AlembicConfig()

            alembic_config.set_main_option('script_location',

                                        'rattail.db:alembic')

            alembic_config.set_main_option('version_locations',

                                        '{} rattail.db:alembic/versions'.format(

                                            versions))

            # generate first revision script for new project

            script = alembic_revision(alembic_config,

                                      version_path=versions,

                                      head='rattail@head',

                                      splice=True,

                                      branch_label=context['python_name'],

                                      message="add {} branch".format(context['python_name']))

            # declare `down_revision = None` ..no way to tell alembic

            # to do that apparently, so we must rewrite file

            with open(script.path, 'rt') as f:

                old_contents = f.read()

            new_contents = []

            for line in old_contents.split('\n'):

                if line.startswith('down_revision ='):

                    line = re.sub(r"'\w+'", 'None', line)

                new_contents.append(line)

            with open(script.path, 'wt') as f:

                f.write('\n'.join(new_contents))

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

        # templates

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

        templates = os.path.join(package, 'templates')

        os.makedirs(templates)

        installer = os.path.join(templates, 'installer')

        os.makedirs(installer)

        self.generate('rattail/package/templates/installer/rattail.conf.mako_tmpl',

                      os.path.join(installer, 'rattail.conf.mako'),

                      **context)

        self.generate('rattail/package/templates/installer/upgrade.sh.mako_',

                      os.path.join(installer, 'upgrade.sh.mako'))

            web_templates = os.path.join(web, 'templates')

            os.makedirs(web_templates)

            self.generate('rattail/package/web/templates/base_meta.mako_tmpl',

                          os.path.join(web_templates, 'base_meta.mako'),

% if uses_fabric:

% endif

import os

import stat

import subprocess

from alembic.util.messaging import obfuscate_url_pw

from rattail.files import resource_path

class Install(commands.Subcommand):

    """

    Install the ${name} app

    """

    name = 'install'

    description = __doc__.strip()

    def run(self, args):

        # nb. technically these would be required and auto-installed

        # as needed (later), but seems better to do this explicitly

        # up-front before any other command output

        self.require_prompt_toolkit()

        self.require_rich()

        self.rprint("\n\t[blue]Welcome to ${name}![/blue]")

        self.rprint("\n\tThis tool will install and configure a new app.")

        self.rprint("\n\t[italic]NB. You should already have created a new database in PostgreSQL or MySQL.[/italic]")

        # continue?

        if not self.basic_prompt("continue?", True, is_bool=True):

            self.rprint()

            sys.exit(0)

        # appdir must not yet exist

        appdir = os.path.join(sys.prefix, 'app')

        if os.path.exists(appdir):

            self.rprint("\n\t[bold red]appdir already exists:[/bold red]  {}\n".format(appdir))

            sys.exit(1)

        # get db info

        dbtype = self.basic_prompt('db type', 'postgresql')

        dbhost = self.basic_prompt('db host', 'localhost')

        dbport = self.basic_prompt('db port', '3306' if dbtype == 'mysql' else '5432')

        dbname = self.basic_prompt('db name', '${python_name}')

        dbuser = self.basic_prompt('db user', 'rattail')

        # get db password

        dbpass = None

        while not dbpass:

            dbpass = self.basic_prompt('db pass', is_password=True)

        # test db connection

        self.rprint("\n\ttesting db connection... ", end='')

        dburl = self.make_db_url(dbtype, dbhost, dbport, dbname, dbuser, dbpass)

        error = self.test_db_connection(dburl)

        if error:

            self.rprint("[bold red]cannot connect![/bold red] ..error was:")

            self.rprint("\n{}".format(error))

            self.rprint("\n\t[bold yellow]aborting mission[/bold yellow]\n")

            sys.exit(1)

        self.rprint("[bold green]good[/bold green]")

        # make the appdir

        self.app.make_appdir(appdir)

        # shared context for generated app files

        context = {

            'envdir': sys.prefix,

            'app_package': '${python_name}',

            'app_title': "${name}",

            'pypi_name': '${python_project_name}',

            'appdir': appdir,

            'db_url': dburl,

            'pyramid_egg': '${egg_name}',

            'beaker_key': '${python_name}',

        }

        # make config files

        rattail_conf = self.app.make_config_file(

            'rattail', os.path.join(appdir, 'rattail.conf'),

            template_path=resource_path('${python_name}:templates/installer/rattail.conf.mako'),

            **context)

        quiet_conf = self.app.make_config_file('quiet', appdir)

        web_conf = self.app.make_config_file(

            'web-complete', os.path.join(appdir, 'web.conf'),

            **context)

        # make upgrade script

        path = os.path.join(appdir, 'upgrade.sh')

        self.app.render_mako_template(

            resource_path('${python_name}:templates/installer/upgrade.sh.mako'),

            context, output_path=path)

        os.chmod(path, stat.S_IRWXU

                 | stat.S_IRGRP

                 | stat.S_IXGRP

                 | stat.S_IROTH

                 | stat.S_IXOTH)

        self.rprint("\n\tappdir created at:  [bold green]{}[/bold green]".format(appdir))

        bindir = os.path.join(sys.prefix, 'bin')

        schema_installed = False

        if self.basic_prompt("install db schema?", True, is_bool=True):

            self.rprint()

            # install db schema

            alembic = os.path.join(bindir, 'alembic')

            cmd = [alembic, '-c', rattail_conf, 'upgrade', 'heads']

            subprocess.check_call(cmd)

            schema_installed = True

            rattail = os.path.join(bindir, 'rattail')

            # set falafel theme

            cmd = [rattail, '-c', quiet_conf, '--no-versioning',

                   'setting-put', 'tailbone.theme', 'falafel']

            subprocess.check_call(cmd)

            # hide theme picker

            cmd = [rattail, '-c', quiet_conf, '--no-versioning',

                   'setting-put', 'tailbone.themes.expose_picker', 'false']

            subprocess.check_call(cmd)

            # set main image

            cmd = [rattail, '-c', quiet_conf, '--no-versioning',

                   'setting-put', 'tailbone.main_image_url', '/tailbone/img/home_logo.png']

            subprocess.check_call(cmd)

            # set header image

            cmd = [rattail, '-c', quiet_conf, '--no-versioning',

                   'setting-put', 'tailbone.header_image_url', '/tailbone/img/rattail.ico']

            subprocess.check_call(cmd)

            # set favicon image

            cmd = [rattail, '-c', quiet_conf, '--no-versioning',

                   'setting-put', 'tailbone.favicon_url', '/tailbone/img/rattail.ico']

            subprocess.check_call(cmd)

            # set vue version

            cmd = [rattail, '-c', quiet_conf, '--no-versioning',

                   'setting-put', 'tailbone.vue_version', '2.6.14']

            subprocess.check_call(cmd)

            # set buefy version

            cmd = [rattail, '-c', quiet_conf, '--no-versioning',

                   'setting-put', 'tailbone.buefy_version', 'latest']

            subprocess.check_call(cmd)

            # set default grid page size

            cmd = [rattail, '-c', quiet_conf, '--no-versioning',

                   'setting-put', 'tailbone.grid.default_pagesize', '20']

            subprocess.check_call(cmd)

            self.rprint("\n\tdb schema installed to:  [bold green]{}[/bold green]".format(

                obfuscate_url_pw(dburl)))

            if self.basic_prompt("create admin user?", True, is_bool=True):

                # get admin credentials

                username = self.basic_prompt('admin username', 'admin')

                password = None

                while not password:

                    password = self.basic_prompt('admin password', is_password=True)

                    if password:

                        confirm = self.basic_prompt('confirm password', is_password=True)

                        if not confirm or confirm != password:

                            self.rprint("[bold yellow]passwords did not match[/bold yellow]")

                            password = None

                fullname = self.basic_prompt('full name')

                self.rprint()

                # make admin user

                rattail = os.path.join(bindir, 'rattail')

                cmd = [rattail, '-c', quiet_conf, 'make-user', '-A', username,

                       '--password', password]

                if fullname:

                    cmd.extend(['--full-name', fullname])

                subprocess.check_call(cmd)

                self.rprint("\n\tadmin user created:  [bold green]{}[/bold green]".format(

                    username))

        self.rprint("\n\t[bold green]initial setup is complete![/bold green]")

        if schema_installed:

            self.rprint("\n\tyou can run the web app with:")

            self.rprint("\n\t[blue]cd {}[/blue]".format(sys.prefix))

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

        self.rprint()

    def make_db_url(self, dbtype, dbhost, dbport, dbname, dbuser, dbpass):

        try:

            # newer style

            from sqlalchemy.engine import URL

            factory = URL.create

        except ImportError:

            # older style

            from sqlalchemy.engine.url import URL

            factory = URL

        if dbtype == 'mysql':

            drivername = 'mysql+mysqlconnector'

        else:

            drivername = 'postgresql+psycopg2'

        return factory(drivername=drivername,

                       username=dbuser,

                       password=dbpass,

                       host=dbhost,

                       port=dbport,

                       database=dbname)

    def test_db_connection(self, url):

        from sqlalchemy import create_engine

        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:

            engine.has_table('whatever')

        except Exception as error:

            return str(error)

## -*- mode: conf; -*-

<%%text>############################################################</%%text>

#

# ${app_title} core config

#

<%%text>############################################################</%%text>

<%%text>##############################</%%text>

# rattail

<%%text>##############################</%%text>

[rattail]

app_title = ${app_title}

app_package = ${app_package}

timezone.default = ${timezone}

appdir = ${appdir}

datadir = ${os.path.join(appdir, 'data')}

batch.files = ${os.path.join(appdir, 'data', 'batch')}

workdir = ${os.path.join(appdir, 'work')}

export.files = ${os.path.join(appdir, 'data', 'exports')}

[rattail.config]

# require = /etc/rattail/rattail.conf

configure_logging = true

usedb = true

preferdb = true