public PontoFuncionarioViewModel(DiaTrabalho ponto, SessaoLogin sessao, IPontoDiaRepository pontoRepository, IUnitOfWork unitOfWork)
        {
            this.ponto = ponto;

            this.Data            = ponto.Data.ToShortDateString();
            this.Funcionario     = ponto.Funcionario.Nome;
            this.Entrada         = ponto.Inicio;
            this.Saida           = ponto.Fim ?? new TimeSpan(0, 0, 0);
            this.pontoRepository = pontoRepository;
            this.unitOfWork      = unitOfWork;
            if (sessao.UsuarioLogado is Funcionario)
            {
                this.AllowEdit = false;
                this.Titulo    = "Ver ponto";
            }
            else
            {
                this.AllowEdit = true;
                this.Titulo    = "Editar/ver ponto";
            }

            Intervalos = ponto.Intervalos.ToList();

            SalvarCommand = new RelayCommand(confirmarSalvar, podeSalvar);
            FecharCommand = new RelayCommand(() => requestView(CLOSE));
        }
        private DiaTrabalho iniciarEncerrarDia(IPontoDiaRepository pontoRepository, IFeriadoRepository feriadoRepository, DateTime entrada, IDataHoraStrategy dataHora)
        {
            var diaTrab = criarPontoTrabalhoDoDia(pontoRepository, feriadoRepository, entrada.Day, entrada.Month, entrada.Year, entrada.Hour);

            criarPontoService(pontoRepository, feriadoRepository, dataHora).encerrarDia(diaTrab);
            return(diaTrab);
        }
        private DiaFolga criarFolgaEm(IPontoDiaRepository repository, DateTime data)
        {
            var service = (PontoServiceMock)FactoryHelper.criarPontoService(funcionario, null, repository, true);

            return
                (service.darFolgaPara(funcionario, data, "desc"));
        }
        private DiaTrabalho criarPontoTrabalhoDoDia(IPontoDiaRepository pontoRepository, IFeriadoRepository feriadoRepository, int dia, int mes, int ano, int hora = 9, int minuto = 0)
        {
            var dt = new DataHoraMockStrategy(new DateTime(ano, mes, dia, hora, minuto, 0));

            return(FactoryHelper
                   .criarPontoFactory(pontoRepository, feriadoRepository)
                   .criarDiaTrabalho(dt, new SessaoLoginMock(funcionario)));
        }
 public RelatorioService(IPontoDiaRepository pontoRepository, FeriadoService feriadoService, IJornadaTrabalhoRepository jornadaRepository, IUnitOfWork unitOfWork)
 {
     this.pontoRepository   = pontoRepository;
     this.feriadoService    = feriadoService;
     this.jornadaRepository = jornadaRepository;
     this.jornadaAtiva      = jornadaRepository.findJornadaAtiva();
     this.unitOfWork        = unitOfWork;
 }
Example #6
0
        private PontoFactory criarFactory(IPontoDiaRepository repo = null)
        {
            if (repo == null)
            {
                repo = new PontoDiaMockRepository();
            }

            return(FactoryHelper.criarPontoFactory(repo));
        }
Example #7
0
        public static PontoFactory criarPontoFactory(FeriadoService feriadoService, IPontoDiaRepository pontoRepository = null)
        {
            if (pontoRepository == null)
            {
                pontoRepository = new PontoDiaMockRepository();
            }

            return(new PontoFactory(pontoRepository, feriadoService));
        }
Example #8
0
        public static PontoFactory criarPontoFactory(IPontoDiaRepository pontoRepository = null, IFeriadoRepository feriadoRepository = null)
        {
            if (feriadoRepository == null)
            {
                feriadoRepository = new FeriadoMockRepository();
            }

            return(criarPontoFactory(new FeriadoService(feriadoRepository), pontoRepository));
        }
Example #9
0
        private PontoService criarService(IDataHoraStrategy dataHoraStrategy = null, IPontoDiaRepository repository = null, Usuario logado = null)
        {
            var sessao = sessaoLogin;

            if (logado != null)
            {
                sessao = new SessaoLoginMock(logado);
            }

            return(FactoryHelper.criarPontoService(sessao, dataHoraStrategy, repository));
        }
Example #10
0
        public SelecaoDataViewModel(IPontoDiaRepository pontoRepository, SessaoLogin sessaoLogin)
        {
            this.pontoRepository = pontoRepository;
            this.sessaoLogin     = sessaoLogin;

            var ontem = DateTime.Today.AddDays(-1);

            this.Data             = ontem;
            this.MaxData          = ontem;
            this.ConfirmarCommand = new RelayCommand(confirmarData);
        }
 public PontoService(PontoFactory pontoFactory, IDataHoraStrategy dataHoraStrategy, FuncionarioPossuiPontoAbertoSpecification pontoAbertoSpec, FuncionarioJaTrabalhouHojeSpecification funcTrabSpec, SessaoLogin sessaoLogin, IPontoDiaRepository pontoRepository, ITipoIntervaloRepository tipoIntervaloRepository)
 {
     this.pontoFactory            = pontoFactory;
     this.dataHoraStrategy        = dataHoraStrategy;
     this.deixouPontoAberto       = pontoAbertoSpec;
     this.jaTrabalhouHoje         = funcTrabSpec;
     this.jaTrabalhouHoje.Data    = dataHoraStrategy.getDataHoraAtual();
     this.sessaoLogin             = sessaoLogin;
     this.pontoRepository         = pontoRepository;
     this.tipoIntervaloRepository = tipoIntervaloRepository;
 }
Example #12
0
        public ControlarPontoViewModel(UnitOfWork unitOfWork, IUsuarioRepositorio usuarioRepository, PontoService pontoService, IPontoDiaRepository pontoRepository, RelatorioService relatorioService)
        {
            this.pontoService     = pontoService;
            this.pontoRepository  = pontoRepository;
            this.relatorioService = relatorioService;

            this.Funcionarios         = usuarioRepository.findFuncionarios();
            this.FuncionarioEscolhido = Funcionarios[0];
            this.ExibirCommand        = new RelayCommand(exibir);

            base.unitOfWork = unitOfWork;
            unitOfWork.openConnection();
        }
        private RelatorioService criarRelatorioService(IPontoDiaRepository pontoRepository = null, IFeriadoRepository feriadoRepository = null, IJornadaTrabalhoRepository jornadaRepository = null)
        {
            if (pontoRepository == null)
            {
                pontoRepository = new PontoDiaMockRepository();
            }

            if (feriadoRepository == null)
            {
                feriadoRepository = new FeriadoMockRepository();
            }

            if (jornadaRepository == null)
            {
                jornadaRepository = new JornadaTrabalhoMockRepository();
            }

            return(new RelatorioService(pontoRepository, new FeriadoService(feriadoRepository), jornadaRepository, new UnitOfWorkMock()));
        }
Example #14
0
 public static PontoService criarPontoService(Funcionario logado, IDataHoraStrategy dataHoraStrategy = null, IPontoDiaRepository pontoRepository = null, bool mock = false, IFeriadoRepository feriadoRepository = null)
 {
     return(criarPontoService(new SessaoLoginMock(logado), dataHoraStrategy, pontoRepository, mock, feriadoRepository));
 }
Example #15
0
        public static PontoService criarPontoService(SessaoLogin sessao, IDataHoraStrategy dataHoraStrategy = null, IPontoDiaRepository pontoRepository = null, bool mock = false, IFeriadoRepository feriadoRepository = null)
        {
            if (dataHoraStrategy == null)
            {
                dataHoraStrategy = new DataHoraMockStrategy(DateTime.Today);
            }

            if (pontoRepository == null)
            {
                pontoRepository = new PontoDiaMockRepository();
            }

            var tipoIntervaloRepository = new TipoIntervaloMockRepository();

            tipoIntervaloRepository.save(new TipoIntervalo("AlmoƧo"));

            if (mock)
            {
                return(new PontoServiceMock(criarPontoFactory(pontoRepository, feriadoRepository),
                                            dataHoraStrategy,
                                            new FuncionarioPossuiPontoAbertoSpecification(pontoRepository),
                                            new FuncionarioJaTrabalhouHojeSpecification(pontoRepository),
                                            sessao,
                                            pontoRepository,
                                            tipoIntervaloRepository));
            }

            return(new PontoService(criarPontoFactory(pontoRepository, feriadoRepository),
                                    dataHoraStrategy,
                                    new FuncionarioPossuiPontoAbertoSpecification(pontoRepository),
                                    new FuncionarioJaTrabalhouHojeSpecification(pontoRepository),
                                    sessao,
                                    pontoRepository,
                                    tipoIntervaloRepository));
        }
Example #16
0
 private static PontoFactory criarPontoFactory(IPontoDiaRepository repo)
 {
     return(new PontoFactory(repo, FeriadoServiceFactory.criarFeriadoService()));
 }
 private PontoService criarPontoService(IPontoDiaRepository pontoRepository, IFeriadoRepository feriadoRepository, IDataHoraStrategy dataHora)
 {
     return
         (FactoryHelper.criarPontoService(funcionario, dataHora, pontoRepository, false, feriadoRepository));
 }
 private PontoService criarPontoService(IPontoDiaRepository pontoRepository, IFeriadoRepository feriadoRepository, int dia, int mes, int ano, int hora)
 {
     return(criarPontoService(pontoRepository, feriadoRepository, new DataHoraMockStrategy(dia, mes, ano, hora)));
 }
Example #19
0
 public PontoServiceMock(PontoFactory pontoFactory, IDataHoraStrategy dataHoraStrategy, FuncionarioPossuiPontoAbertoSpecification pontoAbertoSpec, FuncionarioJaTrabalhouHojeSpecification funcTrabSpec, SessaoLogin sessaoLogin, IPontoDiaRepository pontoRepository, ITipoIntervaloRepository tipoIntervaloRepository) :
     base(pontoFactory, dataHoraStrategy, pontoAbertoSpec, funcTrabSpec, sessaoLogin, pontoRepository, tipoIntervaloRepository)
 {
 }
 private DiaFolga criarFolgaEm(IPontoDiaRepository repository, int dia, int mes, int ano)
 {
     return(criarFolgaEm(repository, new DateTime(ano, mes, dia)));
 }
 public void setUp()
 {
     pontoRepository = new PontoDiaMockRepository();
     funcionario     = new FuncionarioFactory().criarFuncionario("Gui", "gui", "123456", "", "41617099864");
 }
 public PontoFactory(IPontoDiaRepository repository, FeriadoService feriadoService)
 {
     this.repository     = repository;
     this.feriadoService = feriadoService;
 }
 public FuncionarioJaTrabalhouHojeSpecification(IPontoDiaRepository repository)
 {
     this.pontoRepository = repository;
     this.Data            = DateTime.Today;
 }
 public FuncionarioPossuiPontoAbertoSpecification(IPontoDiaRepository repository)
 {
     this.pontoRepository = repository;
 }