SHARE
TWEET

Untitled

a guest Jan 24th, 2020 62 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package com.betha.saude.model.agenda;
  2.  
  3. import com.betha.bfc.enterprise.querydsl.Sort;
  4. import com.betha.bfc.security.UserAccessHolder;
  5. import com.betha.bfc.util.CollectionsBuilder;
  6. import com.betha.saude.enterprise.AbstractService;
  7. import com.betha.saude.enterprise.BasicRepository;
  8. import com.betha.saude.enterprise.grupo.GrupoDto;
  9. import com.betha.saude.enterprise.grupo.GrupoService;
  10. import com.betha.saude.model.agendamento.AgendamentoService;
  11. import com.betha.saude.message.AgendaDisponivel;
  12. import com.betha.saude.model.agenda.ausencia.Ausencia;
  13. import com.betha.saude.model.agenda.ausencia.AusenciaService;
  14. import com.betha.saude.model.agendamento.Agendamento;
  15. import com.betha.saude.model.agendamento.QAgendamento;
  16. import com.betha.saude.model.classificacao.Classificacao;
  17. import com.betha.saude.model.classificacao.ClassificacaoService;
  18. import com.betha.saude.model.commons.enums.TipoClassificacao;
  19. import com.betha.saude.model.feriado.*;
  20. import com.betha.saude.model.programacaoorcamentaria.convenio.cota.ConvenioCotaUnidadeConsumidoraService;
  21. import com.betha.saude.util.SaudeUtil;
  22. import com.mysema.query.BooleanBuilder;
  23. import javax.ejb.TransactionAttribute;
  24. import javax.inject.Inject;
  25. import javax.validation.ValidationException;
  26.  
  27. import java.time.LocalDate;
  28. import java.time.LocalTime;
  29. import java.time.format.DateTimeFormatter;
  30. import java.time.temporal.ChronoUnit;
  31. import java.time.temporal.WeekFields;
  32. import java.util.ArrayList;
  33. import java.util.List;
  34. import java.util.Locale;
  35.  
  36. import static com.betha.saude.model.agenda.Agenda.QNT_SEMANAS_CALCULO;
  37. import static javax.ejb.TransactionAttributeType.REQUIRED;
  38.  
  39. public class AgendaService extends AbstractService {
  40.  
  41.     @Inject
  42.     private BasicRepository basicRepository;
  43.  
  44.     @Inject
  45.     private AgendamentoService agendamentoService;
  46.  
  47.     @Inject
  48.     private ClassificacaoService classificacaoService;
  49.  
  50.     @Inject
  51.     private FeriadoService feriadoService;
  52.  
  53.     @Inject
  54.     private AusenciaService ausenciaService;
  55.  
  56.     @Inject
  57.     private ConvenioCotaUnidadeConsumidoraService convenioCotaUnidadeConsumidoraService;
  58.  
  59.     @Inject
  60.     private GrupoService grupoService;
  61.  
  62.     @Inject
  63.     private UserAccessHolder userAccessHolder;
  64.  
  65.     @TransactionAttribute(REQUIRED)
  66.     public Agenda save(Agenda agenda) {
  67.         if(agenda.getId() != null){
  68.             if (agenda.getPeriodoFinal() != null) {
  69.                 String periodoFinal = agenda.getPeriodoFinal().toString();
  70.                 agendamentoService.cancelAgendamentosDeAgendaDisponiveisParaCancelamento(agenda.getId(), periodoFinal, agenda.getQuantidadeVagaEletivo());
  71.                 /// Olhar aqui ->
  72.                 teste(agenda);
  73.             }
  74.             return basicRepository.merge(agenda);
  75.  
  76.         }
  77.         return basicRepository.persist(agenda);
  78.     }
  79.  
  80.     private void teste(Agenda agenda) {
  81.                 /// Olhar aqui ->
  82.         for (AgendaHorario a: agenda.getAgendaHorario()) {
  83.             getHorariosByAgendaHorario(a, agenda.getQuantidadeVagaEletivo() + agenda.getQuantidadeVagaUrgencia());
  84.         }
  85.  
  86.     }
  87.  
  88.     @TransactionAttribute(REQUIRED)
  89.     public Agenda cancel(Agenda agenda) {
  90.         if(agenda != null) {
  91.             save(agenda);
  92.             agendamentoService.cancelAgendamentosDeAgendaDisponiveisParaCancelamento(agenda.getId(), null, agenda.getQuantidadeVagaEletivo());
  93.         }
  94.         return agenda;
  95.     }
  96.  
  97.     @TransactionAttribute(REQUIRED)
  98.     public Agenda delete(Long profissionalAgendaId) {
  99.         Agenda agenda = basicRepository.find(Agenda.class, profissionalAgendaId);
  100.         if(agenda != null){
  101.             return save(Agenda.Builder.from(agenda).excluido(true).skipValidate().build());
  102.         }
  103.         throw new ValidationException(String.format("Nenhuma agenda de profissional encontrada para o identificador %s.", profissionalAgendaId));
  104.     }
  105.  
  106.     public BooleanBuilder filterAgendaByUserAccess(BooleanBuilder filter, String accessId){
  107.         List<GrupoDto> gruposAccess = grupoService.getGruposByAccessId(accessId);
  108.         List<String> grupoIds = CollectionsBuilder.createDefaultArrayList();
  109.         for (GrupoDto grupoDto:gruposAccess) {
  110.             grupoIds.add(grupoDto.getId());
  111.         }
  112.         QAgenda qAgenda = QAgenda.agenda;
  113.         Classificacao classificacaoAgendaEspecialidade = classificacaoService.getClassificacaoByAtributo1(TipoClassificacao.TIPO_AGENDA, Agenda.TIPO_AGENDA_ESPECIALIDADE);
  114.         filter.and(qAgenda.classificacaoTipoAgenda().id.eq(classificacaoAgendaEspecialidade.getId()));
  115.         filter.and(qAgenda.excluido.isFalse());
  116.         filter.and(qAgenda.cancelado.isFalse());
  117.         filter.and(qAgenda.bloquearUso.isFalse());
  118.         filter.and((qAgenda.periodoInicial.loe(LocalDate.now()).and(qAgenda.periodoFinal.goe(LocalDate.now()))).or(qAgenda.periodoFinal.isNull()));
  119.         if(grupoIds.size() > 0){
  120.             filter.and(qAgenda.agendaConfiguracao().limitarAgendamentoUsuarioEspecifico.eq(Boolean.TRUE)
  121.                     .and(qAgenda.agendaConfiguracao().agendaConfiguracaoUsuario.any().usuarioId.eq(userAccessHolder.get().getUserId()).or(qAgenda.agendaConfiguracao().agendaConfiguracaoUsuario.any().grupoId.in(grupoIds)))
  122.                     .or(qAgenda.agendaConfiguracao().limitarAgendamentoUsuarioEspecifico.eq(Boolean.FALSE)));
  123.         } else {
  124.             filter.and(qAgenda.agendaConfiguracao().limitarAgendamentoUsuarioEspecifico.eq(Boolean.TRUE)
  125.                     .and(qAgenda.agendaConfiguracao().agendaConfiguracaoUsuario.any().usuarioId.eq(userAccessHolder.get().getUserId()))
  126.                     .or(qAgenda.agendaConfiguracao().limitarAgendamentoUsuarioEspecifico.eq(Boolean.FALSE)));
  127.         }
  128.         return filter;
  129.     }
  130.  
  131.     void validateAgendaConcomitant(Agenda agenda){
  132.         List<List<AgendaHorario>> agendaHorarioWeeks = getAgendaHorarioWeeks(agenda);
  133.         getAgendasConcomitantByAgenda(agenda).forEach(agendaConcomitant -> validateAgendaWeek(agendaHorarioWeeks, agendaConcomitant));
  134.     }
  135.  
  136.     public AgendaDisponivel getProximaAgendaDisponivel(String tipoAgenda, Long idEspecialidade, Long idConvenio, Long idUnidadePrestadora, Long idProfissional, LocalDate periodoInicial){
  137.         periodoInicial = periodoInicial != null ? periodoInicial : LocalDate.now();
  138.         List<Agenda> agendas = getAgendasByParams(tipoAgenda, idEspecialidade, idConvenio, idUnidadePrestadora, idProfissional, periodoInicial);
  139.         AgendaDisponivel agendaDisponivel = new AgendaDisponivel();
  140.         for (Agenda agenda:agendas) {
  141.             LocalDate nextDate = periodoInicial;
  142.             List<Agendamento> agendamentos = agendamentoService.findAllAgendamentoByAgenda(agenda, nextDate);
  143.             List<Feriado> feriados = feriadoService.findAllFeriadosByDataUnidade(nextDate, agenda.getUnidadePrestadora().getId());
  144.             List<Ausencia> ausencias = ausenciaService.findAllAusencia(nextDate, agenda.getUnidadePrestadora().getId(), agenda.getProfissional().getId());
  145.             while (hasBeforeDate(nextDate, agendaDisponivel) &&
  146.                   (agenda.getPeriodoFinal() == null || agenda.getPeriodoFinal().isAfter(nextDate) || agenda.getPeriodoFinal().equals(nextDate))){
  147.                 if(!feriadoService.existsFeriadoByDate(feriados,nextDate)){
  148.                     AgendaHorario agendaHorario = getHorarioWork(agenda, nextDate);
  149.                     if(agendaHorario != null){
  150.                         setProximoHorarioAgenda(agendaDisponivel, nextDate, agendaHorario, agenda, agendamentos, feriados, ausencias);
  151.                     }
  152.                 }
  153.                 nextDate = nextDate.plusDays(1);
  154.             }
  155.         }
  156.         return agendaDisponivel;
  157.     }
  158.  
  159.     private boolean hasBeforeDate(LocalDate nextDate, AgendaDisponivel proximoHorarioAgenda){
  160.         return proximoHorarioAgenda == null ||
  161.                proximoHorarioAgenda.getDataAgendamentoEletivo() == null || nextDate.isBefore(proximoHorarioAgenda.getDataAgendamentoEletivo()) ||
  162.                proximoHorarioAgenda.getDataAgendamentoUrgencia() == null || nextDate.isBefore(proximoHorarioAgenda.getDataAgendamentoUrgencia());
  163.     }
  164.  
  165.     private void setProximoHorarioAgenda(AgendaDisponivel proximasVagaAgenda, LocalDate nextDate, AgendaHorario agendaHorario, Agenda agenda, List<Agendamento> agendamentos, List<Feriado> feriados, List<Ausencia> ausencias){
  166.         long totalVagasAgenda = agenda.getQuantidadeVagaEletivo() + agenda.getQuantidadeVagaUrgencia();
  167.         List<LocalTime> horariosAgenda = getHorariosByAgendaHorario(agendaHorario, totalVagasAgenda);
  168.         List<LocalTime> horariosDisponiveis = getHorariosDisponiveis(horariosAgenda, nextDate, agendamentos, feriados, ausencias);
  169.         LocalTime proximoHorarioDisponivel = (!horariosDisponiveis.isEmpty()) ? horariosDisponiveis.get(0) : null;
  170.  
  171.         if(proximoHorarioDisponivel != null){
  172.             if((horariosDisponiveis.size() > agenda.getQuantidadeVagaUrgencia() &&
  173.                (proximasVagaAgenda.getDataAgendamentoEletivo() == null || nextDate.isBefore(proximasVagaAgenda.getDataAgendamentoEletivo())) ||
  174.                (nextDate.equals(proximasVagaAgenda.getDataAgendamentoEletivo()) &&
  175.                (proximasVagaAgenda.getHorariosEletivosDisponiveis().isEmpty() || proximoHorarioDisponivel.isBefore(proximasVagaAgenda.getHorariosEletivosDisponiveis().get(0)))))) {
  176.                 proximasVagaAgenda.setIdAgenda(agenda.getId());
  177.                 proximasVagaAgenda.setQuantidadeVagasEletivo(horariosDisponiveis.size() - agenda.getQuantidadeVagaUrgencia());
  178.                 proximasVagaAgenda.setDataAgendamentoEletivo(nextDate);
  179.                 proximasVagaAgenda.setHorarios(horariosAgenda);
  180.                 proximasVagaAgenda.setHorariosEletivosDisponiveis(horariosDisponiveis);
  181.             }
  182.  
  183.             if((horariosDisponiveis.size() <= totalVagasAgenda &&
  184.                (proximasVagaAgenda.getDataAgendamentoUrgencia() == null || nextDate.isBefore(proximasVagaAgenda.getDataAgendamentoUrgencia())))){
  185.                 proximasVagaAgenda.setQuantidadeVagasUrgencia(totalVagasAgenda - ( horariosDisponiveis.size() + (agenda.getQuantidadeVagaEletivo() -  horariosDisponiveis.size())));
  186.                 proximasVagaAgenda.setDataAgendamentoUrgencia(nextDate);
  187.             }
  188.         }
  189.     }
  190.  
  191.     private List <LocalTime> getHorariosDisponiveis(List<LocalTime> horariosAgenda, LocalDate dataAgendamento, List<Agendamento> agendamentos, List<Feriado> feriados, List<Ausencia> ausencias){
  192.         List <LocalTime> horariosDisponiveis = CollectionsBuilder.createDefaultArrayList();
  193.         for (LocalTime horario: horariosAgenda) {
  194.             if(!agendamentoService.existAgendamentoByAgendaHorario(dataAgendamento, horario, agendamentos) &&
  195.                !ausenciaService.existAusenciaByAgendaHorario(dataAgendamento, horario, ausencias) &&
  196.                !feriadoService.existsPontoFacultativoByAgenda(dataAgendamento, horario, feriados)){
  197.                 horariosDisponiveis.add(horario);
  198.             }
  199.         }
  200.         return horariosDisponiveis;
  201.     }
  202.  
  203.     private List<LocalTime> getHorariosByAgendaHorario(AgendaHorario agendaHorario, long totalVagas){
  204.         List<LocalTime> horarios = CollectionsBuilder.createDefaultArrayList();
  205.         double totalMinutosSegundoPeriodo = 0;
  206.         double totalMinutosPrimeiroPeriodo = 0;
  207.         if(agendaHorario.getPrimeiroPeriodoHoraInicio() != null && agendaHorario.getPrimeiroPeriodoHoraFim() != null){
  208.             totalMinutosPrimeiroPeriodo = ChronoUnit.MINUTES.between(agendaHorario.getPrimeiroPeriodoHoraInicio(),agendaHorario.getPrimeiroPeriodoHoraFim());
  209.         }
  210.         if(agendaHorario.getSegundoPeriodoHoraInicio() != null && agendaHorario.getSegundoPeriodoHoraFim() != null){
  211.             totalMinutosSegundoPeriodo = ChronoUnit.MINUTES.between(agendaHorario.getSegundoPeriodoHoraInicio(),agendaHorario.getSegundoPeriodoHoraFim());
  212.         }
  213.         long intervaloMinutos = Math.round((totalMinutosPrimeiroPeriodo + totalMinutosSegundoPeriodo) / totalVagas);
  214.  
  215.         createHorariosAgendaByIntevalo(agendaHorario.getPrimeiroPeriodoHoraInicio(), agendaHorario.getPrimeiroPeriodoHoraFim(), intervaloMinutos, horarios);
  216.         createHorariosAgendaByIntevalo(agendaHorario.getSegundoPeriodoHoraInicio(), agendaHorario.getSegundoPeriodoHoraFim(), intervaloMinutos, horarios);
  217.          return horarios;
  218.     }
  219.  
  220.  
  221.  
  222.     private void createHorariosAgendaByIntevalo(LocalTime horaInicio, LocalTime horaFim, long intervaloMinutos, List<LocalTime> horarios){
  223.         if(horaInicio != null && horaFim!= null){
  224.             LocalTime proximoHorarioPrimeiroPeriodo = horaInicio;
  225.             while (ChronoUnit.MINUTES.between(proximoHorarioPrimeiroPeriodo, horaFim) >= intervaloMinutos) {
  226.                 horarios.add(proximoHorarioPrimeiroPeriodo);
  227.                 proximoHorarioPrimeiroPeriodo = proximoHorarioPrimeiroPeriodo.plusMinutes(intervaloMinutos);
  228.             }
  229.         }
  230.     }
  231.  
  232.     private AgendaHorario getHorarioWork(Agenda agenda, LocalDate day){
  233.         long weekAgenda = getWeekFromAgendaPeriodoInicial(agenda, null);
  234.         long weekFromAgendaDate = getWeekFromAgendaPeriodoInicial(agenda, day);
  235.         long weekYear = weekFromAgendaDate - weekAgenda;
  236.         for (AgendaHorario agendaHorario : agenda.getAgendaHorario()) {
  237.             String agendaHorarioWeek = agendaHorario.getClassificacaoDiaSemana().getAtributo1();
  238.             if(day.getDayOfWeek().name().equals(agendaHorarioWeek) && !isAgendaHorarioAtivaByWeek(agendaHorario, weekYear, day)){
  239.                 return agendaHorario;
  240.             }
  241.         }
  242.         return null;
  243.     }
  244.  
  245.     private List<Agenda> getAgendasByParams(String tipoAgenda, Long idEspecialidade, Long idConvenio, Long idUnidadePrestadora, Long idProfissional, LocalDate apartirDe){
  246.         Classificacao classificacaoTipoAgenda = classificacaoService.getClassificacaoByAtributo1(TipoClassificacao.TIPO_AGENDA, tipoAgenda);
  247.         QAgenda qAgenda =   QAgenda.agenda;
  248.         BooleanBuilder filter = new BooleanBuilder();
  249.         filter.and(qAgenda.excluido.isFalse());
  250.         filter.and(qAgenda.cancelado.isFalse());
  251.         filter.and(qAgenda.classificacaoTipoAgenda().eq(classificacaoTipoAgenda));
  252.         filter.and((qAgenda.periodoInicial.loe(apartirDe).and(qAgenda.periodoFinal.goe(apartirDe))).or(qAgenda.periodoFinal.isNull()));
  253.         filter.and((qAgenda.agendaHorario.any().primeiroPeriodoHoraInicio.isNotNull()
  254.                 .or(qAgenda.agendaHorario.any().segundoPeriodoHoraInicio.isNotNull()))
  255.                .and(qAgenda.agendaHorario.any().inativo.ne(Boolean.TRUE)));
  256.  
  257.         if(idConvenio != null){
  258.             filter.and(qAgenda.convenio.id.eq(idConvenio));
  259.         }
  260.         if(idUnidadePrestadora != null){
  261.             filter.and(qAgenda.unidadePrestadora.id.eq(idUnidadePrestadora));
  262.         }
  263.         if(idEspecialidade != null){
  264.             filter.and(QAgenda.agenda.especialidade().id.eq(idEspecialidade));
  265.         }
  266.         if(idProfissional != null){
  267.             filter.and(QAgenda.agenda.profissional().id.eq(idProfissional));
  268.         }
  269.         return basicRepository.findAll(Agenda.class, Sort.of(qAgenda.periodoInicial.asc()), filter);
  270.     }
  271.  
  272.  
  273.     private List<Agenda> getAgendasConcomitantByAgenda(Agenda agenda){
  274.         QAgenda qAgenda =   QAgenda.agenda;
  275.         BooleanBuilder filter = new BooleanBuilder();
  276.         filter.and(qAgenda.excluido.isFalse());
  277.         filter.and(qAgenda.cancelado.isFalse());
  278.         filter.and(qAgenda.periodoFinal.goe(LocalDate.now()).or(qAgenda.periodoFinal.isNull()));
  279.         if(agenda.getPeriodoFinal() != null){
  280.             filter.and(qAgenda.periodoInicial.between(agenda.getPeriodoInicial(), agenda.getPeriodoFinal())
  281.                     .or(qAgenda.periodoInicial.loe(agenda.getPeriodoInicial()).and(qAgenda.periodoFinal.goe(agenda.getPeriodoFinal())))
  282.                     .or((qAgenda.periodoFinal.between(agenda.getPeriodoInicial(), agenda.getPeriodoFinal())).or(qAgenda.periodoFinal.isNull())));
  283.         } else {
  284.             filter.and(qAgenda.periodoInicial.between(agenda.getPeriodoInicial(), agenda.getPeriodoFinal())
  285.                     .or((qAgenda.periodoFinal.between(agenda.getPeriodoInicial(), agenda.getPeriodoFinal())).or(qAgenda.periodoFinal.isNull())));
  286.         }
  287.         if(Agenda.TIPO_AGENDA_ESPECIALIDADE.equals(agenda.getClassificacaoTipoAgenda().getAtributo1())){
  288.             filter.and(qAgenda.profissional().id.eq(agenda.getProfissional().getId()));
  289.         } else if(Agenda.TIPO_AGENDA_PROCEDIMENTO.equals(agenda.getClassificacaoTipoAgenda().getAtributo1())){
  290.             filter.and(qAgenda.convenio().id.eq(agenda.getConvenio().getId()));
  291.             filter.and(qAgenda.unidadePrestadora().id.eq(agenda.getUnidadePrestadora().getId()));
  292.             if(agenda.getAgendaEspecifica()){
  293.                 filter.and(qAgenda.procedimento().id.eq(agenda.getProcedimento().getId()));
  294.             }
  295.         }
  296.         if(agenda.getId() != null){
  297.             filter.and(qAgenda.id.ne(agenda.getId()));
  298.         }
  299.         return basicRepository.findAll(Agenda.class, Sort.of(qAgenda.periodoInicial.asc()), filter);
  300.     }
  301.  
  302.     private void validateAgendaWeek(List<List<AgendaHorario>> agendaHorarioWeeks, Agenda agendaConcomitant){
  303.         List<List<AgendaHorario>> agendaHorarioWeekConcomitant = getAgendaHorarioWeeks(agendaConcomitant);
  304.         for (int i = 0; i < agendaHorarioWeekConcomitant.size(); i++) {
  305.             if(agendaHorarioWeeks.size() > i){
  306.                 validateAgendaHorario(agendaHorarioWeeks.get(i), agendaHorarioWeekConcomitant.get((i)));
  307.             }
  308.         }
  309.     }
  310.  
  311.     public List<List<AgendaHorario>> getAgendaHorarioWeeks(Agenda agenda){
  312.         List<List<AgendaHorario>> agendaHorarioWeeks =  createListWeeksYearEmpty();
  313.         LocalDate fistDayOfWeek = agenda.getPeriodoInicial().with(WeekFields.of(Locale.getDefault()).dayOfWeek(), 1);;
  314.         long weekAgenda = getWeekFromAgendaPeriodoInicial(agenda, null);
  315.         long weekAgendaEnd = getWeekFromAgendaPeriodoFinal(agenda);
  316.         long weekAgendaBegin = weekAgenda;
  317.         while(weekAgendaBegin <= weekAgendaEnd){
  318.             int weekMod = (int) (weekAgendaBegin % 12);
  319.             long weekYear = weekAgendaBegin - weekAgenda;
  320.             List<AgendaHorario> agendaHorarios = CollectionsBuilder.createDefaultArrayList();
  321.             for (AgendaHorario agendaHorario:agenda.getAgendaHorario()) {
  322.                 agendaHorarios.add(createAgendaHorarioFromValidate(agendaHorario, weekYear, fistDayOfWeek));
  323.                 if(fistDayOfWeek.getDayOfWeek().name().equals(agendaHorario.getClassificacaoDiaSemana().getAtributo1())){
  324.                     fistDayOfWeek = fistDayOfWeek.plusDays(1);
  325.                 }
  326.             }
  327.             agendaHorarioWeeks.set(weekMod, agendaHorarios);
  328.             weekAgendaBegin++;
  329.         }
  330.         return agendaHorarioWeeks;
  331.     }
  332.  
  333.     private long getWeekFromAgendaPeriodoInicial(Agenda agenda, LocalDate periodoInicial){
  334.         return SaudeUtil.dateFullWeeks(agenda.getPeriodoInicial(), periodoInicial);
  335.     }
  336.  
  337.     private long getWeekFromAgendaPeriodoFinal(Agenda agenda){
  338.         if(agenda.getPeriodoFinal() != null && agenda.getPeriodoInicial().plusWeeks(QNT_SEMANAS_CALCULO).isAfter(agenda.getPeriodoFinal())){
  339.             return SaudeUtil.dateFullWeeks(agenda.getPeriodoInicial(), agenda.getPeriodoFinal());
  340.         }
  341.         return getWeekFromAgendaPeriodoInicial(agenda, null) + QNT_SEMANAS_CALCULO;
  342.     }
  343.  
  344.     private void validateAgendaHorario(List<AgendaHorario> agendaHorarioWeek, List<AgendaHorario> agendaHorarioWeekConcomitant){
  345.         for (int i = 0; i < agendaHorarioWeekConcomitant.size(); i++) {
  346.             if(!agendaHorarioWeek.isEmpty()){
  347.                 AgendaHorario agendaHorario = agendaHorarioWeek.get(i);
  348.                 AgendaHorario agendaHorarioConcomitant = agendaHorarioWeekConcomitant.get(i);
  349.                 if(!agendaHorario.getInativo() && !agendaHorarioConcomitant.getInativo()){
  350.                     validadeAgendaHorarioPrimeiroPeriodo(agendaHorario, agendaHorarioConcomitant);
  351.                 }
  352.             }
  353.         }
  354.     }
  355.  
  356.     private List<List<AgendaHorario>> createListWeeksYearEmpty(){
  357.         List<List<AgendaHorario>> agendaHorarioWeeks = new ArrayList<>();
  358.         for (int i = 0; i < 12; i++) {
  359.             agendaHorarioWeeks.add(CollectionsBuilder.createDefaultArrayList());
  360.         }
  361.         return agendaHorarioWeeks;
  362.     }
  363.  
  364.     private AgendaHorario createAgendaHorarioFromValidate(AgendaHorario agendaHorario, long weekYear, LocalDate dayOfMonth){
  365.         return AgendaHorario.Builder.create()
  366.                 .agenda(agendaHorario.getAgenda())
  367.                 .primeiroPeriodoHoraInicio(agendaHorario.getPrimeiroPeriodoHoraInicio())
  368.                 .primeiroPeriodoHoraFim(agendaHorario.getPrimeiroPeriodoHoraFim())
  369.                 .segundoPeriodoHoraInicio(agendaHorario.getSegundoPeriodoHoraInicio())
  370.                 .segundoPeriodoHoraFim(agendaHorario.getSegundoPeriodoHoraFim())
  371.                 .classificacaoDiaSemana(agendaHorario.getClassificacaoDiaSemana())
  372.                 .inativo(isAgendaHorarioAtivaByWeek(agendaHorario, weekYear, dayOfMonth))
  373.                 .build();
  374.     }
  375.  
  376.     private Boolean isAgendaHorarioAtivaByWeek(AgendaHorario agendaHorario, long weekYear, LocalDate dayOfMonth){
  377.         if(dayOfMonth.isBefore(agendaHorario.getAgenda().getPeriodoInicial()) || (agendaHorario.getAgenda().getPeriodoFinal() != null && dayOfMonth.isAfter(agendaHorario.getAgenda().getPeriodoFinal()))){
  378.             return true;
  379.         }
  380.         if(Agenda.FREQUENCIA_2_SEMANA.equals(agendaHorario.getAgenda().getClassificacaoFrequencia().getAtributo1()) && !agendaHorario.getInativo()){
  381.             return weekYear % 2 != 0;
  382.         }
  383.         if(Agenda.FREQUENCIA_3_SEMANA.equals(agendaHorario.getAgenda().getClassificacaoFrequencia().getAtributo1()) && !agendaHorario.getInativo()){
  384.             return weekYear % 3 != 0;
  385.         }
  386.         if(Agenda.FREQUENCIA_4_SEMANA.equals(agendaHorario.getAgenda().getClassificacaoFrequencia().getAtributo1()) && !agendaHorario.getInativo()){
  387.             return weekYear % 4 != 0;
  388.         }
  389.         return agendaHorario.getInativo();
  390.     }
  391.  
  392.     private void validadeAgendaHorarioPrimeiroPeriodo(AgendaHorario agendaHorario, AgendaHorario agendaHorarioConcomitant){
  393.         LocalTime primeiroPeriodoHoraInicio = agendaHorario.getPrimeiroPeriodoHoraInicio();
  394.         LocalTime primeiroPeriodoHorafim = agendaHorario.getPrimeiroPeriodoHoraFim();
  395.         LocalTime segundoPeriodoHoraInicio = agendaHorario.getSegundoPeriodoHoraInicio();
  396.         LocalTime segundoPeriodoHoraFim = agendaHorario.getSegundoPeriodoHoraFim();
  397.         LocalTime concomitantPrimeiroPeriodoHoraInicio = agendaHorarioConcomitant.getPrimeiroPeriodoHoraInicio();
  398.         LocalTime concomitantPrimeiroPeriodoHorafim = agendaHorarioConcomitant.getPrimeiroPeriodoHoraFim();
  399.         LocalTime concomitantSegundoPeriodoHoraInicio = agendaHorarioConcomitant.getSegundoPeriodoHoraInicio();
  400.         LocalTime concomitantSegundoPeriodoHoraFim = agendaHorarioConcomitant.getSegundoPeriodoHoraFim();
  401.  
  402.         if(concomitantPrimeiroPeriodoHoraInicio.equals(primeiroPeriodoHoraInicio) || concomitantPrimeiroPeriodoHoraInicio.equals(segundoPeriodoHoraInicio)){
  403.             ConcomitantValidationException(agendaHorarioConcomitant, primeiroPeriodoHoraInicio, primeiroPeriodoHorafim);
  404.         }
  405.  
  406.         if(SaudeUtil.isBetween(concomitantPrimeiroPeriodoHoraInicio, primeiroPeriodoHoraInicio, primeiroPeriodoHorafim)){
  407.             ConcomitantValidationException(agendaHorarioConcomitant, primeiroPeriodoHoraInicio, primeiroPeriodoHorafim);
  408.         }
  409.  
  410.         if(SaudeUtil.isBetween(concomitantPrimeiroPeriodoHoraInicio, segundoPeriodoHoraInicio, segundoPeriodoHoraFim)){
  411.             ConcomitantValidationException(agendaHorarioConcomitant, segundoPeriodoHoraInicio, segundoPeriodoHoraFim);
  412.         }
  413.  
  414.         if(SaudeUtil.isBetween(primeiroPeriodoHoraInicio, concomitantPrimeiroPeriodoHoraInicio, concomitantPrimeiroPeriodoHorafim)){
  415.             ConcomitantValidationException(agendaHorarioConcomitant,primeiroPeriodoHoraInicio, primeiroPeriodoHorafim);
  416.         }
  417.  
  418.         if(SaudeUtil.isBetween(primeiroPeriodoHoraInicio, concomitantSegundoPeriodoHoraInicio, concomitantSegundoPeriodoHoraFim)){
  419.             ConcomitantValidationException(agendaHorarioConcomitant, segundoPeriodoHoraInicio, segundoPeriodoHoraFim);
  420.         }
  421.     }
  422.  
  423.     private void ConcomitantValidationException(AgendaHorario agendaHorarioConcomitant, LocalTime periodoHoraInicio, LocalTime periodoHoraFim){
  424.         if(agendaHorarioConcomitant.getAgenda().getPeriodoFinal() != null){
  425.             String message = "%s horário de %s às %s está conflitando com outra agenda do profissional no período %s até %s";
  426.             if(Agenda.TIPO_AGENDA_PROCEDIMENTO.equals(agendaHorarioConcomitant.getAgenda().getClassificacaoTipoAgenda().getAtributo1())){
  427.                 message = "%s horário de %s às %s está conflitando com outra agenda no período %s até %s";
  428.             }
  429.             throw new ValidationException(String.format(message, agendaHorarioConcomitant.getClassificacaoDiaSemana().getNome(), periodoHoraInicio, periodoHoraFim,
  430.                     agendaHorarioConcomitant.getAgenda().getPeriodoInicial().format(DateTimeFormatter.ofPattern("dd/MM/yyyy")),
  431.                     agendaHorarioConcomitant.getAgenda().getPeriodoFinal().format(DateTimeFormatter.ofPattern("dd/MM/yyyy"))));
  432.         }
  433.  
  434.         throw new ValidationException(String.format("%s horário de %s às %s está conflitando com outra agenda do profissional iniciada em %s", agendaHorarioConcomitant.getClassificacaoDiaSemana().getNome(), periodoHoraInicio, periodoHoraFim,
  435.                 agendaHorarioConcomitant.getAgenda().getPeriodoInicial().format(DateTimeFormatter.ofPattern("dd/MM/yyyy"))));
  436.     }
  437.  
  438.     @TransactionAttribute(REQUIRED)
  439.     public Boolean verificaSeAgendamentoTemAgenda(Long agendaId) {
  440.         if (agendaId != null) {
  441.             QAgendamento q = QAgendamento.agendamento;
  442.             BooleanBuilder where = new BooleanBuilder(q.agenda().id.eq(agendaId));
  443.             where.and(q.classificacaoSituacao().atributo1.ne("CANCELADO").or(q.classificacaoSituacao().atributo1.ne("FINALIZADO")));
  444.             return this.basicRepository.exists(Agendamento.class, where);
  445.         } else {
  446.             return false;
  447.         }
  448.     }
  449. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top