/// <summary>
        /// Método que popula a lista de motivos e delimita o aparecer ou não do 'inicio do próximo ciclo'
        /// </summary>
        private void PopulateItems()
        {
            XPCollection <MotivoCancelamento> motivos = MotivoCancelamento.GetMotivosAtivos(Session);

            lookUpEditMotivo.Properties.DataSource = motivos;

            if (Ciclo.Projeto.UltimoFiltro != null)
            {
                if (Ciclo.Projeto.UltimoFiltro.MotivoCancelamentoCiclo != null)
                {
                    lookUpEditMotivo.EditValue = Ciclo.Projeto.UltimoFiltro.MotivoCancelamentoCiclo;
                }
            }

            if (Ciclo.CriarListasItensPendentes(false))
            {
                ListaItensPendentesCicloUserControl.Enabled = true;
            }
            else
            {
                ListaItensPendentesCicloUserControl.Enabled = false;
            }

            ListaItensPendentesCicloUserControl.LstPrioridade.DataSource   = Ciclo._ListaPrioridades;
            ListaItensPendentesCicloUserControl.LstProximoCiclo.DataSource = Ciclo._ListaProximoCiclo;
            ListaItensPendentesCicloUserControl.Ciclo = Ciclo;

            if (Ciclo.RnMostrarInicioProximoCiclo())
            {
                DtInicioProxCiclo.Enabled   = true;
                DtInicioProxCiclo.EditValue = Ciclo._DataProximoCiclo;
            }
        }
        public void QuandoIndicarNoCancelamentoDoCicloCiclo01PassarOMotivoMotivo01EADataDeInicioDoProximoCicloCom05032012(string ciclo, string motivo, string dataInicio)
        {
            CicloDesenv Ciclo = ciclosDic[ciclo];

            MotivoCancelamento Motivo = StepMotivoCancelamento.motivoCancelamentoDic[motivo];

            Ciclo.RnCancelarCiclo(Motivo, Ciclo._DataProximoCiclo);
        }
 /// <summary>
 /// Criar o Ciclo e as Estórias do Ciclo
 /// </summary>
 /// <param name="ciclo">Valor texto do Ciclo</param>
 /// <param name="estorias">Lista valores texto de Estórias do Ciclo</param>
 public static void CriarMotivoCancelamento(string motivoCancelamento, CsStatusMotivoCancelamento statusMotivo, Session session)
 {
     // Inserindo no dicionário
     if (!motivoCancelamentoDic.ContainsKey(motivoCancelamento))
     {
         MotivoCancelamento motivoCancelamentoObj = MotivoCancelamentoFactory.CriarMotivoCancelamento(session, motivoCancelamento, statusMotivo, true);
         motivoCancelamentoDic.Add(motivoCancelamento, motivoCancelamentoObj);
     }
 }
        public void QuandoIndicarNoCancelamentoDoCicloCiclo01OMotivoMotivo01()
        {
            motivosAtivos = new Dictionary <string, MotivoCancelamento>();

            foreach (MotivoCancelamento mot in MotivoCancelamento.GetMotivosAtivos(SessionTest))
            {
                if (!motivosAtivos.ContainsKey(mot.TxDescricao))
                {
                    motivosAtivos.Add(mot.TxDescricao, mot);
                }
            }
        }
        public void MootivoCancelamentoTxDescricaoUnicos()
        {
            MotivoCancelamento modalidade = MotivoCancelamentoFactory.CriarMotivoCancelamento(
                SessionTest, "modalidade1", CsStatusMotivoCancelamento.Ativo, true);

            Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(modalidade,
                                                                               "MotivoCancelamento_TxDescricao_Unique", DefaultContexts.Save));

            MotivoCancelamento modalidade1 = MotivoCancelamentoFactory.CriarMotivoCancelamento(
                SessionTest, "modalidade1", CsStatusMotivoCancelamento.Ativo, true);

            Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(modalidade1,
                                                                                 "MotivoCancelamento_TxDescricao_Unique", DefaultContexts.Save));
        }
        /// <summary>
        /// Factory para criação de motivos de cancelamento
        /// </summary>
        /// <param name="session">Sessão</param>
        /// <param name="txDescricao">Descrição do real motivo de cancelamento do ciclo.</param>
        /// <param name="csSituacao">Mostra se o motivo está ativo ou inativo para utilização</param>
        /// <param name="save">Se deverá ser salvo ou não</param>
        /// <returns>Objeto com dados</returns>
        public static MotivoCancelamento CriarMotivoCancelamento(Session session, String txDescricao,
                                                                 CsStatusMotivoCancelamento csSituacao = CsStatusMotivoCancelamento.Ativo, bool save = true)
        {
            MotivoCancelamento motivoCancelamento = new MotivoCancelamento(session)
            {
                TxDescricao = txDescricao,
                CsSituacao  = csSituacao
            };

            if (save)
            {
                motivoCancelamento.Save();
            }

            return(motivoCancelamento);
        }
Ejemplo n.º 7
0
        public bool Salvar(MotivoCancelamentoDTO dto)
        {
            if (!UsuarioLogado.IsInRole(Funcionalidade.MotivoCancelamentoGravar))
            {
                messageQueue.Add(Resource.Sigim.ErrorMessages.PrivilegiosInsuficientes, TypeMessage.Error);
                return(false);
            }

            if (dto == null)
            {
                throw new ArgumentNullException("dto");
            }

            bool novoItem = false;

            var motivoCancelamento = motivoCancelamentoRepository.ObterPeloId(dto.Id);

            if (motivoCancelamento == null)
            {
                motivoCancelamento = new MotivoCancelamento();
                novoItem           = true;
            }

            motivoCancelamento.Descricao = dto.Descricao;

            if (Validator.IsValid(motivoCancelamento, out validationErrors))
            {
                if (novoItem)
                {
                    motivoCancelamentoRepository.Inserir(motivoCancelamento);
                }
                else
                {
                    motivoCancelamentoRepository.Alterar(motivoCancelamento);
                }

                motivoCancelamentoRepository.UnitOfWork.Commit();
                messageQueue.Add(Resource.Sigim.SuccessMessages.SalvoComSucesso, TypeMessage.Success);
                return(true);
            }
            else
            {
                messageQueue.AddRange(validationErrors, TypeMessage.Error);
            }

            return(false);
        }
        public static bool RnSetUltimoMotivoCancelamento(Session session, Projeto projeto, MotivoCancelamento motivo)
        {
            try
            {
                if (projeto.UltimoFiltro != null)
                {
                    if (projeto.UltimoFiltro.MotivoCancelamentoCiclo != null)
                    {
                        if (projeto.UltimoFiltro.MotivoCancelamentoCiclo.Oid != motivo.Oid)
                        {
                            projeto.UltimoFiltro.MotivoCancelamentoCiclo = motivo;
                        }
                    }
                    else
                    {
                        projeto.UltimoFiltro.MotivoCancelamentoCiclo = motivo;
                    }
                }
                else
                {
                    projeto.UltimoFiltro = new ProjetoUltimoFiltro(projeto.Session);
                    RnSetUltimoMotivoCancelamento(session, projeto, motivo);
                    return(true);
                }

                session.UpdateSchema();
                session.CommitTransaction();
            }catch
            {
                return(false);
            }
            return(true);
        }