ody_migr_settings.py

#!/usr/bin/env python
"""Main module to migrate settings data."""


import os
import logging
import json
import re
import csv

# import only necessary variables for settings
from ody_migr_config import (FEATURE_NOT_FOUND,
                             EXPECTED_EMPTY_FEATURE_CODE,
                             NO_FEATURE_CODE_HREF,
                             NO_MENU_LINK_MODE,
                             HCUCONNECT_MODE_CODE_MAP,
                             FEATURE_CODE_HREF_MAP,
                             DEF_MENU_ITEM_PLATFORM,
                             FA_ICON_MAP,
                             BRANDING_DEFAULTS,
                             BRANDING_TARGET_FILE,
                             BRANDING_BCK_FILE,
                             BRANDING_MMTH_FILE,
                             BRANDING_TMPL_FILE,
                             INSERT,
                             INSERT_ONE,
                             SELECT,
                             DELETE,
                             SUMMARY,
                             TABLE_EXISTS,
                             SERVER_URL,
                             ACTION_OPT_CLEAN,
                             ACTION_OPT_MIGRATE,
                             ACTION_OPT_SUMMARY,
                             DATA_OPT_SETTINGS)

from ody_migr_transaction import PgTransaction
from ody_migr_transaction import pg_crsr_hndlr_decrtr
import ody_migr_db_handler as pg_handler
from ody_migr_mmth_endpoint import MammothMigration
from ody_migr_utils import (decode_base64,
                            custom_css_parser,
                            get_valid_json,
                            format_error_permission,
                            file_exc_decorator,
                            log_progress)

LOGGER = logging.getLogger(__name__)


# MENU MIGRATION OPERATIONS

def _menu_get_feature_code(_menu_dict, _menu_type):
    """ Rule to generate feature code given the href and hrefExtraParams

    Also replace the script url by adding .prg in the relevant string
     location of the href attribute.
    1. handle single hcu* script
    2. handle hcuForms/some-html.html patter
    3. handle "lnapp/AppMain" pattern
    4. handle hcuConnect with mode attribute as extra parameter

    Args:
        _menu_dict: menu record object for this menu/sub-menu item
        _menu_type: type of menu (D, H or S)

    Returns:
        _menu_dict: _menu_dict with updated href path
        code: feature code
    """
    mode = None
    href = EXPECTED_EMPTY_FEATURE_CODE
    code = FEATURE_NOT_FOUND

    # extract hcu* link from the dictionary eg. hcuAccounts, hcuConnect
    if "href" in _menu_dict and _menu_type != "H":
        href = _menu_dict["href"].strip()

        # href is a script name only (no url pattern) other than hcuConnect
        if "/" not in href and href != "hcuConnect":
            if href in NO_FEATURE_CODE_HREF:
                _menu_dict["href"] += ".prg"
                code = EXPECTED_EMPTY_FEATURE_CODE

            elif href in FEATURE_CODE_HREF_MAP:
                code = FEATURE_CODE_HREF_MAP[href]
                _menu_dict["href"] += ".prg"

        # href contains hcuForms format like hcuForms/display-eftfrm.html
        elif "hcuForms" in href:
            code = FEATURE_CODE_HREF_MAP["hcuForms"]
            _menu_dict["href"] = _menu_dict["href"].replace(
                "hcuForms", "hcuForms.prg")

        # href contains "lnapp/AppMain" pattern
        elif "lnapp/AppMain" in href:
            code = "ONLINEAPP"

            _menu_dict["href"] = "{}/eforms/LoanApp.prg".format(SERVER_URL)

        # handle hcuConnect and mode parameter value
        elif href == "hcuConnect" and "hrefExtraParam" in _menu_dict:
            _menu_dict["href"] += ".prg"
            # obtain mode
            if "mode=" in _menu_dict["hrefExtraParam"]:
                ext_params = _menu_dict["hrefExtraParam"]
                for ext_param in ext_params.strip().split("&"):
                    k_v_list = ext_param.strip().split("=")
                    if k_v_list[0].strip() == "mode":
                        mode = k_v_list[1].strip()
                        break

            # if no mode with hcuConnect, ERROR
            if mode is None:
                code = FEATURE_NOT_FOUND

            # mode corresponding to no menu link
            elif mode is not None and mode in NO_MENU_LINK_MODE:
                code = EXPECTED_EMPTY_FEATURE_CODE

            # valid feature code for this specific mode
            elif mode is not None and mode in HCUCONNECT_MODE_CODE_MAP:
                code = HCUCONNECT_MODE_CODE_MAP[mode]
        else:
            pass

        return _menu_dict, code

    else:
        return _menu_dict, href


def _menu_prepare_record(_menu_dict, _type, _order, parent_id, _cu):
    """Prepare a menu record for cu_featuremenu table (all S, H and D types)

    Args:
        _menu_dict: mammoth key-valued pair of data for this menu record
        _type:      type of menu -S, D or H
        _order:     order of display of this menu/sub-menu
        parent_id:  id of the parent menu - only applicable for _type=D
        _cu:        current credit union

    Returns:
        record_values:
            single record: list of values to be inserted in cu_featuremenu
    """
    _menu_dict, feature_code = _menu_get_feature_code(_menu_dict, _type)

    if _type == "S":
        assert parent_id is None
        if "hrefExtraParam" not in _menu_dict:
            _menu_dict["hrefExtraParam"] = ""
        if _menu_dict["target"] == '_blank':
            _menu_dict["target"] = 1
        else:
            _menu_dict["target"] = 0
        _menu_dict["fa-icon"] = FA_ICON_MAP.get(
            _menu_dict["display"]["en_US"], "")

        menu_item_attr = _menu_dict

    elif _type == "H":
        assert parent_id is None
        menu_item_display = _menu_dict["display"]

        assert "en_US" in menu_item_display
        if (menu_item_display["en_US"] in
                ["Communications", "Profile", "Disclosures"]):
            collapseGroup = 1
        else:
            collapseGroup = 0

        memAccFilter = ""
        menu_item_attr = {}
        menu_item_attr["display"] = menu_item_display
        menu_item_attr["collapseGroup"] = collapseGroup
        menu_item_attr["memAccFilter"] = memAccFilter
        menu_item_attr["fa-icon"] = FA_ICON_MAP.get(
            menu_item_display["en_US"], "")

    elif _type == "D":
        if (_menu_dict["display"]["en_US"].lower() == "my moneydesktop"):
            _menu_dict["target"] = 1
        else:
            _menu_dict["target"] = 0

        assert parent_id is not None
        _menu_dict["collapseGroup"] = 0
        _menu_dict["memAccFilter"] = ""
        _menu_dict["fa-icon"] = ""
        if "hrefExtraParam" not in _menu_dict:
            _menu_dict["hrefExtraParam"] = ""
        menu_item_attr = _menu_dict

    else:
        pass

    record_values = [
        _cu,
        _order,
        feature_code,
        parent_id,
        _type,
        get_valid_json(DEF_MENU_ITEM_PLATFORM),
        get_valid_json(menu_item_attr)
    ]

    return record_values


@pg_crsr_hndlr_decrtr
def menu_insert_cu_featuremenu(settings_migr_trns, _menu_main, _cu):
    """Prepare and insert menu records in the database

    Each root-level menu type are identified as type S or H. For H, type,
    sub-menus are sub-identified as type D.

    For all menu/sub-menu record, it first obtains the mapping of Feature Code
    for each record using the href and hrefExtraParam attributes. Then it
    prepares the list of values to be inserted in the cu_featuremenu table.

    The records must be inserted one by one as there are dependencies among the
    records (menu_item_id column of H type should be associated with D types).

    Args:
        settings_migr_trns:     PgTransaction instance handling the
                                current transaction
        _menu_main:             menu dictionary collection
        _cu:                    current credit union code

    Raises:
        psycopg2.Error, psycopg2.Warning on db operation errors
    """

    tbl_name = "cu_featuremenu"

    # cu_featuremenu column names
    columns = [
        "cu",
        "display_order",
        "feature_code",
        "parent_item_id",
        "menu_item_type",
        "menu_item_platform",
        "menu_item_attr"
    ]

    # counter for menu_order (increments for all levels: S, H and D)
    menu_order = 0
    for ind, menu_item in enumerate(_menu_main):
        # suppressdetail = menu_item["suppressdetail"]
        menu_order += 1

        # if type(menu_item["detail"]) is not list:
        #     menu_item["detail"] = [menu_item["detail"]]

        # standalone menu ("S types")
        if len(menu_item["detail"]) == 1:

            # assert suppressdetail == 1
            standalone_menu = menu_item["detail"][0]
            values = _menu_prepare_record(
                standalone_menu, "S", menu_order, None, _cu)
            assert len(columns) == len(values)

            settings_migr_trns(
                INSERT_ONE,
                tbl_name,
                columns,
                values
            )

        # group of sub-menus ("H types")
        else:
            # head of the group
            values = _menu_prepare_record(
                menu_item, "H", menu_order, None, _cu)
            assert len(columns) == len(values)

            settings_migr_trns(
                INSERT_ONE,
                tbl_name,
                columns,
                values,
                returning_col="menu_item_id"
            )
            # get the curerntly inserted PK id
            parent_id = settings_migr_trns.cur.fetchone()[0]

            # children of this group ("D types")
            for ind_sub, sub_menu in enumerate(menu_item["detail"]):
                menu_order += 1
                values = _menu_prepare_record(
                    sub_menu, "D", menu_order, parent_id, _cu)
                assert len(columns) == len(values)

                settings_migr_trns(
                    INSERT_ONE,
                    tbl_name,
                    columns,
                    values
                )


# BRANDING MIGRATION OPERATIONS

def _brnd_update_attr(_m_rule,
                      _m_key,
                      update_with,
                      _ody_attr,
                      _report_list,
                      _updated_branding_attrs):
    """Update a single css attribute

    Also write the udpate report to the report list (_report_list)

    Args:
        _m_rule:                    mammoth css rule eg.body
        _m_key:                     mammoth css rule's one attribute: eg. color
        update_wth:                 css attribute mapped value for Odyssey
        _ody_attr:                  one of the keys from default
                                    `$styleDefaults` associative
                                    array in /app/web/monitor/
                                    scriptssiteSetColor.prg
        _report_list:               list to add attribtue changes for update
                                    report
        _updated_branding_attrs:    dictionary to update attribute changes to
                                    write to a branding file

    """
    default = BRANDING_DEFAULTS[_ody_attr]
    # update if the attribute value is different from default
    if default != update_with:
        _updated_branding_attrs[_ody_attr] = update_with
        _report_list.append("[Mammoth] {} -> {}  ===> [Odyssey] '{}' "
                            "(default  '{}') -> {}"
                            .format(_m_rule, _m_key,
                                    _ody_attr, default, update_with))


def _brnd_update_styles(_brand_mammoth):
    """Map mammoth branding css content to Odyssey

    Useful reources:
        /app/web/monitor/scriptssiteSetColor{.prg, .data}
        /homecu/public_html/bankingIncludes/css/brand.css

    Args:
        _brand_mammoth: dictionary of css attributes from Mammoth brand content

    Results:
        Formatted update result of what values changed from Mammoth to Odyssey

    Example report: (it would be a compressed, single line json string to
        make it easier to deal with it in log monitoring services.)
        [Mammoth] .cu-primary-color -> background-color  ===>
            [Odyssey] 'headerBackground' (default  '#24417A') -> '#01707B'
        [Mammoth] .cu-primary-color -> background-color  ===>
            [Odyssey] 'footerBackground' (default  '#E7E8EA') -> '#01707B'
        [Mammoth] .cu-primary-color -> color  ===>
            [Odyssey] 'headerForeground' (default  '#FFFFFF') -> '#df1313'
        [Mammoth] .cu-primary-color -> color  ===>
            [Odyssey] 'footerForeground' (default  '#777777') -> '#df1313'
        [Mammoth] body -> font-family  ===>
            [Odyssey] 'fontFamily' (default  'Helvetica, "Helvetica Neue",
                 Arial, sans-serif') -> 'helvetica, verdana, sans-serif'
        [Mammoth] body -> background-color  ===>
            [Odyssey] 'menuBackground' (default  '#F8F8F8') -> '#eaeaea'
        [Mammoth] body -> color  ===>
            [Odyssey] 'menuForeground' (default  '#337AB7') -> '#303030'
        [Mammoth] #content -> background  ===>
            [Odyssey] 'contentBackground' (default  '#FFFFFF') -> '#fff'
        [Mammoth] #content -> color  ===>
            [Odyssey] 'contentForeground' (default  '#333333') -> '#000000'
        [Mammoth] #content -> border  ===>
            [Odyssey] 'contentBorderWidth' (default  '0px') -> '1px'
        [Mammoth] #content -> border  ===>
            [Odyssey] 'contentBorderStyle' (default  'solid') -> 'solid'
        [Mammoth] #content -> border  ===>
            [Odyssey] 'contentBorderColor' (default  '#000000') -> '#afafaf'
        [Mammoth] #homecuBannerArea -> background-color  ===>
            [Odyssey] 'bannerBackground' (default  '#161620') -> '#333333'
        [Mammoth] #homecuBannerArea -> height  ===>
            [Odyssey] 'bannerHeight' (default  '60px') -> '60px'
        [Mammoth] #logo_wrapper .logo_content -> background  ===>
            [Odyssey] 'logoBackground' (default  'transparent') -> '#FFFFFF'
        [Mammoth] #logo_wrapper .logo_content -> background-size  ===>
            [Odyssey] 'logoHeightDesktop' (default  '75px') -> '80px'
        [Mammoth] .cu-secondary-color -> background-color  ===>
            [Odyssey] 'menuGroupBackground' (default  '#1B8DD6') -> '#76B84B'
        [Mammoth] .cu-secondary-color -> background-color  ===>
            [Odyssey] 'menuGroupBackgroundLighter'
                (default  '#2198E3') -> '#76B84B'
        [Mammoth] .cu-secondary-color -> color  ===>
            [Odyssey] 'menuGroupForeground' (default  '#FFFFFF') -> '#FFFFFF'
    """
    update_report = []
    updated_branding_attrs = BRANDING_DEFAULTS.copy()

    for _mammoth_rule, _mammoth_attrs in _brand_mammoth.items():

        if _mammoth_rule == "body":

            m_attr_key = "font-family"
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "fontFamily",
                update_report,
                updated_branding_attrs
            )

            m_attr_key = "background-color"
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "menuBackground",
                update_report,
                updated_branding_attrs
            )

            m_attr_key = "color"
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "menuForeground",
                update_report,
                updated_branding_attrs
            )

        elif _mammoth_rule == ".cu-primary-color":

            m_attr_key = "background-color"
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "headerBackground",
                update_report,
                updated_branding_attrs
            )
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "footerBackground",
                update_report,
                updated_branding_attrs
            )

            m_attr_key = "color"
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "headerForeground",
                update_report,
                updated_branding_attrs
            )
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "footerForeground",
                update_report,
                updated_branding_attrs
            )

        elif _mammoth_rule == "#logo_wrapper .logo_content":

            # exclude url part
            m_attr_key = "background"
            m_attr_val = _mammoth_attrs[m_attr_key].split()[0].strip()
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                m_attr_val,
                "logoBackground",
                update_report,
                updated_branding_attrs
            )

            # take only height part, discard width
            m_attr_key = "background-size"
            m_attr_val = _mammoth_attrs[m_attr_key].split()[1].strip()
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                m_attr_val,
                "logoHeightDesktop",
                update_report,
                updated_branding_attrs
            )

        elif _mammoth_rule == "#content":

            m_attr_key = "background"
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "contentBackground",
                update_report,
                updated_branding_attrs
            )

            m_attr_key = "color"
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "contentForeground",
                update_report,
                updated_branding_attrs
            )

            m_attr_key = "border"
            m_attr_val = _mammoth_attrs[m_attr_key].split()
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                m_attr_val[0].strip(),
                "contentBorderWidth",
                update_report,
                updated_branding_attrs
            )
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                m_attr_val[1].strip(),
                "contentBorderStyle",
                update_report,
                updated_branding_attrs
            )
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                m_attr_val[2].strip(),
                "contentBorderColor",
                update_report,
                updated_branding_attrs
            )

        elif _mammoth_rule == ".cu-secondary-color":

            m_attr_key = "background-color"
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "menuGroupBackground",
                update_report,
                updated_branding_attrs
            )
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "menuGroupBackgroundLighter",
                update_report,
                updated_branding_attrs
            )

            m_attr_key = "color"
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "menuGroupForeground",
                update_report,
                updated_branding_attrs
            )

        elif _mammoth_rule == "#homecuBannerArea":

            m_attr_key = "background-color"
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "bannerBackground",
                update_report,
                updated_branding_attrs
            )

            m_attr_key = "height"
            _brnd_update_attr(
                _mammoth_rule,
                m_attr_key,
                _mammoth_attrs[m_attr_key],
                "bannerHeight",
                update_report,
                updated_branding_attrs
            )

    return get_valid_json(update_report), updated_branding_attrs


def _get_branding_fnames(_cu):
    """Utility function to return relevant file paths for branding content"""
    cu_lower = _cu.lower()
    return (BRANDING_TARGET_FILE.format(cu_lower, cu_lower),
            BRANDING_BCK_FILE.format(cu_lower, cu_lower, cu_lower),
            BRANDING_MMTH_FILE.format(cu_lower),
            BRANDING_TMPL_FILE)


def _brnd_migrate_content(_b64_encoded_content, _cu):
    """Decode base64 encoded content and dump to a target file

    - Original mammoth file is saved as BRANDING_MMTH_FILE
    - Migrated odyssey file is saved as BRANDING_TARGET_FILE
    - Backup odyssey file is saved as BRANDING_BCK_FILE

    Args:
        _b64_encoded_content: base64 encoded content
        _cu:                  current cu code

    Raises:
        SystemExit: if IOError, NameError or PermissionError is caught
    """
    target_file, bck_file, mmth_file, template_file = _get_branding_fnames(_cu)

    # keep a temporary copy of a previous target fiel (if exist)
    target_file_exist = False

    try:
        # if the cu specific branding css file exist, copy it to backup
        if os.path.exists(target_file):
            target_file_exist = True
            with open(target_file, "r") as f_init:
                with open(bck_file, "w") as f_bck:
                    f_bck.write(f_init.read())

        # write content to target file
        with open(target_file, 'w') as f_main:
            # decode base64 encoded content to string
            str_content = decode_base64(_b64_encoded_content)

            # save the imported css file as brand.css as mammoth version
            with open(mmth_file, "w") as f_mmth:
                f_mmth.write(str_content)

            # obtain main customizable css content
            css_content_list = str_content.split("/* ** CUSTOM ** */")

            # only the css content excluding contents after CUSTOM part
            main_branding_css = css_content_list[0].strip()

            # there is another commented out function that uses 'tinycss' - a
            # python library for advanced css content parsing
            brand_mammoth = custom_css_parser(main_branding_css)

            # update default branding css content received from mammoth
            # replaces defaults
            update_report, updated_branding_attrs = _brnd_update_styles(
                brand_mammoth)

            LOGGER.debug("[BRANDING] Mammoth to Ody changes:\t{}".format(
                update_report))

            # read template and replace template placeholdes with actual values
            rendered_template_css = ""
            with open(template_file, "r") as f_template:
                rendered_template_css = f_template.read()
                for k, v in updated_branding_attrs.items():
                    rendered_template_css = rendered_template_css.replace(
                        "{{" + k + "}}", v)

            # write the updated css content to a target css file for CU
            f_main.write(rendered_template_css)


    except (IOError, NameError) as err:
        # if target file existed earlier, restore if anything goes wrong
        if target_file_exist and os.path.exists(bck_file):
            os.rename(bck_file, target_file)

        formatted_err = format_error_permission(err, "")
        LOGGER.error(formatted_err)
        raise SystemExit(formatted_err)


# MIGRATE SETTINGS CONTENT FROM MAMMOTH TO ODYSSEY

def move_settings(settings_migr_trns, _response, _verbose, _cu):
    """Migrate settings data obtained from Mammoth to Odyssey.

    Args:
        settings_migr_trns: settings migration transaction instance
        _response (dict):   python dictionary represetntation of the
                            response json dictionary from mammoth
        _verbose:           verbosity of log
        _cu:               current credit union code
    """
    # transfer cuadmin data

    progress_dict = {"completed": 0, "total": 4}

    cuadmin_coll = _response["data"]["cuadmin"]
    where_cu_condition = {"cu": _cu}
    assert type(cuadmin_coll) == list
    for cuadmin_record in cuadmin_coll:
        cuadmin_record["settings"] = get_valid_json({"profile" : "DEF"})
        if _cu.lower().strip() == "cruisecu" and os.getenv('DEVMODE') == '1':
            cuadmin_record["liveserver"] = \
                "https://int-apl0.homecu.net/hculive/xenia-homecu-faux.mp"
        else:
            cuadmin_record["liveserver"] = "#"

    settings_migr_trns(
        INSERT,
        "cuadmin",
        where_conditions={"cu": _cu},
        collection=cuadmin_coll
    )

    if _verbose:
        settings_migr_trns(
            SELECT,
            "cuadmin",
            where_conditions=where_cu_condition
        )

    progress_dict["completed"] += 1
    log_progress(progress_dict)

    # transfer custom-content data
    custom_content_coll = _response["data"]["custom-content"]
    assert type(custom_content_coll) == list

    settings_migr_trns(
        INSERT,
        "cucmsfrags",
        where_conditions=where_cu_condition,
        collection=custom_content_coll
    )

    if _verbose:
        settings_migr_trns(
            SELECT,
            "cucmsfrags",
            where_conditions=where_cu_condition
        )

    progress_dict["completed"] += 1
    log_progress(progress_dict)

    # transfer menu content
    menu_content_coll = _response["data"]["menu"]
    assert type(menu_content_coll) == list

    # prepare row records and populate cu_featuremenu table
    menu_insert_cu_featuremenu(settings_migr_trns, menu_content_coll, _cu)

    if _verbose:
        settings_migr_trns(
            SELECT,
            "cu_featuremenu",
            where_conditions=where_cu_condition
        )

    progress_dict["completed"] += 1
    log_progress(progress_dict)

    # populate lnappconfig table for loanapps
    mmth_lnappconfig_coll = _response["data"]["lnappconfig"]
    for lnappconfig_record in mmth_lnappconfig_coll:
        dict_lnapp_config= json.loads(lnappconfig_record['appconfig'])

        # replace wwwX.homecu.net with TICKET_DOMAIN value, if set
        # otherwise, localhost:8000
        subdomain =  os.getenv("TICKET_DOMAIN", "localhost:8000")
        subdomain = subdomain if subdomain.strip() != "" else "localhost:8000"
        dict_lnapp_config["configLoanCSS"] = re.sub("(.*)(www[356]{1}\.homecu.net)(.*)",
                                                    "\g<1>{}\g<3>".format(subdomain),
                                                    dict_lnapp_config["configLoanCSS"])

        # convert back the value to json string
        lnappconfig_record['appconfig'] = get_valid_json(dict_lnapp_config)

    settings_migr_trns(
        INSERT,
        "lnappconfig",
        collection=mmth_lnappconfig_coll
    )

    progress_dict["completed"] += 1
    log_progress(progress_dict)

    # Migrate file based contents after the db tables are migrated first
    # transfer branding content
    branding_content = _response["data"]["branding"]

    # move brand.css file to CU specific target location
    _brnd_migrate_content(branding_content, _cu)

    LOGGER.info("Branding content migrated!")

    # We wait until the branding content migration completion for db commit.
    # Looks like we did it, good to commit the transaction!
    settings_migr_trns.commit()


@file_exc_decorator
@pg_crsr_hndlr_decrtr
def cleanup_settings(cleanup_transaction, _cu, **kwargs):
    """Cleanup settings content

    If kwargs.get('commit_later') flag is True, we do not commit the
    transaction here (and only cleanup database tables, not the files),
    meaning that the the cleanup may have been executed before actual
    migration. If commit_later flag is False, we commit the transaction
    here and proceed with the file cleanup.

    Args:
        cleanup_transaction:    instance of PgTransaction to which this cleanup
                                process is part of
        _cu:                    current credit union code
        **kwargs:       Options:
                        commit_later: flag to commit transaction later or now

    Raises:
        SystemExit: if IOError, NameError or PermissionError is caught
        psycopg2.Error, psycopg2.Warning on db operation errors
    """
    commit_later = kwargs.get("commit_later", False)

    # all cleanup tables conditioned on cu
    clean_up_tables = ["cucmsfrags", "cuadmin", "cu_featuremenu", "lnappconfig"]
    for tbl in clean_up_tables:
        cleanup_transaction(
            DELETE,
            tbl,
            where_conditions={"cu": _cu}
        )

    if not commit_later:
        (target_file,
         bck_file,
         mmth_file,
         template_file) = _get_branding_fnames(_cu)

        # cleanup file based contents, first
        if os.path.exists(target_file):
            os.remove(target_file)
        if os.path.exists(bck_file):
            os.remove(bck_file)
        if os.path.exists(mmth_file):
            os.remove(mmth_file)

        LOGGER.info("Branding content deleted.")

        # then, commit all the table deletions here
        cleanup_transaction.commit()
        # display summary after cleanup
        cleanup_transaction(
            SUMMARY,
            DATA_OPT_SETTINGS,
            _cu.lower()
        )


@pg_crsr_hndlr_decrtr
def migrate_settings(cu, server, action, user, passwd, verbose):
    """Entry point to the settings migration.

    Args:
        cu:         current credit union code
        server:     Mammoth endpoint server
        action:     one of the migration options to be
                    performed on settings data category
        user:       Mammoth monitor username
        passwd:     Mammoth monitor password
        verbose:    level of verbosity

    Raises:
        psycopg2.Error, psycopg2.Warning on db operation errors
    """
    # check if the required tables exist
    with pg_handler.PGSession() as conn:
        with conn.cursor() as cur:
            tables_exist_transaction = PgTransaction(conn, cur)

            (tables_exist_flag,
             do_not_exist_list) = tables_exist_transaction(
                TABLE_EXISTS,
                DATA_OPT_SETTINGS,
                cu.lower()
            )

            if not tables_exist_flag:
                error_msg = ("Stopping migration. Following table"
                             " schemas do not exist: {}").format(
                    get_valid_json(", ".join(do_not_exist_list)))
                LOGGER.error(error_msg)
                raise SystemExit(error_msg)
            else:
                LOGGER.info(
                    "All required target tables exist! Continuing migration..")

    # migrate settings data
    if action == ACTION_OPT_MIGRATE:
        # get settings data from Mammoth
        settings_migration = MammothMigration(
            cu,
            DATA_OPT_SETTINGS,
            server,
            user,
            passwd
        )
        settings_migration.run()

        LOGGER.info("Initiating migrating response data to odyssey")
        with pg_handler.PGSession() as conn:
            with conn.cursor() as cur:
                # main transaction for settigns migration
                settings_migr_trns = PgTransaction(conn, cur)

                # display summary before migration
                settings_migr_trns(
                    SUMMARY,
                    DATA_OPT_SETTINGS,
                    cu,
                    msg_prefix="BEFORE"
                )

                # we will only commit this cleanup later together with
                # all the migrations for settings
                cleanup_settings(settings_migr_trns, cu, commit_later=True)
                LOGGER.info(
                    "Running initial db cleanup before migration...")

                # migrate obtained data to Odyssey
                move_settings(
                    settings_migr_trns,
                    settings_migration.response,
                    verbose,
                    cu
                )
                # display summary after migration
                settings_migr_trns(
                    SUMMARY,
                    DATA_OPT_SETTINGS,
                    cu,
                    msg_prefix="AFTER"
                )
                LOGGER.info("Settings Migration Completed!")

    # cleanup settings data
    elif action == ACTION_OPT_CLEAN:
        with pg_handler.PGSession() as conn:
            with conn.cursor() as cur:
                # main transaction for settings cleanup
                settings_delete_trns = PgTransaction(conn, cur)
                cleanup_settings(settings_delete_trns, cu)
        LOGGER.info("Settings cleanup completed!")

    # log display settings tables' records count summary
    elif action == ACTION_OPT_SUMMARY:
        with pg_handler.PGSession() as conn:
            with conn.cursor() as cur:
                settings_summary_transaction = PgTransaction(conn, cur)
                # display_summary(settings_summary_transaction, cu)

                settings_summary_transaction(
                    SUMMARY,
                    DATA_OPT_SETTINGS,
                    cu
                )