600 lines
23 KiB
C#
600 lines
23 KiB
C#
|
|
using AutoMapper;
|
|
using DocumentFormat.OpenXml.InkML;
|
|
using DocumentFormat.OpenXml.Office2010.Excel;
|
|
using DocumentFormat.OpenXml.Spreadsheet;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Serilog;
|
|
using System.Collections.Generic;
|
|
using WorkFlowCheck.BL.Services.Interfaces;
|
|
using WorkFlowCheck.Common.DTO;
|
|
using WorkFlowCheck.Common.Enums;
|
|
using WorkFlowCheck.Common.RequestContext;
|
|
using WorkFlowCheck.DL;
|
|
using WorkFlowCheck.DL.Entities;
|
|
|
|
namespace WorkFlowCheck.BL.Services
|
|
{
|
|
public class SyncService : BaseService, ISyncService
|
|
{
|
|
private readonly IRequestContext _requestContext;
|
|
private readonly IUserService _userService;
|
|
private readonly IMessageService _messageService;
|
|
|
|
public SyncService(AppDbContext dbContext,
|
|
IMapper mapper,
|
|
IRequestContext requestContext,
|
|
IMessageService messageService,
|
|
IUserService userService) : base(dbContext, mapper)
|
|
{
|
|
_requestContext = requestContext;
|
|
_userService = userService;
|
|
_messageService = messageService;
|
|
}
|
|
|
|
public async Task<List<CheckPointDTO>> GetAllCheckPointAsync()
|
|
{
|
|
var retVal = new List<CheckPointDTO>();
|
|
|
|
try
|
|
{
|
|
var res = await _dbContext.CheckPoints
|
|
.Include(i => i.CheckListTemplateRows)
|
|
.AsNoTracking()
|
|
.ToListAsync();
|
|
if (res != null)
|
|
{
|
|
retVal = _mapper.Map<List<CheckPointDTO>>(res);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
public async Task<CheckPointDTO> GetCheckPointAsync(int id)
|
|
{
|
|
var retVal = new CheckPointDTO();
|
|
|
|
try
|
|
{
|
|
var checkpoint = await _dbContext.CheckPoints
|
|
.Include(i => i.CheckListTemplateRows)
|
|
.Where(w => w.Id == id)
|
|
.AsNoTracking()
|
|
.FirstOrDefaultAsync();
|
|
if (checkpoint != null)
|
|
{
|
|
retVal = _mapper.Map<CheckPointDTO>(checkpoint);
|
|
|
|
var role = await _dbContext.Roles.Where(w => w.Id == retVal.RoleId).FirstOrDefaultAsync();
|
|
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
public async Task<bool> DeleteCheckPointAsync(int id)
|
|
{
|
|
return await DeleteEntityByIdAsync<CheckPoint>(id);
|
|
}
|
|
public async Task<CheckPointDTO> UpdateCheckPointAsync(CheckPointDTO checkPointDTO)
|
|
{
|
|
var retVal = new CheckPointDTO();
|
|
|
|
try
|
|
{
|
|
if (checkPointDTO.Id == 0) //Hozzáadás, ha Id == 0
|
|
{
|
|
var checkPoint = _mapper.Map<CheckPoint>(checkPointDTO);
|
|
_dbContext.CheckPoints.Add(checkPoint);
|
|
await _dbContext.SaveChangesAsync();
|
|
|
|
retVal = _mapper.Map<CheckPointDTO>(checkPoint);
|
|
}
|
|
else
|
|
{
|
|
var res = await _dbContext.CheckPoints.Where(w => w.Id == checkPointDTO.Id).FirstOrDefaultAsync();
|
|
if (res != null)
|
|
{
|
|
res.ShortName = checkPointDTO.ShortName;
|
|
res.Code = checkPointDTO.Code;
|
|
res.IsEnabled = checkPointDTO.IsEnabled;
|
|
|
|
await _dbContext.SaveChangesAsync();
|
|
|
|
retVal = _mapper.Map<CheckPointDTO>(res);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
public async Task<List<CheckPointDTO>> UpdateAllCheckPointAsync(List<CheckPointDTO> checkPointListDTO)
|
|
{
|
|
var retVal = new List<CheckPointDTO>();
|
|
try
|
|
{
|
|
var ids = checkPointListDTO.Select(dto => dto.Id).ToList();
|
|
var checkPoints = await _dbContext.CheckPoints
|
|
.Where(cp => ids.Contains(cp.Id))
|
|
.ToListAsync();
|
|
|
|
foreach (var checkPoint in checkPoints)
|
|
{
|
|
var dto = checkPointListDTO.FirstOrDefault(d => d.Id == checkPoint.Id);
|
|
if (dto != null)
|
|
{
|
|
checkPoint.Code = dto.Code;
|
|
}
|
|
}
|
|
await _dbContext.SaveChangesAsync();
|
|
retVal = _mapper.Map<List<CheckPointDTO>>(checkPoints);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
public async Task<List<LocationDTO>> GetAllLocationAsync()
|
|
{
|
|
var retVal = new List<LocationDTO>();
|
|
|
|
try
|
|
{
|
|
var res = await _dbContext.Locations.ToListAsync();
|
|
if (res != null)
|
|
{
|
|
retVal = _mapper.Map<List<LocationDTO>>(res);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
public async Task<LocationDTO> GetLocationAsync(int id)
|
|
{
|
|
var retVal = new LocationDTO();
|
|
|
|
try
|
|
{
|
|
var res = await _dbContext.Locations
|
|
.Where(w => w.Id == id)
|
|
.AsNoTracking()
|
|
.FirstOrDefaultAsync();
|
|
if (res != null)
|
|
{
|
|
retVal = _mapper.Map<LocationDTO>(res);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
public async Task<bool> DeleteLocationAsync(int id)
|
|
{
|
|
return await DeleteEntityByIdAsync<DL.Entities.Location>(id);
|
|
}
|
|
public async Task<LocationDTO> UpdateLocationAsync(LocationDTO LocationDTO)
|
|
{
|
|
var retVal = new LocationDTO();
|
|
|
|
try
|
|
{
|
|
if (LocationDTO.Id == 0) //Hozzáadás, ha Id == 0
|
|
{
|
|
var Location = _mapper.Map<DL.Entities.Location>(LocationDTO);
|
|
_dbContext.Locations.Add(Location);
|
|
await _dbContext.SaveChangesAsync();
|
|
|
|
retVal = _mapper.Map<LocationDTO>(Location);
|
|
}
|
|
else
|
|
{
|
|
var res = await _dbContext.Locations.Where(w => w.Id == LocationDTO.Id).FirstOrDefaultAsync();
|
|
if (res != null)
|
|
{
|
|
res.FullName = LocationDTO.FullName;
|
|
await _dbContext.SaveChangesAsync();
|
|
|
|
retVal = _mapper.Map<LocationDTO>(res);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
public async Task<List<EquipmentDTO>> GetAllEquipmentAsync()
|
|
{
|
|
var retVal = new List<EquipmentDTO>();
|
|
|
|
try
|
|
{
|
|
var res = await _dbContext.Equipments.ToListAsync();
|
|
if (res != null)
|
|
{
|
|
retVal = _mapper.Map<List<EquipmentDTO>>(res);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
public async Task<EquipmentDTO> GetEquipmentAsync(int id)
|
|
{
|
|
var retVal = new EquipmentDTO();
|
|
|
|
try
|
|
{
|
|
var res = await _dbContext.Equipments
|
|
.Where(w => w.Id == id)
|
|
.AsNoTracking()
|
|
.FirstOrDefaultAsync();
|
|
if (res != null)
|
|
{
|
|
retVal = _mapper.Map<EquipmentDTO>(res);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
public async Task<bool> DeleteEquipmentAsync(int id)
|
|
{
|
|
return await DeleteEntityByIdAsync<Equipment>(id);
|
|
}
|
|
public async Task<EquipmentDTO> UpdateEquipmentAsync(EquipmentDTO EquipmentDTO)
|
|
{
|
|
var retVal = new EquipmentDTO();
|
|
|
|
try
|
|
{
|
|
if (EquipmentDTO.Id == 0) //Hozzáadás, ha Id == 0
|
|
{
|
|
var Equipment = _mapper.Map<Equipment>(EquipmentDTO);
|
|
_dbContext.Equipments.Add(Equipment);
|
|
await _dbContext.SaveChangesAsync();
|
|
|
|
retVal = _mapper.Map<EquipmentDTO>(Equipment);
|
|
}
|
|
else
|
|
{
|
|
var res = await _dbContext.Equipments.Where(w => w.Id == EquipmentDTO.Id).FirstOrDefaultAsync();
|
|
if (res != null)
|
|
{
|
|
res.ShortName = EquipmentDTO.ShortName;
|
|
res.EquipmentNumber = EquipmentDTO.EquipmentNumber;
|
|
|
|
await _dbContext.SaveChangesAsync();
|
|
|
|
retVal = _mapper.Map<EquipmentDTO>(res);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
public async Task<List<CheckListTemplateHeaderDTO>> GetAllCheckListTemplateAsync(int userId)
|
|
{
|
|
var retVal = new List<CheckListTemplateHeaderDTO>();
|
|
|
|
try
|
|
{
|
|
var user = _dbContext.Users.Where(w => w.Id == userId).FirstOrDefault();
|
|
if (user != null)
|
|
{
|
|
var res = await (from ur in _dbContext.UserRoles
|
|
join rth in _dbContext.RoleCheckListTemplateHeaders on ur.RoleId equals rth.RoleId
|
|
join header in _dbContext.CheckListTemplateHeaders on rth.CheckListTemplateHeaderId equals header.Id
|
|
where ur.UserId == userId
|
|
select header)
|
|
.Include(h => h.CheckListTemplateRows)
|
|
.Distinct()
|
|
.AsNoTracking()
|
|
.ToListAsync();
|
|
|
|
if (res != null)
|
|
{
|
|
retVal = _mapper.Map<List<CheckListTemplateHeaderDTO>>(res);
|
|
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
public async Task<List<CheckListHeaderDTO>> GetAllCheckListAsync(int userId)
|
|
{
|
|
var retVal = new List<CheckListHeaderDTO>();
|
|
|
|
try
|
|
{
|
|
var res = await _dbContext.CheckListHeaders
|
|
.Where(w => w.CheckStatus == CheckStatus.Open ||
|
|
w.CheckStatus == CheckStatus.InProgress ||
|
|
w.CheckStatus == CheckStatus.Blocked ||
|
|
w.CheckStatus == CheckStatus.Sent)
|
|
.Include(i => i.CheckListRows)
|
|
//.ThenInclude(i => i.CheckListTemplateRow)
|
|
.AsNoTracking()
|
|
.ToListAsync();
|
|
|
|
if (res != null)
|
|
{
|
|
retVal = _mapper.Map<List<CheckListHeaderDTO>>(res);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
public async Task<CheckListHeaderDTO> SendCheckListHeaderAsync(CheckListHeaderDTO checkListHeaderDTO)
|
|
{
|
|
var retVal = new CheckListHeaderDTO();
|
|
|
|
try
|
|
{
|
|
if (checkListHeaderDTO.Id > 0)
|
|
{
|
|
var res = await _dbContext.CheckListHeaders
|
|
.Include(i => i.CheckListRows)
|
|
.Where(w => w.Id == checkListHeaderDTO.Id)
|
|
.FirstOrDefaultAsync();
|
|
if (res != null && (res.CheckStatus == CheckStatus.Open ||
|
|
res.CheckStatus == CheckStatus.InProgress))
|
|
{
|
|
var ids = checkListHeaderDTO.CheckListRowDTO?.Select(r => r.Id).ToList();
|
|
if (ids != null && ids.Count > 0)
|
|
{
|
|
var rowsToUpdate = await _dbContext.CheckListRows
|
|
.Where(r => ids.Contains(r.Id))
|
|
.ToListAsync();
|
|
foreach (var row in rowsToUpdate)
|
|
{
|
|
var dtoRow = checkListHeaderDTO.CheckListRowDTO?.FirstOrDefault(r => r.Id == row.Id);
|
|
if (dtoRow != null)
|
|
{
|
|
row.Answer = dtoRow.Answer;
|
|
if (dtoRow.Photo != null && dtoRow.Photo.Length > 0)
|
|
{
|
|
|
|
string imageDirectory = Path.Combine(Directory.GetCurrentDirectory(), "Images");
|
|
var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
|
|
var fileName = $"PH_{timestamp}_{row.CheckListHeaderId}_{row.Id}.jpeg";
|
|
row.PhotoFileName = fileName;
|
|
var filePath = Path.Combine(imageDirectory, fileName);
|
|
await File.WriteAllBytesAsync(filePath, dtoRow.Photo);
|
|
row.Answer = fileName;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
await _dbContext.SaveChangesAsync();
|
|
retVal = _mapper.Map<CheckListHeaderDTO>(res);
|
|
string Answer = "";
|
|
if (NeedBlocking(checkListHeaderDTO, out Answer))
|
|
{
|
|
/// TODO: blokkolás miatt
|
|
res.CheckStatus = CheckStatus.Blocked;
|
|
await _dbContext.SaveChangesAsync();
|
|
|
|
Log.ForContext("TAG", "BusinessFlow").Warning($"Ellenőrzési lap blokkolva: Ellenőrzés:{checkListHeaderDTO.Id}, Felhasználó:{_requestContext.CurrentUsername}");
|
|
|
|
var user = await _userService.GetUserAsync(_requestContext.CurrentUserId ?? 1);
|
|
|
|
foreach (var item in user.RoleDTO)
|
|
{
|
|
var deviceMessageDTO = new DeviceMessageDTO()
|
|
{
|
|
IsReaded = false,
|
|
Message = $"Ellenőrző lap blokkolva! [{checkListHeaderDTO.DocumentNumber}]\n({Answer})",
|
|
SendDate = DateTime.UtcNow,
|
|
ExtraDataJSON = "",
|
|
RoleId = item.ParentId,
|
|
DeviceIdFrom = "",
|
|
DeviceIdTo = "",
|
|
};
|
|
|
|
await this.DeviceMessageSend(deviceMessageDTO);
|
|
|
|
var fCMMessageDTO = new FCMMessageDTO
|
|
{
|
|
Body = deviceMessageDTO.Message,
|
|
Title = "Blokkolási értesítés",
|
|
UserId = user.Id,
|
|
};
|
|
await _messageService.SendFCMMessageToLastToken(fCMMessageDTO);
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
res.CheckStatus = CheckStatus.InProgress;
|
|
|
|
if (CheckIfLastReached(checkListHeaderDTO))
|
|
{
|
|
/// TODO: most kell a CheckStatust állítani és menjen üzenet !
|
|
res.CheckStatus = CheckStatus.Sent;
|
|
Log.ForContext("TAG", "BusinessFlow").Warning($"Ellenőrzési lap státuszváltozása: Ellenőrzés:{checkListHeaderDTO.Id}, Felhasználó:{_requestContext.CurrentUsername}");
|
|
|
|
}
|
|
|
|
await _dbContext.SaveChangesAsync();
|
|
|
|
|
|
retVal = _mapper.Map<CheckListHeaderDTO>(res);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
private bool NeedBlocking(CheckListHeaderDTO checkListHeaderDTO, out string Answer)
|
|
{
|
|
var retVal = false;
|
|
Answer = "";
|
|
if (checkListHeaderDTO.CheckListRowDTO != null && checkListHeaderDTO.CheckListRowDTO.Count > 0)
|
|
{
|
|
var checkListRows = checkListHeaderDTO.CheckListRowDTO;
|
|
foreach (var row in checkListRows)
|
|
{
|
|
if (!string.IsNullOrEmpty(row.Answer))
|
|
{
|
|
if (row.CheckListTemplateRowDTO != null)
|
|
{
|
|
Answer = row.CheckListTemplateRowDTO.OperationDescription;
|
|
if (row.CheckListTemplateRowDTO.AnswerType == "PI-N" && row.Answer == "Igen")
|
|
{
|
|
retVal = true;
|
|
break;
|
|
}
|
|
if (row.CheckListTemplateRowDTO.AnswerType == "I-PN" && row.Answer == "Nem")
|
|
{
|
|
retVal = true;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
private bool CheckIfLastReached(CheckListHeaderDTO checkListHeaderDTO)
|
|
{
|
|
var retVal = false;
|
|
|
|
if (checkListHeaderDTO != null && checkListHeaderDTO.CheckListRowDTO != null && checkListHeaderDTO.CheckListRowDTO.Count > 0)
|
|
{
|
|
var totalRowCount = checkListHeaderDTO.CheckListRowDTO.Where(w => w.CheckListTemplateRowDTO.AnswerType != "PN" &&
|
|
w.CheckListTemplateRowDTO.CheckPointDTO.IsEnabled == true).Count();
|
|
|
|
var answeredCount = checkListHeaderDTO.CheckListRowDTO.Where(w => w.CheckListTemplateRowDTO.AnswerType != "PN" &&
|
|
w.CheckListTemplateRowDTO.CheckPointDTO.IsEnabled == true &&
|
|
string.IsNullOrEmpty(w.Answer) != true).Count();
|
|
|
|
if (totalRowCount == answeredCount) { retVal = true; }
|
|
}
|
|
|
|
|
|
return retVal;
|
|
}
|
|
public async Task<bool> DeviceMessageSend(DeviceMessageDTO deviceMessageDTO)
|
|
{
|
|
var retVal = false;
|
|
try
|
|
{
|
|
var deviceMessage = _mapper.Map<DeviceMessage>(deviceMessageDTO);
|
|
deviceMessage.SendDate = DateTime.UtcNow;
|
|
deviceMessage.IsReaded = false;
|
|
_dbContext.DeviceMessages.Add(deviceMessage);
|
|
await _dbContext.SaveChangesAsync(true);
|
|
retVal = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
return retVal;
|
|
}
|
|
public async Task<List<DeviceMessageDTO>> DeviceMessageReadUnreaded(string deviceId)
|
|
{
|
|
var retVal = new List<DeviceMessageDTO>();
|
|
try
|
|
{
|
|
var res = await _dbContext.DeviceMessages
|
|
.Where(w => w.DeviceIdTo == deviceId && w.IsReaded != true)
|
|
.ToListAsync();
|
|
|
|
if (res != null)
|
|
{
|
|
retVal = _mapper.Map<List<DeviceMessageDTO>>(res);
|
|
foreach (var deviceMessage in res)
|
|
{
|
|
deviceMessage.IsReaded = true;
|
|
deviceMessage.ReceiveDate = DateTime.UtcNow;
|
|
}
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
return retVal;
|
|
}
|
|
public async Task<List<DeviceMessageDTO>> DeviceMessageReadUnreadedRole(int roleId)
|
|
{
|
|
var retVal = new List<DeviceMessageDTO>();
|
|
try
|
|
{
|
|
var res = await _dbContext.DeviceMessages
|
|
.Where(w => w.RoleId == roleId && w.IsReaded != true)
|
|
.ToListAsync();
|
|
|
|
if (res != null)
|
|
{
|
|
retVal = _mapper.Map<List<DeviceMessageDTO>>(res);
|
|
foreach (var deviceMessage in res)
|
|
{
|
|
deviceMessage.IsReaded = true;
|
|
deviceMessage.ReceiveDate = DateTime.UtcNow;
|
|
}
|
|
await _dbContext.SaveChangesAsync();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex.Message);
|
|
}
|
|
return retVal;
|
|
}
|
|
}
|
|
}
|