odoo/setup/lib/cli.py

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

import sys
import urlparse

from config_at import Config
from environments import ENVIRONMENTS, Environment
from functions import CamadeusFunctions

def main():
    def _usage():
        print '\nVerwendung: cam.py <environment> <command> [<module_name>/<setup_function>]\n'
        print 'Commands:\n'
        print '   create                     Neue Datenbank erstellen'
        print '   create_from_dump           Neue Datenbank von Dump erstellen'
        print '   setup                      Modulinstallation, Konfigurationen'
        print '   setup_part setup_function  Aufruf eines einzelnen Setup-Schrittes'
        print '                              "setup_part info" listet die verfügbaren Setup-Schritte auf'
        print '   rollout                    Setzt Dokumentnummern, importiert Benutzer, setzt cam_dmi auf noupdate, ...'
        print '   update module_name         Modul updaten'
        print '   install module_name        Modul installieren'
        print '   uninstall module_name      Modul deinstallieren'
        print '   cancel_upgrade module_name Abbruch Modulinstallation'
        print '   update_modules             Update aller Module in der config-Modulliste'
        print '   update_all                 Update aller verfügbaren Module'
        print '   list-envs                  Environments auflisten'
        print '   anonym                     Daten anonymisieren (Namen, Adresse, E-Mail, ...)'
        print '   invalidate_email           E-Mail Adressen invalidieren (@ > #)\n'
        sys.exit(3)

    argv = sys.argv[1:]
    config = Config()

    if not argv:
        _usage()

    # RUNBOT
    # ./cam runbot create [db] [port] [working-dir]

    if argv[0] == 'runbot':
        import os
        cmd = argv[1]
        db = argv[2]
        port = argv[3]
        setup_path = argv[4]

        env = Environment('http://localhost', port, db, 'admin', 'admin', 'admin')
        os.chdir(setup_path)
    elif argv[0] == 'list-envs':
        print 'name: host:port dbname username'
        for env_name in sorted(ENVIRONMENTS):
            env = ENVIRONMENTS[env_name]
            print '%s: %s:%s %s %s' % (env_name, env.host, env.port, env.dbname, env.username)
        return
    else:
        if len(argv) != 2:
            if len(argv) == 3 and argv[1] in ['update', 'install', 'uninstall', 'cancel_update' 'setup_part']:
                # 'update' requires additional param 'module_name'
                pass
            else:
                _usage()

        cmd = argv[1]

        env = ENVIRONMENTS.get(argv[0])
        if not env:
            print 'Unbekannte Umgebung'
            _usage()

    instance = CamadeusFunctions(env, config)

    methods = None

    if cmd == 'test':
        methods = [
            'login',
        ]

    if cmd == 'create':
        methods = [
            'create_db',
            'login',
            'install_module_sale',
            'setup_accounting',
            'setup_accounting2',
            'set_admin_rights',
        ]

    if cmd == 'create_from_dump':
        methods = [
            'create_db_from_dump',
        ]

    setup_methods = [
        'login',
        'uninstall_chat',
        'install_modules',
        'set_warehouse',
        'base_config',
        'sale_config',
        #'finance_config',
        'hr_config',
        'stock_config',
        'mrp_config',
        'stock_set_cost_method',
        'set_incoterms',
        'purchase_config',
        'set_date_format',
        'set_company',
        'set_taxes',
        'set_uom',
        'set_steuerzuordnung',
        'setup_journals',
        'set_currencies',
        'set_decimal_price',
        'set_default_values',
        'set_translations',
        'set_default_removal_strategy',
        'default_set_order_policy',
        'delete_mail_server',
        'update_values',
        'update_special_values',
        'set_sys_params',
        'setup_reports',
        ]

    if cmd == 'setup':
        methods = setup_methods

    if cmd == 'rollout':
        methods = [
            'login',
            'set_dokumentennummern',
            'set_dmi_noupdate',
            'dmi_confirm_inventory',
            'import_users',
        ]

    if cmd == 'update':
        instance.config.module_name = argv[2]
        methods = [
            'login',
            'update_module',
        ]

    if cmd == 'install':
        instance.config.module_name = argv[2]
        methods = [
            'login',
            'install_module',
        ]

    if cmd == 'uninstall':
        instance.config.module_name = argv[2]
        methods = [
            'login',
            'uninstall_module',
        ]

    if cmd == 'cancel_upgrade':
        instance.config.module_name = argv[2]
        methods = [
            'login',
            'cancel_upgrade_module',
        ]

    if cmd == 'update_modules':
        methods = [
            'login',
            'update_modules',
        ]

    if cmd == 'update_all':
        methods = [
            'login',
            'update_all',
        ]

    if cmd == 'setup_part':
        if ((argv[2] == 'info') or (not (argv[2] in setup_methods))):
            print '\nVerfügbare setup Methoden: ' + str(setup_methods) + '\n'
            return

        methods = [
            'login',
            argv[2],
        ]

    if cmd == 'anonym':
        methods = [
            'login',
            'make_anonymous',
        ]

    if cmd == 'invalidate_email':
        methods = [
            'login',
            'invalidate_email',
        ]

    if not methods:
        print 'Unbekanntes Kommando'
        _usage()

    print env

    local_netlocs = [
        'localhost',
        '127.0.0.1',
        '::1',
    ]
    netloc = urlparse.urlparse(env.host).netloc
    if (netloc not in local_netlocs) or (env.pwd is None):
        print '\nAchtung, diese Umgebung ist nicht lokal!\n'

        print cmd,
        print instance.config.module_name if instance.config.module_name else ''
        print

        env.pwd = raw_input('Passwort: ')

        if cmd == 'create':
            env.super_admin_pw = raw_input('Super-Admin-Passwort: ')

        print

    for method in methods:
        doc = getattr(instance, method).__doc__
        print doc,
        sys.stdout.flush()
        res = getattr(instance, method)()
        print '\r%s: %s' % (res and 'OK     ' or 'ERROR  ', doc)
        if not res:
            print 'Abbruch wegen Fehler'
            return

    print '\nAbgeschlossen.'

if __name__ == '__main__':
    main()