533 lines
22 KiB
C#
533 lines
22 KiB
C#
using CPRNIMS.Domain.Contracts.Canvass;
|
|
using CPRNIMS.Domain.Contracts.SMTP;
|
|
using CPRNIMS.Domain.Services;
|
|
using CPRNIMS.Infrastructure.Dto.Canvass;
|
|
using CPRNIMS.Infrastructure.Entities.Canvass;
|
|
using CPRNIMS.Infrastructure.Helper;
|
|
using CPRNIMS.Infrastructure.ViewModel.Canvass;
|
|
using CPRNIMS.Infrastructure.ViewModel.Common;
|
|
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;
|
|
|
|
public CanvassMgmtController(ErrorMessageService errorMessageService,
|
|
IWebHostEnvironment webHostEnvironment, SMTPHelper sMTPHelper,
|
|
IConfiguration configuration, ICanvass canvass) :
|
|
base(errorMessageService, webHostEnvironment, sMTPHelper, configuration)
|
|
{
|
|
_canvass = canvass;
|
|
_config = configuration;
|
|
_smtpHelper = sMTPHelper;
|
|
}
|
|
|
|
#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("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("PostAllCanvass")]
|
|
public async Task<IActionResult> PostAllCanvass()
|
|
{
|
|
try
|
|
{
|
|
var baseTemplate = EMailTemplate("Content\\SMTPEmailContent", "SendToSupplier.cshtml");
|
|
|
|
// Get all canvass items
|
|
var allCanvass = await _canvass.GetAllForCanvass();
|
|
|
|
// ✅ Group all items by supplier
|
|
var groupedBySupplier = allCanvass
|
|
.GroupBy(x => x.SupplierId)
|
|
.ToList();
|
|
|
|
// Process each supplier group
|
|
foreach (var supplierGroup in groupedBySupplier)
|
|
{
|
|
var firstItem = supplierGroup.First();
|
|
int canvassNo = await _canvass.GetCanvassNo();
|
|
|
|
// Insert all items for this supplier
|
|
foreach (var rfqq in supplierGroup)
|
|
{
|
|
var canvass = new CanvassDto
|
|
{
|
|
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);
|
|
}
|
|
|
|
// ✅ After inserting all items for this supplier, retrieve RFQ info
|
|
var canvassInfo = new CanvassDto
|
|
{
|
|
SupplierId = firstItem.SupplierId,
|
|
UserId = firstItem.UserId,
|
|
FullName = firstItem.FullName,
|
|
CanvassNo = canvassNo + 1
|
|
};
|
|
|
|
var rfq = await _canvass.GetRFQ(canvassInfo);
|
|
|
|
if (rfq?.Any() == true)
|
|
{
|
|
// ✅ Prepare email body
|
|
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);
|
|
|
|
// ✅ Prepare email details
|
|
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);
|
|
|
|
// ✅ Post canvass record after successful send
|
|
await _canvass.PostCanvass(canvassInfo);
|
|
}
|
|
}
|
|
|
|
return Ok(new { message = "All canvass emails sent successfully." });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var errorMessage = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
await PostErrorMessage(errorMessage, "WebApi");
|
|
throw;
|
|
}
|
|
}
|
|
|
|
[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)
|
|
{
|
|
try
|
|
{
|
|
var supplier = new Suppliers();
|
|
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);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.Message ?? ex.Message;
|
|
return BadRequest(new { ErrMessage = message, ErrCode = 0 });
|
|
}
|
|
}
|
|
[HttpPost("PostPutItemTagging")]
|
|
public async Task<IActionResult> PostPutItemTagging([FromBody] CanvassVM canvassVM)
|
|
{
|
|
try
|
|
{
|
|
var supplier = new Suppliers();
|
|
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);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.Message ?? ex.Message;
|
|
return BadRequest(new { ErrMessage = message, ErrCode = 0 });
|
|
}
|
|
}
|
|
[HttpPost("PostCanvass")]
|
|
public async Task<IActionResult> PostCanvass([FromBody] CanvassVM canvassVM)
|
|
{
|
|
try
|
|
{
|
|
var baseTemplate = "n/a";
|
|
|
|
baseTemplate = EMailTemplate("Content\\SMTPEmailContent", "SendToSupplier.cshtml");
|
|
|
|
var CanvassDto = new CanvassDto();
|
|
int canvassNo = await _canvass.GetCanvassNo();
|
|
foreach (var itemCartId in canvassVM.CanvassList.PRDetailsId)
|
|
{
|
|
var index = canvassVM.CanvassList.PRDetailsId.IndexOf(itemCartId);
|
|
|
|
CanvassDto = new CanvassDto
|
|
{
|
|
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);
|
|
|
|
var pR = await _canvass.PostCanvass(CanvassDto);
|
|
|
|
return Ok(pR);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var errorMessage = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
await PostErrorMessage(errorMessage + " PostCanvass", "WebApi");
|
|
throw;
|
|
}
|
|
}
|
|
[HttpPost("PostSuggestedSupp")]
|
|
public async Task<IActionResult> PostSuggestedSupp(CanvassDto CanvassDto)
|
|
{
|
|
try
|
|
{
|
|
var pR = await _canvass.PostSuggestedSupp(CanvassDto);
|
|
|
|
return Ok(pR);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
await PostErrorMessage(message + " PostSuggestedSupp", "WebApi");
|
|
throw;
|
|
}
|
|
}
|
|
[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
|
|
}
|
|
}
|