493 lines
19 KiB
C#
493 lines
19 KiB
C#
using CPRNIMS.Domain.Contracts.PO;
|
|
using CPRNIMS.Domain.Contracts.SMTP;
|
|
using CPRNIMS.Domain.Services;
|
|
using CPRNIMS.Infrastructure.Dto.PO;
|
|
using CPRNIMS.Infrastructure.Dto.SMTP;
|
|
using CPRNIMS.Infrastructure.Entities.PO;
|
|
using CPRNIMS.Infrastructure.Helper;
|
|
using CPRNIMS.Infrastructure.ViewModel.Common;
|
|
using CPRNIMS.Infrastructure.ViewModel.PO;
|
|
using CPRNIMS.WebApi.Controllers.Base;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using System.Text;
|
|
|
|
namespace CPRNIMS.WebApi.Controllers.PO
|
|
{
|
|
[Security.AuthorizeRoles("POMgmt")]
|
|
public class POMgmtController : BaseController
|
|
{
|
|
private readonly ISMTP _sMTP;
|
|
private readonly SMTPHelper _smtpHelper;
|
|
private readonly IPurchaseOrder _purchaseOrder;
|
|
private readonly IConfiguration _config;
|
|
public POMgmtController(ErrorMessageService errorMessageService,
|
|
IWebHostEnvironment webHostEnvironment, IConfiguration configuration
|
|
, IPurchaseOrder purchaseOrder, SMTPHelper sMTPHelper, ISMTP sMTP)
|
|
: base(errorMessageService, webHostEnvironment, configuration)
|
|
{
|
|
_purchaseOrder=purchaseOrder;
|
|
_smtpHelper = sMTPHelper;
|
|
_sMTP = sMTP;
|
|
_config = configuration;
|
|
}
|
|
#region Post Put
|
|
[HttpPost("PostIncShipFollowUp")]
|
|
public async Task<IActionResult> PostIncShipFollowUp([FromBody] PODto dto)
|
|
{
|
|
bool isSuccess = await _purchaseOrder.PostIncShipFollowUp(dto);
|
|
return Ok(new
|
|
{
|
|
success = isSuccess,
|
|
messCode = isSuccess ? 1 : 0,
|
|
message = isSuccess ? "Follow up incoming for shipment successfully!"
|
|
: "Follow up incoming for shipment failed!"
|
|
});
|
|
}
|
|
[HttpPost("DeleteIncShip")]
|
|
public async Task<IActionResult> DeleteIncShip(PODto poDto)
|
|
{
|
|
bool isSuccess = await _purchaseOrder.DeleteIncShip(poDto);
|
|
return Ok(new
|
|
{
|
|
success = isSuccess,
|
|
messCode = isSuccess ? 1 : 0,
|
|
message = isSuccess ? "Removal of incoming for shipment successfully!"
|
|
: "Removal of incoming for shipment failed!"
|
|
});
|
|
}
|
|
[HttpPost("PutPOCancel")]
|
|
public async Task<IActionResult> PutPOCancel(PODto poDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(async () =>
|
|
{
|
|
var poResults = new List<CustomPO>();
|
|
var po = await _purchaseOrder.PutPOCancel(poDto);
|
|
poResults.Add(po);
|
|
return new
|
|
{
|
|
CustomPOs = poResults,
|
|
ProcessedCount = poResults.Count
|
|
};
|
|
},
|
|
nameof(PutPOCancel), true);
|
|
}
|
|
[HttpPost("PostPutCustomPO")]
|
|
public async Task<IActionResult> PostPutCustomPO([FromBody] POVM poVM)
|
|
{
|
|
return await ExecuteWithErrorHandling(async () =>
|
|
{
|
|
var poResults = new List<CustomPO>();
|
|
|
|
if (poVM.PRItemList?.PRDetailsId?.Count > 0)
|
|
{
|
|
for (int i = 0; i < poVM.PRItemList.PRDetailsId.Count; i++)
|
|
{
|
|
var poDto = _purchaseOrder.CreatePoDto(
|
|
poVM,
|
|
0,
|
|
0,
|
|
poVM.PRItemList.PRDetailsId[i],
|
|
poVM.PRItemList.UnitPrice[i],
|
|
poVM.PRItemList.Amount[i],
|
|
poVM.PRItemList.PRNo[i],
|
|
poVM.PRItemList.Quantity[i],
|
|
poVM.PRItemList.Specification[i]
|
|
);
|
|
|
|
var po = await _purchaseOrder.PostPutCustomPO(poDto);
|
|
poResults.Add(po);
|
|
}
|
|
}
|
|
|
|
await _purchaseOrder.Prerequisite(poVM);
|
|
|
|
return new
|
|
{
|
|
CustomPOs = poResults,
|
|
ProcessedCount = poResults.Count
|
|
};
|
|
},
|
|
nameof(PostPutCustomPO),true);
|
|
}
|
|
[HttpPost("ApprovedSelectedPO")]
|
|
public async Task<IActionResult> ApprovedSelectedPO([FromBody] POVM poVM)
|
|
{
|
|
return await ExecuteWithErrorHandling(async () =>
|
|
{
|
|
var results = new List<object>();
|
|
|
|
if (poVM.POList?.PONo?.Count > 0)
|
|
{
|
|
for (int i = 0; i < poVM.POList.PONo.Count; i++)
|
|
{
|
|
var dto = new PODto
|
|
{
|
|
PONo = poVM.POList.PONo[i],
|
|
UserId = poVM.UserId,
|
|
};
|
|
|
|
var result = await _purchaseOrder.ApprovedSelectedPO(dto);
|
|
results.Add(new { PONo = dto.PONo, Result = result });
|
|
}
|
|
}
|
|
|
|
return new
|
|
{
|
|
ProcessedCount = results.Count,
|
|
Results = results
|
|
};
|
|
},
|
|
nameof(ApprovedSelectedPO), true);
|
|
}
|
|
[HttpPost("PutMyPONo")]
|
|
public async Task<IActionResult> PutMyPONo(PODto pODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.PutMyPONo(pODto),
|
|
nameof(PutMyPONo), true
|
|
);
|
|
}
|
|
|
|
[HttpPost("PostPutPO")]
|
|
public async Task<IActionResult> PostPutPO([FromBody] POVM poVM)
|
|
{
|
|
return await ExecuteWithErrorHandling(async () =>
|
|
{
|
|
var poResult = await _purchaseOrder.PostPutPO(_purchaseOrder.CreatePoDto(poVM, 0, 0, 0, 0, 0, 0, 0,"n/a"));
|
|
await _purchaseOrder.Prerequisite(poVM);
|
|
|
|
return new { PoResult = poResult};
|
|
},
|
|
nameof(PostPutPO), true);
|
|
}
|
|
|
|
[HttpPost("PostPOToSupplier")]
|
|
public async Task<IActionResult> PostPOToSupplier(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.PostPOToSupplier(PODto),
|
|
nameof(PostPOToSupplier), true
|
|
);
|
|
}
|
|
[HttpPost("PostApprovedPO")]
|
|
public async Task<IActionResult> PostApprovedPO(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.PostApprovedPO(PODto),
|
|
nameof(PostApprovedPO), true
|
|
);
|
|
}
|
|
[HttpPost("PostApprovedSupplier")]
|
|
public async Task<IActionResult> PostApprovedSupplier(PODto PODto)
|
|
{
|
|
var cred = new SMTPCredentialDto
|
|
{
|
|
SMTPTypeId = 1,//must be dynamic in a future
|
|
UserId = PODto.UserId
|
|
};
|
|
var mySMTP = await _sMTP.GetSMTPCredential(cred);
|
|
var baseTemplate = "n/a";
|
|
|
|
baseTemplate = EMailTemplate("Content\\SMTPEmailContent", "SendToApprovedSupplier.cshtml");
|
|
|
|
var rfq = await _purchaseOrder.GetRFQ(PODto);
|
|
var message = new StringBuilder(baseTemplate);
|
|
var messageDetails = new EmailMessageDetailsVM();
|
|
if (mySMTP.Count > 0)
|
|
{
|
|
messageDetails.Recipient = rfq[0].EmailAddress;
|
|
messageDetails.Message = message.ToString();
|
|
messageDetails.Subject = "LLI - Request For Delivery";
|
|
messageDetails.CC = _config["Canvass:CC"];
|
|
messageDetails.SenderEmail = mySMTP[0].SenderEmail;
|
|
messageDetails.DisplayName = mySMTP[0].SenderDisplayName;
|
|
messageDetails.NewPassword = mySMTP[0].Password;
|
|
messageDetails.OutGoingPort = mySMTP[0].OutgoingPort;
|
|
messageDetails.Server = mySMTP[0].Server;
|
|
messageDetails.UserName = mySMTP[0].SenderUserName;
|
|
messageDetails.IsCanvass = true;
|
|
}
|
|
if (!await _smtpHelper.SendEmailAsync(messageDetails))
|
|
{
|
|
messageDetails.Recipient = rfq[0].EmailAddress;
|
|
messageDetails.Message = message.ToString();
|
|
messageDetails.Subject = "LLI - Request For Delivery";
|
|
messageDetails.CC = _config["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;
|
|
await _smtpHelper.SendEmailAsync(messageDetails);
|
|
}
|
|
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.PostApprovedSupplier(PODto),
|
|
nameof(PostApprovedSupplier), true
|
|
);
|
|
}
|
|
[HttpPost("PostApprovedSuggested")]
|
|
public async Task<IActionResult> PostApprovedSuggested(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.PostApprovedSuggested(PODto),
|
|
nameof(PostApprovedSuggested), true
|
|
);
|
|
}
|
|
[HttpPost("PutPRItemDetails")]
|
|
public async Task<IActionResult> PutPRItemDetails(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.PutPRItemDetails(PODto),
|
|
nameof(PutPRItemDetails), true
|
|
);
|
|
}
|
|
[HttpPost("PutPOItemDetail")]
|
|
public async Task<IActionResult> PutPOItemDetail(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.PutPOItemDetail(PODto),
|
|
nameof(PutPOItemDetail), true
|
|
);
|
|
}
|
|
[HttpPost("PostPutDocRequired")]
|
|
public async Task<IActionResult> PostPutDocRequired(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.PostPutDocRequired(PODto),
|
|
nameof(PostPutDocRequired),true
|
|
);
|
|
}
|
|
[HttpPost("PostPutOtherCharges")]
|
|
public async Task<IActionResult> PostPutOtherCharges(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.PostPutOtherCharges(PODto),
|
|
nameof(PostPutOtherCharges), true
|
|
);
|
|
}
|
|
[HttpPost("PostPutIncoterms")]
|
|
public async Task<IActionResult> PostPutIncoterms(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.PostPutIncoterms(PODto),
|
|
nameof(PostPutIncoterms), true
|
|
);
|
|
}
|
|
#endregion
|
|
#region Get
|
|
[HttpPost("GetIncomingShipment")]
|
|
public async Task<IActionResult> GetIncomingShipment(PODto itemDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetIncomingShipment(itemDto),
|
|
nameof(GetIncomingShipment), false
|
|
);
|
|
}
|
|
[HttpPost("GetPRPOSummaryItem")]
|
|
public async Task<IActionResult> GetPRPOSummaryItem(PODto itemDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetPRPOSummaryItem(itemDto),
|
|
nameof(GetPRPOSummaryItem), false
|
|
);
|
|
}
|
|
[HttpPost("GetPRPOSummaryReport")]
|
|
public async Task<IActionResult> GetPRPOSummaryReport(PODto itemDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetPRPOSummaryReport(itemDto),
|
|
nameof(GetPRPOSummaryReport), false
|
|
);
|
|
}
|
|
[HttpPost("GetIncoterms")]
|
|
public async Task<IActionResult> GetIncoterms(PODto itemDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetIncoterms(itemDto),
|
|
nameof(GetIncoterms),false
|
|
);
|
|
}
|
|
[HttpPost("GetPOItemDetail")]
|
|
public async Task<IActionResult> GetPOItemDetail(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetPOItemDetail(PODto),
|
|
nameof(GetPOItemDetail), false
|
|
);
|
|
}
|
|
[HttpPost("GetSupplierBidByItem")]
|
|
public async Task<IActionResult> GetSupplierBidByItem(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetSupplierBidByItem(PODto),
|
|
nameof(GetSupplierBidByItem), false
|
|
);
|
|
}
|
|
[HttpPost("GetSupplierBidById")]
|
|
public async Task<IActionResult> GetSupplierBidById(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetSupplierBidById(PODto),
|
|
nameof(GetSupplierBidById), false
|
|
);
|
|
}
|
|
[HttpPost("GetForBiddingApproval")]
|
|
public async Task<IActionResult> GetForBiddingApproval(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetForBiddingApproval(PODto),
|
|
nameof(GetForBiddingApproval), false
|
|
);
|
|
}
|
|
[HttpPost("GetForPOPerSuppEmail")]
|
|
public async Task<IActionResult> GetForPOPerSuppEmail(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetForPOPerSuppEmail(PODto),
|
|
nameof(GetForPOPerSuppEmail), false
|
|
);
|
|
}
|
|
|
|
[HttpPost("GetForPO")]
|
|
public async Task<IActionResult> GetForPO(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetForPO(PODto),
|
|
nameof(GetForPO), false
|
|
);
|
|
}
|
|
[HttpPost("GetMyCreatedPO")]
|
|
public async Task<IActionResult> GetMyCreatedPO(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetMyCreatedPO(PODto),
|
|
nameof(GetMyCreatedPO), false
|
|
);
|
|
}
|
|
[HttpPost("GetCreatedPO")]
|
|
public async Task<IActionResult> GetCreatedPO(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetCreatedPO(PODto),
|
|
nameof(GetCreatedPO), false
|
|
);
|
|
}
|
|
[HttpPost("GetForPOApprovalByPRNo")]
|
|
public async Task<IActionResult> GetForPOApprovalByPRNo(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetForPOApprovalByPRNo(PODto),
|
|
nameof(GetForPOApprovalByPRNo), false
|
|
);
|
|
}
|
|
[HttpPost("GetForPOApproval")]
|
|
public async Task<IActionResult> GetForPOApproval(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetForPOApproval(PODto),
|
|
nameof(GetForPOApproval), false
|
|
);
|
|
}
|
|
[HttpPost("GetApprovedPO")]
|
|
public async Task<IActionResult> GetApprovedPO(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetApprovedPO(PODto),
|
|
nameof(GetApprovedPO), false
|
|
);
|
|
}
|
|
[HttpPost("GetApprovedPOPerEmail")]
|
|
public async Task<IActionResult> GetApprovedPOPerEmail(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetApprovedPOPerEmail(PODto),
|
|
nameof(GetApprovedPOPerEmail), false
|
|
);
|
|
}
|
|
[HttpPost("GetCreatedPOPerSupId")]
|
|
public async Task<IActionResult> GetCreatedPOPerSupId(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetCreatedPOPerSupId(PODto),
|
|
nameof(GetCreatedPOPerSupId), false
|
|
);
|
|
}
|
|
[HttpPost("GetPaymentTerms")]
|
|
public async Task<IActionResult> GetPaymentTerms(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetPaymentTerms(PODto),
|
|
nameof(GetPaymentTerms), false
|
|
);
|
|
}
|
|
[HttpPost("GetPortOfDischarge")]
|
|
public async Task<IActionResult> GetPortOfDischarge(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetPortOfDischarge(PODto),
|
|
nameof(GetPortOfDischarge), false
|
|
);
|
|
}
|
|
[HttpPost("GetLatestPO")]
|
|
public async Task<IActionResult> GetLatestPO(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetLatestPO(PODto),
|
|
nameof(GetLatestPO), false
|
|
);
|
|
}
|
|
[HttpPost("GetLatestPO2")]
|
|
public async Task<IActionResult> GetLatestPO2(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetLatestPO2(PODto),
|
|
nameof(GetLatestPO2), false
|
|
);
|
|
}
|
|
[HttpPost("GetDocRequired")]
|
|
public async Task<IActionResult> GetDocRequired(PODto PODto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetDocRequired(PODto),
|
|
nameof(GetDocRequired), false
|
|
);
|
|
}
|
|
[HttpPost("GetOtherCharges")]
|
|
public async Task<IActionResult> GetOtherCharges(PODto poDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetOtherCharges(poDto),
|
|
nameof(GetOtherCharges), false
|
|
);
|
|
}
|
|
[HttpPost("GetSuppliers")]
|
|
public async Task<IActionResult> GetSuppliers(PODto poDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetSuppliers(poDto),
|
|
nameof(GetSuppliers), false
|
|
);
|
|
}
|
|
[HttpPost("GetPRWOCanvass")]
|
|
public async Task<IActionResult> GetPRWOCanvass(PODto poDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetPRWOCanvass(poDto),
|
|
nameof(GetPRWOCanvass), false
|
|
);
|
|
}
|
|
[HttpPost("GetIndexCard")]
|
|
public async Task<IActionResult> GetIndexCard(PODto poDto)
|
|
{
|
|
return await ExecuteWithErrorHandling(
|
|
() => _purchaseOrder.GetIndexCard(poDto),
|
|
nameof(GetIndexCard), false
|
|
);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|