public BaseResponse <SearchJobResult> SearchJobs(SearchJobModel searchJobModel)
        {
            var modelValid = Valid(searchJobModel);

            if (!modelValid.Data)
            {
                return(new BaseResponse <SearchJobResult> (false, modelValid.ErrorMessage));
            }

            var jobList          = new List <JobsModel> ();
            var successMailsList = new List <bool> ();

            for (int page = searchJobModel.PageStart; page <= searchJobModel.PageEnd; page++)
            {
                var result = this.SearchService.BuscarVagasPagina(searchJobModel.Tag, page);
                if (result.Ok)
                {
                    jobList.AddRange(result.Data);
                }
            }

            var emailsList = new List <string> ();

            foreach (var item in jobList)
            {
                if (!item.ContemEmail)
                {
                    continue;
                }

                foreach (var email in item.EmailsRelacionados)
                {
                    if (!emailsList.Contains(email))
                    {
                        emailsList.Add(email);
                        var resultMail = this.EmailService.EnviarEmail(email, item);
                        successMailsList.Add(resultMail);
                    }
                }
            }

            var coreResult = new SearchJobResult()
            {
                QtdVagas          = jobList.Count(),
                QtdVagasComEmail  = jobList.Where(x => x.ContemEmail).Count(),
                QtdVagasSemEmail  = jobList.Where(x => !x.ContemEmail).Count(),
                QtdEmailsEnviados = successMailsList.Where(x => x).Count(),
                QtdEmailsErros    = successMailsList.Where(x => !x).Count()
            };

            return(new BaseResponse <SearchJobResult> (coreResult));
        }
        public async Task <IActionResult> Search([FromBody] SearchJobModel model)
        {
            var searchDTO = mapper.Map <SearchJobModel, SearchJobDTO> (model);

            if (ApiContext.CurrentUser.IsAuthenticated)
            {
                searchDTO.UserId = ApiContext.CurrentUser.UserId;
            }
            var jobsDTO = await jobService.Search(searchDTO);

            var jobsModel = mapper.Map <PagedResponseDTO <JobDTO>, PagedResponseModel <JobModel> >(jobsDTO);

            return(Ok(jobsModel));
        }
        private BaseResponse <bool> Valid(SearchJobModel model)
        {
            if (model.PageStart > model.PageEnd)
            {
                return(new BaseResponse <bool> (false, "Pagina de inicio maior que pagina final"));
            }

            if (string.IsNullOrEmpty(model.Tag))
            {
                return(new BaseResponse <bool> (false, "Tag vazia"));
            }

            return(new BaseResponse <bool> (true));
        }
        public async Task <IActionResult> Post([FromBody] SearchJobModel searchJobModel)
        {
            Console.WriteLine($"{DateTime.Now}  ** INICIADO ** -> Tag: {searchJobModel.Tag}, Pagina inicial: {searchJobModel.PageStart}, Pagina Final: {searchJobModel.PageEnd}");

            var coreResult = this.JobSearchCore.SearchJobs(searchJobModel);

            Console.WriteLine($"{DateTime.Now}  ** FINALIZADO ** -> Tag: {searchJobModel.Tag}, Pagina inicial: {searchJobModel.PageStart}, Pagina Final: {searchJobModel.PageEnd}");

            if (coreResult.Ok)
            {
                return(Ok(coreResult));
            }
            else
            {
                return(BadRequest(coreResult));
            }
        }