9.4合并算法通用示例

## 第二次计算时执行校验
if dc.calc_second_flag:
    if dc.cur_value == 'EntityCurrency':
        print('执行校验')
        main_cube.clear_data(account['Validation'].Base(), *none_pov)
        main_cube.loc[(account['V001'], *none_pov)] = main_cube.loc[(
            account['BS1n2'], *total_pov)] - main_cube.loc[(account['BS3n4'], *total_pov)] + 0

    if dc.calc_second_flag:
        #当执行目标节点后完后执行校验（如果执行的是合并逻辑目标节点就是合并节点 如果是计算逻辑 目标节点就是当前计算节点）
        if dc.cur_value == 'EntityCurrency' and dc.target_vertex == dc.cur_entity:
            # 批量执行校验
            print('执行校验')
            print(dc.target_vertex)
            print(dc.cur_entity)
            # 拿到所有跑完逻辑的实体
            completed_entity = dc.p2['completed_entity']
            completed_entity.add(dc.cur_entity)
            # 拿到纯子代的实体
            completed_entity = [i for i in completed_entity if not re.match(PARENT_CHILD_PARSE, i)]
            print(completed_entity)
            # 把上述实体放到scope中
            main_cube.scope(en[completed_entity])
            main_cube.clear_data(ac['Validation'].Base(), *none_pov)
            main_cube.loc[(ac['V001'], *none_pov)] = main_cube.loc[(
                ac['BS1n2'], *total_pov)] - main_cube.loc[(ac['BS3n4'], *total_pov)] + 0
            main_cube.loc[(ac['V002'], *none_pov)] = 0
            main_cube.loc[(ac['V003'], *none_pov)] = 0

if dc.cur_value == 'EntityCurrencyAdjs':
    if dc.entity_is_base:
        print("执行重分类")
        main_cube.clear_data(audittrail['RECL_ADJ02'])
        main_cube.loc[(audittrail['RECL_ADJ02'], account['220299'], movement['BAL'], *d_none_pov)] = \
            main_cube.loc[(audittrail['RECL_ADJ02'], account['220299'], movement['BAL'], *d_none_pov)] + \
            main_cube.loc[
                (account['2202'],
                 audittrail['DRAFT'], value['EntityCurrency'], movement['BAL'], *d_none_pov)].loc[
                main_cube.data < 0] * (-1)
        main_cube.loc[(audittrail['RECL_ADJ02'], account['112299'], movement['BAL'], *d_none_pov)] = \
            main_cube.loc[(audittrail['RECL_ADJ02'], account['112299'], movement['BAL'], *d_none_pov)] + \
            main_cube.loc[
                (account['2202'],
                 audittrail['DRAFT'], value['EntityCurrency'], movement['BAL'], *d_none_pov)].loc[
                main_cube.data < 0] * (-1)

        main_cube.loc[(audittrail['RECL_ADJ02'], account['112299'], movement['BAL'], *d_none_pov)] = \
            main_cube.loc[(audittrail['RECL_ADJ02'], account['112299'], movement['BAL'], *d_none_pov)] + \
            main_cube.loc[
                (account['1122'],
                 audittrail['DRAFT'], value['EntityCurrency'], movement['BAL'], *d_none_pov)].loc[
                main_cube.data < 0] * (-1)
        main_cube.loc[(audittrail['RECL_ADJ02'], account['220299'], movement['BAL'], *d_none_pov)] = \
            main_cube.loc[(audittrail['RECL_ADJ02'], account['220299'], movement['BAL'], *d_none_pov)] + \
            main_cube.loc[
                (account['1122'],
                 audittrail['DRAFT'], value['EntityCurrency'], movement['BAL'], *d_none_pov)].loc[
                main_cube.data < 0] * (-1)

        reclass_journal_df = main_cube.loc[
            (audittrail['RECL_ADJ02'], account[['112299', '220299']], movement['BAL'], partner.root.Base(),
             *d_none_pov)].to_dataframe()
        print('往来重分类')

reclass_journal_df = main_cube.loc[
    (audittrail['RECL_ADJ02'], account[['112299', '220299']], movement['BAL'], partner.root.Base(),
     *d_none_pov)].to_dataframe()
print('往来重分类')
print(reclass_journal_df)
dc.append_calc_journal(reclass_journal_df, '往来重分类')

import re

import pandas as pd

from Python.common.common_tools import PARENT_CHILD_PARSE, parse_parent
from Python.deep_consol.deep_consol import deep_consol as dc
from Python.deep_consol.journal_model import journal_model


def custom_process_control_post_python(p2):
    if p2.get("completed_entity"):
        t = journal_model.table
        where = ((t.year == p2['year']) &
                 (t.period == p2['period']) &
                 (t.scenario == p2['scenario']) &
                 (t.version == p2['version']) &
                 (t.value.isin(["Elimination", 'EntityCurrencyAdjs']))) & \
                (t.entity.isin(p2.get("completed_entity")))

        r = journal_model.delete(where)
        print(r)
        # 构造凭证
        rlt = dc.journal_data()

        def get_consol_name(row):
            consol = ''
            if re.match(PARENT_CHILD_PARSE, row['entity']):
                consol = parse_parent(row['entity'])
            return pd.Series({'consol': consol})

        head_df = rlt[0]
        line_df = rlt[1]
        head_df['consol'] = head_df.apply(get_consol_name, axis=1)
        print(line_df)
        print(head_df)
        # 存入凭证模型
        if not head_df.empty and not line_df.empty:
            head_df['_type'] = 'sys_journal'
            r = journal_model.save(head_df=head_df,
                                   line_df=line_df,
                                   )
            print(r)

main_cube.clear_data(movement['OPN'])
main_cube.loc[movement['OPN']] = main_cube.loc[(*last_pov, movement['CLO'])]

main_cube.loc[movement['OPN'], account['410411']] = main_cube.loc[
    (*last_pov, account['4104'], movement['CLO'])]

## 利润结转：410301本年利润=PL60000000归母净利润
## 清除数据
main_cube.clear_data({"account": account["410301"]})
## 除了原始数据，其他审计路径上都计算
main_cube.scope({"audittrail":audittrail["Report"].Base() - audittrail["DRAFT"].Base()}):
main_cube.loc[account["410301"],movement["INC", "BAL"]] = cube1.loc[account["PL60000000"]]

vPat = parse_parent(cur_entity)
## 清数
main_cube.clear_data(ad['EQADJ'])

## EQADJ期初结转， EQADJ=上年EQADJ_T
if cur_year > '2018':
    # 4103= 不结转期初
    # 410411 = 上年4104+410301
    main_cube.loc[(ac['410411'], *movementope_eqadj)] = \
    fn.round(main_cube.loc[(ac['4104'], *just_last_year_period, value_pa, *movementgen_eqadj_t)] + \
             main_cube.loc[(ac['410301'], *just_last_year_period, value_pa, *movementgen_eqadj_t)], 2)

    # 4104（除410411）= 不结转期初
    # 其他科目=上年
    account_bs_base_remove_410301_4104base = ac['BS'].Base() - ac['410301'] - ac['4104'].Base()
    main_cube.loc[(account_bs_base_remove_410301_4104base, *movementope_eqadj)] = \
    fn.round(main_cube.loc[(*just_last_year_period, value_pa, *movementgen_eqadj_t)], 2)

    child = dc.EntityMD.list(vPat, 'child', with_parent=True)
## 这里返回的 子公司清单中已经排除掉active是否的了,所以不用判断 isactive
for ch in child:
    ch = ch.data  # loc中直接使用ch（EntityStr类型）会报错，需要使用 ch.data（string类型）
    ch_only_child = parse_child(ch)  # 获取fu.zi 中的 纯zi
    is_subsid = dc.EntityMD.entity_type(ch) == 'subsidiary'
    vPown = dc.EntityMD.share_percentage(ch)  # 持股比例

    if is_subsid and vPown > 0:

        accts1 = \
        ac['4301'].Base() + \
        ac['4401'].Base() + \
        (ac['4002'].Base() - ac['400201'])
        movements = mov['INC', 'DEC', 'EXADJ', 'OPEE1']

        # par[ch_only_child] partner不可以传fu.zi
        main_cube.loc[(accts1, par[ch_only_child], *d13_GEN, ad['EQADJ'], movements)] = \
        fn.round(main_cube.loc[en[ch], val['CNYTotal'], par['TotalPartner'], ad['Report']] * vPown, 2)

        if cur_year > '2018':
            target_audEQADJ_d13GEN = (par[ch_only_child], *d13_GEN, ad['EQADJ'])
            # 定义目标1来源+目标2的7、8来源
            source_movOPEE1 = (
                en[ch], *d13_GEN, mov['OPEE1'], ad['Report'], val['CNYTotal'], par['TotalPartner'])
            source_movNETMOV = (
                en[ch], *d13_GEN, *movement_netmov_report, val['CNYTotal'], par['TotalPartner'])

            main_cube.loc[(ac['410499'], *target_audEQADJ_d13GEN, mov['OPEE1'])] = \
            fn.round((main_cube.loc[(ac['4104'], *source_movOPEE1)] +
                      main_cube.loc[(ac['4101'], *source_movOPEE1)]) * vPown, 2)

            # 关于entity的处理
            main_cube.loc[(ac['410499'], *target_audEQADJ_d13GEN, mov['INC'])] = \
                            fn.round((main_cube.loc[(ac['4104'], *source_movNETMOV)] +
                                      main_cube.loc[(ac['4101'], *source_movNETMOV)] +
                                      main_cube.loc[(ac['4102'], *source_movNETMOV)] -
                                      main_cube.loc[(ac['410406'], *source_movNETMOV)] -
                                      main_cube.loc[(ac['410412'], *source_movNETMOV)] -
                                      main_cube.loc[(ac['410407'], *source_movNETMOV)] -
                                      main_cube.loc[(ac['4104'], *source_movOPEE1)] -
                                      main_cube.loc[(ac['4101'], *source_movOPEE1)]) * vPown, 2)

            # Retained Earning mov
            target_movGEN_audEQADJ = (par[ch_only_child], *d13_GEN, *movementgen_eqadj)
            source_value_CNYTotal = (en[ch], *d13_GEN, mov['MovementGEN'], val['CNYTotal'], par['TotalPartner'])
            source_value_PA = (en[ch], *d13_GEN, mov['MovementGEN'], val['ParentAdjs'], par['TotalPartner'])

            main_cube.loc[(ac['61110198'], *target_movGEN_audEQADJ)] = \
                fn.round((main_cube.loc[(ac['4103'], *source_value_CNYTotal, ad['Report'])] +
                          main_cube.loc[
                              (ac['PL60000000'], *source_value_PA, ad['PGZZADJ_T'])]) * vPown, 2)

            main_cube.loc[(ac['61110101'], *target_movGEN_audEQADJ)] = \
                fn.round(main_cube.loc[ac['410406'], en[ch], ad['Report'],
                mov['NETMOV'], val['CNYTotal'], par['TotalPartner']] * vPown, 2)

            main_cube.loc[(ac['410301'], par[ch_only_child], *movementgen_eqadj)] = \
                fn.round(main_cube.loc[ac['PL60000000']], 2)
            main_cube.loc[(ac['410301'], par[ch_only_child], mov['INC'], ad['EQADJ'])] = \
                fn.round(main_cube.loc[ac['PL60000000'], mov['MovementGEN']], 2)

            target_audEQADJ_d3GEN = (par[ch_only_child], d3['D3GEN'], ad['EQADJ'])
            main_cube.loc[(ac['15110102'], *target_audEQADJ_d3GEN, mov['INC'])] = \
                fn.round(main_cube.loc[ac['BS41000000'], mov['INC']] - \
                         main_cube.loc[ac['BS41000000'], mov['DEC']] + \
                         main_cube.loc[ac['BS41000000'], mov['EXADJ']], 2)

            main_cube.loc[(ac['15110102'], *target_audEQADJ_d3GEN, mov['OPEE1'])] = \
                fn.round(main_cube.loc[ac['BS41000000']], 2)

## Equity Elimination-子公司权益抵消
account_BS41000000_desc = (ac['BS41000000'].Base() - ac['410301']).attr('name').collect()

if vMethon == 'equ_consol' and entity_type == 'subsidiary' and ElimEquity:
    df = df_equity[
    (df_equity['account'].isin(account_BS41000000_desc))
    ]
    if not df.empty:
        dc.con(row=df, dest=(value_elim, ad['EQElim']), factor=-1, nature='权益抵消')
        dc.con(row=df, dest=(ac['PLUG03'], value_elim, par['NoPartner'], ad['EQElim']), factor=1,
               nature='权益抵消')