using CPRNIMS.Domain.Contracts.Canvass;
using CPRNIMS.Infrastructure.Database;
using CPRNIMS.Infrastructure.Dto.Canvass;
using CPRNIMS.Infrastructure.Entities.Canvass;
using CPRNIMS.Infrastructure.Entities.Purchasing;
using Microsoft.Data.SqlClient;
using Microsoft.EntityFrameworkCore;
using System.Data;
using static CPRNIMS.Domain.Services.OutputParamMessage;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CPRNIMS.Domain.Services.Canvass
{
    public class Canvass : ICanvass
    {
        private readonly NonInventoryDbContext _dbContext;
        public Canvass(NonInventoryDbContext dbContext)
        {
            _dbContext = dbContext;
        }
        #region Get
        public async Task<List<ItemListWOEmail>> GetItemSupplierWOEmail(CanvassDto CanvassDto)
        {
            try
            {
                var allItems = await _dbContext.ItemListWOEmails
                     .FromSqlRaw($"EXEC GetItemSupplierWOEmail @PRNo = '{CanvassDto.PRNo}'")
                    .ToListAsync();

                return allItems ?? new List<ItemListWOEmail>();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<List<BiddingItem>> GetSupplierBid(CanvassDto CanvassDto)
        {
            var allItems = await _dbContext.BiddingItems
                 .FromSqlRaw($"EXEC GetSupplierBid @UserId,@IsHistory",
                   new SqlParameter("@UserId", CanvassDto.UserId),
                   new SqlParameter("@IsHistory", CanvassDto.IsHistory))
                 .ToListAsync();

            return allItems ?? new List<BiddingItem>();
        }
        public async Task<List<PerSupplier>> GetCanvassPerSupplier(CanvassDto CanvassDto)
        {
            try
            {
                var allItems = await _dbContext.PerSuppliers
                    .FromSqlRaw($"EXEC GetCanvassPerSupplier @UserId",
                    new SqlParameter("@UserId", CanvassDto.UserId))
                    .ToListAsync();

                return allItems ?? new List<PerSupplier>();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<List<RFQPerSupplier>> GetSupplierBidByItem(CanvassDto CanvassDto)
        {
            var allItems = await _dbContext.RFQPerSuppliers
                  .FromSqlRaw($"EXEC GetSupplierBidByItem @UserId,@Status,@ItemNo,@CanvassId,@IsHistory,@PRDetailsId",
                  new SqlParameter("@UserId", CanvassDto.UserId),
                  new SqlParameter("@Status", CanvassDto.Status),
                  new SqlParameter("@ItemNo", CanvassDto.ItemNo),
                  new SqlParameter("@CanvassId", CanvassDto.CanvassId),
                   new SqlParameter("@IsHistory", CanvassDto.IsHistory),
                  new SqlParameter("@PRDetailsId", CanvassDto.PRDetailsId))
                  .ToListAsync();

            return allItems ?? new List<RFQPerSupplier>();
        }
        public async Task<List<PRDetails>> GetCanvassById(CanvassDto CanvassDto)
        {
            var allItems = await _dbContext.PRDetails
                   .FromSqlRaw("EXEC GetCanvassById @UserId",
                   new SqlParameter("@UserId", CanvassDto.UserId))
                   .ToListAsync();

            return allItems ?? new List<PRDetails>();
        }
        public async Task<List<PRDetails>> GetCanvassByItemNo(CanvassDto CanvassDto)
        {
            var allItems = await _dbContext.PRDetails
                 .FromSqlRaw($"EXEC GetCanvassByItemNo @UserId, @ItemNo",
                  new SqlParameter("@UserId", CanvassDto.UserId),
                  new SqlParameter("@ItemNo", CanvassDto.ItemNo))
                .ToListAsync();

            return allItems ?? new List<PRDetails>();
        }
        public async Task<List<PRDetails>> GetCanvassByPRNo(CanvassDto CanvassDto)
        {
            var allItems = await _dbContext.PRDetails
                     .FromSqlRaw("EXEC GetCanvassByPRNo @UserId, @PRNo",
                       new SqlParameter("@UserId", CanvassDto.UserId),
                       new SqlParameter("@PRNo", CanvassDto.PRNo))
                    .ToListAsync();

            return allItems ?? new List<PRDetails>();
        }
        public async Task<List<CanvassGroupByPRNo>> GetCanvassGroupByPRNo(CanvassDto CanvassDto)
        {
            var allItems = await _dbContext.CanvassGroupByPRNos
                     .FromSqlRaw("EXEC GetCanvassGroupByPRNo @UserId,@PRNo,@AggreItemNo,@IsTagging",
                       new SqlParameter("@UserId", CanvassDto.UserId),
                       new SqlParameter("@PRNo", CanvassDto.PRNo),
                       new SqlParameter("@AggreItemNo", CanvassDto.AggreItemNo ?? "N/A"),
                       new SqlParameter("@IsTagging", CanvassDto.IsTagging))
                    .ToListAsync();

            return allItems ?? new List<CanvassGroupByPRNo>();
        }
        public async Task<List<Suppliers>> GetSupplierItemWOEmail(CanvassDto CanvassDto)
        {
            try
            {
                var allItems = await _dbContext.Suppliers
                     .FromSqlRaw($"EXEC GetSupplierItemWOEmail @ItemNo = '{CanvassDto.ItemNo}'")
                    .ToListAsync();

                return allItems ?? new List<Suppliers>();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<List<Suppliers>> GetSupplierById(CanvassDto CanvassDto)
        {
            try
            {
                var allItems = await _dbContext.Suppliers
                 .FromSqlRaw($"EXEC GetSupplierById @SupplierId",
                  new SqlParameter("@SupplierId", CanvassDto.SupplierId))
                 .ToListAsync();

                return allItems ?? new List<Suppliers>();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<List<RFQReference>> GetRFQ(CanvassDto CanvassDto)
        {
            try
            {
                var allItems = await _dbContext.RFQReferences
                   .FromSqlRaw($"EXEC GetRFQPerSupplier @SupplierId,@UserId",
                    new SqlParameter("@SupplierId", CanvassDto.SupplierId),
                    new SqlParameter("@UserId", CanvassDto.UserId))
                   .ToListAsync();

                return allItems ?? new List<RFQReference>();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }  
        public async Task<List<PRDetails>> GetPRItemList(CanvassDto CanvassDto)
        {
            try
            {
                var allItems = await _dbContext.PRDetails
                     .FromSqlRaw($"EXEC GetPRItemList @UserId = '{CanvassDto.UserId}'")
                    .ToListAsync();

                return allItems ?? new List<PRDetails>();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<List<PRDetails>> GetCanvassPerSupplierEmail(CanvassDto CanvassDto)
        {
            try
            {
                var allItems = await _dbContext.PRDetails
                     .FromSqlRaw($"EXEC GetCanvassPerSupplierEmail  @UserId = '{CanvassDto.UserId}', @EmailAddress = '{CanvassDto.EmailAddress}'")
                    .ToListAsync();

                return allItems ?? new List<PRDetails>();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<List<PRDetails>> GetPRItem(CanvassDto CanvassDto)
        {
            try
            {
                var allItems = await _dbContext.PRDetails
                     .FromSqlRaw($"EXEC GetPRItem  @UserId = '{CanvassDto.UserId}', @ItemNo = {CanvassDto.ItemNo}")
                    .ToListAsync();

                return allItems ?? new List<PRDetails>();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<List<WOResponse>> GetCanvassWOResponse(CanvassDto CanvassDto)
        {
            try
            {
                var allItems = await _dbContext.WOResponses
                     .FromSqlRaw($"EXEC GetCanvassWOResponse  @UserId = '{CanvassDto.UserId}'")
                    .ToListAsync();

                return allItems ?? new List<WOResponse>();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<int> GetCanvassNo()
        {
            try
            {
                var latestCanvassNo = await _dbContext.Canvasses
                    .OrderByDescending(ic => ic.CanvassNo) 
                    .FirstOrDefaultAsync(); 

                if (latestCanvassNo != null)
                {
                    return latestCanvassNo.CanvassNo;
                }
                else
                {
                    return 0; 
                }
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<List<WOResponseById>> GetWOResponseBySuppId(CanvassDto CanvassDto)
        {
            try
            {
                var allItems = await _dbContext.WOResponseByIds
                     .FromSqlRaw($"EXEC GetWOResponseBySuppId  @UserId = '{CanvassDto.UserId}',@SupplierId = '{CanvassDto.SupplierId}'")
                    .ToListAsync();

                return allItems ?? new List<WOResponseById>();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<RFQ> PostPerSupplierToken(CanvassDto CanvassDto)
        {
            try
            {
                await _dbContext.Database
                  .ExecuteSqlRawAsync("EXEC PostPerSupplierToken @UserId,@SupplierId,@PRNo,@ItemNo,@CanvassNo,@PRDetailsId",
                   new SqlParameter("@UserId", CanvassDto.UserId),
                   new SqlParameter("@SupplierId", CanvassDto.SupplierId),
                   new SqlParameter("@PRNo", CanvassDto.PRNo),
                   new SqlParameter("@ItemNo", CanvassDto.ItemNo), 
                   new SqlParameter("@CanvassNo", CanvassDto.CanvassNo),
                   new SqlParameter("@PRDetailsId", CanvassDto.PRDetailsId));

                return new RFQ();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<List<SupplierBidById>> GetSupplierBidById(CanvassDto CanvassDto)
        {
            try
            {
                var allItems = await _dbContext.SupplierBidByIds
                    .FromSqlRaw($"EXEC GetSupplierBidById @CanvassDetailId",
                     new SqlParameter("@CanvassDetailId", CanvassDto.CanvassDetailId))
                    .ToListAsync();

                return allItems ?? new List<SupplierBidById>();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<List<Suppliers>> GetMySuppliers(CanvassDto CanvassDto)
        {
            try
            {
                var allItems = await _dbContext.Suppliers
                    .FromSqlRaw($"EXEC GetMySuppliers @UserId,@SupplierId",
                     new SqlParameter("@UserId", CanvassDto.UserId),
                     new SqlParameter("@SupplierId", CanvassDto.SupplierId))
                    .ToListAsync();

                return allItems ?? new List<Suppliers>();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<List<MyPRWOCanvass>> GetMyPRWOCanvass(CanvassDto itemDto)
        {
            var allItems = await _dbContext.MyPRWOCanvass
                    .FromSqlRaw($"EXEC GetMyPRWOCanvass @UserId,@SupplierId,@Query",
                     new SqlParameter("@UserId", itemDto.UserId),
                     new SqlParameter("@SupplierId", itemDto.SupplierId),
                     new SqlParameter("@Query", itemDto.Query))
                    .ToListAsync();

            return allItems ?? new List<MyPRWOCanvass>();
        }
        public async Task<List<Infrastructure.Entities.Canvass.PRList>> 
        GetPRListByPRNo(CanvassDto canvassDto)
        {
            var allItems = await _dbContext.PRItemList
                   .FromSqlRaw($"EXEC GetPRListByPRNo @PRNo,@UserId",
                     new SqlParameter("@UserId", canvassDto.UserId),
                     new SqlParameter("@PRNo", canvassDto.PRNo))
                   .ToListAsync();

            return allItems ?? new List<Infrastructure.Entities.Canvass.PRList>();
        }

        public async Task<List<PRDetails>> GetCanvassPerSupplierId(CanvassDto itemCodeDto)
        {
            var allItems = await _dbContext.PRDetails
                    .FromSqlRaw($"EXEC GetCanvassPerSupplierId @UserId,@SupplierId",
                    new SqlParameter("@UserId", itemCodeDto.UserId),
                    new SqlParameter("@SupplierId", itemCodeDto.SupplierId))
                    .ToListAsync();

            return allItems ?? new List<PRDetails>();
        }

        public async Task<List<AlternativeOfferDetails>> 
        GetAlternativeOfferByPRDetailId(CanvassDto canvassDto)
        {
            var allItems = await _dbContext.AlternativeOfferDetails
              .FromSqlRaw($"EXEC GetAlternativeOfferByPRDetailId @UserId,@PRDetailsId",
                new SqlParameter("@UserId", canvassDto.UserId),
                new SqlParameter("@PRDetailsId", canvassDto.PRDetailsId))
              .ToListAsync();

            return allItems ?? new List<AlternativeOfferDetails>();
        }
        public async Task<List<ForCanvass>> GetForCanvassPerItem(CanvassDto CanvassDto)
        {
            var allItems = await _dbContext.ForCanvasses
                 .FromSqlRaw($"EXEC GetForCanvassPerItem @UserId,@ItemNo",
                     new SqlParameter("@UserId", CanvassDto.UserId),
                     new SqlParameter("@ItemNo", CanvassDto.ItemNo))
                 .ToListAsync();

            return allItems ?? new List<ForCanvass>();
        }
        public async Task<List<ForCanvassFollowUp>> GetCanvassForFollowUp(CanvassDto canvassDto)
        {
            var allItems = await _dbContext.ForCanvassFollowUps
                      .FromSqlRaw($"EXEC GetCanvassForFollowUp")
                     .ToListAsync();

            return allItems ?? new List<ForCanvassFollowUp>();
        }
        public async Task<List<AllForCanvass>> GetAllForCanvass()
        {
            var allForCanvass = await _dbContext.AllForCanvasses
                  .FromSqlRaw("EXEC GetAllForCanvass").ToListAsync();
            return allForCanvass ?? new List<AllForCanvass>();
        }
        #endregion
        #region Post Put
        public async Task<Suppliers> PostApprovedSupp(CanvassDto CanvassDto)
        {
            try
            {
                await _dbContext.Database
                       .ExecuteSqlRawAsync("EXEC PostApprovedSupp  @UserId,@CanvassId,@ItemNo",
                         new SqlParameter("@UserId", CanvassDto.UserId),
                         new SqlParameter("@CanvassId", CanvassDto.CanvassId != null ? CanvassDto.CanvassId : 0L),
                         new SqlParameter("@ItemNo", CanvassDto.ItemNo != null ? CanvassDto.ItemNo : 0L));

                return new Suppliers();
            }
            catch (SqlException ex)
            {
                throw;
            }
        }
        public async Task<CanvassDetail> PostSuggestedSupp(CanvassDto CanvassDto)
        {
            try
            {
                await _dbContext.Database
                       .ExecuteSqlRawAsync("EXEC PostSuggestedSupp  @UserId,@CanvassDetailId,@ItemNo,@SupplierId,@CanvassId",
                         new SqlParameter("@UserId", CanvassDto.UserId),
                         new SqlParameter("@CanvassDetailId", CanvassDto.CanvassDetailId),
                         new SqlParameter("@ItemNo", CanvassDto.ItemNo),
                         new SqlParameter("@SupplierId", CanvassDto.SupplierId),
                          new SqlParameter("@CanvassId", CanvassDto.CanvassId));
                return new CanvassDetail();
            }
            catch (SqlException ex)
            {
                throw;
            }
        }
        public async Task<PRDetails> PostCanvass(CanvassDto CanvassDto)
        {
            try
            {
                await _dbContext.Database
                   .ExecuteSqlRawAsync("EXEC PostCanvass @UserId, @SupplierId, @Status,@Remarks",
                    new SqlParameter("@SupplierId", CanvassDto.SupplierId != null ? CanvassDto.SupplierId : 0L),
                    new SqlParameter("@UserId", CanvassDto.UserId),
                     new SqlParameter("@Status", CanvassDto.Status),
                       new SqlParameter("@Remarks", CanvassDto.Remarks ?? "N/A"));
                return new PRDetails();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<Suppliers> PostTaggingSupplier(CanvassDto CanvassDto)
        {
            try
            {
                var (messCode, message) = CreateOutputParams();

                await _dbContext.Database
                    .ExecuteSqlRawAsync($"EXEC PostPutSupplier @SupplierId, @ItemNo, @IsActive, @UserId, @SupplierName, " +
                    "@EmailAddress, @Address, @ContactNo, @ContactPerson,@IsTagging, @MessCode OUTPUT, @Message OUTPUT",
                    new SqlParameter("@SupplierId", CanvassDto.SupplierId != null ? CanvassDto.SupplierId : 0L),
                    new SqlParameter("@ItemNo", CanvassDto.ItemNo),
                    new SqlParameter("@IsActive", CanvassDto.IsActive),
                    new SqlParameter("@UserId", CanvassDto.UserId),
                    new SqlParameter("@SupplierName", CanvassDto.SupplierName),
                    new SqlParameter("@EmailAddress", CanvassDto.EmailAddress),
                    new SqlParameter("@Address", CanvassDto.Address ?? "NONE"),
                    new SqlParameter("@ContactNo", CanvassDto.ContactNo ?? "NONE"),
                    new SqlParameter("@ContactPerson", CanvassDto.ContactPerson ?? "NONE"),
                    new SqlParameter("@IsTagging", CanvassDto.IsTagging),
                    messCode,
                    message);

                if ((byte)messCode.Value == 0) 
                {
                    throw new Exception(message.Value.ToString());
                }
                return new Suppliers();
            }
            catch (SqlException ex)
            {
                throw;
            }
        }
        public async Task<Suppliers> PostPutItemTagging(CanvassDto canvassDto)
        {
            try
            {
                var (messCode, message) = CreateOutputParams();

                await _dbContext.Database
                    .ExecuteSqlRawAsync($"EXEC PostPutItemTagging @SupplierId, @ItemNo, @IsActive, @UserId," +
                    "@MessCode OUTPUT, @Message OUTPUT",
                    new SqlParameter("@SupplierId", canvassDto.SupplierId != null ? canvassDto.SupplierId : 0L),
                    new SqlParameter("@ItemNo", canvassDto.ItemNo),
                    new SqlParameter("@IsActive", canvassDto.IsActive),
                    new SqlParameter("@UserId", canvassDto.UserId),
                    messCode,
                    message);

                if ((byte)messCode.Value == 0) 
                {
                    throw new Exception(message.Value.ToString());
                }
                return new Suppliers();
            }
            catch (SqlException ex)
            {
                throw;
            }
        }
        public async Task<Suppliers> PostPutSupplier(CanvassDto CanvassDto)
        {
            try
            {
                var messCode = new SqlParameter("@MessCode", SqlDbType.TinyInt) { Direction = ParameterDirection.Output };
                var message = new SqlParameter("@Message", SqlDbType.VarChar, 8000) { Direction = ParameterDirection.Output };

                await _dbContext.Database
                    .ExecuteSqlRawAsync($"EXEC PostPutSupplier @SupplierId, @ItemNo, @IsActive, @UserId, @SupplierName, " +
                    "@EmailAddress, @Address, @ContactNo, @ContactPerson,@IsTagging, @MessCode OUTPUT, @Message OUTPUT",
                    new SqlParameter("@SupplierId", CanvassDto.SupplierId != null ? CanvassDto.SupplierId : 0L),
                    new SqlParameter("@ItemNo", CanvassDto.ItemNo),
                    new SqlParameter("@IsActive", CanvassDto.IsActive),
                    new SqlParameter("@UserId", CanvassDto.UserId),
                    new SqlParameter("@SupplierName", CanvassDto.SupplierName),
                    new SqlParameter("@EmailAddress", CanvassDto.EmailAddress),
                    new SqlParameter("@Address", CanvassDto.Address ?? "NONE"),
                    new SqlParameter("@ContactNo", CanvassDto.ContactNo ?? "NONE"),
                    new SqlParameter("@ContactPerson", CanvassDto.ContactPerson ?? "NONE"),
                    new SqlParameter("@IsTagging", CanvassDto.IsTagging),
                    messCode,
                    message);

                if ((byte)messCode.Value == 0)
                {
                    throw new Exception(message.Value.ToString());
                }

                return new Suppliers();
            }
            catch (SqlException ex)
            {
                throw;
            }
        }
        public async Task<Suppliers> PostPutMySupplier(CanvassDto canvassDto)
        {
            try
            {
                var messCode = new SqlParameter("@MessCode", SqlDbType.TinyInt) { Direction = ParameterDirection.Output };
                var message = new SqlParameter("@Message", SqlDbType.VarChar, 8000) { Direction = ParameterDirection.Output };

                await _dbContext.Database
                    .ExecuteSqlRawAsync($"EXEC PostPutMySupplier @SupplierId, @ItemNo, @IsActive, @UserId, @SupplierName," +
                    "@EmailAddress, @Address, @ContactNo, @ContactPerson,@TinNo,@LeadTime,@CurrencyId,@VatInc,@PaymentTermsId," +
                    "@MessCode OUTPUT, @Message OUTPUT",
                    new SqlParameter("@SupplierId", canvassDto.SupplierId != null ? canvassDto.SupplierId : 0L),
                    new SqlParameter("@ItemNo", canvassDto.ItemNo),
                    new SqlParameter("@IsActive", canvassDto.IsActive),
                    new SqlParameter("@UserId", canvassDto.UserId),
                    new SqlParameter("@SupplierName", canvassDto.SupplierName),
                    new SqlParameter("@EmailAddress", canvassDto.EmailAddress),
                    new SqlParameter("@Address", canvassDto.Address ?? "NONE"),
                    new SqlParameter("@ContactNo", canvassDto.ContactNo ?? "NONE"),
                    new SqlParameter("@ContactPerson", canvassDto.ContactPerson ?? "NONE"),
                    new SqlParameter("@TinNo", canvassDto.TinNo ?? "NONE"),
                    new SqlParameter("@LeadTime", canvassDto.LeadTime ?? "NONE"),
                    new SqlParameter("@CurrencyId", canvassDto.CurrencyId),
                    new SqlParameter("@VatInc", canvassDto.VatInc),
                    new SqlParameter("@PaymentTermsId", canvassDto.PaymentTermsId),
                    messCode,
                    message);

                if ((byte)messCode.Value == 0)
                {
                    throw new Exception(message.Value.ToString());
                }

                return new Suppliers();
            }
            catch (SqlException ex)
            {
                throw;
            }
        }
        public async Task<CanvassDetail> PutSuppUnitPrice(CanvassDto CanvassDto)
        {
            try
            {
                await _dbContext.Database
                   .ExecuteSqlRawAsync($"EXEC PutSuppUnitPrice @UserId, @CanvassDetailId, @UnitPrice",
                    new SqlParameter("@CanvassDetailId", CanvassDto.CanvassDetailId != null ? CanvassDto.CanvassDetailId : 0L),
                    new SqlParameter("@UserId", CanvassDto.UserId),
                    new SqlParameter("@UnitPrice", CanvassDto.UnitPrice));
                return new CanvassDetail();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<ForCanvassFollowUp> PutSupplierCanvass(long canvassSupplierId)
        {
            try
            {
                await _dbContext.Database
                   .ExecuteSqlRawAsync("EXEC PutCanvassForFollowUp @CanvassSupplierId",
                    new SqlParameter("@CanvassSupplierId", canvassSupplierId));
                return new ForCanvassFollowUp();
            }
            catch (SqlException ex)
            {
                ex.ToString();
                throw;
            }
        }
        public async Task<CanvassDetail> PutSuppBidDetails(CanvassDto canvassDto)
        {
            await _dbContext.Database
                 .ExecuteSqlRawAsync($"EXEC PutSuppBidDetails @UserId,@CanvassDetailId,@PRDetailsId,@UnitPrice,@Terms," +
                 $"@ItemName,@Specification,@Qty,@DeliveryDate,@CurrencyId,@Remarks,@Manufacturer,@UOMName,@IsReset",
                  new SqlParameter("@UserId", canvassDto.UserId),
                  new SqlParameter("@CanvassDetailId", canvassDto.CanvassDetailId),
                  new SqlParameter("@PRDetailsId", canvassDto.PRDetailsId),
                  new SqlParameter("@UnitPrice", canvassDto.UnitPrice),
                  new SqlParameter("@Terms", canvassDto.Terms),
                  new SqlParameter("@ItemName", canvassDto.ItemName),
                  new SqlParameter("@Specification", canvassDto.Specification),
                  new SqlParameter("@Qty", canvassDto.Qty),
                  new SqlParameter("@DeliveryDate", canvassDto.CommitmentDate),
                  new SqlParameter("@CurrencyId", canvassDto.CurrencyId),
                  new SqlParameter("@Remarks", canvassDto.Remarks),
                  new SqlParameter("@Manufacturer", canvassDto.Manufacturer),
                  new SqlParameter("@UOMName", canvassDto.UOMName),
                  new SqlParameter("@IsReset", canvassDto.IsReset));
            return new CanvassDetail();
        }
        public async Task<CanvassSupplier> UnlockFormLink(CanvassDto canvassDto)
        {
            await _dbContext.Database
                .ExecuteSqlRawAsync("EXEC UnlockFormLink @UserId,@CanvassSupplierId",
                 new SqlParameter("@UserId", canvassDto.UserId),
                 new SqlParameter("@CanvassSupplierId", canvassDto.CanvassSupplierId));
            return new CanvassSupplier();
        }
        #endregion
    }
}