WorkFlowCheck/src/WorkFlowCheck.MAUI/Services/CheckListService.cs

using AutoMapper;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using System.Diagnostics;
using System.Net.Http.Json;
using System.Runtime.CompilerServices;
using WorkFlowCheck.Common.DTO;
using WorkFlowCheck.Common.Enums;
using WorkFlowCheck.MAUI.DataLayer;
using WorkFlowCheck.MAUI.Services.Interfaces;

namespace WorkFlowCheck.MAUI.Services
{
    public class CheckListService : BaseService, ICheckListService
    {
        private readonly IUserService _userService;
        private readonly ISyncService _syncService;
        public CheckListService(HttpClient httpClient,
                                IConfiguration configuration,
                                AppDbContext dbContext,
                                IMapper mapper,
                                IUserService userService,
                                ISyncService syncService) : base(httpClient, dbContext, mapper)
        {
            _userService = userService;
            _syncService = syncService;
        }

        public async Task<ApiResponseDTO<CheckPointDTO>> GetCheckPoint(int checkPointId)
        {
            var retVal = new ApiResponseDTO<CheckPointDTO>() { IsSuccess = true };
            try
            {
                var res = await _dbContext.CheckPoints.Include(i => i.CheckListTemplateRows).Where(w => w.Id == checkPointId).FirstOrDefaultAsync();
                retVal.Data = _mapper.Map<CheckPointDTO>(res);
            }
            catch (Exception ex)
            {
                retVal.IsSuccess = false;
                retVal.Errors.Add(ex.Message);
            }
            return retVal;
        }
        public async Task<ApiResponseDTO<CheckPointDTO>> GetCheckPoint(string checkPointCode)
        {
            var retVal = new ApiResponseDTO<CheckPointDTO>() { IsSuccess = true };
            try
            {
                var res = await _dbContext.CheckPoints.Include(i => i.CheckListTemplateRows).Where(w => w.Code == checkPointCode).FirstOrDefaultAsync();
                retVal.Data = _mapper.Map<CheckPointDTO>(res);
            }
            catch (Exception ex)
            {
                retVal.IsSuccess = false;
                retVal.Errors.Add(ex.Message);
            }
            return retVal;
        }

        public async Task<ApiResponseDTO<CheckListHeaderDTO>> StartNew(CheckListHeaderNewDTO checkListHeaderNewDTO)
        {
            try
            {
                await PrepareAuthenticatedRequestAsync();
                // Az API végpont meghatározása
                string endpoint = $"{_httpClient.BaseAddress}api/checklist/StartNewCheckList";

                using (HttpResponseMessage httpResponseMessage = await _httpClient.PostAsJsonAsync(endpoint, checkListHeaderNewDTO))
                {
                    httpResponseMessage.EnsureSuccessStatusCode();

                    var jsonString = await httpResponseMessage.Content.ReadAsStringAsync();
                    var response = JsonConvert.DeserializeObject<ApiResponseDTO<CheckListHeaderDTO>>(jsonString);

                    return response ?? new ApiResponseDTO<CheckListHeaderDTO>
                    {
                        IsSuccess = false,
                    };
                }
            }
            catch (Exception ex)
            {
                // Hiba visszaadása
                return new ApiResponseDTO<CheckListHeaderDTO>
                {
                    IsSuccess = false
                };
            }
        }

        public async Task<List<CheckListHeaderDTO>> GetCheckLists(int userId)
        {
            //await _syncService.SyncDatas();

            var retVal = new List<CheckListHeaderDTO>();
            try
            {
                var res = await _dbContext.CheckListHeaders
                                           .Include(i => i.CheckListTemplateHeader)
                                           .Where(w => w.CheckStatus == CheckStatus.Open ||
                                                     w.CheckStatus == CheckStatus.InProgress ||
                                                     w.CheckStatus == CheckStatus.Blocked ||
                                                     w.CheckStatus == CheckStatus.Sent)
                                           .ToListAsync();
                retVal = _mapper.Map<List<CheckListHeaderDTO>>(res);
            }
            catch (Exception ex)
            {

            }
            return retVal;
        }

        public async Task<List<CheckListTemplateHeaderDTO>> GetCheckListTemplates(int userId)
        {
            //await _syncService.SyncDatas();

            var retVal = new List<CheckListTemplateHeaderDTO>();
            try
            {
                var res = await _dbContext.CheckListTemplateHeaders
                                          .ToListAsync();
                retVal = _mapper.Map<List<CheckListTemplateHeaderDTO>>(res);
            }
            catch (Exception ex)
            {

            }
            return retVal;
        }

        public async Task<List<CheckListRowDTO>> GetCheckListRowsByCheckPointCode(int userId, int checkListHeaderId, string checkPointCode)
        {
            var retVal = new List<CheckListRowDTO>();

            try
            {
                var checkListRows = await _dbContext.CheckListRows
                                            .Include(i => i.CheckListTemplateRow)
                                            .ThenInclude(i => i.CheckPoint)
                                            .Include(i => i.CheckListHeader)
                                            .Where(w => w.CheckListTemplateRow.CheckPoint.Code == checkPointCode &&
                                                        w.CheckListHeader.UserId == userId &&
                                                        w.CheckListHeaderId == checkListHeaderId)
                                            .AsNoTracking()
                                            .ToListAsync();
                retVal = _mapper.Map<List<CheckListRowDTO>>(checkListRows);
            }
            catch (Exception ex)
            {


            }


            return retVal;
        }

        public async Task<CheckListRowDTO> UpdateCheckListRow(CheckListRowDTO checkListRowDTO, bool withPhoto = true)
        {
            var retVal = checkListRowDTO;
            try
            {
                var checkListRow = await _dbContext.CheckListRows
                                                    //.AsNoTracking() 
                                                    .Where(w => w.Id == checkListRowDTO.Id).FirstOrDefaultAsync();
                if (checkListRow != null)
                {
                    if (checkListRow.Answer != checkListRowDTO.Answer)
                    {
                        checkListRow.Answer = checkListRowDTO.Answer;
                    }

                    if (checkListRowDTO.Photo != null && checkListRowDTO.Photo.Length > 0 && withPhoto)
                    {
                        if (!checkListRow.Photo.SequenceEqual(checkListRowDTO.Photo ?? Array.Empty<byte>()))
                        {
                            checkListRow.Photo = checkListRowDTO.Photo ?? Array.Empty<byte>();
                        }
                    }
                    await _dbContext.SaveChangesAsync();
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
            return retVal;
        }

        public async Task<bool> UnBlockCheckListHeader(CheckListHeaderDTO checkListHeaderDTO)
        {
            var retVal = false;
            try
            {
                var checkListHeader = await _dbContext.CheckListHeaders
                                                    .Where(w => w.Id == checkListHeaderDTO.Id)
                                                    .FirstOrDefaultAsync();
                if (checkListHeader != null)
                {
                    var userDTO = _userService.GetCurrentUser();
                    var endpoint = $"{_httpClient.BaseAddress}api/CheckList/UnBlockCheckListHeader/{checkListHeaderDTO.Id}/{userDTO.Id}";
                    var response = await _httpClient.GetFromJsonAsync<ApiResponseDTO<bool>>(endpoint);
                    if (response != null)
                    {
                        if (response.IsSuccess)
                        {
                            checkListHeader.CheckStatus = CheckStatus.InProgress;
                            await _dbContext.SaveChangesAsync();
                            retVal = true;
                        }
                    }
                }
            }
            catch (Exception ex)
            {


            }
            return retVal;
        }
        public async Task<bool> BlockCheckListHeader(CheckListHeaderDTO checkListHeaderDTO)
        {
            var retVal = false;
            try
            {
                var checkListHeader = await _dbContext.CheckListHeaders
                                                    .Where(w => w.Id == checkListHeaderDTO.Id)
                                                    .FirstOrDefaultAsync();
                if (checkListHeader != null)
                {
                    var userDTO = _userService.GetCurrentUser();
                    var endpoint = $"{_httpClient.BaseAddress}api/CheckList/BlockCheckListHeader/{checkListHeaderDTO.Id}/{userDTO.Id}";
                    var response = await _httpClient.GetFromJsonAsync<ApiResponseDTO<bool>>(endpoint);
                    if (response != null)
                    {
                        if (response.IsSuccess)
                        {
                            checkListHeader.CheckStatus = CheckStatus.Blocked;
                            await _dbContext.SaveChangesAsync();
                            retVal = true;
                        }
                    }
                }
            }
            catch (Exception ex)
            {


            }
            return retVal;
        }
        public async Task<bool> CloseCheckListHeader(CheckListHeaderCloseDTO checkListHeaderCloseDTO)
        {
            var retVal = false;
            try
            {
                var checkListHeader = await _dbContext.CheckListHeaders
                                                    .Where(w => w.Id == checkListHeaderCloseDTO.Id)
                                                    .FirstOrDefaultAsync();
                if (checkListHeader != null)
                {
                    var userDTO = _userService.GetCurrentUser();
                    var endpoint = $"{_httpClient.BaseAddress}api/CheckList/CloseCheckListHeader";
                    using (HttpResponseMessage httpResponseMessage = await _httpClient.PostAsJsonAsync(endpoint, checkListHeaderCloseDTO))
                    {
                        httpResponseMessage.EnsureSuccessStatusCode();

                        var jsonString = await httpResponseMessage.Content.ReadAsStringAsync();
                        var response = JsonConvert.DeserializeObject<ApiResponseDTO<bool>>(jsonString);
                        if (response != null)
                        {
                            if (response.IsSuccess)
                            {
                                checkListHeader.CheckStatus = CheckStatus.Closed;
                                await _dbContext.SaveChangesAsync();
                                retVal = true;
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                retVal = false;
            }
            return retVal;
        }
        public async Task<bool> AcceptCheckListHeader(CheckListHeaderDTO checkListHeaderDTO)
        {
            var retVal = false;
            try
            {
                var checkListHeader = await _dbContext.CheckListHeaders
                                                    .Where(w => w.Id == checkListHeaderDTO.Id)
                                                    .FirstOrDefaultAsync();
                if (checkListHeader != null)
                {
                    var userDTO = _userService.GetCurrentUser();
                    var endpoint = $"{_httpClient.BaseAddress}api/CheckList/AcceptCheckListHeader/{checkListHeaderDTO.Id}/{userDTO.Id}";
                    var response = await _httpClient.GetFromJsonAsync<ApiResponseDTO<bool>>(endpoint);
                    if (response != null)
                    {
                        if (response.IsSuccess)
                        {
                            checkListHeader.CheckStatus = CheckStatus.Signed;
                            await _dbContext.SaveChangesAsync();
                            retVal = true;
                        }
                    }
                }
            }
            catch (Exception ex)
            {


            }
            return retVal;
        }

        public async Task<CheckPointDTO> GetNextCheckpointNotSend(CheckListHeaderDTO checkListHeaderDTO)
        {
            var retVal = new CheckPointDTO();
            try
            {
                var firstUnansweredCheckPoint = await _dbContext.CheckListRows
                                                                .Include(i => i.CheckListTemplateRow)
                                                                    .ThenInclude(i => i.CheckPoint)
                                                                .Where(w => w.CheckListHeaderId == checkListHeaderDTO.Id
                                                                         && string.IsNullOrEmpty(w.Answer.Trim())
                                                                         && w.CheckListTemplateRow.AnswerType != "PN")
                                                                .Select(w => w.CheckListTemplateRow.CheckPoint)
                                                                .OrderBy(cp => cp.ShortName)
                                                                .FirstOrDefaultAsync();

                if (firstUnansweredCheckPoint != null)
                {
                    retVal = _mapper.Map<CheckPointDTO>(firstUnansweredCheckPoint);
                }
            }
            catch (Exception ex)
            {


            }
            return retVal;
        }
    }
}