diff --git a/ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240917110039.java b/ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240917110039.java new file mode 100644 index 0000000000..404498dbb3 --- /dev/null +++ b/ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240917110039.java @@ -0,0 +1,86 @@ +package it.integry.ems.migration.model; + +import it.integry.ems.migration._base.BaseMigration; +import it.integry.ems.migration._base.IntegryCustomerDB; +import it.integry.ems.migration._base.MigrationModelInterface; + +public class Migration_20240917110039 extends BaseMigration implements MigrationModelInterface { + + @Override + public void up() throws Exception { + if (isHistoryDB()) + return; + + + if (!isCustomerDb(IntegryCustomerDB.Carelli_Winact)) return; + + createOrUpdateFunction("steup_getGrigliaVendita", "CREATE FUNCTION [dbo].[steup_getGrigliaVendita](\n" + + " @codMdep VARCHAR(5), @codJfas VARCHAR(5)\n" + + ")\n" + + " RETURNS TABLE\n" + + " AS\n" + + " RETURN(WITH tipiArt AS (SELECT value_string AS cod_mtip\n" + + " FROM dbo.ParseStringIntoArray((SELECT value\n" + + " FROM stb_gest_setup\n" + + " WHERE gest_name = 'PVM'\n" + + " AND section = 'RILEVAZIONI_STEUP'\n" + + " AND key_section = 'EXCLUDE_COD_MTIP'), '|') t)\n" + + " , art AS (SELECT DISTINCT cod_griglia, cod_mart\n" + + " FROM carelli.dbo.vtb_griglia_art\n" + + " WHERE cod_griglia = @codMdep\n" + + " AND data_validita =\n" + + " (SELECT MAX(data_validita) FROM carelli.dbo.vtb_griglia_art WHERE cod_griglia = @codMdep) \n" + + " )\n" + + " \n" + + " SELECT DISTINCT case when @codJfas = '01' then art_det.cod_mart_griglia else mtb_aart.cod_mart end as cod_mart,\n" + + " mtb_aart.descrizione,\n" + + " mtb_aart.bar_code,\n" + + " mtb_aart.cod_msgr,\n" + + " mtb_aart.plu,\n" + + " art_det.cod_mart_griglia AS cod_madre \n" + + " FROM carelli.dbo.mtb_aart\n" + + " INNER JOIN jrl_fasi_mtb_grup ON\n" + + " mtb_aart.cod_mgrp = jrl_fasi_mtb_grup.cod_mgrp\n" + + " INNER JOIN (SELECT cod_mart, cod_comp AS cod_mart_griglia\n" + + " FROM carelli.dbo.mtb_comp\n" + + " UNION ALL\n" + + " SELECT cod_comp AS cod_mart, cod_mart AS cod_mart_griglia\n" + + " FROM carelli.dbo.mtb_comp \n" + + " where @codJfas <> '01'\n" + + " UNION ALL\n" + + " SELECT cod_mart, cod_mart AS cod_mart_griglia\n" + + " FROM carelli.dbo.mtb_aart\n" + + " WHERE cod_mart NOT IN (SELECT cod_mart FROM carelli.dbo.mtb_comp)) AS art_det\n" + + " ON mtb_aart.cod_mart = art_det.cod_mart\n" + + " INNER JOIN art ON art_det.cod_mart_griglia = art.cod_mart\n" + + " WHERE jrl_fasi_mtb_grup.cod_jfas = @codJfas\n" + + " AND flag_stato = 'A'\n" + + " AND (mtb_aart.cod_mtip IS NULL OR mtb_aart.cod_mtip NOT IN (SELECT cod_mtip FROM tipiArt))\n" + + " UNION ALL\n" + + " SELECT DISTINCT mtb_aart.cod_mart as cod_mart,\n" + + " mtb_aart.descrizione,\n" + + " mtb_aart.bar_code,\n" + + " mtb_aart.cod_msgr,\n" + + " mtb_aart.plu,\n" + + " mtb_aart.cod_mart AS cod_madre \n" + + " FROM carelli.dbo.mtb_aart\n" + + " INNER JOIN jrl_fasi_mtb_grup ON\n" + + " mtb_aart.cod_mgrp = jrl_fasi_mtb_grup.cod_mgrp\n" + + " INNER JOIN (SELECT DISTINCT cod_mdep, cod_mart \n" + + " FROM carelli.dbo.[getGrigliaAcquisto](null, null, @codMdep, null, null) griglia \n" + + " where griglia.tipo_variazione <> 'D' AND \n" + + " EXISTS( select cod_mart from carelli.dbo.mtb_aart WHERE mtb_aart.cod_mart = griglia.cod_mart AND mtb_aart.cod_mgrp = '03')) art ON \n" + + " mtb_aart.cod_mart = art.cod_mart\n" + + " WHERE jrl_fasi_mtb_grup.cod_jfas = @codJfas\n" + + " AND flag_stato = 'A'\n" + + " AND (mtb_aart.cod_mtip IS NULL OR mtb_aart.cod_mtip NOT IN (SELECT cod_mtip FROM tipiArt))\n" + + " \n" + + " )"); + } + + @Override + public void down() throws Exception { + + } + +} diff --git a/ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240917110814.java b/ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240917110814.java new file mode 100644 index 0000000000..f6240724d4 --- /dev/null +++ b/ems-core/src/main/java/it/integry/ems/migration/model/Migration_20240917110814.java @@ -0,0 +1,279 @@ +package it.integry.ems.migration.model; + +import it.integry.ems.migration._base.BaseMigration; +import it.integry.ems.migration._base.MigrationModelInterface; + +public class Migration_20240917110814 extends BaseMigration implements MigrationModelInterface { + + @Override + public void up() throws Exception { + if (isHistoryDB()) + return; + + + createOrUpdateFunction("getListinoVendita_id", "CREATE FUNCTION [dbo].[getListinoVendita_id](@datavalidita DATETIME, @codvlis VARCHAR(5), @codmart VARCHAR(15))\n" + + " RETURNS TABLE AS\n" + + " RETURN \n" + + "\n" + + " --declare @datavalidita DATETIME, @codvlis VARCHAR(5), @codmart VARCHAR(15)\n" + + "\n" + + " with lisv AS (\n" + + " SELECT vtb_list_data.cod_vlis,\n" + + " vtb_list_data.versione,\n" + + " vtb_list_data.id_listino as id_listino,\n" + + " vtb_list_data.data_iniz,\n" + + " vtb_list_data.cod_vlis AS cod_vlis_rif,\n" + + " vtb_list_data.versione AS versione_rif\n" + + " FROM vtb_list_data \n" + + " WHERE vtb_list_data.data_fine IS NULL\n" + + " AND vtb_list_data.cod_promo IS NULL \n" + + " and vtb_list_data.cod_vlis_rif IS NULL\n" + + " UNION\n" + + " SELECT vtb_list_data.cod_vlis,\n" + + " vtb_list_data.versione,\n" + + " vtb_list_data_rif.id_listino,\n" + + " vtb_list_data.data_iniz,\n" + + " vtb_list_data.cod_vlis_rif AS cod_vlis_rif,\n" + + " vtb_list_data.versione_rif AS versione_rif\n" + + " FROM vtb_list_data \n" + + " INNER JOIN vtb_list_data vtb_list_data_rif on vtb_list_data.cod_vlis_rif = vtb_list_data_rif.cod_vlis and vtb_list_data.versione_rif = vtb_list_data_rif.versione\n" + + " WHERE vtb_list_data.data_fine IS NULL\n" + + " AND vtb_list_data.cod_promo IS NULL \n" + + " \n" + + " \n" + + " )\n" + + "\n" + + " , last_lisv AS ( \n" + + " SELECT vtb_list.cod_vlis AS cod_vlis,\n" + + " mtb_lisv_data.cod_mart,\n" + + " MAX(vtb_list_data.id_listino) AS max_id_lisv,\n" + + " IsNull(vtb_list_data.cod_vlis_rif, IsNull(vtb_list.cod_vlis_rif, vtb_list.cod_vlis)) AS 'cod_vlis_rif'\n" + + " FROM vtb_list\n" + + " INNER JOIN mtb_lisv_data ON vtb_list.cod_vlis = mtb_lisv_data.cod_vlis\n" + + " LEFT OUTER JOIN lisv vtb_list_data ON mtb_lisv_data.cod_vlis = vtb_list_data.cod_vlis AND\n" + + " mtb_lisv_data.versione = vtb_list_data.versione AND\n" + + " vtb_list_data.data_iniz <= ISNULL(@datavalidita, GETDATE()) \n" + + " GROUP BY vtb_list.cod_vlis,\n" + + " mtb_lisv_data.cod_mart,\n" + + " IsNull(vtb_list_data.cod_vlis_rif, IsNull(vtb_list.cod_vlis_rif, vtb_list.cod_vlis)) ),\n" + + " art as (\n" + + " select mtb_aart.cod_mart, mtb_aart.qta_cnf, mtb_aart.perc_sfrido, mtb_aart.colli_pedana, mtb_aart.colli_strato, mtb_aart.flag_incl_listino\n" + + " from mtb_aart )\n" + + " SELECT vtb_list.cod_vlis,\n" + + " vtb_list.descrizione,\n" + + " vtb_list_data.data_iniz AS data_iniz,\n" + + " vtb_list_data.versione AS versione,\n" + + " vtb_list.cod_divi,\n" + + " vtb_list.cambio,\n" + + " vtb_list.flag_arr_prz_iva,\n" + + " vtb_list.arr_ric,\n" + + " vtb_list.flag_list_iva_inclusa,\n" + + " vtb_list.flag_lisv_margine,\n" + + " vtb_list.flag_add_trasp,\n" + + " tmp_list.cod_mart AS 'cod_mart',\n" + + " mtb_lisv_data.unt_mis_ven AS unt_mis_ven,\n" + + " ISNULL(mtb_lisv_data.rap_conv, 1) AS rap_conv,\n" + + " ISNULL(mtb_lisv_data.prz_base, 0) AS prz_base,\n" + + " ISNULL(mtb_lisv_data.ricarica, 0) AS ricarico,\n" + + " CASE\n" + + " WHEN mtb_lisv_data.prz_vend IS NOT NULL AND mtb_lisv_data.prz_vend <> 0 THEN\n" + + " ROUND((ISNULL(mtb_lisv_data.prz_vend, 0) -\n" + + " (ISNULL(mtb_lisv_data.prz_base, 0) / (1 - mtb_aart.perc_sfrido / 100))) /\n" + + " ISNULL(mtb_lisv_data.prz_vend, 0) * 100, 2)\n" + + " ELSE 0 END AS margine_eff,\n" + + " \n" + + " CASE\n" + + " WHEN mtb_lisv_data.prz_base IS NOT NULL AND mtb_lisv_data.prz_base <> 0 THEN\n" + + " ROUND((ISNULL(mtb_lisv_data.prz_vend, 0) -\n" + + " (ISNULL(mtb_lisv_data.prz_base, 0) / (1 - mtb_aart.perc_sfrido / 100))) /\n" + + " (ISNULL(mtb_lisv_data.prz_base, 0) / (1 - mtb_aart.perc_sfrido / 100)) * 100, 2)\n" + + " ELSE 0 END AS ricarico_eff,\n" + + " \n" + + " ISNULL(mtb_lisv_data.magg_prz_vend, 0) AS magg_prz_vend,\n" + + " ISNULL(mtb_lisv_data.prz_vend, 0) AS prz_vend,\n" + + " ISNULL(mtb_lisv_data.prz_vend_iva, 0) AS prz_vend_iva,\n" + + " ISNULL(mtb_lisv_data.perc_sco1, 0) AS perc_sco1,\n" + + " ISNULL(mtb_lisv_data.perc_sco2, 0) AS perc_sco2,\n" + + " ISNULL(mtb_lisv_data.perc_sco3, 0) AS perc_sco3,\n" + + " ISNULL(mtb_lisv_data.perc_sco4, 0) AS perc_sco4,\n" + + " ISNULL(mtb_lisv_data.perc_prov, 0) AS perc_prov,\n" + + " ISNULL(mtb_lisv_data.fisso_prov, 0) AS fisso_prov,\n" + + " ISNULL(mtb_lisv_data.posizione, '') AS posizione,\n" + + " ISNULL(mtb_lisv_data.perc_gest, 0) AS perc_gest,\n" + + " ISNULL(mtb_lisv_data.val_gest, 0) AS val_gest,\n" + + " mtb_lisv_data.data_agg_prz AS data_agg_prz,\n" + + " ISNULL(mtb_lisv_data.perc_ispe, 0) AS perc_ispe,\n" + + " ISNULL(mtb_lisv_data.val_ispe, 0) AS val_ispe,\n" + + " ISNULL(mtb_lisv_data.perc_promo, 0) AS perc_promo,\n" + + " ISNULL(mtb_lisv_data.val_promo, 0) AS val_promo,\n" + + " ISNULL(mtb_lisv_data.perc_oneri, 0) AS perc_oneri,\n" + + " ISNULL(mtb_lisv_data.val_oneri, 0) AS val_oneri,\n" + + " mtb_lisv_data.tipo_variazione AS tipo_variazione,\n" + + " mtb_lisv_data.note AS note,\n" + + " mtb_lisv_data.aggiornato_da AS aggiornato_da,\n" + + " mtb_lisv_data.prz_vend * (1 - mtb_lisv_data.perc_sco1 / 100) * (1 - mtb_lisv_data.perc_sco2 / 100) *\n" + + " (1 - mtb_lisv_data.perc_sco3 / 100) *\n" + + " (1 - mtb_lisv_data.perc_sco4 / 100) AS prz_vend_netto,\n" + + " CASE\n" + + " WHEN ISNULL(mtb_lisv_data.colli_pedana, 0) <> 0 THEN mtb_lisv_data.colli_pedana\n" + + " ELSE mtb_aart.colli_pedana END AS colli_pedana,\n" + + " mtb_lisv_data.cod_tcol_ul AS cod_tcol_ul,\n" + + " mtb_lisv_data.cod_tcol_ui AS cod_tcol_ui,\n" + + " ISNULL(mtb_lisv_data.prz_vend_sug, 0) AS prz_vend_sug,\n" + + " CASE\n" + + " WHEN ISNULL(mtb_lisv_data.qta_cnf, 0) <> 0\n" + + " AND dbo.getGestSetup('VTB_LIST', 'SETUP', 'QTA_CNF_LISTINO') = 'S' \n" + + " THEN mtb_lisv_data.qta_cnf\n" + + " ELSE mtb_aart.qta_cnf END AS qta_cnf,\n" + + " CASE\n" + + " WHEN ISNULL(mtb_lisv_data.colli_strato, 0) <> 0 THEN mtb_lisv_data.colli_strato\n" + + " ELSE mtb_aart.colli_strato END AS colli_strato,\n" + + " mtb_lisv_data.descrizione_html AS descrizione_html,\n" + + " mtb_lisv_data.colli_pedana AS colli_pedana_lisv,\n" + + " mtb_lisv_data.qta_cnf AS qta_cnf_lisv,\n" + + " mtb_lisv_data.colli_strato AS colli_strato_lisv,\n" + + " mtb_lisv_data.sconto_cartoni,\n" + + " mtb_lisv_data.sconto_strato,\n" + + " mtb_lisv_data.sconto_pedane,\n" + + " vtb_list.flag_attivo,\n" + + " vtb_list_data.note AS note_testata,\n" + + " ISNULL(mtb_lisv_data.flag_prz_bloccato, 'N') AS flag_prz_bloccato,\n" + + " vtb_list_data.porto AS porto,\n" + + " mtb_lisv_data.system_note,\n" + + " mtb_lisv.add_val_spese,\n" + + " mtb_lisv.add_ric_spese,\n" + + " mtb_lisv.add_sco_spese,\n" + + " mtb_aart.flag_incl_listino\n" + + " FROM last_lisv tmp_list\n" + + " INNER JOIN vtb_list ON vtb_list.cod_vlis = tmp_list.cod_vlis\n" + + " INNER JOIN mtb_lisv\n" + + " ON tmp_list.cod_vlis_rif = mtb_lisv.cod_vlis AND tmp_list.cod_mart = mtb_lisv.cod_mart\n" + + " INNER JOIN art mtb_aart ON tmp_list.cod_mart = mtb_aart.cod_mart\n" + + " LEFT OUTER JOIN vtb_list_data ON tmp_list.cod_vlis_rif = vtb_list_data.cod_vlis AND\n" + + " tmp_list.max_id_lisv = vtb_list_data.id_listino\n" + + " LEFT OUTER JOIN mtb_lisv_data ON vtb_list_data.cod_vlis = mtb_lisv_data.cod_vlis AND\n" + + " tmp_list.cod_mart = mtb_lisv_data.cod_mart AND\n" + + " vtb_list_data.versione = mtb_lisv_data.versione\n" + + "\n" + + " WHERE (@codmart IS NULL OR tmp_list.cod_mart = @codmart)\n" + + " AND (@codvlis IS NULL OR tmp_list.cod_vlis = @codvlis)"); + createOrUpdateFunction("getPromozioneVendita_new", "CREATE FUNCTION [dbo].[getPromozioneVendita_new] (@dataIniz datetime, @dataFine datetime, @codVlis varchar(5), @codPromo varchar(10), @codMart varchar(15)) RETURNS TABLE AS \n" + + " return \n" + + "\n" + + "-- declare @dataIniz datetime, @dataFine datetime, @codVlis varchar(5), @codPromo varchar(10), @codMart varchar(15)\n" + + "\n" + + " with lisv AS (\n" + + " SELECT vtb_list_data.cod_vlis,\n" + + " vtb_list_data.versione,\n" + + " vtb_list_data.id_listino as id_listino,\n" + + " vtb_list_data.data_iniz,\n" + + " vtb_list_data.cod_vlis AS cod_vlis_rif,\n" + + " vtb_list_data.versione AS versione_rif,\n" + + " vtb_list_data.cod_promo,\n" + + " vtb_list_data.data_fine,\n" + + " vtb_list_data.note\n" + + " FROM vtb_list_data \n" + + " WHERE vtb_list_data.cod_promo IS NOT NULL \n" + + " and vtb_list_data.cod_vlis_rif IS NULL\n" + + " UNION\n" + + " SELECT vtb_list_data.cod_vlis,\n" + + " vtb_list_data.versione,\n" + + " vtb_list_data_rif.id_listino,\n" + + " vtb_list_data.data_iniz,\n" + + " vtb_list_data.cod_vlis_rif AS cod_vlis_rif,\n" + + " vtb_list_data.versione_rif AS versione_rif,\n" + + " vtb_list_data_rif.cod_promo,\n" + + " vtb_list_data_rif.data_fine,\n" + + " vtb_list_data.note\n" + + " FROM vtb_list_data \n" + + " INNER JOIN vtb_list_data vtb_list_data_rif on vtb_list_data.cod_vlis_rif = vtb_list_data_rif.cod_vlis and vtb_list_data.versione_rif = vtb_list_data_rif.versione\n" + + " WHERE vtb_list_data.cod_promo IS NOT NULL )\n" + + " , testata_lisv as (\n" + + " select *\n" + + " from lisv\n" + + " WHERE (@codvlis IS NULL OR lisv.cod_vlis = @codVlis) \n" + + " AND (@codPromo IS NULL OR lisv.cod_promo = @codPromo)\n" + + " AND (((@dataFine IS NULL OR ISNULL(@dataIniz, cast(GetDate() as DATE)) = @dataFine) AND \n" + + " ISNULL(@dataIniz, cast(GetDate() as DATE)) BETWEEN lisv.data_iniz AND lisv.data_fine) OR \n" + + " (@dataFine IS NOT NULL AND ISNULL(@dataIniz, cast(GetDate() as DATE)) <> @dataFine AND \n" + + " (lisv.data_iniz BETWEEN ISNULL(@dataIniz, cast(GetDate() as DATE)) AND @dataFine OR \n" + + " lisv.data_fine BETWEEN ISNULL(@dataIniz, cast(GetDate() as DATE)) AND @dataFine OR \n" + + " ISNULL(@dataIniz, cast(GetDate() as DATE)) BETWEEN lisv.data_iniz AND lisv.data_fine OR\n" + + " @dataFine BETWEEN lisv.data_iniz AND lisv.data_fine ))) )\n" + + " SELECT vtb_list.cod_vlis, \n" + + " vtb_list.descrizione, \n" + + " vtb_list_data.data_iniz, \n" + + " vtb_list_data.data_fine,\n" + + " vtb_list_data.cod_promo,\n" + + " vtb_list_data.versione, \n" + + " vtb_list.cod_divi,\n" + + " vtb_list.flag_arr_prz_iva, \n" + + " vtb_list.arr_ric,\n" + + " vtb_list.flag_list_iva_inclusa,\n" + + " vtb_list.flag_lisv_margine, \n" + + " mtb_lisv_data.cod_mart as cod_mart, \n" + + " mtb_lisv_data.unt_mis_ven as unt_mis_ven,\n" + + " mtb_lisv_data.rap_conv as rap_conv, \n" + + " mtb_lisv_data.prz_base as prz_base, \n" + + " mtb_lisv_data.ricarica as ricarico,\n" + + " \n" + + " CASE\n" + + " WHEN mtb_lisv_data.prz_vend IS NOT NULL AND mtb_lisv_data.prz_vend <> 0 THEN\n" + + " ROUND((ISNULL(mtb_lisv_data.prz_vend, 0) -\n" + + " (ISNULL(mtb_lisv_data.prz_base, 0) / (1 - mtb_aart.perc_sfrido / 100))) /\n" + + " ISNULL(mtb_lisv_data.prz_vend, 0) * 100, 2)\n" + + " ELSE 0 END AS margine_eff,\n" + + " CASE\n" + + " WHEN mtb_lisv_data.prz_base IS NOT NULL AND mtb_lisv_data.prz_base <> 0 THEN\n" + + " ROUND((ISNULL(mtb_lisv_data.prz_vend, 0) -\n" + + " (ISNULL(mtb_lisv_data.prz_base, 0) / (1 - mtb_aart.perc_sfrido / 100))) /\n" + + " (ISNULL(mtb_lisv_data.prz_base, 0) / (1 - mtb_aart.perc_sfrido / 100)) * 100, 2)\n" + + " ELSE 0 END AS ricarico_eff,\n" + + " mtb_lisv_data.prz_vend as prz_vend, \n" + + " mtb_lisv_data.prz_vend_iva as prz_vend_iva, \n" + + " mtb_lisv_data.perc_sco1 as perc_sco1, \n" + + " mtb_lisv_data.perc_sco2 as perc_sco2, \n" + + " mtb_lisv_data.perc_sco3 as perc_sco3, \n" + + " mtb_lisv_data.perc_sco4 as perc_sco4, \n" + + " mtb_lisv_data.perc_prov as perc_prov, \n" + + " mtb_lisv_data.fisso_prov as fisso_prov, \n" + + " mtb_lisv_data.posizione as posizione, \n" + + " mtb_lisv_data.perc_gest as perc_gest, \n" + + " mtb_lisv_data.val_gest as val_gest, \n" + + " mtb_lisv_data.data_agg_prz as data_agg_prz, \n" + + " mtb_lisv_data.perc_ispe as perc_ispe, \n" + + " mtb_lisv_data.val_ispe as val_ispe, \n" + + " mtb_lisv_data.perc_promo as perc_promo, \n" + + " mtb_lisv_data.val_promo as val_promo, \n" + + " mtb_lisv_data.perc_oneri as perc_oneri, \n" + + " mtb_lisv_data.val_oneri as val_oneri, \n" + + " mtb_lisv_data.tipo_variazione as tipo_variazione, \n" + + " mtb_lisv_data.note as note,\n" + + " mtb_lisv_data.aggiornato_da as aggiornato_da,\n" + + " mtb_lisv_data.prz_vend * (1 - mtb_lisv_data.perc_sco1/100) * (1 - mtb_lisv_data.perc_sco2/100)* (1 - mtb_lisv_data.perc_sco3/100)* (1 - mtb_lisv_data.perc_sco4/100) as prz_vend_netto,\n" + + " vtb_promo.descrizione as 'descr_promo',\n" + + " vtb_promo.data_iniz_sell_out,\n" + + " vtb_promo.data_fine_sell_out,\n" + + " vtb_promo.flag_tipo_promo,\n" + + " mtb_lisv_data.sconto_cartoni,\n" + + " mtb_lisv_data.sconto_strato,\n" + + " mtb_lisv_data.sconto_pedane,\n" + + " mtb_lisv_data.giacenza,\n" + + " mtb_lisv_data.magg_prz_vend,\n" + + " vtb_promo.flag_sconto_contrattuale,\n" + + " vtb_promo.intercode_xml_variazioni,\n" + + " vtb_list_data.note as note_testata,\n" + + " vtb_promo.flag_tipologia\n" + + " FROM vtb_list inner join testata_lisv vtb_list_data on vtb_list.cod_vlis = vtb_list_data.cod_vlis_rif\n" + + " inner join mtb_lisv_data on vtb_list_data.cod_vlis_rif = mtb_lisv_data.cod_vlis AND vtb_list_data.versione_rif = mtb_lisv_data.versione\n" + + " inner join mtb_aart on mtb_lisv_data.cod_mart = mtb_aart.cod_mart\n" + + " inner join vtb_promo on vtb_list_data.cod_promo = vtb_promo.cod_promo \n" + + " WHERE (@codMart IS NULL OR mtb_lisv_data.cod_mart = @codMart)"); + } + + @Override + public void down() throws Exception { + + } + +} diff --git a/ems-core/src/main/java/it/integry/ems_model/entity/GtbBancAzi.java b/ems-core/src/main/java/it/integry/ems_model/entity/GtbBancAzi.java index d3135bef1c..fbda2cc332 100644 --- a/ems-core/src/main/java/it/integry/ems_model/entity/GtbBancAzi.java +++ b/ems-core/src/main/java/it/integry/ems_model/entity/GtbBancAzi.java @@ -3,6 +3,7 @@ package it.integry.ems_model.entity; import com.fasterxml.jackson.annotation.JsonTypeName; import it.integry.ems_model.annotation.*; import it.integry.ems_model.base.EntityBase; +import it.integry.ems_model.base.EquatableEntityInterface; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.kie.api.definition.type.PropertyReactive; @@ -10,12 +11,13 @@ import org.kie.api.definition.type.PropertyReactive; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; +import java.util.Objects; @Master @PropertyReactive @Table(GtbBancAzi.ENTITY) @JsonTypeName(GtbBancAzi.ENTITY) -public class GtbBancAzi extends EntityBase { +public class GtbBancAzi extends EntityBase implements EquatableEntityInterface { private final static Logger logger = LogManager.getLogger(); @@ -212,4 +214,21 @@ public class GtbBancAzi extends EntityBase { GtbBancAziEff gtbBancAziEff = new GtbBancAziEff(); gtbBancAziEff.deleteAllEntities(connection, this); } + + @Override + public int hashCodeKey() { + return Objects.hash(getCodBancAzi()); + } + + @Override + public boolean equalsKey(GtbBancAzi other) { + if (this == other) + return true; + + if(hashCodeKey() != other.hashCodeKey()) + return false; + + return Objects.equals(getCodBancAzi(), other.getCodBancAzi()); + + } } diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeBancheAziendaliImportController.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeBancheAziendaliImportController.java new file mode 100644 index 0000000000..542cec3aa3 --- /dev/null +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/controller/ExchangeBancheAziendaliImportController.java @@ -0,0 +1,43 @@ +package it.integry.ems.system.exchange.controller; + +import it.integry.common.var.CommonConstants; +import it.integry.ems.javabeans.RequestDataDTO; +import it.integry.ems.response.ServiceRestResponse; +import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; +import it.integry.ems.system.exchange.service.ExchangePartiteMagazzinoImportService; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Scope; +import org.springframework.web.bind.annotation.*; + +import javax.servlet.http.HttpServletRequest; + +@RestController +@Scope("request") +@RequestMapping("exchange/banche-aziendali/") +public class ExchangeBancheAziendaliImportController { + + private final Logger logger = LogManager.getLogger(); + + @Autowired + private ExchangePartiteMagazzinoImportService exchangeBancheAziendaliImportService; + + @Autowired + private RequestDataDTO requestDataDTO; + + @RequestMapping(value = "import", method = RequestMethod.GET) + public @ResponseBody + ServiceRestResponse importBancheAziendali(HttpServletRequest request, + @RequestParam(CommonConstants.PROFILE_DB) String profileDb, + @RequestParam() String profileDbExchange) throws Exception { + + + try (MultiDBTransactionManager internalDb = new MultiDBTransactionManager(profileDb); + MultiDBTransactionManager exchangeDb = new MultiDBTransactionManager(profileDbExchange)) { + exchangeBancheAziendaliImportService.importPartiteMagazzinoLavorazione(internalDb, exchangeDb,requestDataDTO); + } + return ServiceRestResponse.createPositiveResponse(); + } + +} diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeBancheAziendaliImportService.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeBancheAziendaliImportService.java new file mode 100644 index 0000000000..14681f082d --- /dev/null +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeBancheAziendaliImportService.java @@ -0,0 +1,126 @@ +package it.integry.ems.system.exchange.service; + +import it.integry.ems.expansion.RunnableThrowable; +import it.integry.ems.javabeans.RequestDataDTO; +import it.integry.ems.service.EntityProcessor; +import it.integry.ems.sync.MultiDBTransaction.MultiDBTransactionManager; +import it.integry.ems_model.base.EquatableEntityInterface; +import it.integry.ems_model.entity.GtbBancAzi; +import it.integry.ems_model.types.OperationType; +import it.integry.ems_model.utility.UtilityDB; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.sql.Connection; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.Collectors; + +@SuppressWarnings("rawtypes") +@Service +public class ExchangeBancheAziendaliImportService { + + //TODO: To be remove, only for fast development + private final String ROSSOGARGANO_EXCHANGE_USER = "EXCHANGE"; + + + @Autowired + private EntityProcessor entityProcessor; + + @Autowired + private ExchangeImportSchemaManagerService exchangeImportSchemaManagerService; + + @Autowired + private ExchangeImportDataManagerService exchangeImportDataManagerService; + + private final Logger logger = LogManager.getLogger(); + + public void importBancheAziendali(MultiDBTransactionManager internalMultiDb, MultiDBTransactionManager exchangeMultiDb, RequestDataDTO requestDataDTO) throws Exception { + + boolean useTempTable = true; + + try { + exchangeImportSchemaManagerService.syncSchema(exchangeMultiDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.BancheAziendali, useTempTable); + + final List exchangeImportedData = retrieveBanche( + exchangeMultiDb.getPrimaryConnection(), + + true, false); + + final List exchangeUpdatedData = retrieveBanche( + exchangeMultiDb.getPrimaryConnection(), + false, useTempTable); + + List allData = exchangeImportDataManagerService + .runSync(GtbBancAzi.class, exchangeImportedData, exchangeUpdatedData); + + allData.forEach(x -> x.setOperation(x.getOperation() == OperationType.INSERT ? OperationType.INSERT_OR_UPDATE : x.getOperation())); + + allData = allData.stream().filter(x -> x.getOperation() != OperationType.DELETE) + .collect(Collectors.toList()); + + final Exception[] firstExceptionToThrow = {null}; + + AtomicInteger importedCounter = new AtomicInteger(); + List calls = new ArrayList<>(); + + for (EquatableEntityInterface dataToSave : allData) { + logger.debug("Importate {} banche aziendali di {}", importedCounter.incrementAndGet(), allData.size()); + try { + entityProcessor.processEntity(dataToSave, true, true, ROSSOGARGANO_EXCHANGE_USER, internalMultiDb, requestDataDTO); + singleUpdateImported(exchangeMultiDb.getPrimaryConnection(), (GtbBancAzi) dataToSave, useTempTable); + + internalMultiDb.commitAll(); + exchangeMultiDb.commitAll(); + + } catch (Exception ex) { + if (firstExceptionToThrow[0] == null) firstExceptionToThrow[0] = ex; + + logger.error("Errore durante l'importazione della banca aziendale", ex); + internalMultiDb.rollbackAll(); + exchangeMultiDb.rollbackAll(); + } + + + } + + if (firstExceptionToThrow[0] != null) throw firstExceptionToThrow[0]; + } finally { + if (useTempTable) + exchangeImportSchemaManagerService.deleteTempTables(exchangeMultiDb.getPrimaryConnection(), ExchangeImportSchemaManagerService.SchemaType.BancheAziendali); + } + } + + + private List retrieveBanche(Connection connection, + boolean retrieveAlreadyImported, boolean useTempTable) throws Exception { + + String gtbBancAziOriginalName = "gtb_banc_azi"; + String gtbBancAziTableName = gtbBancAziOriginalName + (useTempTable ? "_tmp" : ""); + + if (useTempTable) { + UtilityDB.executeStatement(connection, + "INSERT INTO " + gtbBancAziTableName + + " SELECT * FROM " + gtbBancAziOriginalName + ); + } + + + return exchangeImportDataManagerService.retrieveDataFromExchange(connection, GtbBancAzi.class, + gtbBancAziTableName, null, retrieveAlreadyImported); + } + + + private void singleUpdateImported(Connection connection, GtbBancAzi importedData, boolean useTempTable) throws Exception { + final HashMap importedKey = new HashMap() {{ + put("cod_banc_azi", importedData.getCodBancAzi()); + }}; + + exchangeImportDataManagerService.updateImportedStatus(connection, "gtb_banc_azi", importedKey, useTempTable); + } + +} diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeImportSchemaManagerService.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeImportSchemaManagerService.java index 1e3a12f800..605e0d8cdb 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeImportSchemaManagerService.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeImportSchemaManagerService.java @@ -24,7 +24,8 @@ public class ExchangeImportSchemaManagerService { Articoli(4), PartiteMagazzinoLavorazione(5), VersamentoGrezzo(6), - CampiRaccolta(7); + CampiRaccolta(7), + BancheAziendali(8); private final int value; @@ -67,6 +68,7 @@ public class ExchangeImportSchemaManagerService { put(SchemaType.PartiteMagazzinoLavorazione, Arrays.asList("mtb_partita_mag_lav")); put(SchemaType.VersamentoGrezzo, Arrays.asList("mtb_colt_versamento_grezzo", "mtb_colr_versamento_grezzo")); put(SchemaType.CampiRaccolta, Collections.singletonList("campi_raccolta")); + put(SchemaType.BancheAziendali, Arrays.asList("gtb_banc_azi")); }}; public void syncSchema(Connection connection, SchemaType schemaType, boolean createTempTablesToo) throws Exception { diff --git a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeSystemManagerService.java b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeSystemManagerService.java index 90d6c99e3f..6870547538 100644 --- a/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeSystemManagerService.java +++ b/ems-engine/src/main/java/it/integry/ems/system/exchange/service/ExchangeSystemManagerService.java @@ -134,6 +134,10 @@ public class ExchangeSystemManagerService { final ExchangeOrdiniImportService beanCampiRaccolta = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeOrdiniImportService.class); beanCampiRaccolta.importCampiDiRaccolta(internalDb, exchangeDb, requestDataDTO); break; + case BancheAziendali: + final ExchangeBancheAziendaliImportService beanBancheAziendali = ContextLoader.getCurrentWebApplicationContext().getBean(ExchangeBancheAziendaliImportService.class); + beanBancheAziendali.importBancheAziendali(internalDb, exchangeDb, requestDataDTO); + break; } }