const models = require('vn-loopback/server/server').models;
const LoopBackContext = require('loopback-context');

describe('sale canEdit()', () => {
    const employeeId = 1;
    beforeAll(async() => {
        const activeCtx = {
            accessToken: {userId: 9},
            http: {
                req: {
                    headers: {origin: 'http://localhost'}
                }
            }
        };
        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
            active: activeCtx
        });
    });

    describe('sale not exists', () => {
        it('should return error if sale not exists', async() => {
            const tx = await models.Sale.beginTransaction({});

            try {
                const options = {transaction: tx};

                const developerId = 9;
                const ctx = {req: {accessToken: {userId: developerId}}};

                let max = await models.Sale.findOne({fields: ['id'], order: 'id DESC'}, options);
                max.id = max.id + 1;

                const sales = [max.id];
                await models.Sale.canEdit(ctx, sales, options);

                await tx.rollback();
            } catch (e) {
                await tx.rollback();
                error = e.message;
            }

            expect(error).toEqual('The sales do not exists');
        });
    });

    describe('sale editTracked', () => {
        it('should return true if the role is production regardless of the saleTrackings', async() => {
            const tx = await models.Sale.beginTransaction({});

            try {
                const options = {transaction: tx};

                const productionUserID = 49;
                const ctx = {req: {accessToken: {userId: productionUserID}}};

                const sales = [25];

                await models.Sale.canEdit(ctx, sales, options);

                await tx.rollback();
            } catch (e) {
                await tx.rollback();
                throw e;
            }
        });

        it('should return true if the role is not production and none of the sales has saleTracking', async() => {
            const tx = await models.Sale.beginTransaction({});

            try {
                const options = {transaction: tx};

                const salesPersonUserID = 18;
                const ctx = {req: {accessToken: {userId: salesPersonUserID}}};

                const sales = [10];

                await models.Sale.canEdit(ctx, sales, options);

                await tx.rollback();
            } catch (e) {
                await tx.rollback();
                throw e;
            }
        });
    });

    describe('sale editCloned', () => {
        const saleCloned = [29];

        it('should return true if any of the sales is cloned and has the correct role', async() => {
            const tx = await models.Sale.beginTransaction({});
            const roleEnabled = await models.ACL.findOne({
                where: {
                    model: 'Sale',
                    property: 'editCloned',
                    permission: 'ALLOW'
                }
            });
            if (!roleEnabled || !roleEnabled.principalId) return await tx.rollback();

            try {
                const options = {transaction: tx};

                const role = await models.VnRole.findOne({
                    where: {
                        name: roleEnabled.principalId
                    }
                });
                const ctx = {req: {accessToken: {userId: role.id}}};

                await models.Sale.canEdit(ctx, saleCloned, options);

                await tx.rollback();
            } catch (e) {
                await tx.rollback();
                throw e;
            }
        });
    });

    describe('sale editFloramondo', () => {
        it('should return false if any of the sales isFloramondo', async() => {
            const tx = await models.Sale.beginTransaction({});
            const sales = [26];
            let error;
            try {
                const options = {transaction: tx};

                const ctx = {req: {accessToken: {userId: employeeId}}};
                const saleToEdit = await models.Sale.findById(sales[0], null, options);
                await saleToEdit.updateAttribute('itemFk', 9, options);

                await models.Sale.canEdit(ctx, sales, options);
                await tx.rollback();
            } catch (e) {
                await tx.rollback();
                error = e;
            }

            expect(error).toEqual(
                new Error('It is not possible to modify sales that their articles are from Floramondo'));
        });

        it('should return true if any of the sales is of isFloramondo and has the correct role', async() => {
            const tx = await models.Sale.beginTransaction({});
            const sales = [26];

            const roleEnabled = await models.ACL.findOne({
                where: {
                    model: 'Sale',
                    property: 'editFloramondo',
                    permission: 'ALLOW'
                }
            });

            if (!roleEnabled || !roleEnabled.principalId) return await tx.rollback();

            try {
                const options = {transaction: tx};

                const role = await models.VnRole.findOne({
                    where: {
                        name: roleEnabled.principalId
                    }
                });
                const ctx = {req: {accessToken: {userId: role.id}}};

                // For test
                const saleToEdit = await models.Sale.findById(sales[0], null, options);
                await saleToEdit.updateAttribute('itemFk', 9, options);

                await models.Sale.canEdit(ctx, sales, options);

                await tx.rollback();
            } catch (e) {
                await tx.rollback();
                throw e;
            }
        });
    });
});