Secure routes

Diligent.WebAPI.Business/Services/AdService.cs

             }
 
             _logger.LogInformation($"Change ad expired time");
-            ad.ExpiredAt = DateTime.UtcNow;
+            ad.ExpiredAt = DateTime.Now;
             _logger.LogInformation($"Ad expired time changed successfully");
 
             _context.Entry(ad).State = EntityState.Modified;

Diligent.WebAPI.Business/Services/ApplicantService.cs

                 FirstName = request.FirstName,
                 LastName = request.LastName,
                 Position = ad.Title,
-                DateOfApplication = DateTime.UtcNow,
+                DateOfApplication = DateTime.Now,
                 CV = fileName,
                 Email = request.Email,
                 PhoneNumber = request.PhoneNumber,

Diligent.WebAPI.Business/Services/AuthenticationService.cs

                     new Claim(JwtRegisteredClaimNames.Jti, user.Id.ToString()),
                     new Claim("id", user.Id.ToString())
                 }),
-                Expires = DateTime.UtcNow.AddMinutes(_authSettings.JwtExpiredTime),
+                Expires = DateTime.Now.AddMinutes(_authSettings.JwtExpiredTime),
                 SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
             };
             var token = tokenHandler.CreateToken(tokenDescriptor);
                 JwtId = user.Id.ToString(),
                 UserId = user.Id,
                 User = user,
-                CreationDate = DateTime.UtcNow,
-                ExpiryDate = DateTime.UtcNow.AddMinutes(_authSettings.JwtRefreshExpiredTime)
+                CreationDate = DateTime.Now,
+                ExpiryDate = DateTime.Now.AddMinutes(_authSettings.JwtRefreshExpiredTime)
             };
 
             var existRefreshToken = await _databaseContext.RefreshTokens.Where(x => x.UserId == user.Id).FirstOrDefaultAsync();
             {
                 existRefreshToken.Token = writedToken;
                 existRefreshToken.JwtId = token.Id;
-                existRefreshToken.CreationDate = DateTime.UtcNow;
-                existRefreshToken.ExpiryDate = DateTime.UtcNow.AddMinutes(_authSettings.JwtRefreshExpiredTime);
+                existRefreshToken.CreationDate = DateTime.Now;
+                existRefreshToken.ExpiryDate = DateTime.Now.AddMinutes(_authSettings.JwtRefreshExpiredTime);
 
                 if (authenticate)
                 {
             var expiryDateTimeUtc = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)
                 .AddMinutes(expiryDateUnix);
 
-            if (expiryDateTimeUtc < DateTime.UtcNow)
+            if (expiryDateTimeUtc < DateTime.Now)
             {
                 return new RefreshTokenResultDto
                 {
                 };
             }
 
-            if (DateTime.UtcNow > storedRefreshToken.ExpiryDate)
+            if (DateTime.Now > storedRefreshToken.ExpiryDate)
             {
                 return new RefreshTokenResultDto { Error = "This refresh token has expired" };
             }
                 return new RefreshTokenResultDto { Error = "This refresh token does not match this JWT" };
             }
 
-            storedRefreshToken.ExpiryDate = DateTime.UtcNow.AddMinutes(_authSettings.JwtRefreshExpiredTime);
+            storedRefreshToken.ExpiryDate = DateTime.Now.AddMinutes(_authSettings.JwtRefreshExpiredTime);
 
             await _databaseContext.SaveChangesAsync();
 

Diligent.WebAPI.Business/Services/Emailer.cs

 
             if (emailResult)
             {
-                email.SentTime = DateTime.UtcNow;
+                email.SentTime = DateTime.Now;
             }
 
             //_logger.LogInformation("Save email in db");
 
             if (emailResult)
             {
-                email.SentTime = DateTime.UtcNow;
+                email.SentTime = DateTime.Now;
             }
 
             //var dbResult = WriteEmailToDb(email);
                 Body = body,
                 IsHtml = isHtml,
                 DontSendBefore = dontSendBefore,
-                CreateTime = DateTime.UtcNow
+                CreateTime = DateTime.Now
             };
 
 

Diligent.WebAPI.Business/Services/InsuranceCompaniesService.cs

         public async Task CreateInsuranceCompany(InsuranceCompanyCreateDto insuranceCompanyCreateDto)
         {
             var insuranceCompany = _mapper.Map<InsuranceCompany>(insuranceCompanyCreateDto);
-            insuranceCompany.CreatedAtUtc = DateTime.UtcNow;
+            insuranceCompany.CreatedAtUtc = DateTime.Now;
             await _context.InsuranceCompanies.AddAsync(insuranceCompany);
             await _context.SaveChangesAsync();
         }
                 throw new EntityNotFoundException($"Insurance company not found");
 
             _mapper.Map(insuranceCompanyUpdateDto, insuranceCompany);
-            insuranceCompany.UpdatedAtUtc = DateTime.UtcNow;
+            insuranceCompany.UpdatedAtUtc = DateTime.Now;
 
             _context.Entry(insuranceCompany).State = EntityState.Modified;
             await _context.SaveChangesAsync();

Diligent.WebAPI.Business/Services/InsurancePoliciesService.cs

                 throw new EntityNotFoundException("Insurance policy not found");
 
             _mapper.Map(insurancePolicyUpdateDto, insurancePolicy);
-            insurancePolicy.UpdatedAtUtc = DateTime.UtcNow;
+            insurancePolicy.UpdatedAtUtc = DateTime.Now;
 
             _context.Entry(insurancePolicy).State = EntityState.Modified;
             await _context.SaveChangesAsync();

Diligent.WebAPI.Business/Services/InsurersService.cs

                 throw new EntityNotFoundException("Insurer not found");
 
             _mapper.Map(insurerUpdateDto, insurer);
-            insurer.UpdatedAtUtc = DateTime.UtcNow;
+            insurer.UpdatedAtUtc = DateTime.Now;
 
             _context.Entry(insurer).State = EntityState.Modified;
             await _context.SaveChangesAsync();

Diligent.WebAPI.Business/Services/ScreeningTestService.cs

             try
             {
                 var result = JsonConvert.DeserializeObject<AuthSuccessResponse>(content);
-                var expires = result.Expires.Value - DateTime.UtcNow;
+                var expires = result.Expires.Value - DateTime.Now;
                 var cacheEntryOptions = new MemoryCacheEntryOptions()
                    .SetSlidingExpiration(TimeSpan.FromSeconds(60))
                    .SetAbsoluteExpiration(expires)

Diligent.WebAPI.Business/Services/WebhookSubscriptionService.cs

         {
             // map dto to db model
             WebhookSubscription subscription = _mapper.Map<WebhookSubscription>(dto);
-            subscription.CreatedAtUtc = DateTime.UtcNow;
+            subscription.CreatedAtUtc = DateTime.Now;
             subscription.IsActive = true;
 
             // add to db

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

     [ApiVersion("1.0")]
     [Route("v{version:apiVersion}/ads")]
     [ApiController]
+
     public class AdsController : ControllerBase
     {
         private readonly IAdService _adService;
             _adService = adService;
         }
 
+
+        [Authorize]
         [HttpGet]
         public async Task<IActionResult> GetAll() =>
             Ok(await _adService.GetAllAsync());
 
+        [Authorize]
         [HttpGet("{id}")]
         public async Task<IActionResult> GetById([FromRoute] int id) =>
             Ok(await _adService.GetByIdAsync(id));
 
+        [Authorize]
         [HttpGet("details/{id}")]
         public async Task<IActionResult> GetAdDetailsById([FromRoute] int id) =>
             Ok(await _adService.GetAdDetailsByIdAsync(id));
 
+        [Authorize]
         [HttpGet("archive")]
         public async Task<IActionResult> GetArchiveAds() =>
             Ok(await _adService.GetArchiveAds());
 
+        [Authorize]
         [HttpGet("filtered")]
         public async Task<IActionResult> GetFilteredAds([FromQuery] AdFilterDto request) =>
             Ok(await _adService.GetFilteredAdsAsync(request));
 
+        [Authorize]
         [HttpPost]
         public async Task<IActionResult> Create([FromBody]AdCreateDto request)
         {
             return StatusCode((int)HttpStatusCode.Created);
         }
 
+        [Authorize]
         [HttpPut("{id}")]
         public async Task<IActionResult> Update([FromBody] AdUpdateDto request, [FromRoute]int id)
         {
             return Ok();
         }
 
+        [Authorize]
         [HttpPut("archive-active-ad/{id}")]
         public async Task<IActionResult> ArchiveActiveAd([FromRoute] int id)
         {
             return Ok();
         }
 
+        [Authorize]
         [HttpDelete("{id}")]
         public async Task<IActionResult> DeleteAd([FromRoute]int id)
         {

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

             _applicantService = applicantService;
         }
 
+        [Authorize]
         [HttpGet]
         public async Task<IActionResult> GetFilteredApplicants([FromQuery] ApplicantFilterDto applicantFilterDto) =>
             Ok(await _applicantService.GetFilteredApplicants(applicantFilterDto));
             return Ok();
         }
 
+        [Authorize]
         [HttpGet("processes/{id}")]
         public async Task<IActionResult> GetProcesses(int id)
         {
             return Ok(await _applicantService.GetApplicantWithSelectionProcessesById(id));
         }
 
+        [Authorize]
         [HttpGet("options")]
         public async Task<IActionResult> GetOptions()
         {
             return Ok(await _applicantService.GetOptions());
         }
 
+        [Authorize]
         [HttpPost("selection-init")]
         public async Task<IActionResult> InitSelection(ApplicantProcessRequestDTO model)
         {
             return Ok();
         }
 
+        [Authorize]
         [HttpPost("apply-for-ad")]
         public async Task<IActionResult> ApplyForAd([FromForm]ApplyForAdRequestDto request)
         {

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

             _patternService = patternService;
         }
 
+        [Authorize]
         [HttpGet]
         public async Task<IActionResult> GetAll() =>
             Ok(await _patternService.GetAllAsync());
 
+        [Authorize]
         [HttpGet("{id}")]
         public async Task<IActionResult> GetById([FromRoute] int id) =>
             Ok(await _patternService.GetByIdAsync(id));
 
+        [Authorize]
         [HttpGet("filter")]
         public async Task<IActionResult> GetFilteredPatterns([FromQuery] FilterPatternDto request) =>
             Ok(await _patternService.GetFilteredPatternsAsync(request));
 
+        [Authorize]
         [HttpGet("corresponding-pattern-applicants/{id}")]
         public async Task<IActionResult> GetFilteredPatterns([FromRoute] int id) =>
             Ok(await _patternService.GetCorrespondingPatternApplicants(id));
 
 
+        [Authorize]
         [HttpPost]
         public async Task<IActionResult> Create([FromBody] PatternCreateDto request)
         {
             return StatusCode((int)HttpStatusCode.Created);
         }
 
+        [Authorize]
         [HttpPost("schedule-interview")]
         public async Task<IActionResult> ScheduleInterview([FromBody] ScheduleInterviewDto request)
         {
             return Ok(result);
         }
 
+        [Authorize]
         [HttpPut("{id}")]
         public async Task<IActionResult> Update([FromBody]PatternUpdateDto request, [FromRoute]int id)
         {
             return Ok();
         }
 
+        [Authorize]
         [HttpDelete("{id}")]
         public async Task<IActionResult> DeletePattern([FromRoute] int id)
         {

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

             _scheduleService = scheduleService;
         }
 
+        [Authorize]
         [HttpGet]
         public async Task<IActionResult> GetSchedule(int month,int year) =>
             Ok(await _scheduleService.GetScheduleForCertainPeriod(month, year));

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

         {
             _selectionLevelService = selectionLevelService;
         }
-        //[Authorize]
+        [Authorize]
         [HttpGet]
         public async Task<IActionResult> GetAll() =>
             Ok(await _selectionLevelService.GetAllAsync());
 
+        [Authorize]
         [HttpGet("filtered")]
         public async Task<IActionResult> GetFilteredLevels([FromQuery] SelectionProcessFilterDto request) =>
            Ok(_selectionLevelService.GetFilteredLevelsAsync(request));
 
-        //[Authorize]
+        [Authorize]
         [HttpGet("{id}")]
         public async Task<IActionResult> GetById([FromRoute] int id) =>
             Ok(await _selectionLevelService.GetByIdAsync(id));

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

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

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

             _technologyService = technologyService;
         }
 
+        [Authorize]
         [HttpGet]
         public async Task<IActionResult> GetAll() =>
             Ok(await _technologyService.GetAllAsync());
 
+        [Authorize]
         [HttpGet("{id}")]
         public async Task<IActionResult> GetById([FromRoute] int id) =>
             Ok(await _technologyService.GetByIdAsync(id));

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

             return Ok(response.Data);
         }
 
+        [Authorize]
         [HttpPost("verify-invite")]
         public async Task<IActionResult> VerifyInvite(string email, string token)
         {
             return Ok(result);
         }
 
-        //[Authorize]
+        [Authorize]
         [HttpPost]
         public async Task<IActionResult> CreateUser([FromBody] CreateUserRequestDto model)
         {

Diligent.WebAPI.Host/Middlewares/JwtMiddleware.cs

             if (refreshToken == null)
                 return;
 
-            refreshToken.ExpiryDate = DateTime.UtcNow.AddMinutes(30);
+            refreshToken.ExpiryDate = DateTime.Now.AddMinutes(30);
 
             await service.UpdateRefreshToken(refreshToken);
         }

Diligent.WebAPI.Tests/Controllers/AdsControllerTests.cs

                 Id = 1,
                 Title = "React Developer",
                 MinimumExperience = 0,
-                CreatedAt = DateTime.UtcNow,
-                ExpiredAt = DateTime.UtcNow.AddDays(30),
+                CreatedAt = DateTime.Now,
+                ExpiredAt = DateTime.Now.AddDays(30),
                 KeyResponsibilities = "KR|KR",
                 Requirements = "R|R|R",
                 Offer = "O|O",
                 Id = 1,
                 Title = "React Developer",
                 MinimumExperience = 0,
-                CreatedAt = DateTime.UtcNow,
-                ExpiredAt = DateTime.UtcNow.AddDays(30),
+                CreatedAt = DateTime.Now,
+                ExpiredAt = DateTime.Now.AddDays(30),
                 KeyResponsibilities = "KR|KR",
                 Requirements = "R|R|R",
                 Offer = "O|O"
             {
                 Title = "React Developer",
                 MinimumExperience = 0,
-                CreatedAt = DateTime.UtcNow,
-                ExpiredAt = DateTime.UtcNow.AddDays(30),
+                CreatedAt = DateTime.Now,
+                ExpiredAt = DateTime.Now.AddDays(30),
                 KeyResponsibilities = "KR|KR",
                 Requirements = "R|R|R",
                 Offer = "O|O"
             {
                 Title = "React Developer",
                 MinimumExperience = 0,
-                CreatedAt = DateTime.UtcNow,
-                ExpiredAt = DateTime.UtcNow.AddDays(30),
+                CreatedAt = DateTime.Now,
+                ExpiredAt = DateTime.Now.AddDays(30),
                 KeyResponsibilities = "KR|KR",
                 Requirements = "R|R|R",
                 Offer = "O|O"
             {
                 Title = "React Developer",
                 MinimumExperience = 0,
-                CreatedAt = DateTime.UtcNow,
-                ExpiredAt = DateTime.UtcNow.AddDays(30),
+                CreatedAt = DateTime.Now,
+                ExpiredAt = DateTime.Now.AddDays(30),
                 KeyResponsibilities = "KR|KR",
                 Requirements = "R|R|R",
                 Offer = "O|O"

Diligent.WebAPI.Tests/Services/AdServiceTests.cs

                 Id = 1,
                 Title = "React Developer",
                 MinimumExperience = 0,
-                CreatedAt = DateTime.UtcNow,
-                ExpiredAt = DateTime.UtcNow.AddDays(30),
+                CreatedAt = DateTime.Now,
+                ExpiredAt = DateTime.Now.AddDays(30),
                 KeyResponsibilities = "KR|KR",
                 Requirements = "R|R|R",
                 Offer = "O|O",
                 Id = 2,
                 Title = ".NET Developer",
                 MinimumExperience = 0,
-                CreatedAt = DateTime.UtcNow.AddDays(-2),
-                ExpiredAt = DateTime.UtcNow.AddDays(-1),
+                CreatedAt = DateTime.Now.AddDays(-2),
+                ExpiredAt = DateTime.Now.AddDays(-1),
                 KeyResponsibilities = "KR|KR",
                 Requirements = "R|R|R",
                 Offer = "O|O",
             {
                 Title = "Vue Developer",
                 MinimumExperience = 0,
-                CreatedAt = DateTime.UtcNow,
-                ExpiredAt = DateTime.UtcNow.AddDays(30),
+                CreatedAt = DateTime.Now,
+                ExpiredAt = DateTime.Now.AddDays(30),
                 KeyResponsibilities = "KR|KR",
                 Requirements = "R|R|R",
                 Offer = "O|O",
             {
                 Title = "Vue Developer",
                 MinimumExperience = 0,
-                CreatedAt = DateTime.UtcNow,
-                ExpiredAt = DateTime.UtcNow.AddDays(30),
+                CreatedAt = DateTime.Now,
+                ExpiredAt = DateTime.Now.AddDays(30),
                 KeyResponsibilities = "KR|KR",
                 Requirements = "R|R|R",
                 Offer = "O|O",
             {
                 Title = "Vue Developer",
                 MinimumExperience = 0,
-                CreatedAt = DateTime.UtcNow,
-                ExpiredAt = DateTime.UtcNow.AddDays(30),
+                CreatedAt = DateTime.Now,
+                ExpiredAt = DateTime.Now.AddDays(30),
                 KeyResponsibilities = "KR|KR",
                 Requirements = "R|R|R",
                 Offer = "O|O",