Merge branch 'feature/2183_interviewer_selection_methods' of Neca/HRCenter into BE_dev

Diligent.WebAPI.Business/Services/Interfaces/ISelectionProcessService.cs

         Task<bool> FinishSelectionProcess(SelectionProcessCreateDto model);
         Task<List<SelectionLevelInfoDto>> GetCountByLevels(List<string> statuses);
         Task UpdateSelectionProcessStatusAsync(int id, SelectionProcessUpdateStatusDto selectionProcessUpdateStatusDto);
+        Task StatusUpdate(StatusChangeDTO model);
     }
 }

Diligent.WebAPI.Business/Services/SelectionLevelService.cs

             var fromDb = await _context.SelectionLevels
                 .Include(sl => sl.SelectionProcesses)
                 .ThenInclude(sp => sp.Applicant)
+                .Include(sl => sl.SelectionProcesses)
+                .ThenInclude(sp => sp.Scheduler)
                 .ToListAsync();
 
             _logger.LogInformation($"Received {fromDb.Count} levels from db.");

Diligent.WebAPI.Business/Services/SelectionProcessService.cs

     {
         private readonly DatabaseContext _context;
         private readonly IMapper _mapper;
+        private readonly UserManager<User> _userManager;
         private readonly ILogger<SelectionProcessService> _logger;
 
-        public SelectionProcessService(DatabaseContext context, IMapper mapper, ILogger<SelectionProcessService> logger)
+        public SelectionProcessService(UserManager<User> userManager,DatabaseContext context, IMapper mapper, ILogger<SelectionProcessService> logger)
         {
             _context = context;
             _mapper = mapper;
             _logger = logger;
+            _userManager = userManager;
         }
 
         public async Task<List<SelectionProcessResposneDto>> GetAllAsync()
             {
                 _logger.LogError($"Applicant is in the last selection level");
                 throw new EntityNotFoundException("Candidate came to the last selection level");
+                // ovde sacuvati promene i return odraditi
+                // da ne bi pravilo novi proces
+                // exception treba ukloniti
             }
 
             SelectionProcess newProcess = new SelectionProcess
                 SelectionLevelId = nextLevel.Id,
                 Status = "Čeka na zakazivanje",
                 ApplicantId = sp.ApplicantId,
-                SchedulerId = model.SchedulerId
+                //SchedulerId = model.SchedulerId
             };
             _context.SelectionProcesses.Add(newProcess);
             _logger.LogInformation($"Create and add new selection process");
             _logger.LogInformation($"Selection process saved to DB");
             await result;
         }
+        public async Task StatusUpdate(StatusChangeDTO model)
+        {
+            var process = await _context.SelectionProcesses.FindAsync(model.ProcessId);
+
+            if (process is null)
+                throw new EntityNotFoundException("Process does not exist.");
+
+            if (model.NewStatus == "Zakazan" && model.SchedulerId is not null)
+            {
+                var user = await _userManager.FindByIdAsync(model.SchedulerId.ToString());
+
+                if (user is null)
+                    throw new EntityNotFoundException("Scheduler does not exist.");
+
+                process.SchedulerId = user.Id;
+            }
+
+            process.Status = model.NewStatus;
+            process.Date = model.Appointment;
+
+            await _context.SaveChangesAsync();
+        }
     }
 }

Diligent.WebAPI.Contracts/DTOs/Applicant/ApplicantProcessRequestDTO.cs

     {
         [Required]
         public int ApplicantId { get; set; }
-        public int SchedulerId { get; set; }
+        public int? SchedulerId { get; set; }
         public DateTime? Appointment { get; set; }
     }
 }

Diligent.WebAPI.Contracts/DTOs/SelectionProcess/SelectionProcessResposneDto.cs

 using Diligent.WebAPI.Contracts.DTOs.Applicant;
+using Diligent.WebAPI.Contracts.DTOs.User;
 
 namespace Diligent.WebAPI.Contracts.DTOs.SelectionProcess
 {
         public DateTime? Date { get; set; }
         public string? Link { get; set; }
         public ApplicantViewDto Applicant { get; set; }
+        public UserResponseDTO Scheduler { get; set; }
         public int SelectionLevelId { get; set; }
     }
 }

Diligent.WebAPI.Contracts/DTOs/SelectionProcess/StatusChangeDTO.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Diligent.WebAPI.Contracts.DTOs.SelectionProcess
+{
+    public class StatusChangeDTO
+    {
+        [Required]
+        public string NewStatus { get; set; }
+        [Required]
+        public int ProcessId { get; set; }
+        public int? SchedulerId { get; set; }
+        public DateTime? Appointment { get; set; }
+    }
+}

Diligent.WebAPI.Host/Controllers/V1/SelectionProcessesController.cs

         public async Task<IActionResult> FinishSelectionProcess([FromBody] SelectionProcessCreateDto model) =>
             Ok(await _selectionProcessesService.FinishSelectionProcess(model));
 
+        //[Authorize]
+        [HttpPost("status-update")]
+        public async Task<IActionResult> UpdateStatus([FromBody] StatusChangeDTO model)
+        {
+            await _selectionProcessesService.StatusUpdate(model);
+            return Ok("Status updated.");
+        }
         //[HttpPost]
         //public async Task<IActionResult> Create([FromBody] SelectionProcessCreateDto request)
         //{