//.........
public async Task <bool> AddUpdateCountryAsync(cor_country model)
{
if (model.CountryId > 0)
{
var item = await _dataContext.cor_country.FindAsync(model.CountryId);
_dataContext.Entry(item).CurrentValues.SetValues(model);
}
else
{
await _dataContext.cor_country.AddAsync(model);
}
return(await _dataContext.SaveChangesAsync() > 0);
}
public async Task <LookUpRegRespObj> Handle(AddUpdateCountryCommand request, CancellationToken cancellationToken)
{
try
{
if (request.CountryId < 1)
{
if (await _dataContext.cor_country.AnyAsync(x => x.CountryName.Trim().ToLower() == request.CountryName.Trim().ToLower() && x.Deleted == false))
{
return(new LookUpRegRespObj
{
Status = new APIResponseStatus
{
IsSuccessful = false,
Message = new APIResponseMessage
{
FriendlyMessage = "This Name Already Exist"
}
}
});
}
}
var item = new cor_country
{
Active = true,
CountryCode = request.CountryCode,
CountryId = request.CountryId,
CountryName = request.CountryName,
CreatedOn = request.CreatedOn,
Deleted = false,
CreatedBy = request.CreatedBy
};
await _repo.AddUpdateCountryAsync(item);
return(new LookUpRegRespObj
{
Status = new APIResponseStatus
{
IsSuccessful = true,
Message = new APIResponseMessage
{
FriendlyMessage = "Item Added successfully"
}
}
});
}
catch (Exception ex)
{
#region Log error to file
return(new LookUpRegRespObj
{
Status = new APIResponseStatus
{
IsSuccessful = false,
Message = new APIResponseMessage
{
FriendlyMessage = "Error occured!! Unable to process request",
TechnicalMessage = $"{ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}"
}
}
});
#endregion
}
}
public async Task UploadCountry(byte[] record, string createdBy)
{
try
{
var uploadedRecord = new List <cor_country>();
using (MemoryStream stream = new MemoryStream(record))
using (ExcelPackage excelPackage = new ExcelPackage(stream))
{
//Use first sheet by default
ExcelWorksheet workSheet = excelPackage.Workbook.Worksheets[1];
int totalRows = workSheet.Dimension.Rows;
//First row is considered as the header
for (int i = 2; i <= totalRows; i++)
{
uploadedRecord.Add(new cor_country
{
CountryName = workSheet.Cells[i, 1].Value.ToString(),
CountryCode = workSheet.Cells[i, 2].Value.ToString(),
Active = true,
Deleted = false,
CreatedBy = createdBy,
CreatedOn = DateTime.Now,
UpdatedBy = createdBy,
UpdatedOn = DateTime.Now,
});
}
}
if (uploadedRecord.Count > 0)
{
foreach (var item in uploadedRecord)
{
var countryDb = await _dataContext.cor_country.FirstOrDefaultAsync(x => x.CountryCode == item.CountryCode &&
x.Deleted == false);
if (countryDb != null)
{
countryDb.CountryName = item.CountryName;
countryDb.CountryCode = item.CountryCode;
countryDb.Active = true;
countryDb.Deleted = false;
countryDb.UpdatedBy = createdBy;
countryDb.UpdatedOn = DateTime.Now;
}
else
{
var country = new cor_country
{
CountryName = item.CountryName,
CountryCode = item.CountryCode,
Active = true,
Deleted = false,
CreatedBy = createdBy,
CreatedOn = DateTime.Now,
};
_dataContext.cor_country.Add(country);
}
}
await _dataContext.SaveChangesAsync();
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <FileUploadRespObj> Handle(UploadCountryCommand request, CancellationToken cancellationToken)
{
try
{
var apiResponse = new FileUploadRespObj {
Status = new APIResponseStatus {
IsSuccessful = false, Message = new APIResponseMessage()
}
};
var files = _accessor.HttpContext.Request.Form.Files;
var byteList = new List <byte[]>();
foreach (var fileBit in files)
{
if (fileBit.Length > 0)
{
using (var ms = new MemoryStream())
{
await fileBit.CopyToAsync(ms);
byteList.Add(ms.ToArray());
}
}
}
var userId = _accessor.HttpContext.User?.FindFirst(x => x.Type == "userId").Value;
var user = await _userManager.FindByIdAsync(userId);
var _Country = await _repo.GetAllCountryAsync();
var uploadedRecord = new List <CommonLookupsObj>();
ExcelPackage.LicenseContext = LicenseContext.NonCommercial;
if (byteList.Count() > 0)
{
foreach (var byteItem in byteList)
{
using (MemoryStream stream = new MemoryStream(byteItem))
using (ExcelPackage excelPackage = new ExcelPackage(stream))
{
//Use first sheet by default
ExcelWorksheet workSheet = excelPackage.Workbook.Worksheets[0];
int totalRows = workSheet.Dimension.Rows;
int totalColumns = workSheet.Dimension.Columns;
if (totalColumns != 2)
{
apiResponse.Status.Message.FriendlyMessage = $"Two (2) Columns Expected";
return(apiResponse);
}
//First row is considered as the header
for (int i = 2; i <= totalRows; i++)
{
var lkp = new CommonLookupsObj
{
ExcelLineNumber = i,
LookupName = workSheet.Cells[i, 1]?.Value != null ? workSheet.Cells[i, 1]?.Value.ToString() : string.Empty,
Code = workSheet.Cells[i, 2]?.Value != null ? workSheet.Cells[i, 2]?.Value.ToString() : string.Empty,
};
uploadedRecord.Add(lkp);
}
}
}
}
var _CountryList = await _repo.GetAllCountry();
if (uploadedRecord.Count > 0)
{
foreach (var item in uploadedRecord)
{
if (string.IsNullOrEmpty(item.Code))
{
apiResponse.Status.Message.FriendlyMessage = $"Country Code can not be empty on line {item.ExcelLineNumber}";
return(apiResponse);
}
if (string.IsNullOrEmpty(item.LookupName))
{
apiResponse.Status.Message.FriendlyMessage = $"Country Name can not be empty on line {item.ExcelLineNumber}";
return(apiResponse);
}
var currentCountry = _CountryList.FirstOrDefault(c => c.CountryCode.ToLower() == item.Code.ToLower() && c.Deleted == false);
if (currentCountry == null)
{
var country = new cor_country
{
CountryName = item.LookupName,
CountryCode = item.Code,
};
await _repo.AddUpdateCountryAsync(country);
}
else
{
currentCountry.CountryName = item.LookupName;
currentCountry.CountryCode = item.Code;
await _repo.AddUpdateCountryAsync(currentCountry);
}
}
}
apiResponse.Status.IsSuccessful = true;
apiResponse.Status.Message.FriendlyMessage = "Successful";
return(apiResponse);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
