580 lines
21 KiB
C#
580 lines
21 KiB
C#
using Azure;
|
|
using CPRNIMS.Domain.Services;
|
|
using CPRNIMS.Domain.UIContracts.Account;
|
|
using CPRNIMS.Domain.UIContracts.Items;
|
|
using CPRNIMS.Domain.UIServices.Updater;
|
|
using CPRNIMS.Infrastructure.Dto.Items;
|
|
using CPRNIMS.Infrastructure.Helper;
|
|
using CPRNIMS.Infrastructure.ViewModel.Items;
|
|
using CPRNIMS.WebApps.Controllers.Base;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.AspNetCore.SignalR;
|
|
using System.Text.Json;
|
|
|
|
|
|
namespace CPRNIMS.WebApps.Controllers.Items
|
|
{
|
|
public class ItemMgmtController : BaseMethod
|
|
{
|
|
private readonly IItem _item;
|
|
List<ItemVM>? response;
|
|
ItemVM? postPutItem;
|
|
private readonly IConfiguration _config;
|
|
private readonly IHubContext<CartHub> _hubContext;
|
|
public ItemMgmtController(ErrorLogHelper errorMessageService,
|
|
IWebHostEnvironment webHostEnvironment, IConfiguration config, TokenHelper tokenHelper,
|
|
IItem item, IHubContext<CartHub> hubContext,IAccount account)
|
|
: base(errorMessageService, webHostEnvironment,tokenHelper, account)
|
|
{
|
|
_item = item;
|
|
_config = config;
|
|
_hubContext = hubContext;
|
|
}
|
|
#region PutPost
|
|
public async Task<IActionResult> PostPutItemCart(ItemVM viewModel)
|
|
{
|
|
try
|
|
{
|
|
var postPutItem = await _item.PostPutItemCart(GetUser(), viewModel);
|
|
int count = await UpdateCart(viewModel);
|
|
await _hubContext.Clients.User(viewModel.UserId).SendAsync("ReceiveCartUpdate", count);
|
|
|
|
if (postPutItem.messCode != 0)
|
|
{
|
|
return Json(new { success = true, cartCount = count });
|
|
}
|
|
return Json(new { success = false, Response = postPutItem.message });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
|
|
throw;
|
|
}
|
|
}
|
|
public async Task<int> UpdateCart(ItemVM viewModel)
|
|
{
|
|
viewModel.IsCount = true;
|
|
int count=0;
|
|
var itemCartResp = await _item.GetItemCart(GetUser(), viewModel);
|
|
if (itemCartResp.Count <= 0)
|
|
{
|
|
ViewBag.CartItemCount = 0;
|
|
}
|
|
else
|
|
{
|
|
ViewBag.CartItemCount = itemCartResp[0].CartItemCount;
|
|
count = itemCartResp[0].CartItemCount;
|
|
}
|
|
return count;
|
|
}
|
|
public async Task<IActionResult> PutItemDetail(ItemVM viewModel)
|
|
{
|
|
try
|
|
{
|
|
string base64Image;
|
|
|
|
if (viewModel.ItemAttachPath==null)
|
|
{
|
|
var defaultImagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "Content", "Common", "empty.jpg");
|
|
byte[] imageBytes = await System.IO.File.ReadAllBytesAsync(defaultImagePath);
|
|
string imageBase64 = Convert.ToBase64String(imageBytes);
|
|
base64Image = $"data:image/jpeg;base64,{imageBase64}";
|
|
}
|
|
else
|
|
{
|
|
base64Image = viewModel.ItemAttachPath;
|
|
}
|
|
var (uploadResult,isSuccess) = await UploadBase64Image(base64Image);
|
|
if (isSuccess) {
|
|
viewModel.ItemAttachPath = uploadResult;
|
|
|
|
postPutItem = await _item.PutItemDetail(GetUser(), viewModel);
|
|
|
|
if (postPutItem.messCode != 0)
|
|
{
|
|
return Json(new { success = true, data = postPutItem });
|
|
}
|
|
|
|
}
|
|
return Json(new { success = false, response = uploadResult ?? postPutItem.statusResponse });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return Json(new { success = false, response = "An error occurred.", details = ex.Message });
|
|
}
|
|
}
|
|
|
|
public async Task<IActionResult> PostPutItem(ItemVM viewModel)
|
|
{
|
|
try
|
|
{
|
|
var postPutItem = await _item.PostPutItem(GetUser(), viewModel);
|
|
|
|
if (postPutItem.messCode != 0)
|
|
{
|
|
return Json(new
|
|
{
|
|
success = true,
|
|
data = postPutItem,
|
|
itemCodeId = postPutItem.ItemCodeId
|
|
});
|
|
}
|
|
|
|
return Json(new { success = false, response = postPutItem.message });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
throw;
|
|
}
|
|
}
|
|
private async Task<string?> SaveAttachmentAsync(IFormFile? file, string? oldFileName)
|
|
{
|
|
var uploadsPath = Path.Combine(
|
|
_webHostEnvironment.WebRootPath,
|
|
"Content", "Uploads", "PRAttachment");
|
|
|
|
Directory.CreateDirectory(uploadsPath);
|
|
|
|
// If no new file uploaded, return old filename
|
|
if (file == null)
|
|
return oldFileName;
|
|
|
|
// Delete old file if exists
|
|
if (!string.IsNullOrWhiteSpace(oldFileName))
|
|
{
|
|
await DeleteAttachmentAsync(oldFileName);
|
|
}
|
|
|
|
// Validate file extension
|
|
var allowedExtensions = new[] { ".csv", ".xlsx", ".xls", ".pdf" };
|
|
var fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant();
|
|
|
|
if (!allowedExtensions.Contains(fileExtension))
|
|
{
|
|
throw new InvalidOperationException("Invalid file type. Only CSV, Excel, and PDF files are allowed.");
|
|
}
|
|
|
|
// Validate file size (5MB max)
|
|
if (file.Length > 5 * 1024 * 1024)
|
|
{
|
|
throw new InvalidOperationException("File size exceeds 5MB limit.");
|
|
}
|
|
|
|
// Generate new unique filename with original extension
|
|
var newFileName = $"{Guid.NewGuid()}{fileExtension}";
|
|
var newFilePath = Path.Combine(uploadsPath, newFileName);
|
|
|
|
// Save new file
|
|
await using var stream = new FileStream(newFilePath, FileMode.Create);
|
|
await file.CopyToAsync(stream);
|
|
|
|
// Return only filename (NOT full path)
|
|
return newFileName;
|
|
}
|
|
|
|
private async Task DeleteAttachmentAsync(string fileName)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(fileName))
|
|
return;
|
|
|
|
var uploadsPath = Path.Combine(
|
|
_webHostEnvironment.WebRootPath,
|
|
"Content", "Uploads", "PRAttachment");
|
|
|
|
var filePath = Path.Combine(uploadsPath, fileName);
|
|
|
|
if (System.IO.File.Exists(filePath))
|
|
{
|
|
await Task.Run(() => System.IO.File.Delete(filePath));
|
|
}
|
|
}
|
|
|
|
[HttpPost]
|
|
public async Task<IActionResult> PostPurchRequest([FromForm] string ItemCartIds,
|
|
[FromForm] DateTime DateNeeded,
|
|
[FromForm] byte RequestTypeId,
|
|
[FromForm] int ChargeTo,
|
|
[FromForm] string? Remarks,
|
|
[FromForm] string? ProjectCode,
|
|
IFormFile? file)
|
|
{
|
|
try
|
|
{
|
|
// Deserialize the ItemCartIds JSON string
|
|
var itemCartList = JsonSerializer.Deserialize<List<ItemCartDto>>(ItemCartIds);
|
|
|
|
if (itemCartList == null || !itemCartList.Any())
|
|
{
|
|
return Json(new { success = false, response = "No items selected" });
|
|
}
|
|
|
|
var viewModel = new ItemVM
|
|
{
|
|
DateNeeded = DateNeeded,
|
|
RequestTypeId = RequestTypeId,
|
|
ChargeTo = ChargeTo,
|
|
Remarks = Remarks,
|
|
ProjectCode = ProjectCode,
|
|
ItemCartVM = new ItemCartVM
|
|
{
|
|
ItemCartId = itemCartList.Select(ic => ic.ItemCartId).ToList(),
|
|
Qty = itemCartList.Select(ic => ic.Qty).ToList(),
|
|
ItemNo = itemCartList.Select(ic => ic.ItemNo).ToList()
|
|
}
|
|
};
|
|
|
|
// Save attachment if provided
|
|
string? savedFileName = await SaveAttachmentAsync(file, null);
|
|
|
|
viewModel.FileName = savedFileName;
|
|
viewModel.OrigFileName = file.FileName;
|
|
|
|
var postPutItem = await _item.PostPurchRequest(GetUser(), viewModel);
|
|
|
|
if (postPutItem.messCode != 0)
|
|
{
|
|
return Json(new { success = true, message = "Purchase request created successfully" });
|
|
}
|
|
|
|
// Delete uploaded file if request failed
|
|
if (!string.IsNullOrWhiteSpace(savedFileName))
|
|
{
|
|
await DeleteAttachmentAsync(savedFileName);
|
|
}
|
|
|
|
return Json(new { success = false, response = postPutItem.message });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.Message ?? ex.Message;
|
|
return Json(new { success = false, response = "An error occurred while processing your request" });
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Get
|
|
public async Task<IActionResult> GetProjectCode(string term)
|
|
{
|
|
var item = new ItemVM();
|
|
item.FileName = term;
|
|
response = await _item.GetProjectCode(GetUser(), item);
|
|
return GetResponse(response);
|
|
}
|
|
public async Task<IActionResult> GetImageFileIds()
|
|
{
|
|
try
|
|
{
|
|
var fileIds = new List<string>();
|
|
var googleDriveService = new GoogleDriveService("secret");
|
|
fileIds.Add(await googleDriveService.GetFileIdByNameAsync("1.jpg"));
|
|
fileIds.Add(await googleDriveService.GetFileIdByNameAsync("2.jpg"));
|
|
fileIds.Add(await googleDriveService.GetFileIdByNameAsync("3.jpg"));
|
|
return Json(fileIds);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Handle exception
|
|
return BadRequest(ex.Message);
|
|
}
|
|
}
|
|
public IActionResult GetImage(string url)
|
|
{
|
|
return Redirect(url);
|
|
}
|
|
public async Task<IActionResult> GetItemDetail(ItemVM viewModels)
|
|
{
|
|
try
|
|
{
|
|
response = await _item.GetItemDetail(GetUser(), viewModels);
|
|
response[0].URL = _config["CommonEndpoints:ApiDefaultHeaders:ItemImages"];
|
|
return GetResponse(response);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
|
|
throw;
|
|
}
|
|
}
|
|
public async Task<IActionResult> GetItemCart(ItemVM viewModels)
|
|
{
|
|
try
|
|
{
|
|
response = await _item.GetItemCart(GetUser(), viewModels);
|
|
return GetResponse(response);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
|
|
throw;
|
|
}
|
|
}
|
|
public async Task<IActionResult> GetItemList()
|
|
{
|
|
var viewModels = new ItemVM();
|
|
response = await _item.GetItemList(GetUser(), viewModels);
|
|
return GetResponse(response);
|
|
}
|
|
public async Task<IActionResult> GetItemCateg(ItemVM viewModels)
|
|
{
|
|
|
|
try
|
|
{
|
|
var responseQuery = await _item.GetItemCateg(GetUser(), viewModels);
|
|
|
|
if (responseQuery == null)
|
|
{
|
|
responseQuery = new List<ItemVM>();
|
|
}
|
|
|
|
return Json(new { success = true, data = responseQuery });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
throw;
|
|
}
|
|
}
|
|
public async Task<IActionResult> GetItemColor(string query)
|
|
{
|
|
try
|
|
{
|
|
var viewModels = new ItemVM();
|
|
viewModels.ItemColorName = query;
|
|
var responseQuery = await _item.GetItemColor(GetUser(), viewModels);
|
|
|
|
if (responseQuery == null)
|
|
{
|
|
responseQuery = new List<ItemVM>();
|
|
}
|
|
|
|
// Convert the data to the format expected by jQuery UI Autocomplete
|
|
var formattedData = responseQuery.Select(item => new
|
|
{
|
|
label = item.ItemColorName,
|
|
value = item.ItemColorId,
|
|
});
|
|
|
|
return Json(new { success = true, data = formattedData });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
throw;
|
|
}
|
|
}
|
|
public async Task<IActionResult> GetItemLocalization(string query)
|
|
{
|
|
try
|
|
{
|
|
var viewModels = new ItemVM();
|
|
viewModels.ItemLocalName = query;
|
|
var responseQuery = await _item.GetItemLocalization(GetUser(), viewModels);
|
|
|
|
if (responseQuery == null)
|
|
{
|
|
responseQuery = new List<ItemVM>();
|
|
}
|
|
|
|
// Convert the data to the format expected by jQuery UI Autocomplete
|
|
var formattedData = responseQuery.Select(item => new
|
|
{
|
|
label = item.ItemLocalName,
|
|
value = item.ItemLocalId,
|
|
});
|
|
|
|
return Json(new { success = true, data = formattedData });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
throw;
|
|
}
|
|
}
|
|
public async Task<IActionResult> GetItemUOM(string query)
|
|
{
|
|
try
|
|
{
|
|
var viewModels = new ItemVM();
|
|
viewModels.UOMName = query;
|
|
var responseQuery = await _item.GetItemUOM(GetUser(), viewModels);
|
|
|
|
if (responseQuery == null)
|
|
{
|
|
responseQuery = new List<ItemVM>();
|
|
}
|
|
|
|
var formattedData = responseQuery.Select(item => new
|
|
{
|
|
label = item.UOMName,
|
|
value = item.UOMId,
|
|
});
|
|
|
|
return Json(new { success = true, data = formattedData });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
throw;
|
|
}
|
|
}
|
|
public async Task<IActionResult> GetDepartment()
|
|
{
|
|
try
|
|
{
|
|
var viewModels = new ItemVM();
|
|
var responseQuery = await _item.GetDepartment(GetUser(), viewModels);
|
|
|
|
if (responseQuery == null)
|
|
{
|
|
responseQuery = new List<ItemVM>();
|
|
}
|
|
|
|
return Json(new { success = true, data = responseQuery });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
throw;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Views
|
|
public async Task<IActionResult> Index()
|
|
{
|
|
var viewModels = new ItemVM();
|
|
await UpdateCart(viewModels);
|
|
|
|
return await IsAuthenTicated();
|
|
}
|
|
public async Task<IActionResult> ItemCart(byte TypeOfRequest)
|
|
{
|
|
ViewBag.TypeOfRequest = TypeOfRequest;
|
|
return await IsAuthenTicated();
|
|
}
|
|
#endregion
|
|
#region Common
|
|
public async Task<(string,bool)> UploadBase64Image(string base64Image)
|
|
{
|
|
try
|
|
{
|
|
// Extract image format from base64 string
|
|
var base64Data = base64Image.Substring(base64Image.IndexOf(',') + 1);
|
|
var imageFormat = base64Image.Substring(base64Image.IndexOf('/') + 1, base64Image.IndexOf(';') - base64Image.IndexOf('/') - 1);
|
|
|
|
// Check image format
|
|
if (imageFormat.ToLowerInvariant() != "jpeg" && imageFormat.ToLowerInvariant() != "jpg" && imageFormat.ToLowerInvariant() != "png")
|
|
{
|
|
return ("Only JPG and PNG images are allowed.", false);
|
|
}
|
|
|
|
// Decode base64 string to byte array
|
|
byte[] imageBytes;
|
|
try
|
|
{
|
|
imageBytes = Convert.FromBase64String(base64Data);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
return ("Invalid Base64 data.", false);
|
|
}
|
|
// Check byte array size (8MB limit)
|
|
const int maxFileSizeInBytes = 8 * 1024 * 1024; // 8 MB
|
|
if (imageBytes.Length > maxFileSizeInBytes)
|
|
{
|
|
return ("Exceed 8MB.",false);
|
|
}
|
|
|
|
// Save the decoded byte array to the shared folder
|
|
var serverPath = _config["LLI:NonInvent:ImageUploadSettings:UploadPath"];
|
|
var fileName = Guid.NewGuid().ToString() + "." + imageFormat;
|
|
var filePath = Path.Combine(serverPath, fileName);
|
|
|
|
await System.IO.File.WriteAllBytesAsync(filePath, imageBytes);
|
|
|
|
return (fileName,true);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Handle exception
|
|
Console.WriteLine(ex.ToString());
|
|
throw;
|
|
}
|
|
}
|
|
public async Task<IActionResult> UploadMultipleFile(List<IFormFile> files,long itemNo)
|
|
{
|
|
try
|
|
{
|
|
foreach (var file in files)
|
|
{
|
|
// Check file size
|
|
if (file.Length > 2 * 1024 * 1024) // 2MB limit
|
|
{
|
|
return Json(new { success = false, Response = "File size should not exceed 2MB." });
|
|
}
|
|
|
|
// Check file extension
|
|
var fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant();
|
|
if (fileExtension != ".jpg" && fileExtension != ".png")
|
|
{
|
|
return Json(new { success = false, Response = "Only JPG and PNG files are allowed." });
|
|
}
|
|
|
|
// Save the uploaded file to the shared folder
|
|
var serverPath = "\\\\172.16.16.215\\NonInventory"; // Shared folder path
|
|
var fileName = Guid.NewGuid().ToString() + fileExtension; // Generate unique file name
|
|
var filePath = Path.Combine(serverPath, fileName); // Combine path and file name
|
|
|
|
using (var stream = new FileStream(filePath, FileMode.Create))
|
|
{
|
|
await file.CopyToAsync(stream);
|
|
}
|
|
|
|
return Json(new { success = true });
|
|
}
|
|
|
|
return Json(new { success = true });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
|
|
return Json(new { success = false, Response ="There is something wrong, please ask administrator!" });
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
#region Commented
|
|
//private DriveService _driveService;
|
|
//public async Task<IActionResult> Index()
|
|
//{
|
|
// var filePath = "D:\\sourcecode\\test.txt";
|
|
// var fileName = Path.GetFileName(filePath);
|
|
// var mimeType = "text/plain"; // Assuming the file is a text file
|
|
|
|
// try
|
|
// {
|
|
// GoogleCredential credential = GoogleCredential.FromFile("path/to/service-account-key.json")
|
|
// .CreateScoped(DriveService.ScopeConstants.Drive);
|
|
|
|
// // Create the Drive service using the service account credential
|
|
// _driveService = new DriveService(new BaseClientService.Initializer
|
|
// {
|
|
// HttpClientInitializer = credential,
|
|
// ApplicationName = "Your Application Name"
|
|
// });
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// // Log the error or handle it appropriately
|
|
// // For example, you can throw an exception or set _driveService to null
|
|
// _driveService = null;
|
|
// }
|
|
// return View();
|
|
//}
|
|
#endregion
|
|
}
|
|
}
|