.konchrc

# -*- coding: utf-8 -*-
# vi: set ft=python :

"""
Useful functions for the development of CdiscountApi
"""

import os
import datetime
from cdiscountapi.cdiscountapi import Connection
from functools import lru_cache
from pathlib import Path
import konch
import yaml
from lxml import etree
from tabulate import tabulate
import time
import json
import operator
import pandas as pd
from pycdiscount import PyCdiscount


# CONSTANTS
METADATA_DIR = 'personal/scripts/metadata'

days = datetime.timedelta(days=1)
now = datetime.datetime.now()
offer_filters = {
    'BeginCreationDate': now - 300 * days,
    'StatusList': {'DiscussionStateFilter': 'All'}
}

order_filters = {
    'BeginCreationDate': now - 300 * days,
}


# HELPERS
def strtime(date):
    return datetime.datetime.strftime(date, '%Y-%m-%dT%H:%M:%S') if date else ""


@lru_cache(maxsize=128)
def get_codes(filename, code=None):
    with open(filename) as f:
        data = json.load(f)
    df = pd.DataFrame(data)
    if code:
        result = df[df.code == code].meaning.values[0]
    else:
        result = df
    return result


def error_codes(code=None):
    return get_codes("docs/error_codes.json", code)


def property_codes(code=None):
    return get_codes("docs/property_codes.json", code)


def extract(response):
    """
    Extract the individual elements from a response

    Usage:
        orders = response['OrderList']['Order']
        offers = response['OfferList']['Offer']
        claims = response['ClaimList']['Claim']
    """
    keys = (
        ('OrderList', 'Order'),
        ('OfferList', 'Offer'),
        ('ClaimList', 'Claim'),
    )
    for k in keys:
        if k[0] in response:
            return response[k[0]][k[1]]
    raise ValueError('Unknown keys: {}'.format(response.keys()))


@lru_cache(maxsize=128)
def get_tree(api):
    tree = api.products.get_allowed_category_tree()
    return tree['CategoryTree']['ChildrenCategoryList']['CategoryTree']


def walk_tree(tree):
    graph = {}
    for branch in tree:
        name = branch['Name']
        if branch.get('ChildrenCategoryList', {}) is not None:
            graph[name] = walk_tree(branch['ChildrenCategoryList']['CategoryTree'])
        else:
            graph[name] = branch['Code']
    return graph


def analyze_preprod_choice(value):
    """
    value must be '0' (False) or '1' (True)
    """
    if value not in ('0', '1'):
        raise ValueError('value must be "0" (False) or "1" (True)')
    return bool(int(value))


def load_cassette(cassette_name):
    """
    Load the cassette saved in yaml by vcrpy

    :param cassette_name: The name of the cassette
    :type cassette_name: str
    :return: the data contained in the cassette
    """
    fname = Path("cdiscountapi/tests/cassettes").joinpath(cassette_name)
    if not fname.exists():
        raise Exception(f'{fname} does not exist.')
    return yaml.load(fname.read_text())


def create_request(api, operation, **kwargs):
    """
    Example
    >>> element = create_request(api, 'GetProductList',
                                 productFilter={'CategoryCode': '42'})
    """
    return api.client.create_message(api.client.service, operation,
                                     headerMessage=api.header, **kwargs)


def show_request(api, operation, **kwargs):
    request = create_request(api, operation, **kwargs)
    print(etree.tostring(request, pretty_print=True).decode('utf8'))


def make_offer_row(offer):
    row = {}
    row["Sku"] = offer["SellerProductId"]
    row["Ean"] = offer["ProductEan"]
    row["Condition"] = offer["ProductCondition"]
    row["Price"] = offer["Price"]
    row["Quantity"] = offer["Stock"]
    row["CreationDate"] = offer["CreationDate"]
    row["OfferState"] = offer["OfferState"]
    row["LastUpdateDate"] = offer["LastUpdateDate"]
    return row


def get_offers_list(api, **kwargs):
    """
    Example:
        offers_list = get_offers_list(api, PageNumber=1)
    """
    kwargs.setdefault('PageNumber', 1)
    offers_list = api.offers.get_offer_list_paginated(**kwargs)
    table = [make_offer_row(offer) for offer in offers_list]
    return pd.DataFrame(table)


def get_offer_list_paginated(api, **kwargs):
    kwargs.setdefault('PageNumber', 1)
    response = api.offers.get_offer_list_paginated(**kwargs)
    offer_list_paginated = response['OfferList']['Offer']
    table = [make_offer_row(offer) for offer in offer_list_paginated]
    return pd.DataFrame(table)


def get_orders_list(api, **kwargs):
    def make_row(order):
        """
        Usage:
            row = make_row(response['OrderList']['Order'][i])
        """
        row = {}
        row['OrderNumber'] = order['OrderNumber']
        row['OrderState'] = order['OrderState']
        row['CreationDate'] = order['CreationDate']
        row['Status'] = order['CreationDate']
        row['Price'] = order['InitialTotalAmount']
        customer = order['Customer']
        row['Customer'] = f'{customer["FirstName"]} {customer["LastName"]}'

        items = order['OrderLineList']['OrderLine']
        row['Ean'] = [x['ProductEan'] for x in items]
        row['Condition'] = [x['ProductCondition'] for x in items]
        row['Sku'] = [x['Sku'] for x in items]
        row['Quantity'] = [x['Quantity'] for x in items]
        row['ProductId'] = [x['ProductId'] for x in items]
        row['HasClaim'] = [x['HasClaim'] for x in items]
        row['SellerProductId'] = [x['SellerProductId'] for x in items]
        return row

    response = api.orders.get_order_list(**kwargs)
    orders = response['OrderList']['Order']
    table = [make_row(order) for order in orders]
    return pd.DataFrame(table)


def get_offer_package_submission_results(api):
    metadata = Path().cwd().joinpath(METADATA_DIR)
    if not metadata.exists():
        raise ValueError(f"Can't find the metadata directory {metadata}")

    def fromepoch(epoch):
        return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(epoch))

    def make_row(content):
        row = {}
        row['PackageId'] = content['response']['PackageId']
        submission_result = api.offers.get_offer_package_submission_result(
            int(row['PackageId'])
        )
        row['Success'] = submission_result['OperationSuccess']
        row['SellerProductIds'] = ','.join(
            x['SellerProductId'] for x in content['offers']
        )[0:30]
        row['PackageName'] = content['base_package_name']
        row['Date'] = fromepoch(content['timestamp'])
        row['Status'] = submission_result['PackageIntegrationStatus']
        row['Errors'] = submission_result['NumberOfErrors']
        row['Comment'] = content['comment'][0:42]
        return row

    table = []
    for f in metadata.iterdir():
        content = json.loads(f.read_text())
        table.append(make_row(content))
    return pd.DataFrame(table)


def get_offer_package_submission_result(api, feed_submission_id):
    def make_row(content):
        row = {}
        row["Status"] = content["OfferIntegrationStatus"]
        row["Ean"] = content["ProductEan"]
        row["SKU"] = content["SellerProductId"]
        row["Validated"] = content["Validated"]
        plog = content["PropertyList"]["OfferReportPropertyLog"][0]
        row["PropertyCode"] = plog["PropertyCode"]
        row["PropertyError"] = plog["PropertyError"]
        row["Name"] = plog["Name"]
        return row
    offer_package_submission_result = api.offers.get_offer_package_submission_result(
        feed_submission_id
    )["OfferLogList"]

    if offer_package_submission_result:
        offer_report_logs = offer_package_submission_result["OfferReportLog"]
        table = map(make_row, offer_report_logs)
        return pd.DataFrame(table)


def get_offer_questions(api, ndays=7, state='All'):
    days = datetime.timedelta(days=1)
    now = datetime.datetime.now()

    def make_row(content):
        row = {}
        row['Id'] = content['Id']
        row['CloseDate'] = strtime(content['CloseDate'])
        row['CreationDate'] = strtime(content['CreationDate'])
        row['LastUpdatedDate'] = strtime(content['LastUpdatedDate'])
        row['Messages'] = len(content['Messages']['Message'])
        row['Status'] = content['Status']
        row['Subject'] = content['Subject'][0:30]
        row['ProductEAN'] = content['ProductEAN']
        row['SKU'] = content['ProductSellerReference']
        return row

    filters = {
        'BeginCreationDate': now - ndays * days,
        'StatusList': {'DiscussionStateFilter': state}
    }
    offer_question_list = api.discussions.get_offer_question_list(
        **filters
    )['OfferQuestionList']

    if offer_question_list:
        offer_questions = offer_question_list['OfferQuestion']
        table = []
        for x in offer_questions:
            table.append(make_row(x))
        return pd.DataFrame(table)


def get_order_questions(api, ndays=7, state='All'):
    days = datetime.timedelta(days=1)
    now = datetime.datetime.now()

    def make_row(content):
        row = {}
        row['Id'] = content['Id']
        row['CloseDate'] = strtime(content['CloseDate'])
        row['CreationDate'] = strtime(content['CreationDate'])
        row['LastUpdatedDate'] = strtime(content['LastUpdatedDate'])
        row['Messages'] = len(content['Messages']['Message'])
        row['Status'] = content['Status']
        row['Subject'] = content['Subject'][0:30]
        row['OrderNumber'] = content['OrderNumber']
        return row

    filters = {
        'BeginCreationDate': now - ndays * days,
        'StatusList': {'DiscussionStateFilter': state}
    }
    order_question_list = api.discussions.get_order_question_list(
        **filters
    )['OrderQuestionList']

    if order_question_list:
        order_questions = order_question_list['OrderQuestion']
        table = []
        for x in order_questions:
            table.append(make_row(x))
        return pd.DataFrame(table)


def get_order_claims(api, ndays=7, state='All'):
    days = datetime.timedelta(days=1)
    now = datetime.datetime.now()

    def make_row(content):
        row = {}
        row['Id'] = content['Id']
        row['CloseDate'] = strtime(content['CloseDate'])
        row['CreationDate'] = strtime(content['CreationDate'])
        row['LastUpdatedDate'] = strtime(content['LastUpdatedDate'])
        row['Messages'] = len(content['Messages']['Message'])
        row['Status'] = content['Status']
        row['Subject'] = content['Subject'][0:30]
        row['OrderNumber'] = content['OrderNumber']
        row['ClaimType'] = content['ClaimType']
        return row

    filters = {
        'BeginCreationDate': now - ndays * days,
        'StatusList': {'DiscussionStateFilter': state}
    }
    order_claim_list = api.discussions.get_order_claim_list(
        **filters
    )['OrderClaimList']

    if order_claim_list:
        order_claims = order_claim_list['OrderClaim']
        table = []
        for x in order_claims:
            table.append(make_row(x))
        return pd.DataFrame(table)


def show_table(df, tablefmt="simple"):
    """
    Usage:
        show_table(df)
    """
    print(tabulate(df, headers=df.columns, tablefmt=tablefmt))


cdiscount_api_preprod = os.getenv('CDISCOUNT_API_PREPROD')
preprod = analyze_preprod_choice(cdiscount_api_preprod) if\
    cdiscount_api_preprod else False

if preprod:
    banner = '==Preprod environment for Cdiscount=='
else:
    banner = '**Production environment for Cdiscount**'

header_message = {
    'Context': {
        'SiteID': 100,
        'CatalogID': 1
    },
    'Localization': {
        'Country': 'Fr',
        'Currency': 'Eur',
    },
    'Security': {
        'IssuerID': None,
        'SessionID': None,
        'UserName': '',
    },
    'Version': 1.0,
}

# Available options:
#   'context', 'banner', 'shell', 'prompt', 'output',
#   'context_format', 'ipy_extensions', 'ipy_autoreload',
#   'ipy_colors', 'ipy_highlighting_style'

konch.config({
    'banner': banner,
    'context': {
        'api': Connection(os.getenv('CDISCOUNT_API_LOGIN'),
                          os.getenv('CDISCOUNT_API_PASSWORD'),
                          preprod=preprod,
                          header_message=header_message),
        'products_api': PyCdiscount(api_key=os.getenv('CDISCOUNT_API_KEY')),
        'get_tree': get_tree,
        'load_cassette': load_cassette,
        'create_request': create_request,
        'show_request': show_request,
        'get_offers_list': get_offers_list,
        'get_offer_list_paginated': get_offer_list_paginated,
        # 'get_offer_package_submission_results': get_offer_package_submission_results,
        'get_offer_package_submission_result': get_offer_package_submission_result,
        'show_table': show_table,
        'get_offer_questions': get_offer_questions,
        'get_order_questions': get_order_questions,
        'get_order_claims': get_order_claims,
        'get_orders_list': get_orders_list,
        'offer_filters': offer_filters,
        'order_filters': order_filters,
        'extract': extract,
        'property_codes': property_codes,
        'error_codes': error_codes,
    },
    "shell": "ipython",
    "ipy_autoreload": True,
})


def setup():
    pass


def teardown():
    pass