/* eslint-disable @typescript-eslint/camelcase */
import { HttpException, HttpStatus, Injectable,Inject } from '@nestjs/common';
import { ShoppingItens } from 'src/domain/entity/tables/estprevendai.entity';
import { Sale } from 'src/domain/entity/tables/estvenda.entity';
import { Pcpedctemp } from 'src/domain/entity/tables/pcpedctemp.entity';
import { Connection, QueryRunner } from 'typeorm';
import { Pcclient } from '../../domain/entity/tables/pcclient.entity';
import { Pcpeditemp } from 'src/domain/entity/tables/pcpeditemp.entity';
import { Cart } from 'src/domain/models/cart.model';
import { Pcpedc } from '../../domain/entity/tables/pcpedc.entity';
import { connectionOptions } from 'src/configs/typeorm.config';
import { ListsService } from 'src/backoffice/lists/lists.service';
import { CustomerService } from '../customer/customer.service';
import { AddressCustomerService } from '../address-customer/address-customer.service';
import { ShoppingService } from '../shopping/shopping.service';
import Redis = require('ioredis');


@Injectable()
export class OrderService {

    constructor(
        @Inject('REDIS_CLIENT') private readonly redisClient: Redis.Redis,
        private readonly listsService: ListsService,
        private readonly customerService: CustomerService,
        private readonly addressCustomerService: AddressCustomerService,
        private readonly shoppingService: ShoppingService,
    ) { }

    async create(cart: Cart) {
        const shopping = await this.findShopping(cart.id);
        if (shopping == null)
            throw new HttpException("Carrinho de compras não localizado.", HttpStatus.NOT_FOUND);
        const order = await this.createOrder(cart);
        return order;
    }

    async deleteOrdersDelivery(orderId: number, userId: number) {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();

        try {
            const orderCancel = await queryRunner.query('SELECT PCPEDC.NUMPED FROM PCPEDC WHERE NUMPED = :NUMPED', [orderId]);

            if (orderCancel !== null && orderCancel.length > 0) {
                await queryRunner.startTransaction();
                await queryRunner.query("UPDATE PCPEDC SET VENDAASSISTIDA = 'N', RESERVAESTOQUETV7 = 'N' WHERE NUMPEDENTFUT = :1", [orderId]);
                await queryRunner.commitTransaction();
                const ordersDelivery = await queryRunner
                    .query("SELECT PCPEDC.NUMPED FROM PCPEDC WHERE NUMPEDENTFUT = :1", [orderId]);
                for (const orderDelivery of ordersDelivery) {
                    await queryRunner
                        .query("BEGIN ESK_VENDA.CANCELAR_PEDIDO(:1, :2); END;", [orderDelivery.numped, userId]);
                }
            }
        } catch (erro) {
            if (queryRunner.isTransactionActive) {
                await queryRunner.commitTransaction();
            }
            throw erro;
        } finally {
            if (queryRunner.isTransactionActive) {
                await queryRunner.rollbackTransaction();
            }
            await queryRunner.release();
            await connection.close();
        }
    }

    async createOrder(cart: Cart) {

        const prevenda = await this.shoppingService.getShopping(cart.id);
        let idPreOrder = 0;
        cart.idSeller = prevenda.codusur;
        if (prevenda.numped > 0) {
            idPreOrder = await this.getIdOrder(prevenda.codusur);
        } else {
            idPreOrder = await this.getIdOrder(cart.idSeller);
        }

        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();

        try {

            if (prevenda.numped > 0) {
                // await this.deleteOrdersDelivery(prevenda.numped, cart.userId);
                const orders = await queryRunner.query('SELECT PCPEDC.NUMPED FROM PCPEDC WHERE NUMPED = :NUMPED', [prevenda.numped]);
                if (orders !== null && orders.length > 0) {
                    await queryRunner
                        .query("BEGIN ESK_VENDA.CANCELAR_PEDIDO(:1, :2); END;", [prevenda.numped, cart.userId]);
                    const orderCancel = await queryRunner
                        .query('SELECT PCPEDC.NUMPED FROM PCPEDC WHERE NUMPED = :1', [prevenda.numped]);
                    if (orderCancel.length > 0) {
                        throw new HttpException('Não foi possível alterar o pedido de venda, verifique se o pedido já não encontra-se FATURADO ou em SEPARAÇÃO.', HttpStatus.BAD_REQUEST);
                    }
                }

            }

            //  if ( prevenda.codcli === null || prevenda.codcli === 1){
            //      this.createPreCustomer(cart);
            //  }

            const preOrder = await this.createPreOrder(cart, idPreOrder);

            await queryRunner
                .query("BEGIN IMPORTARVENDAS.IMPORTARPEDIDOWEB(:preOrder, :idSeller); END;", [preOrder.numpedrca, preOrder.codusur]);

            const order = await queryRunner.manager
                .getRepository(Pcpedc)
                .createQueryBuilder('pcpedc')
                .where("\"pcpedc\".numpedrca = :idPreOrder AND \"pcpedc\".CONDVENDA IN  (1,7)", { idPreOrder: preOrder.numpedrca })
                .getOne();

            if (!order) {
                const logPreOrder = await queryRunner.query('SELECT PCPEDCTEMP.NUMPEDRCA, PCPEDCTEMP.observacao_pc as \"resultado\" FROM PCPEDCTEMP WHERE PCPEDCTEMP.NUMPEDRCA = :idPreOrder',
                    [preOrder.numpedrca]);
                console.log(JSON.stringify(logPreOrder));
                throw new HttpException('Erro ao gerar pedido de venda - ' + logPreOrder[0].resultado, HttpStatus.INTERNAL_SERVER_ERROR);
            }

            if (queryRunner.isTransactionActive) {
                queryRunner.commitTransaction();
            }

            await queryRunner.startTransaction();
            try {
                // Atualizar numero do pedido na tabela de pre venda para
                let sql = ` UPDATE ESTPREVENDAC SET NUMPED = ${order.numped} ` +
                    `  WHERE ESTPREVENDAC.ID = '${cart.id}' `;
                await queryRunner.query(sql);

                sql = `UPDATE PCORCAVENDAC SET ORCAMENTOUTILIZADO = 'S' ` +
                    `                       ,NUMPED = ${order.numped} ` +
                    ` WHERE PCORCAVENDAC.NUMORCA = ( SELECT ESTPREVENDAC.NUMORCA FROM ESTPREVENDAC WHERE ID = '${cart.id}' )  `;
                await queryRunner.query(sql);

                //  await queryRunner
                //      .query("BEGIN ESK_VENDA.RESERVA_PIGMENTO_TINTOMETRICO(:1); END;", [cart.id]);


                sql = `UPDATE PCPEDC SET ` +
                    `                   POSICAO = 'L' ` +
                    `                 , MOTIVOPOSICAO = NULL ` +
                    `                 , CODMOTIVO = NULL ` +
                    `                 , DATA = TRUNC(DATA) ` +
                    `                 , CODMOTBLOQUEIO = 0 ` +
                    `                 , CODDISTRIB = 1 ` +
                    `                 , DTENTREGA = TRUNC(DTENTREGA) ` +
                    `                 , ORIGEMPED = 'T' ` +
                    `                 , DTABERTURAPEDPALM = TRUNC(DTABERTURAPEDPALM) ` +
                    `                 , ROTINALANC = 'VENDAWEB' ` +
                    `                 , ROTINALANCULTALT = 'VENDAWEB'  ` +
                    `                 , TIPOVENDA = 'VV'               ` +
                    `                 , TIPOEMBALAGEM = 'U'            ` +
                    `                 , PRAZO1  = NVL(PRAZO1,0)          ` +
                    `      WHERE NUMPED = :1 ` +
                    `        AND NOT EXISTS(SELECT PCBLOQUEIO.CODMOTBLOQUEIO FROM PCBLOQUEIO WHERE PCBLOQUEIO.CODCOB = PCPEDC.CODCOB) ` +
                    `        AND ( CODCOB IN ('DH', 'D') OR CODCOB LIKE 'CAR%'  ` +
                    `                  OR EXISTS(SELECT PCCOB.CODCOB FROM PCCOB ` +
                    `                                               WHERE PCCOB.CODCOB = PCPEDC.CODCOB ` +
                    `                                                 AND NVL(PCCOB.CARTAO,'N') = 'S') ) `;
                await queryRunner.manager
                    .query(sql, [order.numped]);
                sql = `UPDATE PCPEDI SET POSICAO = 'L' WHERE NUMPED = :1 ` +
                    ` AND EXISTS( SELECT PCPEDC.NUMPED FROM PCPEDC ` +
                    `              WHERE PCPEDC.NUMPED = PCPEDI.NUMPED ` +
                    `                AND NOT EXISTS(SELECT PCBLOQUEIO.CODMOTBLOQUEIO FROM PCBLOQUEIO WHERE PCBLOQUEIO.CODCOB = PCPEDC.CODCOB) ` +
                    `                AND ( PCPEDC.CODCOB IN ('DH', 'D', 'CAR') OR CODCOB LIKE 'CAR%' ` +
                    `                       OR EXISTS(SELECT PCCOB.CODCOB FROM PCCOB ` +
                    `                                  WHERE PCCOB.CODCOB = PCPEDC.CODCOB   ` +
                    `                                    AND NVL(PCCOB.CARTAO,'N') = 'S') ) )`;
                await queryRunner.manager
                    .query(sql, [order.numped]);

                await this.updateStatusItem(queryRunner, order.numped);


                sql = ` UPDATE PCPEDC SET ` +
                    `                   POSICAO = 'L' ` +
                    `                 , MOTIVOPOSICAO = NULL ` +
                    `                 , CODMOTIVO = NULL ` +
                    `                 , DATA = TRUNC(DATA) ` +
                    `                 , DTENTREGA     = TRUNC(DTENTREGA) ` +
                    `                 , DTPREVENTREGA = TRUNC(DTENTREGA) ` +
                    `                 , ORIGEMPED = 'T' ` +
                    `                 , DTABERTURAPEDPALM = TRUNC(DTABERTURAPEDPALM) ` +
                    `                 , ROTINALANC = 'VENDAWEB' ` +
                    `                 , ROTINALANCULTALT = 'VENDAWEB' ` +
                    `                 , CODMOTBLOQUEIO = NULL ` +
                    `                 , CODDISTRIB = 1 ` +
                    `                 , TIPOVENDA = 'VV'               ` +
                    `                 , TIPOEMBALAGEM = 'U'            ` +
                    `                 , PRAZO1  = NVL(PRAZO1,0)        ` +
                    `WHERE NOT EXISTS(SELECT PCPEDI.CODPROD FROM PCPEDI ` +
                    `               WHERE PCPEDI.NUMPED = PCPEDC.NUMPED ` +
                    `                 AND PCPEDI.POSICAO NOT IN ('L') ) ` +
                    `    AND PCPEDC.NUMPEDENTFUT = :1 ` +
                    `    AND EXISTS(SELECT TV7.NUMPED FROM PCPEDC TV7 WHERE TV7.NUMPED = PCPEDC.NUMPEDENTFUT ` +
                    `                  AND TV7.POSICAO = 'L' )`;

                await queryRunner.manager.query(sql, [order.numped]);
                sql = ` UPDATE PCPEDC SET ` +
                    `                   POSICAO =  ( SELECT PCPEDI.POSICAO FROM PCPEDI WHERE PCPEDI.NUMPED = PCPEDC.NUMPED AND ROWNUM = 1 ) ` +
                    `                 , MOTIVOPOSICAO = NULL ` +
                    `                 , CODMOTIVO = NULL ` +
                    `                 , DTENTREGA = TRUNC(DTENTREGA) ` +
                    `                 , DTPREVENTREGA = TRUNC(DTENTREGA) ` +
                    `                 , DATA = TRUNC(DATA) ` +
                    `                 , ORIGEMPED = 'T' ` +
                    `                 , DTABERTURAPEDPALM = TRUNC(DTABERTURAPEDPALM) ` +
                    `                 , ROTINALANC = 'VENDAWEB' ` +
                    `                 , ROTINALANCULTALT = 'VENDAWEB' ` +
                    `                 , CODMOTBLOQUEIO = NULL ` +
                    `                 , CODDISTRIB = 1 ` +
                    `                 , TIPOVENDA = 'VV'               ` +
                    `                 , TIPOEMBALAGEM = 'U'            ` +
                    `                 , PRAZO1  = NVL(PRAZO1,0)        ` +
                    `WHERE  EXISTS(SELECT PCPEDI.CODPROD FROM PCPEDI ` +
                    `               WHERE PCPEDI.NUMPED = PCPEDC.NUMPED ` +
                    `                 AND PCPEDI.POSICAO NOT IN ('L') ) ` +
                    `    AND PCPEDC.NUMPEDENTFUT = :1 ` +
                    `    AND EXISTS(SELECT TV7.NUMPED FROM PCPEDC TV7 WHERE TV7.NUMPED = PCPEDC.NUMPEDENTFUT ` +
                    `                  AND TV7.POSICAO = 'L' )`;
                await queryRunner.manager.query(sql, [order.numped]);

                // atualizar campos padrão para rotina 4116
                sql = ` UPDATE PCPEDC SET ` +
                    `                   DTENTREGA = TRUNC(DTENTREGA) ` +
                    `                 , DATA = TRUNC(DATA) ` +
                    `                 , DTPREVENTREGA = TRUNC(DTENTREGA) ` +
                    `                 , ORIGEMPED = 'T' ` +
                    `                 , VLFRETE   =  0 ` +
                    `                 , DTABERTURAPEDPALM = TRUNC(DTABERTURAPEDPALM) ` +
                    `                 , ROTINALANC = 'VENDAWEB' ` +
                    `                 , ROTINALANCULTALT = 'VENDAWEB' ` +
                    `                 , CODMOTBLOQUEIO   = CASE WHEN PCPEDC.POSICAO = 'B' THEN CODMOTBLOQUEIO ELSE 0 END ` +
                    `                 , CODDISTRIB = 1 ` +
                    `                 , TIPOVENDA = 'VV'               ` +
                    `                 , TIPOEMBALAGEM = 'U'            ` +
                    `                 , PRAZO1  = NVL(PRAZO1,0)        ` +
                    `                 , VENDAASSISTIDA  = 'S'          ` +
                    `                 , MATERIALDECONSTRUCAO  = 'S'    ` +
                    `                 , TIPOPRIORIDADEENTREGA = '${cart.shippingPriority}' ` +
                    `                 , CODUSUR3    = ${preOrder.codusur3} ` +
                    `                 , OBSENTREGA3 = '${preOrder.obsentrega3}' ` +
                    `                 , CODPRACA = CASE WHEN '${cart.shippingPriority}' = 'M' THEN ${cart.idStorePlace} ` +
                    `                                   WHEN NVL(CODENDENTCLI,0) = 0 THEN CODPRACA ELSE ` +
                    `                                        NVL((SELECT PCCLIENTENDENT.CODPRACAENT FROM PCCLIENTENDENT ` +
                    `                                              WHERE PCCLIENTENDENT.CODCLI = PCPEDC.CODCLI AND ` +
                    `                                                    PCCLIENTENDENT.CODENDENTCLI = PCPEDC.CODENDENTCLI), PCPEDC.CODPRACA ) END ` +
                    `WHERE ( PCPEDC.NUMPED = :1 OR PCPEDC.NUMPEDENTFUT = :2 ) `;
                await queryRunner.manager.query(sql, [order.numped, order.numped]);

                sql = ` UPDATE PCPEDC SET ` +
                    `                   CODCOB    = ( SELECT TV7.CODCOB FROM PCPEDC TV7 WHERE TV7.NUMPED = PCPEDC.NUMPEDENTFUT ) ` +
                    `                 , CODPLPAG  = ( SELECT TV7.CODPLPAG FROM PCPEDC TV7 WHERE TV7.NUMPED = PCPEDC.NUMPEDENTFUT ) ` +
                    `                 , RESERVAESTOQUETV7 = 'N' ` +
                    `                 , DTENTREGA = ( SELECT TV7.DTENTREGA FROM PCPEDC TV7 WHERE TV7.NUMPED = PCPEDC.NUMPEDENTFUT ) ` +
                    `WHERE (PCPEDC.NUMPEDENTFUT = :1 ) `;
                await queryRunner.manager.query(sql, [order.numped]);

                sql = ` UPDATE PCPEDI SET CODSUPERVISOR = ( SELECT PCPEDC.CODSUPERVISOR FROM PCPEDC WHERE PCPEDC.NUMPED = PCPEDI.NUMPED ) ` +
                    `                    ,DTENTREGA = ( SELECT PCPEDC.DTENTREGA FROM PCPEDC WHERE PCPEDI.NUMPED = PCPEDC.NUMPED )         ` +
                    `                    ,COMPLEMENTO   = NVL(( SELECT PCPEDITEMP.COMPLEMENTO FROM PCPEDITEMP, PCPEDCTEMP ` +
                    `                                            WHERE PCPEDITEMP.NUMPEDRCA = PCPEDCTEMP.NUMPEDRCA ` +
                    `                                              AND PCPEDCTEMP.NUMPED    = PCPEDI.NUMPED ` +
                    `                                              AND PCPEDITEMP.CODPROD   = PCPEDI.CODPROD ` +
                    `                                              AND PCPEDITEMP.NUMSEQ    = PCPEDI.NUMSEQ  ` +
                    `                                              AND ROWNUM = 1 ), PCPEDI.COMPLEMENTO)  ` +
                    ` WHERE PCPEDI.NUMPED IN ( SELECT PCPEDC.NUMPED FROM PCPEDC ` +
                    `                           WHERE PCPEDC.NUMPED = :1 OR PCPEDC.NUMPEDENTFUT = :2 ) `;
                await queryRunner.manager.query(sql, [order.numped, order.numped]);

                await queryRunner.commitTransaction();
            } catch (err) {
                await queryRunner.rollbackTransaction();
                console.log(err);
            }


            let status = '';
            const statusOrder = await queryRunner
                .query('SELECT PCPEDC.POSICAO as "status" FROM PCPEDC WHERE NUMPED = :1', [order.numped]);
            switch (statusOrder[0].status) {
                case 'L': {
                    status = 'LIBERADO';
                    break;
                }
                case 'P': {
                    status = 'PENDENTE';
                    break;
                }
                case 'B': {
                    status = 'BLOQUEADO';
                    break;
                }
                case 'F': {
                    status = 'FATURADO';
                    break;
                }
                case 'C': {
                    status = 'CANCELADO';
                    break;
                }

            }

            /* Sempre ira retornar status = LIBERADO*/
            //  status = 'LIBERADO';

            return {
                idOrder: order.numped,
                status: status
            };
        } catch (err) {
            console.log(err);
            this.deletePreOrder(idPreOrder);
            throw err;
            // since we have errors let's rollback changes we made
        } finally {
            // you need to release query runner which is manually created:
            await queryRunner.release();
            await connection.close();
        }
    }

    async updateStatusItem(queryRunner: QueryRunner, orderId: number) {
        const sql = ` SELECT PCPEDI.ROWID as "rid", PCPEDI.NUMPED as "numped", PCPEDI.CODPROD as "codprod", PCPEDI.CODFILIALRETIRA as "codfilialretira", ` +
            `        PCPEDI.QT as "qt", PCPEDI.POSICAO as "posicao", ` +
            `        ( NVL(PCEST.QTESTGER,0) - NVL(PCEST.QTRESERV,0) - NVL(PCEST.QTBLOQUEADA,0) - NVL(PCEST.QTPENDENTE,0) + PCPEDI.QT ) as "qtestoque_disponivel" ` +
            `   FROM PCPEDI, PCPEDC, PCEST, PCPEDC TV7 ` +
            ` WHERE PCPEDI.CODPROD = PCEST.CODPROD ` +
            `   AND PCPEDI.NUMPED = PCPEDC.NUMPED ` +
            `   AND PCPEDC.NUMPEDENTFUT = TV7.NUMPED ` +
            `   AND PCPEDI.CODFILIALRETIRA = PCEST.CODFILIAL ` +
            `   AND NOT EXISTS(SELECT PCBLOQUEIO.CODMOTBLOQUEIO FROM PCBLOQUEIO WHERE PCBLOQUEIO.CODCOB = TV7.CODCOB) ` +
            `   AND ( TV7.CODCOB IN ('DH', 'D', 'CAR') OR ( TV7.CODCOB LIKE 'CAR%' ) OR EXISTS(SELECT PCCOB.CODCOB FROM PCCOB ` +
            `                                                 WHERE PCCOB.CODCOB = TV7.CODCOB ` +
            `                                                   AND NVL(PCCOB.CARTAO,'N') = 'S') ) ` +
            `   AND PCPEDC.NUMPEDENTFUT = :1 FOR UPDATE `;
        const itensTV8 = await queryRunner.query(sql, [orderId]);

        for (const item of itensTV8) {
            await this.updateStockItem(queryRunner, item);
        }
    }

    async updateStockItem(queryRunner: QueryRunner, item: any) {
        let sql = "";
        if (item.posicao === "B") {
            if (item.qt > item.qtestoque_disponivel) {
                sql = `UPDATE PCPEDI SET POSICAO = 'P' ` +
                    ` WHERE PCPEDI.ROWID = :1`;
                await queryRunner.manager.query(sql, [item.rid]);
            } else {
                sql = `UPDATE PCEST SET QTPENDENTE = GREATEST((QTPENDENTE - :1), 0) ` +
                    `                 ,QTRESERV = QTRESERV + :2 ` +
                    `  WHERE PCEST.CODFILIAL = :3 AND PCEST.CODPROD = :4`;
                await queryRunner.manager.query(sql, [item.qt, item.qt, item.codfilialretira, item.codprod]);
                sql = `UPDATE PCPEDI SET POSICAO = 'L' ` +
                    ` WHERE PCPEDI.ROWID = :1`;
                await queryRunner.manager.query(sql, [item.rid]);
            }
        }
    }

    async updateOrderDelivery(orderDelivery: Pcpedc, order: Pcpedc) {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        await queryRunner.startTransaction();
        try {
            await queryRunner.manager
                .createQueryBuilder()
                .update(Pcpedc)
                .set({
                    codplpag: order.codplpag,
                    codcob: order.codcob,
                    condvenda: 8,
                    numpedentfut: order.numped,
                    log: null,
                    codmotivo: null,
                    motivoposicao: null,
                    vlbonific: 0,
                    vendaassistida: 'S'
                })
                .where("numped = :numped", { numped: orderDelivery.numped })
                .execute();
            await queryRunner.commitTransaction();
        } catch (err) {
            await queryRunner.rollbackTransaction();
            throw err;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async deletePreOrder(idPreOrder: number) {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        await queryRunner.startTransaction();
        try {
            await queryRunner.manager
                .createQueryBuilder()
                .delete()
                .from(Pcpeditemp)
                .where("\"PCPEDITEMP\".NUMPEDRCA = :numpedrca", { numpedrca: idPreOrder })
                .execute();

            await queryRunner.manager
                .createQueryBuilder()
                .delete()
                .from(Pcpedctemp)
                .where("\"PCPEDCTEMP\".NUMPEDRCA = :numpedrca", { numpedrca: idPreOrder })
                .execute();
            await queryRunner.commitTransaction();
        } catch (err) {
            await queryRunner.rollbackTransaction();
            throw err;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async createPreOrder(cart: Cart, idPreOrder: number, idPreOrderTV7: number = null) {

        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        await queryRunner.startTransaction();
        console.log('iniciando transação');

        try {
            const customer = await this.getCustomer(cart.idCustomer);
            let idSellerPreorder = cart.idSeller;
            //Verifica se existe orçamento para a prevenda (CART)
            const cartPreOrder = await queryRunner.query('SELECT ESTPREVENDAC.NUMORCA, PCORCAVENDAC.CODUSUR as "idSeller" ' +
                '  FROM ESTPREVENDAC, PCORCAVENDAC ' +
                ` WHERE ESTPREVENDAC.ID = '${cart.id}' ` +
                '   AND ESTPREVENDAC.NUMORCA = PCORCAVENDAC.NUMORCA ');

            if (cartPreOrder != null && cartPreOrder.length > 0) {
                idSellerPreorder = cartPreOrder[0].idSeller;
            }

            const supervisor = await queryRunner.manager.query('SELECT PCUSUARI.CODSUPERVISOR FROM PCUSUARI WHERE CODUSUR = :1', [idSellerPreorder]);
            console.log(supervisor);

            //Create pre-customers 
            if (cart.idCustomer === 1 && cart.preCustomerDocument !== null) {
                const preCustomer = await queryRunner.query(`SELECT ESTVENDAPRECLIENTE.CPF FROM ESTVENDAPRECLIENTE ` +
                    ` WHERE IDCART = :1 AND CPF = :2`, [cart.id, cart.preCustomerDocument]);
                if (preCustomer === null || preCustomer.length === 0) {
                    const sqlInsert = ` INSERT INTO ESTVENDAPRECLIENTE ( CPF, IDCART, NOME, TELEFONE, DTCADASTRO, CODUSUR, NUMPEDRCA ) ` +
                        `  VALUES ( REGEXP_REPLACE(:CPF, '[^0-9]', '') , :IDCART, :NOME, :TELEFONE, SYSDATE, :CODUSUR, :NUMPEDRCA ) `;
                    await queryRunner.query(sqlInsert, [cart.preCustomerDocument,
                    cart.id, cart.preCustomerName, cart.preCustomerPhone, cart.idSeller, idPreOrder]);
                }
            } else {
                if (cart.preCustomerDocument !== null) {
                    await queryRunner.query(`DELETE FROM ESTVENDAPRECLIENTE WHERE IDCART = :1 AND REGEXP_REPLACE(:CPF, '[^0-9]', '')`,
                        [cart.id, cart.preCustomerDocument]);
                }
            }


            //#region create PCPEDCTEMP
            console.log('Cart: ' + cart);
            const dateNow = new Date();
            const dateDelivery = new Date();
            dateDelivery.setDate(dateNow.getDate() + 3);
            const preOrder = new Pcpedctemp();
            preOrder.numpedrca = idPreOrder;
            preOrder.percvenda = 100;
            preOrder.codcob = cart.idBilling;
            preOrder.codplpag = cart.idPaymentPlan;
            if (cart.idAddress > 0) {
                preOrder.codendentcli = cart.idAddress;
                preOrder.codendent = cart.idAddress;
            }
            preOrder.condvenda = 7;
            if (idPreOrderTV7) {
                preOrder.condvenda = 1;
            }
            preOrder.dtaberturapedpalm = new Date();
            preOrder.dtinclusao = new Date();
            preOrder.dtimportacao = new Date();
            preOrder.data = new Date();
            preOrder.hora = preOrder.data.getHours();
            preOrder.minuto = preOrder.data.getMinutes();
            preOrder.dtentrega = dateDelivery;
            preOrder.codfilial = cart.saleStore,
                preOrder.codfilialnf = preOrder.codfilial;
            preOrder.codusur = idSellerPreorder; // cart.idSeller;
            if (supervisor != null) {
                preOrder.codsupervisor = supervisor.codsupervisor;
            }
            preOrder.codemitente = cart.userId;
            preOrder.codusur3 = cart.idProfessional;
            preOrder.tipointegracao = "W";
            preOrder.validarnivelvenda = "N";
            preOrder.dtentrega = cart.shippingDate;
            preOrder.esc_tipoentrega = (cart.scheduleDelivery === true) ? 'P' : 'N';
            // preOrder.vlfrete = cart.shippingValue; --Já esta sendo incluido item para o valor de frete
            preOrder.vldescontocupom = 0;
            preOrder.vldescontofinanceiro = 0;
            preOrder.vlentrada = 0;
            preOrder.vlfretenf = 0;
            preOrder.vloutrasdesp = 0;
            preOrder.vltroco = 0;
            preOrder.origemped = "W";
            preOrder.integradora = 10;
            preOrder.importado = "N";
            preOrder.codautorizacaotef = 0;
            preOrder.esc_ajustarfinanceiro = "N";
            preOrder.esc_obternsu = "N";
            preOrder.esc_vloutrasdespweb = 0;
            preOrder.pedidopagoecommerce = "S";
            preOrder.numpedmktplace = "";
            preOrder.numitens = cart.itens.length;
            preOrder.obs1 = cart.notation1;
            preOrder.obs2 = cart.notation2;
            preOrder.obsentrega1 = cart.deliveryNote1;
            preOrder.obsentrega2 = cart.deliveryNote2;
            preOrder.obsentrega3 = cart.deliveryNote3;

            //Dados do cliente
            preOrder.codcli = cart.idCustomer;
            preOrder.codpraca = (cart.shippingPriority == "M" && cart.idStorePlace != null ) ? cart.idStorePlace : customer.codpraca;
            preOrder.fretedespacho = customer.fretedespacho;
            preOrder.codfornecfrete = cart.carrierId;

            preOrder.numpedcli = preOrder.numpedrca.toString();
            preOrder.numpedweb = preOrder.numpedrca;
            preOrder.data = new Date();
            preOrder.vlfrete = 0; //cart.shippingValue;
            //#endregion

            //#region create PCPEDITEMP

            let numeroSeq = 1;
            for (const item of cart.itens) {

                const kit = await queryRunner.query('SELECT PCFORMPROD.CODPRODMP as "idProduct", ' +
                    '       PCFORMPROD.QTPRODMP as "qtComponent", ' +
                    '       PCPRODUT.CODAUXILIAR as "ean"       ,' +
                    `       case when ESTLISTAPRODUTOS.PRECOPROMOCIONAL > 0 AND '${cart.idBilling}' <> 'CHM' THEN ` +
                    '               ESTLISTAPRODUTOS.precopromocional ' +
                    '        ELSE ESTLISTAPRODUTOS.precovenda END as "listPrice" ' +
                    ' FROM PCFORMPROD, PCPRODUT, ESTLISTAPRODUTOS  ' +
                    ' WHERE PCFORMPROD.CODPRODACAB = :1  ' +
                    '   AND PCFORMPROD.CODPRODMP = PCPRODUT.CODPROD ' +
                    '   AND PCPRODUT.CODPROD = ESTLISTAPRODUTOS.CODPROD ' +
                    '   AND ESTLISTAPRODUTOS.CODFILIAL = :2',
                    [item.idProduct, preOrder.codfilial]);
                if (kit.length > 0) {
                    for (const componente of kit) {

                        const listPrice = componente.listPrice;

                        const salePrice = (componente.listPrice *
                            (item.salePrice / item.listPrice)).toFixed(2);

                        const itemOrder = new Pcpeditemp();
                        itemOrder.tipointegracao = "W";
                        itemOrder.integradora = 10;
                        itemOrder.numpedrca = idPreOrder;
                        itemOrder.numpedweb = idPreOrder;
                        itemOrder.codcli = cart.idCustomer;
                        itemOrder.codusur = idSellerPreorder; //cart.idSeller;
                        itemOrder.numseq = numeroSeq;
                        itemOrder.codprod = componente.idProduct;
                        itemOrder.codauxiliar = componente.ean;
                        itemOrder.codfilialretira = item.idStock;
                        itemOrder.tipoentrega = (item.deliveryMethod == 'RA') ? "RP" : item.deliveryMethod;
                        itemOrder.rp_imediata = (item.deliveryMethod == 'RA') ? "S" : "N";
                        if ( item.deliveryMethod == 'RA') {
                            preOrder.dtentrega = new Date();
                        }
                        itemOrder.ptabela = Number.parseFloat(listPrice);
                        itemOrder.pvenda = Number.parseFloat(salePrice);
                        itemOrder.qt = (item.quantity * componente.qtComponent);
                        itemOrder.data = new Date();
                        itemOrder.complemento = item.descriptionAux;
                        itemOrder.localizacao = item.environment;

                        await queryRunner.manager
                            .createQueryBuilder()
                            .insert()
                            .into(Pcpeditemp)
                            .values(itemOrder)
                            .execute();

                        numeroSeq = numeroSeq + 1;
                    };
                } else {
                    const itemOrder = new Pcpeditemp();
                    itemOrder.tipointegracao = "W";
                    itemOrder.integradora = 10;
                    itemOrder.numpedrca = idPreOrder;
                    itemOrder.numpedweb = idPreOrder;
                    itemOrder.codcli = cart.idCustomer;
                    itemOrder.codusur = idSellerPreorder; //cart.idSeller;
                    itemOrder.numseq = numeroSeq;
                    itemOrder.codprod = item.idProduct;
                    itemOrder.codauxiliar = item.ean;
                    itemOrder.codfilialretira = item.idStock;
                    itemOrder.tipoentrega = (item.deliveryMethod == 'RA') ? "RP" : item.deliveryMethod;
                    itemOrder.rp_imediata = (item.deliveryMethod == 'RA') ? "S" : "N";
                    if ( item.deliveryMethod == 'RA') {
                        preOrder.dtentrega = new Date();
                    }
                    itemOrder.ptabela = item.listPrice;
                    itemOrder.pvenda = item.salePrice;
                    itemOrder.qt = item.quantity;
                    itemOrder.data = new Date();
                    itemOrder.complemento = item.descriptionAux;
                    itemOrder.localizacao = item.environment;

                    await queryRunner.manager
                        .createQueryBuilder()
                        .insert()
                        .into(Pcpeditemp)
                        .values(itemOrder)
                        .execute();

                    numeroSeq = numeroSeq + 1;

                }
            }

            //#endregion

            if (cart.shippingValue > 0) {
                const itemOrder = new Pcpeditemp();
                itemOrder.tipointegracao = "W";
                itemOrder.integradora = 10;
                itemOrder.numpedrca = idPreOrder;
                itemOrder.numpedweb = idPreOrder;
                itemOrder.codcli = cart.idCustomer;
                itemOrder.codusur = idSellerPreorder; //cart.idSeller;
                itemOrder.numseq = numeroSeq;
                itemOrder.codprod = 48500;
                itemOrder.codauxiliar = 48500;
                itemOrder.codfilialretira = '12';
                itemOrder.tipoentrega = 'EF';
                itemOrder.ptabela = Number.parseFloat(cart.shippingValue.toString());
                itemOrder.pvenda = Number.parseFloat(cart.shippingValue.toString());
                itemOrder.qt = 1;
                itemOrder.data = new Date();


                await queryRunner.manager
                    .createQueryBuilder()
                    .insert()
                    .into(Pcpeditemp)
                    .values(itemOrder)
                    .execute();

                numeroSeq = numeroSeq + 1;
            }

            // execute some operations on this transaction:
            await queryRunner.manager
                .createQueryBuilder()
                .insert()
                .into(Pcpedctemp)
                .values(preOrder)
                .execute();

            await queryRunner.commitTransaction();
            return preOrder;

        } catch (err) {
            await queryRunner.rollbackTransaction();
            throw err;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
        

    }

    async findSale(id: string) {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const sale = await queryRunner.manager
                .getRepository(Sale)
                .createQueryBuilder('estvenda')
                .where("\"estvenda\".id = :id", { id: id })
                .getOne();
            return sale;
        } catch (error) {
            console.log(error);
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async findShopping(idshopping: string) {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const shopping = await queryRunner.manager
                .getRepository(ShoppingItens)
                .createQueryBuilder('estshopping')
                .where("\"estshopping\".id = :id", { id: idshopping })
                .getMany();
            return shopping;
        } catch (error) {
            console.log(error);
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async getIdOrder(idSeller: number): Promise<number> {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        console.log('Consultando usuario ' + idSeller);
        let sql = 'SELECT NVL(PROXNUMPEDWEB,0) as "proxnumpedweb" FROM PCUSUARI ' +
            ' WHERE PCUSUARI.CODUSUR = :1 FOR UPDATE';
        const seller = await queryRunner.query(sql, [idSeller]);
       
        const idOrder = seller[0].proxnumpedweb;
        console.log(idOrder);

        await queryRunner.startTransaction();

        try {

            sql = 'UPDATE PCUSUARI SET PROXNUMPEDWEB = NVL(PROXNUMPEDWEB,0) + 1 ' +
                '   WHERE PCUSUARI.CODUSUR = :1';
            await queryRunner.query(sql, [idSeller]);

           
            await queryRunner.commitTransaction();
            return idOrder;

        } catch (err) {

            await queryRunner.rollbackTransaction();
            console.log(err);
            return -1;

        } finally {

            await queryRunner.release();
            await connection.close();
        }

    }

    async getCustomer(idCustomer: number) {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const customer = await queryRunner.manager
                .getRepository(Pcclient)
                .createQueryBuilder('pcclient')
                .where("\"pcclient\".codcli = :idCustomer", { idCustomer })
                .getOne();
            return customer;
        } catch (error) {
            console.log(error);
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async getOrders(store: string, initialDate: Date, finalDate: Date,
        document: string, name: string, sellerId: number, idOrder: string) {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        let sqlWhere = '';
        let sql = '';

        try {

            sql = ` SELECT TO_CHAR(PCPEDC.DATA, \'DD/MM/YYYY\') as "createDate"  ` +
                `       ,PCPEDC.NUMPED as "orderId"  ` +
                `       ,PCPEDC.CODFILIAL as "store"  ` +
                `       ,CASE WHEN PCPEDC.POSICAO = 'B' THEN 'BLOQUEADO' ` +
                `             WHEN PCPEDC.POSICAO = 'P' THEN 'PENDENTE' ` +
                `             WHEN PCPEDC.POSICAO = 'L' THEN 'LIBERADO' ` +
                `             WHEN PCPEDC.POSICAO = 'M' THEN 'MONTADO'  ` +
                `             WHEN PCPEDC.POSICAO = 'F' THEN 'FATURADO' END as "status" ` +
                `        ,PCPEDC.CODCLI     as "customerId" ` +
                `        ,PCPEDC.CODUSUR    as "sellerId" ` +
                `        ,PCCLIENT.CLIENTE as "customerName" ` +
                `        ,PCPEDC.VLATEND   as "orderValue"  ` +
                `        ,PCPEDC.NUMITENS  as "itens" ` +
                `        ,CASE WHEN ( SELECT COUNT(1) FROM ESTPIX WHERE ESTPIX.NUMPED = PCPEDC.NUMPED ) > 0 THEN 'S' ELSE 'N' END as "pixCreate" ` + 
                `  FROM PCPEDC, PCCLIENT ` +
                ` WHERE PCPEDC.CODCLI = PCCLIENT.CODCLI ` +
                `   AND PCPEDC.CONDVENDA IN (1,7) ` +
                `   AND PCPEDC.DTCANCEL IS NULL AND PCPEDC.POSICAO NOT IN ('C') `;
            `   AND PCPEDC.ROTINALANC = 'VENDAWEB' `;
            if (store != null && store != '') {
                sqlWhere += ` AND PCPEDC.CODFILIAL = '${store}'  `;
            }
            if (document != null && document != '') {
                sqlWhere += `   AND REGEXP_REPLACE(PCCLIENT.CGCENT, '[^0-9]', '') = REGEXP_REPLACE('${document}', '[^0-9]', '')`;
            }
            if (name != null && name != '') {
                sqlWhere += `   AND PCCLIENT.CLIENTE LIKE '${name.replace('@', '%')}'||'%'`;
            }
            if (sellerId > 0) {
                sqlWhere += ` AND PCPEDC.CODUSUR = ${sellerId}  `;
            }
            if (idOrder.trim() != null && idOrder.trim() != '') {
                sqlWhere += ` AND PCPEDC.NUMPED = ${idOrder}  `;
            }

            //tratamento de data//
            const startDate = new Date(initialDate);
            let day = startDate.getDate();
            let month = ("00" + (startDate.getMonth() + 1)).slice(-2);
            let year = startDate.getFullYear();
            const startFormat = day + "/" + month + "/" + year;
            const endDate = new Date(finalDate);
            day = endDate.getDate();
            month = ("00" + (endDate.getMonth() + 1)).slice(-2);
            year = endDate.getFullYear();
            const endFormat = day + "/" + month + "/" + year;

            sqlWhere += ` AND PCPEDC.DATA BETWEEN TO_DATE('${startFormat}', 'DD/MM/YYYY') AND TO_DATE('${endFormat}', 'DD/MM/YYYY')  `;

            const result = await queryRunner.query(sql + sqlWhere);
            return result;
        } catch (error) {
            console.log(error);
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }

    }
      

    async getItensOrder(idOrder: number) {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        let sql = '';

        try {

            sql = ` SELECT PCPEDI.CODPROD as "productId", PCPRODUT.DESCRICAO as "description", ` +
                `        PCPRODUT.EMBALAGEM as "package",                                    ` +
                `        ( SELECT PCPEDITEMP.COMPLEMENTO  FROM PCPEDITEMP                    ` +
                `            WHERE PCPEDC.NUMPEDRCA = PCPEDITEMP.NUMPEDRCA                   ` +
                `              AND PCPEDI.CODPROD   = PCPEDITEMP.CODPROD                     ` +
                `              AND PCPEDI.NUMSEQ    = PCPEDITEMP.NUMSEQ  ) as "color" ,      ` +
                `        ( SELECT PCPEDITEMP.LOCALIZACAO  FROM PCPEDITEMP                ` +
                `            WHERE PCPEDC.NUMPEDRCA = PCPEDITEMP.NUMPEDRCA               ` +
                `              AND PCPEDI.CODPROD   = PCPEDITEMP.CODPROD                 ` +
                `              AND PCPEDI.NUMSEQ    = PCPEDITEMP.NUMSEQ  ) as "local",   ` +
                `        PCPEDI.QT as "quantity", PCPEDI.PVENDA as "price", ( PCPEDI.QT * PCPEDI.PVENDA ) as "subTotal" ` +
                `   FROM PCPEDI, PCPEDC, PCPRODUT                                        ` +
                `  WHERE PCPEDI.CODPROD = PCPRODUT.CODPROD                               ` +
                `    AND PCPEDI.NUMPED  = PCPEDC.NUMPED                                  ` +
                `    AND PCPEDC.CONDVENDA IN (7,1)                                       ` +
                `    AND PCPEDC.NUMPED = :NUMPED                                         ` +
                //                 `   AND PCPEDC.ROTINALANC = 'VENDAWEB'                                   ` + 
                ` ORDER BY PCPEDI.NUMSEQ                                                 `;
            const result = await queryRunner.query(sql, [idOrder]);
            return result;
        } catch (error) {
            console.log(error);
            throw error;
        } finally {
            await queryRunner.release();
            await connection.close();
        }

    }

    async getCartId(orderId: number) {
        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const order = await queryRunner.query('SELECT PCPEDC.DATA as "createDate" ' +
                '      ,PCPEDC.NUMPED             as "orderId" ' +
                '      ,PCPEDC.CODFILIAL          as "invoiceStore" ' +
                '      ,PCPEDC.CODCLI             as "customerId" ' +
                '      ,PCPEDC.CODPLPAG           as "paymentPlanId" ' +
                '      ,PCPEDC.CODCOB             as "billindId" ' +
                '      ,PCPEDC.CODENDENT          as "addressId" ' +
                '      ,PCPEDC.CODUSUR3           as "partnerId" ' +
                '      ,ESTPREVENDAC.ID           as "cartId" ' +
                '      ,PCPEDC.POSICAO            as "status" ' +

                '      ,PCPEDC.OBS                as "notification" ' +
                '      ,PCPEDC.OBS1               as "notification1" ' +
                '      ,PCPEDC.OBS2               as "notification2" ' +
                '      ,PCPEDC.OBSENTREGA1        as "notificationDelivery1" ' +
                '      ,PCPEDC.OBSENTREGA2        as "notificationDelivery2" ' +
                '      ,PCPEDC.OBSENTREGA3        as "notificationDelivery3" ' +
                '      ,PCPEDC.DTENTREGA          as "deliveryDate" ' +
                '      ,ESTPREVENDAC.ENTREGAPROGRAMADA as "squeduleDelivery" ' +
                `      ,NVL(PCPEDC.TIPOPRIORIDADEENTREGA, 'B')  as "priorityDelivery" ` +
                '  FROM PCPEDC, ESTPREVENDAC ' +
                ' WHERE PCPEDC.NUMPED = ESTPREVENDAC.NUMPED ' +
                '   AND PCPEDC.NUMPED = :1', [orderId]);

            if (order.length == 0) {
                throw new HttpException(`Pedido não foi localizado`, HttpStatus.NOT_FOUND);
            }

            if (order.status == 'F') {
                throw new HttpException(`Pedido já FATURADO, alteração não permitida.`, HttpStatus.NOT_FOUND);
            }

            const invoiceStores = await this.listsService.GetStoreAll();
            const invoiceStore = await invoiceStores.find(data => data.id === order[0].invoiceStore);
            const customer = await this.customerService.findCustomerById(order[0].customerId);
            const billinds = await this.listsService.GetBilling(order[0].customerId);
            const partners = await this.listsService.GetPartners();
            const address = await this.addressCustomerService.getAddress(order[0].customerId, order[0].addressId);
            const billing = billinds.find(data => data.codcob === order[0].billindId);
            const paymentPlans = await this.listsService.GetPaymentPlan(billing.codcob);
            const paymentPlan = paymentPlans.find(data => data.codplpag === order[0].paymentPlanId);
            const partner = partners.find(data => data.id === order[0].partnerId);

            return {
                cartId: order[0].cartId, invoiceStore: invoiceStore, customer: customer, partner: partner,
                paymentPlan: paymentPlan, billing: billing, address: address,
                notification: order[0].notification, notification1: order[0].notification1, notification2: order[0].notification2,
                notificationDelivery1: order[0].notificationDelivery1, notificationDelivery2: order[0].notificationDelivery2, notificationDelivery3: order[0].notificationDelivery3,
                deliveryDate: order[0].deliveryDate, squeduleDelivery: order[0].esc_tipoEntrega == 'P' ? true : false, priorityDelivery: order[0].priorityDelivery
            }

        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async createPreCustomer(cart: Cart) {

        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        await queryRunner.startTransaction();
        try {
            const preCustomer = await queryRunner.query(`SELECT ESTVENDAPRECLIENTE.CPF FROM ESTVENDAPRECLIENTE ` +
                ` WHERE IDCART = :1 AND CPF = :2`, [cart.id, cart.preCustomerDocument]);
            if (preCustomer.length === 0) {
                const sqlInsert = ` INSERT INTO ESTVENDAPRECLIENTE ( CPF, IDCART, NOME, TELEFONE, DTCADASTRO, CODUSUR ) ` +
                    `  VALUES ( REGEXP_REPLACE(:CPF, '[^0-9]', '') , :IDCART, :NOME, :TELEFONE, SYSDATE, :CODUSUR ) `;
                await queryRunner.query(sqlInsert, [cart.preCustomerDocument,
                cart.id, cart.preCustomerName, cart.preCustomerPhone, cart.idSeller]);
            } else {

            }
            await queryRunner.commitTransaction();

        } catch (err) {
            await queryRunner.rollbackTransaction();
            console.log(err);
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async productsWithoutTax(idCart: string, idCustomer: number) {
        const sql = '     SELECT ESTPREVENDAI.CODPROD as "productId", PCPRODUT.DESCRICAO as "description", ' +
            '        PCPRODUT.EMBALAGEM as "package", PCCLIENT.ESTENT as "uf"                  ' +
            '   FROM ESTPREVENDAI, ESTPREVENDAC, PCCLIENT, PCPRODUT                 ' +
            '  WHERE ESTPREVENDAI.IDCART  = ESTPREVENDAC.ID                         ' +
            '    AND ESTPREVENDAI.CODPROD = PCPRODUT.CODPROD                        ' +
            '    AND PCCLIENT.CODCLI      = :CODCLI                                 ' +
            '    AND ESTPREVENDAC.ID      = :ID                                     ' +
            '    AND NOT EXISTS(SELECT PCTRIBUT.CODST FROM PCTABTRIB, PCTRIBUT      ' +
            '                    WHERE PCTABTRIB.CODFILIALNF = ESTPREVENDAC.CODFILIAL ' +
            '                      AND PCTABTRIB.UFDESTINO   = PCCLIENT.ESTENT      ' +
            '                      AND PCTABTRIB.CODPROD     = PCPRODUT.CODPROD     ' +
            '                      AND PCTABTRIB.CODST       = PCTRIBUT.CODST )     ';

        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const products = await queryRunner.query(sql, [idCustomer, idCart]);
            return products;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

    async OrderRetiraPosterior() {

        const sql = ' SELECT                                                ' +
            '   p.DATA                      as "data"               ' +
            '  ,p.numped                    as "orderId"            ' +
            `  ,TO_CHAR(p.datapedido, 'DD/MM/YYYY HH24:MI')     as "orderDate"          ` +
            '  ,p.CODCLI                    as "customerId"         ' +
            '  ,p.cliente                   as "customerName"       ' +
            '  ,p.codusur                   as "sellerId"           ' +
            '  ,p.nomevendedor              as "sellerName"         ' +
            '  ,p.etapa_pedido              as "process"            ' +
            '  ,p.progresso                 as "progress"           ' +
            `  ,TO_CHAR(p.DATA_ETAPA_PEDIDO, 'DD/MM/YYYY HH24:MI')         as "processDate"        ` +
            '  ,round( trunc(sysdate-p.DATAPEDIDO) * 24 + (sysdate-p.DATAPEDIDO - trunc(sysdate-p.DATAPEDIDO)) * 24) as "timeHour"  ' +
            '  ,round(( ( trunc(sysdate-p.DATAPEDIDO) * 24 + (sysdate-p.DATAPEDIDO - trunc(sysdate-p.DATAPEDIDO)) * 24) -           ' +
            '      TRUNC(( trunc(sysdate-p.DATAPEDIDO) * 24 + (sysdate-p.DATAPEDIDO - trunc(sysdate-p.DATAPEDIDO)) * 24)) ) * 60,0) as "timeMinute"   ' +
            '   FROM esvpedidoretiraposterior p                     ' +
            '   ORDER BY p.datapedido   ';

        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const orders = await queryRunner.query(sql);
            return orders;
        } finally {
            await queryRunner.release();
            await connection.close();
        }


    }

    async getProductsOrder(store: string, initialDate: Date, finalDate: Date,
        document: string, name: string, sellerId: number, idOrder: string,
        typeFilterProduct: string, productText: string
        ) {

        const sql = `SELECT  PCPEDC.DATA          as "date"
                            ,PCPEDC.NUMPED        as "orderId"
                            ,PCPEDC.NUMNOTA       as "invoice"
                            ,PCPEDC.CODCLI        as "customerId"
                            ,PCCLIENT.CLIENTE     as "customer"
                            ,PCUSUARI.NOME        as "seller"
                            ,PCPEDI.CODPROD       as "productId"
                            ,PCPRODUT.DESCRICAO   as "product"
                            ,PCPRODUT.EMBALAGEM   as "package"
                            ,PCPEDI.QT            as "quantity"
                            ,( SELECT PCPEDITEMP.COMPLEMENTO FROM PCPEDITEMP
                                WHERE PCPEDITEMP.NUMPEDRCA  = PCPEDC.NUMPEDRCA
                                  AND PCPEDITEMP.CODPROD    = PCPEDI.CODPROD
                                  AND PCPEDITEMP.NUMSEQ     = PCPEDI.NUMSEQ
                                  AND ROWNUM = 1 ) as "color"
                            ,( SELECT PCPEDITEMP.LOCALIZACAO FROM PCPEDITEMP
                                 WHERE PCPEDITEMP.NUMPEDRCA  = PCPEDC.NUMPEDRCA
                                  AND PCPEDITEMP.CODPROD    = PCPEDI.CODPROD
                                  AND PCPEDITEMP.NUMSEQ     = PCPEDI.NUMSEQ
                                  AND ROWNUM = 1 ) as "local"
                            ,CASE WHEN PCPEDI.TIPOENTREGA = 'RI' THEN 'RETIRA IMEDIATA'
                                  WHEN PCPEDI.TIPOENTREGA = 'RP' THEN 'RETIRA POSTERIOR'
                                  WHEN PCPEDI.TIPOENTREGA = 'EN' THEN 'ENTREGA'
                                  WHEN PCPEDI.TIPOENTREGA = 'EF' THEN 'ENTREGA FUTURA'
                                  WHEN PCPEDI.TIPOENTREGA = 'EN' THEN 'ENTREGA FUTURA'
                             ELSE 'OUTROS' END as "deliveryType" 
                            ,PCPEDI.NUMPED||'-'||PCPEDI.CODPROD||'-'||PCPEDI.NUMSEQ as "itemId"            
                        FROM PCPEDI, PCPEDC, PCCLIENT, PCUSUARI, PCPRODUT
                        WHERE PCPEDI.NUMPED  = PCPEDC.NUMPED
                        AND PCPEDC.DTCANCEL IS NULL
                        AND PCPEDC.CONDVENDA IN (1,7)
                        AND PCPEDC.CODCLI  = PCCLIENT.CODCLI
                        AND PCPEDC.CODUSUR = PCUSUARI.CODUSUR  
                        AND PCPEDI.CODPROD = PCPRODUT.CODPROD `;

        let sqlWhere = '';
        if (store != null && store != '' && store != '99') {
                sqlWhere += ` AND PCPEDC.CODFILIAL = '${store}'  `;
            }
            if (document != null && document != '') {
                sqlWhere += `   AND REGEXP_REPLACE(PCCLIENT.CGCENT, '[^0-9]', '') = REGEXP_REPLACE('${document}', '[^0-9]', '')`;
            }
            if (name != null && name != '') {
                sqlWhere += `   AND PCCLIENT.CLIENTE LIKE '${name.replace('@', '%')}'||'%'`;
            }
            if (sellerId > 0) {
                sqlWhere += ` AND PCPEDC.CODUSUR = ${sellerId}  `;
            }
            if (idOrder.trim() != null && idOrder.trim() != '') {
                sqlWhere += ` AND PCPEDC.NUMPED = ${idOrder}  `;
            }

            if ( typeFilterProduct != '') {
                switch (typeFilterProduct) {
                    case 'ID': 
                        sqlWhere += ` AND PCPEDI.CODPROD = ${productText} `;
                        break;
                    case 'EAN': 
                        sqlWhere += ` AND PCPRODUT.CODAUXILIAR = ${productText} `;
                        break;
                    case 'TEXT':
                        sqlWhere += ` AND PCPRODUT.DESCRICAO LIKE '${productText}%' `;
                        break;
                    case 'PARTNER': 
                        sqlWhere += ` AND PCPRODUT.CODFAB like '${productText}%'`;
                        break;
                    default: break;
                }
            }

            //tratamento de data//
            const startDate = new Date(initialDate);
            let day = startDate.getDate();
            let month = ("00" + (startDate.getMonth() + 1)).slice(-2);
            let year = startDate.getFullYear();
            const startFormat = day + "/" + month + "/" + year;
            const endDate = new Date(finalDate);
            day = endDate.getDate();
            month = ("00" + (endDate.getMonth() + 1)).slice(-2);
            year = endDate.getFullYear();
            const endFormat = day + "/" + month + "/" + year;

            sqlWhere += ` AND PCPEDI.DATA BETWEEN TO_DATE('${startFormat}', 'DD/MM/YYYY') AND TO_DATE('${endFormat}', 'DD/MM/YYYY')  `;
                

        const connection = new Connection(connectionOptions);
        await connection.connect();
        const queryRunner = connection.createQueryRunner();
        await queryRunner.connect();
        try {
            const orders = await queryRunner.query(sql + sqlWhere);
            return orders;
        } finally {
            await queryRunner.release();
            await connection.close();
        }
    }

}