686 lines
28 KiB
C#
686 lines
28 KiB
C#
using AutoMapper;
|
|
using CPRNIMS.Domain.Contracts.Canvass;
|
|
using CPRNIMS.Domain.Services;
|
|
using CPRNIMS.Domain.Services.Canvass;
|
|
using CPRNIMS.Infrastructure.Dto.Canvass;
|
|
using CPRNIMS.Infrastructure.Dto.Canvass.Request;
|
|
using CPRNIMS.Infrastructure.Dto.Canvass.Response;
|
|
using CPRNIMS.Infrastructure.Entities.Canvass;
|
|
using CPRNIMS.Infrastructure.Helper;
|
|
using CPRNIMS.Infrastructure.ViewModel.Canvass;
|
|
using CPRNIMS.Infrastructure.ViewModel.Common;
|
|
using CPRNIMS.WebApi.Security;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using System.Text;
|
|
|
|
namespace CPRNIMS.WebApi.Controllers.Canvass
|
|
{
|
|
[Security.AuthorizeRoles("CanvassMgmt")]
|
|
public class CanvassMgmtController : Base.BaseController
|
|
{
|
|
private readonly SMTPHelper _smtpHelper;
|
|
private readonly ICanvass _canvass;
|
|
private readonly IConfiguration _config;
|
|
private readonly SupplierSearchService _supplierSearchService;
|
|
private readonly IMapper _mapper;
|
|
public CanvassMgmtController(ErrorMessageService errorMessageService,
|
|
IWebHostEnvironment webHostEnvironment, SMTPHelper sMTPHelper,
|
|
IConfiguration configuration, ICanvass canvass, SupplierSearchService supplierSearchService,
|
|
IMapper mapper) :
|
|
base(errorMessageService, webHostEnvironment, configuration)
|
|
{
|
|
_canvass = canvass;
|
|
_config = configuration;
|
|
_smtpHelper = sMTPHelper;
|
|
_supplierSearchService= supplierSearchService;
|
|
_mapper = mapper;
|
|
}
|
|
|
|
#region Get
|
|
[HttpPost("GetSupplierItemWOEmail")]
|
|
public async Task<IActionResult> GetSupplierItemWOEmail(CanvassDto viewModel)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetSupplierItemWOEmail(viewModel),
|
|
nameof(GetSupplierItemWOEmail), false
|
|
);
|
|
}
|
|
[HttpPost("GetSupplierById")]
|
|
public async Task<IActionResult> GetSupplierById(CanvassDto viewModel)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetSupplierById(viewModel),
|
|
nameof(GetSupplierById), false
|
|
);
|
|
}
|
|
[HttpPost("GetItemSupplierWOEmail")]
|
|
public async Task<IActionResult> GetItemSupplierWOEmail(CanvassDto viewModel)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetItemSupplierWOEmail(viewModel),
|
|
nameof(GetItemSupplierWOEmail), false
|
|
);
|
|
}
|
|
[HttpPost("GetCanvassByPRNo")]
|
|
public async Task<IActionResult> GetCanvassByPRNo(CanvassDto itemCodeDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetCanvassByPRNo(itemCodeDto),
|
|
nameof(GetCanvassByPRNo), false
|
|
);
|
|
}
|
|
[HttpPost("GetSupplierBid")]
|
|
public async Task<IActionResult> GetSupplierBid(CanvassDto itemCodeDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetSupplierBid(itemCodeDto),
|
|
nameof(GetSupplierBid), false
|
|
);
|
|
}
|
|
[HttpPost("GetSupplierBidByItem")]
|
|
public async Task<IActionResult> GetSupplierBidByItem(CanvassDto itemCodeDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetSupplierBidByItem(itemCodeDto),
|
|
nameof(GetSupplierBidByItem), false
|
|
);
|
|
}
|
|
[HttpPost("GetSupplierBidById")]
|
|
public async Task<IActionResult> GetSupplierBidById(CanvassDto itemCodeDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetSupplierBidById(itemCodeDto),
|
|
nameof(GetSupplierBidById), false
|
|
);
|
|
}
|
|
[HttpPost("GetCanvassPerSupplier")]
|
|
public async Task<IActionResult> GetCanvassPerSupplier(CanvassDto itemCodeDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetCanvassPerSupplier(itemCodeDto),
|
|
nameof(GetCanvassPerSupplier), false
|
|
);
|
|
}
|
|
[HttpPost("GetItemsForTagging")]
|
|
public async Task<IActionResult> GetItemsForTagging(CanvassDto itemCodeDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetItemsForTagging(itemCodeDto),
|
|
nameof(GetItemsForTagging), false
|
|
);
|
|
}
|
|
[HttpPost("GetCanvassPerSupplierId")]
|
|
public async Task<IActionResult> GetCanvassPerSupplierId(CanvassDto itemCodeDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetCanvassPerSupplierId(itemCodeDto),
|
|
nameof(GetCanvassPerSupplierId), false
|
|
);
|
|
}
|
|
[HttpPost("GetCanvassPerSupplierEmail")]
|
|
public async Task<IActionResult> GetCanvassPerSupplierEmail(CanvassDto itemCodeDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetCanvassPerSupplierEmail(itemCodeDto),
|
|
nameof(GetCanvassPerSupplierEmail), false
|
|
);
|
|
}
|
|
[HttpPost("GetPRItemList")]
|
|
public async Task<IActionResult> GetPRItemList(CanvassDto itemCodeDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetPRItemList(itemCodeDto),
|
|
nameof(GetPRItemList), false
|
|
);
|
|
}
|
|
[HttpPost("GetPRItem")]
|
|
public async Task<IActionResult> GetPRItem(CanvassDto itemCodeDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetPRItem(itemCodeDto),
|
|
nameof(GetPRItem), false
|
|
);
|
|
}
|
|
[HttpPost("GetCanvassById")]
|
|
public async Task<IActionResult> GetCanvassById(CanvassDto CanvassDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetCanvassById(CanvassDto),
|
|
nameof(GetCanvassById), false
|
|
);
|
|
}
|
|
[HttpPost("GetCanvassWOResponse")]
|
|
public async Task<IActionResult> GetCanvassWOResponse(CanvassDto CanvassDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetCanvassWOResponse(CanvassDto),
|
|
nameof(GetCanvassWOResponse), false
|
|
);
|
|
}
|
|
[HttpPost("GetWOResponseBySuppId")]
|
|
public async Task<IActionResult> GetWOResponseBySuppId(CanvassDto CanvassDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetWOResponseBySuppId(CanvassDto),
|
|
nameof(GetWOResponseBySuppId), false
|
|
);
|
|
}
|
|
[HttpPost("GetForCanvassPerItem")]
|
|
public async Task<IActionResult> GetForCanvassPerItem(CanvassDto CanvassDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetForCanvassPerItem(CanvassDto),
|
|
nameof(GetForCanvassPerItem), false
|
|
);
|
|
}
|
|
[HttpPost("GetPRListByPRNo")]
|
|
public async Task<IActionResult> GetPRListByPRNo(CanvassDto CanvassDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetPRListByPRNo(CanvassDto),
|
|
nameof(GetPRListByPRNo), false
|
|
);
|
|
}
|
|
[HttpPost("GetMySuppliers")]
|
|
public async Task<IActionResult> GetMySuppliers(CanvassDto CanvassDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetMySuppliers(CanvassDto),
|
|
nameof(GetMySuppliers), false
|
|
);
|
|
}
|
|
[HttpPost("GetMyPRWOCanvass")]
|
|
public async Task<IActionResult> GetMyPRWOCanvass(CanvassDto itemDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetMyPRWOCanvass(itemDto),
|
|
nameof(GetMyPRWOCanvass), false
|
|
);
|
|
}
|
|
[HttpPost("GetCanvassGroupByPRNo")]
|
|
public async Task<IActionResult> GetCanvassGroupByPRNo(CanvassDto itemDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetCanvassGroupByPRNo(itemDto),
|
|
nameof(GetCanvassGroupByPRNo), false
|
|
);
|
|
}
|
|
[HttpPost("GetAlternativeOfferByPRDetailId")]
|
|
public async Task<IActionResult> GetAlternativeOfferByPRDetailId(CanvassDto itemDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.GetAlternativeOfferByPRDetailId(itemDto),
|
|
nameof(GetAlternativeOfferByPRDetailId), false
|
|
);
|
|
}
|
|
#endregion
|
|
|
|
#region Post Put
|
|
[HttpPost("PostSupplierForCanvass")]
|
|
public async Task<IActionResult> PostSupplierForCanvass(CanvassVM canvass, CancellationToken ct)
|
|
{
|
|
var currentUser = User.ToUserClaims();
|
|
if (currentUser == null)
|
|
return Unauthorized();
|
|
|
|
var results = await _canvass.GetSupplierForCanvass(canvass.SupplierId, currentUser.UserName, ct);
|
|
|
|
var baseTemplate = EMailTemplate("Content\\SMTPEmailContent", "SendToSupplier.cshtml");
|
|
|
|
var CanvassDto = new ForCanvassDto();
|
|
int canvassNo = await _canvass.GetCanvassNo();
|
|
|
|
foreach (var item in results)
|
|
{
|
|
CanvassDto = new ForCanvassDto
|
|
{
|
|
PRDetailsId = item.PRDetailsId,
|
|
PRNo = item.PRNo,
|
|
ItemNo = item.ItemNo,
|
|
SupplierId = item.SupplierId,
|
|
UserId = currentUser.UserId,
|
|
FullName = currentUser.FullName,
|
|
CanvassNo = canvassNo + 1,
|
|
};
|
|
await _canvass.PostPerSupplierToken(CanvassDto);
|
|
}
|
|
|
|
var rfq = await _canvass.GetRFQ(CanvassDto);
|
|
|
|
var message = new StringBuilder(baseTemplate);
|
|
message.Replace("@ViewBag.FormLink", Convert.ToString(_configuration["WebEndPoint:SupplierForm"] + rfq[0].Token));
|
|
message.Replace("@ViewBag.Supplier", rfq[0].SupplierName);
|
|
message.Replace("@ViewBag.Signature", currentUser.FullName);
|
|
|
|
var messageDetails = new EmailMessageDetailsVM();
|
|
messageDetails.AttachPath = GetRelativePath(@"Content\Documents\Pdf\Offer_Submission_Procedure.pdf");
|
|
|
|
messageDetails.Recipient = rfq[0].EmailAddress;
|
|
messageDetails.Message = message.ToString();
|
|
messageDetails.Subject = "CLMS - Request For Quotation #PRNo: " + rfq[0].AggrePRNo;
|
|
messageDetails.CC = Convert.ToString(_configuration["Canvass:CC"]);
|
|
messageDetails.SenderEmail = _config["SMTP:SenderEmail"];
|
|
messageDetails.DisplayName = "lloydlabinc.com";
|
|
messageDetails.NewPassword = _config["SMTP:Password"];
|
|
messageDetails.OutGoingPort = 587;
|
|
messageDetails.Server = _config["SMTP:Server"];
|
|
messageDetails.UserName = _config["SMTP:UserName"];
|
|
messageDetails.IsSuccess = false;
|
|
messageDetails.IsCanvass = true;
|
|
|
|
await _smtpHelper.SendEmailAsync(messageDetails);
|
|
|
|
return Ok(new {success=true, data = rfq, messCode=1});
|
|
}
|
|
[HttpPost("StartCanvass")]
|
|
public async Task<IActionResult> StartCanvass([FromBody] CanvassVM canvass,CancellationToken ct)
|
|
{
|
|
var result = await _canvass.StartCanvass(canvass,ct);
|
|
if (!result.IsSuccess)
|
|
{
|
|
return BadRequest(result.Error);
|
|
}
|
|
return Ok(new { result, messCode = 1 });
|
|
}
|
|
[HttpPost("PostAllCanvass")]
|
|
public async Task<IActionResult> PostAllCanvass()
|
|
{
|
|
var baseTemplate = EMailTemplate("Content\\SMTPEmailContent", "SendToSupplier.cshtml");
|
|
|
|
var allCanvass = await _canvass.GetAllForCanvass();
|
|
|
|
var groupedBySupplier = allCanvass
|
|
.GroupBy(x => x.SupplierId)
|
|
.ToList();
|
|
|
|
foreach (var supplierGroup in groupedBySupplier)
|
|
{
|
|
var firstItem = supplierGroup.First();
|
|
int canvassNo = await _canvass.GetCanvassNo();
|
|
|
|
|
|
foreach (var rfqq in supplierGroup)
|
|
{
|
|
var canvass = new ForCanvassDto
|
|
{
|
|
PRDetailsId = rfqq.PRDetailsId,
|
|
PRNo = rfqq.PRNo,
|
|
ItemNo = rfqq.ItemNo,
|
|
SupplierId = rfqq.SupplierId,
|
|
UserId = rfqq.UserId,
|
|
FullName = rfqq.FullName,
|
|
CanvassNo = canvassNo + 1
|
|
};
|
|
|
|
await _canvass.PostPerSupplierToken(canvass);
|
|
}
|
|
|
|
var canvassInfo = new ForCanvassDto
|
|
{
|
|
SupplierId = firstItem.SupplierId,
|
|
UserId = firstItem.UserId,
|
|
FullName = firstItem.FullName,
|
|
CanvassNo = canvassNo + 1
|
|
};
|
|
|
|
var rfq = await _canvass.GetRFQ(canvassInfo);
|
|
|
|
if (rfq?.Any() == true)
|
|
{
|
|
var message = new StringBuilder(baseTemplate);
|
|
message.Replace("@ViewBag.FormLink", Convert.ToString(_configuration["WebEndPoint:SupplierForm"] + rfq[0].Token));
|
|
message.Replace("@ViewBag.Supplier", rfq[0].SupplierName);
|
|
message.Replace("@ViewBag.Signature", firstItem.FullName);
|
|
|
|
var messageDetails = new EmailMessageDetailsVM
|
|
{
|
|
AttachPath = GetRelativePath(@"Content\Documents\Pdf\Offer_Submission_Procedure.pdf"),
|
|
Recipient = rfq[0].EmailAddress,
|
|
Message = message.ToString(),
|
|
Subject = "CLMS - Request For Quotation #PRNo: " + rfq[0].AggrePRNo,
|
|
CC = Convert.ToString(_configuration["Canvass:CC"]),
|
|
SenderEmail = _config["SMTP:SenderEmail"],
|
|
DisplayName = "lloydlabinc.com",
|
|
NewPassword = _config["SMTP:Password"],
|
|
OutGoingPort = 587,
|
|
Server = _config["SMTP:Server"],
|
|
UserName = _config["SMTP:UserName"],
|
|
IsSuccess = false,
|
|
IsCanvass = true
|
|
};
|
|
|
|
await _smtpHelper.SendEmailAsync(messageDetails);
|
|
}
|
|
}
|
|
|
|
return Ok(new { message = "All canvass emails sent successfully." });
|
|
}
|
|
|
|
[HttpPost("PostCanvassFollowUp")]
|
|
public async Task<IActionResult> PostCanvassFollowUp(CanvassDto itemDto)
|
|
{
|
|
try
|
|
{
|
|
var baseTemplate = EMailTemplate("Content\\SMTPEmailContent", "SendToSupplier.cshtml");
|
|
|
|
var canvassFolloUp = await _canvass.GetCanvassForFollowUp(itemDto);
|
|
foreach (var canvassSupplierId in canvassFolloUp)
|
|
{
|
|
var message = new StringBuilder(baseTemplate);
|
|
|
|
message.Replace("@ViewBag.FormLink", Convert.ToString(_config["WebEndPoint:SupplierForm"] + canvassSupplierId.FormLink));
|
|
message.Replace("@ViewBag.Supplier", Convert.ToString(canvassSupplierId.SupplierName));
|
|
message.Replace("@ViewBag.Signature", canvassSupplierId.Signature);
|
|
|
|
var messageDetails = new EmailMessageDetailsVM
|
|
{
|
|
Recipient = canvassSupplierId.EmailAddress,
|
|
Message = message.ToString(),
|
|
Subject = canvassSupplierId.Subject,
|
|
CC = canvassSupplierId.CC,
|
|
SenderEmail = canvassSupplierId.SenderEmail,
|
|
DisplayName = canvassSupplierId.DisplayName,
|
|
NewPassword = canvassSupplierId.Password,
|
|
OutGoingPort = 587,
|
|
Server = canvassSupplierId.Server,
|
|
UserName = canvassSupplierId.SenderEmail,
|
|
IsSuccess = false
|
|
};
|
|
messageDetails.IsCanvass = true;
|
|
messageDetails.AttachPath = @"C:\webapi\Content\Documents\Pdf\Offer_Submission_Procedure.pdf";
|
|
if (await _smtpHelper.SendEmailAsync(messageDetails))
|
|
{
|
|
await _canvass.PutSupplierCanvass(canvassSupplierId.CanvassSupplierId);
|
|
}
|
|
}
|
|
|
|
return Ok(new { success = true, messCode = 1 });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var errorMessage = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
await PostErrorMessage(errorMessage, "WebApi");
|
|
throw;
|
|
}
|
|
}
|
|
[HttpPost("PostPutSupplier")]
|
|
public async Task<IActionResult> PostPutSupplier(CanvassDto CanvassDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.PostPutSupplier(CanvassDto),
|
|
nameof(PostPutSupplier), true
|
|
);
|
|
}
|
|
[HttpPost("PostTaggingSupplier")]
|
|
public async Task<IActionResult> PostTaggingSupplier([FromBody] CanvassVM canvassVM)
|
|
{
|
|
var supplier = new SupplierResponse();
|
|
foreach (var items in canvassVM.SupplierList.SupplierId)
|
|
{
|
|
var index = canvassVM.SupplierList.SupplierId.IndexOf(items);
|
|
|
|
var CanvassDto = new CanvassDto
|
|
{
|
|
SupplierId = canvassVM.SupplierList.SupplierId[index],
|
|
ItemNo = canvassVM.ItemNo,
|
|
IsActive = true,
|
|
UserId = canvassVM.UserId,
|
|
SupplierName = "N/A",
|
|
EmailAddress = "N/A",
|
|
Address = "N/A",
|
|
ContactNo = "N/A",
|
|
ContactPerson = "N/A",
|
|
IsTagging = true
|
|
};
|
|
|
|
supplier = await _canvass.PostTaggingSupplier(CanvassDto);
|
|
}
|
|
return Ok(supplier);
|
|
}
|
|
[HttpPost("PostPutItemTagging")]
|
|
public async Task<IActionResult> PostPutItemTagging([FromBody] CanvassVM canvassVM)
|
|
{
|
|
var supplier = new SupplierResponse();
|
|
foreach (var items in canvassVM.ItemList.ItemNo)
|
|
{
|
|
var index = canvassVM.ItemList.ItemNo.IndexOf(items);
|
|
|
|
var CanvassDto = new CanvassDto
|
|
{
|
|
ItemNo = canvassVM.ItemList.ItemNo[index],
|
|
SupplierId = canvassVM.SupplierId,
|
|
IsActive = canvassVM.IsActive,
|
|
UserId = canvassVM.UserId,
|
|
};
|
|
|
|
supplier = await _canvass.PostPutItemTagging(CanvassDto);
|
|
}
|
|
return Ok(supplier);
|
|
}
|
|
[HttpPost("PostCanvass")]
|
|
public async Task<IActionResult> PostCanvass([FromBody] CanvassVM canvassVM)
|
|
{
|
|
var baseTemplate = EMailTemplate("Content\\SMTPEmailContent", "SendToSupplier.cshtml");
|
|
|
|
var CanvassDto = new ForCanvassDto();
|
|
int canvassNo = await _canvass.GetCanvassNo();
|
|
|
|
foreach (var itemCartId in canvassVM.CanvassList.PRDetailsId)
|
|
{
|
|
var index = canvassVM.CanvassList.PRDetailsId.IndexOf(itemCartId);
|
|
|
|
CanvassDto = new ForCanvassDto
|
|
{
|
|
PRDetailsId = canvassVM.CanvassList.PRDetailsId[index],
|
|
PRNo = canvassVM.CanvassList.PRNo[index],
|
|
ItemNo = canvassVM.CanvassList.ItemNo[index],
|
|
SupplierId = canvassVM.SupplierId,
|
|
UserId = canvassVM.UserId,
|
|
FullName = canvassVM.FullName,
|
|
CanvassNo = canvassNo + 1,
|
|
};
|
|
await _canvass.PostPerSupplierToken(CanvassDto);
|
|
}
|
|
|
|
var rfq = await _canvass.GetRFQ(CanvassDto);
|
|
|
|
var message = new StringBuilder(baseTemplate);
|
|
message.Replace("@ViewBag.FormLink", Convert.ToString(_configuration["WebEndPoint:SupplierForm"] + rfq[0].Token));
|
|
message.Replace("@ViewBag.Supplier", rfq[0].SupplierName);
|
|
message.Replace("@ViewBag.Signature", CanvassDto.FullName);
|
|
|
|
var messageDetails = new EmailMessageDetailsVM();
|
|
messageDetails.AttachPath = GetRelativePath(@"Content\Documents\Pdf\Offer_Submission_Procedure.pdf");
|
|
|
|
messageDetails.Recipient = rfq[0].EmailAddress;
|
|
messageDetails.Message = message.ToString();
|
|
messageDetails.Subject = "CLMS - Request For Quotation #PRNo: " + rfq[0].AggrePRNo;
|
|
messageDetails.CC = Convert.ToString(_configuration["Canvass:CC"]);
|
|
messageDetails.SenderEmail = _config["SMTP:SenderEmail"];
|
|
messageDetails.DisplayName = "lloydlabinc.com";
|
|
messageDetails.NewPassword = _config["SMTP:Password"];
|
|
messageDetails.OutGoingPort = 587;
|
|
messageDetails.Server = _config["SMTP:Server"];
|
|
messageDetails.UserName = _config["SMTP:UserName"];
|
|
messageDetails.IsSuccess = false;
|
|
messageDetails.IsCanvass = true;
|
|
await _smtpHelper.SendEmailAsync(messageDetails);
|
|
|
|
return Ok(rfq);
|
|
}
|
|
[HttpPost("PostSearchSupplierAndSend")]
|
|
public async Task<IActionResult> PostSearchSupplierAndSend(CancellationToken ct)
|
|
{
|
|
var items = await _canvass.GetForAISearchingTagging(ct);
|
|
if (items == null || !items.Any())
|
|
return BadRequest("No items found.");
|
|
|
|
var rawSuppliers = await _canvass.GetSuppliers(ct) ?? new List<Suppliers>();
|
|
var existingSuppliers = _mapper.Map<List<SupplierResponse>>(rawSuppliers);
|
|
|
|
var supplierResults = new List<object>();
|
|
|
|
foreach (var item in items)
|
|
{
|
|
try
|
|
{
|
|
var results = await ProcessItemAsync(item, existingSuppliers, ct);
|
|
supplierResults.AddRange(results);
|
|
}
|
|
catch (Exception) { }
|
|
}
|
|
|
|
return Ok(new { totalProcessed = supplierResults.Count, suppliers = supplierResults });
|
|
}
|
|
private async Task<List<object>> ProcessItemAsync(
|
|
ForAISearchingTagging item,
|
|
List<SupplierResponse> existingSuppliers,
|
|
CancellationToken ct)
|
|
{
|
|
var suppliers = await _supplierSearchService
|
|
.SearchAndFilterSuppliersAsync(item.ItemName, item.ItemDescription, item.IsInternational);
|
|
|
|
if (!suppliers.Any())
|
|
{
|
|
await _canvass.DeleteAsync(item.PRDetailsId, ct);
|
|
return new List<object>();
|
|
}
|
|
|
|
var results = new List<object>();
|
|
int canvassNo = await _canvass.GetCanvassNo();
|
|
bool anySuccess = false;
|
|
bool isProd = Convert.ToBoolean(_configuration["SMTP:IsLive"]);
|
|
|
|
foreach (var supplier in suppliers)
|
|
{
|
|
try
|
|
{
|
|
int supplierId;
|
|
|
|
var matchedId = await _supplierSearchService
|
|
.FindMatchingExistingSupplierAsync(supplier, existingSuppliers);
|
|
|
|
if (matchedId.HasValue)
|
|
{
|
|
supplierId = matchedId.Value;
|
|
}
|
|
else
|
|
{
|
|
var supplierRequest = _mapper.Map<SupplierRequest>(supplier);
|
|
supplierRequest.ItemNo = item.ItemNo;
|
|
|
|
var result = await _canvass.PostPutSupplierAsync(supplierRequest, ct);
|
|
if (result?.Value == null) continue;
|
|
|
|
supplierId = result.Value.SupplierId;
|
|
|
|
existingSuppliers.Add(result.Value);
|
|
}
|
|
|
|
var canvassDto = new ForCanvassDto
|
|
{
|
|
PRDetailsId = item.PRDetailsId,
|
|
PRNo = item.PRNo,
|
|
ItemNo = item.ItemNo,
|
|
SupplierId = supplierId,
|
|
UserId = item.UserId,
|
|
FullName = item.FullName,
|
|
CanvassNo = ++canvassNo,
|
|
};
|
|
|
|
await _canvass.PostPerSupplierToken(canvassDto);
|
|
|
|
var rfq = await _canvass.GetRFQ(canvassDto);
|
|
if (rfq == null || !rfq.Any()) continue;
|
|
|
|
var emailRequest = BuildEmailRequest(item, supplier, rfq[0].Token, isProd);
|
|
await _canvass.SendRFQ(emailRequest);
|
|
|
|
anySuccess = true;
|
|
results.Add(new
|
|
{
|
|
item = item.ItemName,
|
|
supplier = supplier.SupplierName,
|
|
email = supplier.EmailAddress,
|
|
canvassNo = canvassDto.CanvassNo,
|
|
isExisting = matchedId.HasValue
|
|
});
|
|
}
|
|
catch (Exception) { continue; }
|
|
}
|
|
|
|
if (anySuccess)
|
|
await _canvass.DeleteAsync(item.PRDetailsId, ct);
|
|
|
|
return results;
|
|
}
|
|
private SupplierEmailRequest BuildEmailRequest(
|
|
ForAISearchingTagging item, SupplierResponse supplier, string token,bool isProd) => new()
|
|
{
|
|
AttachPath = GetRelativePath(@"Content\Documents\Pdf\Offer_Submission_Procedure.pdf"),
|
|
Recipient = isProd ? supplier.EmailAddress : _configuration["SMTP:TestRecipient"] ?? "rmsoriano@lloydlab.com",
|
|
Subject = $"LLI - Request For Quotation #PRNo: {item.PRNo}",
|
|
CC = _configuration["Canvass:CC"] ?? "rmsoriano@lloydlab.com",
|
|
SenderEmail = _config["SMTP:SenderEmail"],
|
|
DisplayName = "lloydlabinc.com",
|
|
Password = _config["SMTP:Password"],
|
|
OutGoingPort = 587,
|
|
Server = _config["SMTP:Server"],
|
|
UserName = _config["SMTP:UserName"],
|
|
FormLink = _configuration["WebEndPoint:SupplierForm"] ?? "",
|
|
Token = token,
|
|
SupplierName = supplier.SupplierName,
|
|
Purchaser = item.FullName,
|
|
IsCanvass = true,
|
|
};
|
|
[HttpPost("PostSuggestedSupp")]
|
|
public async Task<IActionResult> PostSuggestedSupp(CanvassDto CanvassDto)
|
|
{
|
|
var pR = await _canvass.PostSuggestedSupp(CanvassDto);
|
|
|
|
return Ok(pR);
|
|
}
|
|
[HttpPost("PostApprovedSupp")]
|
|
public async Task<IActionResult> PostApprovedSupp(CanvassDto CanvassDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.PostApprovedSupp(CanvassDto),
|
|
nameof(PostApprovedSupp), true
|
|
);
|
|
}
|
|
[HttpPost("PutSuppUnitPrice")]
|
|
public async Task<IActionResult> PutSuppUnitPrice(CanvassDto CanvassDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.PutSuppUnitPrice(CanvassDto),
|
|
nameof(PutSuppUnitPrice), true
|
|
);
|
|
}
|
|
[HttpPost("PutSuppBidDetails")]
|
|
public async Task<IActionResult> PutSuppBidDetails(CanvassDto CanvassDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.PutSuppBidDetails(CanvassDto),
|
|
nameof(PutSuppBidDetails), true
|
|
);
|
|
}
|
|
[HttpPost("PostPutMySupplier")]
|
|
public async Task<IActionResult> PostPutMySupplier(CanvassDto CanvassDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.PostPutMySupplier(CanvassDto),
|
|
nameof(PostPutMySupplier), true
|
|
);
|
|
}
|
|
[HttpPost("UnlockFormLink")]
|
|
public async Task<IActionResult> UnlockFormLink(CanvassDto CanvassDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _canvass.UnlockFormLink(CanvassDto),
|
|
nameof(UnlockFormLink), true
|
|
);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|