/// <summary>
/// returns all sections in the database
/// </summary>
/// <returns></returns>
public async Task <AlpApiResponse <List <SectionDto> > > GetAllSections()
{
var response = new AlpApiResponse <List <SectionDto> >();
try
{
_logger.LogDebug(new
{
action = nameof(GetAllSections)
}.ToString());
var sections = await _context.Section.AsNoTracking()
.Include(section => section.Floor)
.Include(section => section.Department)
.ToListAsync();
response.Value = sections.Select(Section => Section.EntityToDto()).ToList();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// updates a itemnature by dto
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <AlpApiResponse> UpdateItemNature(ItemNatureDto dto)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(UpdateItemNature),
dto = dto?.ToString()
}.ToString());
dto.Validate();
var updatedEntity = await _context.ItemNature.FirstOrDefaultAsync(itemNature => itemNature.ItemNatureId == dto.Id);
updatedEntity.UpdateEntityByDto(dto);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// gets all floors from database
/// </summary>
/// <returns></returns>
public async Task <AlpApiResponse> DeleteItemNatureById(int itemNatureId)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(DeleteItemNatureById),
itemNatureId
}.ToString());
var entity = await _context.ItemNature.FirstOrDefaultAsync(itemNature => itemNature.ItemNatureId == itemNatureId);
_context.ItemNature.Remove(entity);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// updates a department by dto
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <AlpApiResponse> UpdateDepartment(DepartmentDto dto)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(UpdateDepartment),
dto = dto?.ToString()
}.ToString());
dto.Validate();
var updatedEntity = await _context.Department.Include(department => department.Employee).FirstOrDefaultAsync(Department => Department.DepartmentId == dto.Id);
updatedEntity.UpdateEntityByDto(dto);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Success = false;
response.Message = e.Message;
}
return(response);
}
/// <summary>
/// gets nonlocked floors
/// </summary>
/// <returns></returns>
public async Task <AlpApiResponse <List <FloorDto> > > GetAvailableFloors()
{
var response = new AlpApiResponse <List <FloorDto> >();
try
{
_logger.LogDebug(new
{
action = nameof(GetAvailableFloors)
}.ToString());
var floors = await _context.Floor.AsNoTracking().Include(floor => floor.Building).Where(floor => !floor.Locked).ToListAsync();
response.Value = floors.Select(floor => floor.EntityToDto()).ToList();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// gets a building by its id
/// </summary>
/// <param name="buildingId"></param>
/// <returns></returns>
public async Task <AlpApiResponse <BuildingDto> > GetBuildingById(int buildingId)
{
var response = new AlpApiResponse <BuildingDto>();
try
{
_logger.LogDebug(new
{
action = nameof(GetBuildingById),
buildingId
}.ToString());
var entity = await _context.Building.Include(building => building.Location).FirstOrDefaultAsync(building => building.BuildingId == buildingId);
response.Value = entity.EntityToDto();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// gets all the buldings from the database
/// </summary>
/// <returns></returns>
public async Task <AlpApiResponse <List <BuildingDto> > > GetAllBuildings()
{
var response = new AlpApiResponse <List <BuildingDto> >();
try
{
_logger.LogDebug(new
{
action = nameof(GetAllBuildings)
}.ToString());
var buildings = await _context.Building.AsNoTracking().Include(building => building.Location).ToListAsync();
response.Value = buildings.Select(building => building.EntityToDto()).ToList();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// returns all departments in the database
/// </summary>
/// <returns></returns>
public async Task <AlpApiResponse <List <DepartmentDto> > > GetAllDepartments()
{
var response = new AlpApiResponse <List <DepartmentDto> >();
try
{
_logger.LogDebug(new
{
action = nameof(GetAllDepartments)
}.ToString());
var departments = await _context.Department.AsNoTracking().Include(department => department.Employee).ToListAsync();
response.Value = departments.Select(department => department.EntityToDto()).ToList();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Success = false;
response.Message = e.Message;
}
return(response);
}
/// <summary>
/// gets all non retured employees
/// </summary>
/// <returns></returns>
public async Task <AlpApiResponse <List <EmployeeDto> > > GetAvailableEmployees()
{
var response = new AlpApiResponse <List <EmployeeDto> >();
try
{
_logger.LogDebug(new
{
action = nameof(GetAllEmployees)
}.ToString());
var employees = await _context.Employee.AsNoTracking()
.Include(employee => employee.Department)
.Include(employee => employee.Section)
.Where(employee => employee.RetirementDate == null)
.ToListAsync();
response.Value = employees.Select(employee => employee.EntityToDto()).ToList();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// gets a floors without locks
/// </summary>
/// <param name="floorId"></param>
/// <returns></returns>
public async Task <AlpApiResponse <List <ItemNatureDto> > > GetAvailableItemNatures()
{
var response = new AlpApiResponse <List <ItemNatureDto> >();
try
{
_logger.LogDebug(new
{
action = nameof(GetAvailableItemNatures)
}.ToString());
var entites = await _context.ItemNature.AsNoTracking().Where(itemNature => !itemNature.Locked).ToListAsync();
response.Value = entites.Select(e => e.EntityToDto()).ToList();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// gets a floor by id
/// </summary>
/// <param name="floorId"></param>
/// <returns></returns>
public async Task <AlpApiResponse <ItemNatureDto> > GetItemNatureById(int itemNatureId)
{
var response = new AlpApiResponse <ItemNatureDto>();
try
{
_logger.LogDebug(new
{
action = nameof(GetItemNatureById),
itemNatureId
}.ToString());
var entity = await _context.ItemNature.FirstOrDefaultAsync(itemNature => itemNature.ItemNatureId == itemNatureId);
response.Value = entity.EntityToDto();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// queues the operation for later handling
/// if the user is admin, it is immediately handled
/// </summary>
/// <param name="operationList"></param>
/// <param name="sessionToken"></param>
/// <returns></returns>
public async Task <AlpApiResponse <List <ItemDto> > > QueueOperations(List <OperationDto> operationList, string sessionToken)
{
var response = new AlpApiResponse <List <ItemDto> >();
try
{
_logger.LogDebug(new
{
action = nameof(QueueOperations),
operationList = operationList?.ToString()
}.ToString());
var roleType = _accountService.GetRoleTypeFromToken(sessionToken);
response.Value = new List <ItemDto>();
foreach (var dto in operationList)
{
var entity = dto.DtoToEntity();
entity.DateOfCompletion = DateTime.Now;
await _context.Operation.AddAsync(entity);
await _context.SaveChangesAsync();
if (roleType == RoleType.Admin)
{
var result = await DoOperation(entity.OperationId);
if (!result.Success)
{
var item = await _context.Item.FirstOrDefaultAsync(i => i.ItemId == dto.ItemId);
if (item != null)
{
response.Value.Add(item.EntityToDto());
}
}
}
}
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// change items owner to departmentchief
/// </summary>
/// <param name="itemId"></param>
/// <returns></returns>
public async Task <AlpApiResponse> ChangeOwnerToDepartmentChief(int itemId)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(ChangeOwnerToDepartmentChief),
itemId
}.ToString());
var item = await _context.Item.Include(it => it.Department).FirstOrDefaultAsync(it => it.ItemId == itemId);
if (item == null)
{
response.Success = false;
response.Message = "A tárgy nem található az adatbázisban!";
return(response);
}
if (item.Department == null)
{
response.Success = false;
response.Message = "A tárgy nincs osztályhoz rendelve, így nem lehet az osztályvezetőjére terhelni!";
return(response);
}
if (!item.Department.EmployeeId.HasValue)
{
response.Success = false;
response.Message = "A választott osztálynak nincs tárolva az osztályvezetője!";
return(response);
}
item.EmployeeId = item.Department.EmployeeId;
await _context.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// Logs the account out, destroying its sessiontoken
/// </summary>
/// <param name="encryptedSessionToken"></param>
/// <returns></returns>
public async Task <AlpApiResponse> Logout(string encryptedSessionToken)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(Logout)
}.ToString());
if (string.IsNullOrEmpty(encryptedSessionToken))
{
response.Success = false;
response.Message = "Érvénytelen session Token!";
return(response);
}
var sessionData = _encryptionService.Decrypt <SessionTokenData>(encryptedSessionToken);
if (sessionData == null)
{
response.Success = false;
response.Message = "Sikertelen kijelentkezés!";
return(response);
}
var user = await _context.Account.FirstOrDefaultAsync(account => account.AccountId == sessionData.AccountId);
if (user == null)
{
response.Success = false;
response.Message = "Sikertelen kijelentkezés!";
return(response);
}
user.Token = string.Empty;
await _context.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// changes the lockstate of a building
/// </summary>
/// <param name="buildingId"></param>
/// <returns></returns>
public async Task <AlpApiResponse> ToggleBuildingLockStateById(int buildingId)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(ToggleBuildingLockStateById),
buildingId
}.ToString());
var getByIdReply = await GetBuildingById(buildingId);
if (!getByIdReply.Success)
{
response.Success = getByIdReply.Success;
response.Message = getByIdReply.Message;
return(response);
}
var building = getByIdReply.Value;
building.Locked = !building.Locked;
var updateReply = await UpdateBuilding(building);
if (!updateReply.Success)
{
response.Success = updateReply.Success;
response.Message = updateReply.Message;
return(response);
}
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// change the itemnature state of floor
/// </summary>
/// <param name="floorId"></param>
/// <returns></returns>
public async Task <AlpApiResponse> ToggleItemNatureLockStateById(int itemNatureId)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(ToggleItemNatureLockStateById),
itemNatureId
}.ToString());
var getByIdReply = await GetItemNatureById(itemNatureId);
if (!getByIdReply.Success)
{
response.Success = getByIdReply.Success;
response.Message = getByIdReply.Message;
return(response);
}
var itemNature = getByIdReply.Value;
itemNature.Locked = !itemNature.Locked;
var updateRespone = await UpdateItemNature(itemNature);
if (!updateRespone.Success)
{
response.Success = updateRespone.Success;
response.Message = updateRespone.Message;
return(response);
}
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// changes the locked state of a location
/// </summary>
/// <param name="locationId"></param>
/// <returns></returns>
public async Task <AlpApiResponse> ToggleLocationLockStateById(int locationId)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(ToggleLocationLockStateById),
locationId
}.ToString());
var getByIdResponse = await GetLocationById(locationId);
if (!getByIdResponse.Success)
{
response.Success = getByIdResponse.Success;
response.Message = getByIdResponse.Message;
return(response);
}
var location = getByIdResponse.Value;
location.Locked = !location.Locked;
var updateResponse = await UpdateLocation(location);
if (!updateResponse.Success)
{
response.Success = updateResponse.Success;
response.Message = updateResponse.Message;
return(response);
}
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// adds a new item
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <AlpApiResponse> AddNewItem(ItemDto dto)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(AddNewItem),
dto = dto?.ToString()
}.ToString());
dto.Validate();
await CheckIfDuplicateAsync(dto);
var entity = dto.DtoToEntity();
entity.Building = null;
entity.Floor = null;
entity.ItemNature = null;
entity.ItemState = null;
entity.ItemType = null;
entity.Department = null;
entity.Employee = null;
entity.Section = null;
entity.DateOfCreation = DateTime.Now;
await _context.Item.AddAsync(entity);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// change items owner to payloadid
/// </summary>
/// <param name="itemId"></param>
/// <param name="payLoadId"></param>
/// <returns></returns>
public async Task <AlpApiResponse> ChangeOwner(int itemId, int?payLoadId)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(ChangeOwnerToDepartmentChief),
itemId
}.ToString());
var item = await _context.Item.Include(it => it.Department).FirstOrDefaultAsync(it => it.ItemId == itemId);
if (item == null)
{
response.Success = false;
response.Message = "A tárgy nem található az adatbázisban!";
return(response);
}
var employee = await _context.Employee.FirstOrDefaultAsync(emp => emp.EmployeeId == payLoadId);
if (employee == null)
{
response.Success = false;
response.Message = "Az munkavállaló nem található az adatbázisban!";
return(response);
}
item.EmployeeId = employee.EmployeeId;
await _context.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// sets the retirement date of an employee to today
/// </summary>
/// <param name="employeeId"></param>
/// <returns></returns>
public async Task <AlpApiResponse> RetireEmployee(int employeeId)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(RetireEmployee),
employeeId
}.ToString());
var entity = await _context.Employee.FirstOrDefaultAsync(employee => employee.EmployeeId == employeeId);
if (entity == null)
{
response.Success = false;
response.Message = "Nem található a munkavállaló az adatbázisban";
return(response);
}
if (entity.RetirementDate != null)
{
response.Success = false;
response.Message = "Ennek a munkavállalónak már megszűnt a munkaviszonya";
return(response);
}
entity.RetirementDate = DateTime.Now;
await _context.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// changes the lockedstate of a department
/// </summary>
/// <param name="departmentId"></param>
/// <returns></returns>
public async Task <AlpApiResponse> ToggleDepartmentLockStateById(int departmentId)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(ToggleDepartmentLockStateById),
departmentId
}.ToString());
var getByIdResponse = await GetDepartmentById(departmentId);
if (!getByIdResponse.Success)
{
response.Success = getByIdResponse.Success;
response.Message = getByIdResponse.Message;
return(response);
}
var department = getByIdResponse.Value;
department.Locked = !department.Locked;
var updateResponse = await UpdateDepartment(department);
if (!updateResponse.Success)
{
response.Success = updateResponse.Success;
response.Message = updateResponse.Message;
return(response);
}
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Success = false;
response.Message = e.Message;
}
return(response);
}
/// <summary>
/// checks if the employee is in the table
/// if yes, updates it
/// if no adds it
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <AlpApiResponse> AddOrEditEmployee(EmployeeDto dto)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(AddOrEditEmployee),
dto = dto?.ToString()
}.ToString());
dto.Validate();
var oldEntity = await _context.Employee.FirstOrDefaultAsync(employee => employee.EmployeeId == dto.Id);
if (oldEntity != null)
{
oldEntity.UpdateEntityByDto(dto);
await _context.SaveChangesAsync();
}
else
{
var entity = dto.DtoToEntity();
entity.Department = null;
entity.Section = null;
await _context.Employee.AddAsync(entity);
await _context.SaveChangesAsync();
}
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
public async Task <AlpApiResponse <ItemTypeDto> > InsertNewItemType(ItemTypeDto dto)
{
var response = new AlpApiResponse <ItemTypeDto>();
try
{
_logger.LogDebug(new
{
action = nameof(InsertNewItemType),
dto = dto?.ToString()
}.ToString());
dto.Validate();
var itemNature = await _context.ItemNature.FirstOrDefaultAsync(itemN => itemN.ItemNatureId == dto.ItemNatureId);
if (itemNature == null)
{
throw new Exception("A típushoz tartozó eszköz jelleget kötelező megadni!");
}
var entity = dto.DtoToEntity();
entity.ItemNature = null;
await _context.ItemType.AddAsync(entity);
await _context.SaveChangesAsync();
response.Value = entity.EntityToDto();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// returns the filtered employees depending onthe filterinfo
/// </summary>
/// <param name="filterInfo"></param>
/// <returns></returns>
public async Task <AlpApiResponse <List <EmployeeDto> > > FilterEmployees(EmployeeFilterInfo filterInfo)
{
var response = new AlpApiResponse <List <EmployeeDto> >();
try
{
_logger.LogDebug(new
{
action = nameof(FilterEmployees),
info = filterInfo?.ToString()
}.ToString());
var nameIsNull = string.IsNullOrEmpty(filterInfo.Name);
var employees = await _context.Employee.AsNoTracking()
.Include(employee => employee.Department)
.Include(employee => employee.Section)
.Where(employee => (nameIsNull || employee.EmployeeName.Contains(filterInfo.Name)) &&
(!filterInfo.DepartmentId.HasValue || employee.DepartmentId == filterInfo.DepartmentId) &&
(!filterInfo.SectionId.HasValue || employee.SectionId == filterInfo.SectionId))
.ToListAsync();
response.Value = employees.Select(employee => employee.EntityToDto()).ToList();
foreach (var dto in response.Value)
{
dto.HasAccess = await _context.Account.AsNoTracking().AnyAsync(acc => acc.EmployeeId == dto.Id);
}
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// gets all the items an employee has
/// </summary>
/// <param name="employeeId"></param>
/// <returns></returns>
public async Task <AlpApiResponse <List <ItemDto> > > GetItemsByEmployeeId(int employeeId)
{
var response = new AlpApiResponse <List <ItemDto> >();
try
{
_logger.LogDebug(new
{
action = nameof(GetItemsByEmployeeId),
employeeId
}.ToString());
var items = await _context.Item.AsNoTracking()
.Include(item => item.Department)
.Include(item => item.Employee)
.Include(item => item.Building)
.Include(item => item.Section)
.Include(item => item.Floor)
.Include(item => item.ItemNature)
.Include(item => item.ItemState)
.Include(item => item.ItemType)
.Where(item => item.EmployeeId == employeeId).ToListAsync();
var dtoList = items.Select(item => item.EntityToDto()).ToList();
response.Value = dtoList;
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// set items dateofscrap to now
/// </summary>
/// <param name="itemId"></param>
/// <returns></returns>
public async Task <AlpApiResponse> Scrap(int itemId)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(ChangeOwnerToDepartmentChief),
itemId
}.ToString());
var item = await _context.Item.Include(it => it.Department).FirstOrDefaultAsync(it => it.ItemId == itemId);
if (item == null)
{
response.Success = false;
response.Message = "A tárgy nem található az adatbázisban!";
return(response);
}
item.DateOfScrap = DateTime.Now;
item.ItemStateId = 2;
await _context.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// updates itemstate by dto
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <AlpApiResponse> UpdateItemState(ItemStateDto dto)
{
var response = new AlpApiResponse();
try
{
_logger.LogDebug(new
{
action = nameof(UpdateItemState),
dto = dto?.ToString()
}.ToString());
dto.Validate();
if (dto.Id == 1 || dto.Id == 2 || dto.Id == 3)
{
response.Success = false;
response.Message = "Ennek a státusznak az adatai nem változtathatóak!";
return(response);
}
var updatedEntity = await _context.ItemState.FirstOrDefaultAsync(itemState => itemState.ItemStateId == dto.Id);
updatedEntity.UpdateEntityByDto(dto);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// gets an item by id
/// </summary>
/// <param name="itemId"></param>
/// <returns></returns>
public async Task <AlpApiResponse <ItemDto> > GetItemById(int itemId)
{
var response = new AlpApiResponse <ItemDto>();
try
{
_logger.LogDebug(new
{
action = nameof(GetItemById),
itemId
}.ToString());
var entity = await _context.Item.FirstAsync(item => item.ItemId == itemId);
if (entity == null)
{
response.Success = false;
response.Message = "Ez a leltárelem nincs benne az adatbázisban!";
return(response);
}
response.Value = entity.EntityToDto();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// adds a new section to the database
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <AlpApiResponse <SectionDto> > InsertNewSection(SectionDto dto)
{
var response = new AlpApiResponse <SectionDto>();
try
{
_logger.LogDebug(new
{
action = nameof(InsertNewSection),
dto = dto?.ToString()
}.ToString());
dto.Validate();
var entity = dto.DtoToEntity();
entity.Floor = null;
entity.Department = null;
await _context.Section.AddAsync(entity);
await _context.SaveChangesAsync();
response.Value = entity.EntityToDto();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
/// <summary>
/// gets an employee by name
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public async Task <AlpApiResponse <List <EmployeeDto> > > GetByName(string name)
{
var response = new AlpApiResponse <List <EmployeeDto> >();
try
{
_logger.LogDebug(new
{
action = nameof(GetByName),
name
}.ToString());
if (string.IsNullOrEmpty(name))
{
return(null);
}
name = name.ToLower();
var entities = await _context.Employee.Where(employee => employee.EmployeeName.ToLower().Equals(name)).ToListAsync();
response.Value = entities.Select(entity => entity.EntityToDto()).ToList();
}
catch (Exception e)
{
_logger.LogError(new
{
exception = e,
message = e.Message,
innerException = e,
innerExceptionMessage = e.InnerException?.Message
}.ToString());
response.Message = e.Message;
response.Success = false;
}
return(response);
}
