Beispiel #1
0
        public void AtualizarTarefaNaoAjusteManual(SolicitacaoBeneficio SolBenef)
        {
            Guid tipoAtividadeExecucao;

            if (!Guid.TryParse(ConfigurationManager.GetSettingValue("TipoAtividadeExecucao"), out tipoAtividadeExecucao))
            {
                throw new ArgumentException("(CRM) Faltando parâmetro TipoAtividadeExecucao no SDKore");
            }

            if (SolBenef.TipoSolicitacao != null && !SolBenef.AjusteSaldo.Value)
            {
                var tarefaService = new TarefaService(RepositoryService);

                Lookup referenteA    = new Lookup(SolBenef.ID.Value, "");
                Lookup tipoAtividade = new Lookup(tipoAtividadeExecucao, "");
                var    tarefa        = tarefaService.ObterPor(referenteA.Id, tipoAtividade.Id, (int)Enum.Tarefa.StateCode.Ativo);

                if (tarefa != null)
                {
                    tarefa.Resultado           = (int)Enum.Tarefa.Resultado.PagamentoEfetuadoPedidoGerado;
                    tarefa.PareceresAnteriores = "Validada/Aprovada";
                    tarefa.Status = 5;
                    tarefa.State  = 1;

                    string retorno;
                    tarefaService.Persistir(tarefa, out retorno);
                }
            }
        }
Beispiel #2
0
        public bool PersistirMotivoPausaNaTarefa(PausaTarefa pausa)
        {
            bool persistiu = false;
            var  _mTarefa  = BuscaTarefa(pausa.Tarefa.Id);

            if (_mTarefa != null)
            {
                //atribui para a Tarefa o mesmo motivo
                _mTarefa.MotivoPausa = pausa.Motivo.Name;
                string retorno;

                TarefaService tarefaService = new TarefaService(OrganizationName, isOffline);
                persistiu = tarefaService.Persistir(_mTarefa, out retorno) != null;
            }

            return(persistiu);
        }
        public void CriarTarefaParaChecklistCompromissoCanal(int ordem, CompromissosDoCanal compromissoDoCanal)
        {
            ParametroGlobal parametroFrequenciaChecklist = RepositoryService.ParametroGlobal
                                                           .ObterPor((int)Enum.TipoParametroGlobal.FrequenciaChecklist, compromissoDoCanal.UnidadeDeNegocio.Id, null, null, null, compromissoDoCanal.Compromisso.Id, null, null);

            if (parametroFrequenciaChecklist == null)
            {
                throw new ArgumentException("(CRM) Parâmetro Global Frequencia de Checklist não encontrado para o Compromisso Envio de evidências de Showroom e Unidade de Negócio [" + compromissoDoCanal.UnidadeDeNegocio.Name + "].");
            }

            var compromissoPrograma = new CompromissosDoPrograma(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline)
            {
                ID   = compromissoDoCanal.CompromissosDoPrograma.ID,
                Nome = compromissoDoCanal.CompromissosDoPrograma.Nome
            };

            TarefaService ServiceTarefas           = new TarefaService(RepositoryService);
            string        tituloAtividadeChecklist = ServiceTarefas.ObterProximaAtividadeCheckup(ordem + 1, compromissoPrograma);


            Tarefa task = new Tarefa(RepositoryService);

            task.ReferenteA = new Lookup(compromissoDoCanal.ID.Value, SDKore.Crm.Util.Utility.GetEntityName(compromissoDoCanal));
            task.Assunto    = tituloAtividadeChecklist;
            task.Ordem      = ordem;
            task.Conclusao  = DateTime.Now.AddDays(parametroFrequenciaChecklist.GetValue <int>());

            var tipoTarefa = new TarefaService(RepositoryService).BuscarTipoTarefa("Checklist");

            if (tipoTarefa != null)
            {
                task.TipoDeAtividade = new Lookup(tipoTarefa.ID.Value, SDKore.Crm.Util.Utility.GetEntityName(tipoTarefa));
            }

            Guid idTarefa = RepositoryService.Tarefa.Create(task);

            if (idTarefa != Guid.Empty)
            {
                Domain.Model.Usuario proprietario = new Domain.Servicos.UsuarioService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline).BuscarProprietario("itbc_compdocanal", "itbc_compdocanalid", compromissoDoCanal.Id);
                if (proprietario != null)
                {
                    new Domain.Servicos.UtilService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline).MudarProprietarioRegistro("systemuser", proprietario.ID.Value, "task", idTarefa);
                }
            }
        }
        public void TestarTarefaVisitaComercial()
        {
            string organizationName = ConfigurationManager.GetSettingValue("OrganizacaoIntelbras");

            Domain.Servicos.TarefaService ServiceTarefas = new Domain.Servicos.TarefaService(organizationName, false);
            Domain.Model.Tarefa           Tarefa         = ServiceTarefas.BuscaTarefa(new Guid("BEC979ED-A74F-E411-93F5-00155D013E70"));

            if (Tarefa.ReferenteA.Type.Equals("account"))
            {
                Domain.Model.Conta canal = new Intelbras.CRM2013.Domain.Servicos.ContaService(organizationName, false).BuscaConta(Tarefa.ReferenteA.Id);
                if (canal == null || canal.Classificacao == null)
                {
                    throw new ArgumentException("Conta cadastrada no campo 'Referente a' não encontrada!");
                }

                Domain.Model.ParametroGlobal paramGlobal = new Intelbras.CRM2013.Domain.Servicos.ParametroGlobalService(organizationName, false).ObterPor((int)Domain.Enum.TipoParametroGlobal.FrequenciaChecklist, null, canal.Classificacao.Id, null, null, null, null, (int)Domain.Enum.ParametroGlobal.Parametrizar.VisitaComercial);
                Domain.Model.ParametroGlobal paramGlobalListaAtividades = new Intelbras.CRM2013.Domain.Servicos.ParametroGlobalService(organizationName, false).ObterPor((int)Domain.Enum.TipoParametroGlobal.AtividadesChecklist, null, canal.Classificacao.Id, null, null, null, null, (int)Domain.Enum.ParametroGlobal.Parametrizar.VisitaComercial);

                List <String> lstAtividades = new Intelbras.CRM2013.Domain.Servicos.TarefaService(organizationName, false).ConverterParametroParaLista(paramGlobalListaAtividades.Valor);

                if (lstAtividades.Count > 0)
                {
                    string atividade = ServiceTarefas.ObterProximaAtividadeCheckup(lstAtividades, Tarefa.Assunto);

                    if (!string.IsNullOrEmpty(atividade))
                    {
                        Domain.Model.Tarefa novaTarefa = new Domain.Model.Tarefa(organizationName, false);

                        novaTarefa.Assunto = atividade;

                        Domain.Model.TipoDeAtividade tipoAtividade = new Domain.Servicos.TarefaService(organizationName, false).BuscarTipoTarefa("Checklist");
                        if (tipoAtividade != null)
                        {
                            novaTarefa.TipoDeAtividade = new SDKore.DomainModel.Lookup(tipoAtividade.ID.Value, tipoAtividade.Nome, "");
                        }
                        novaTarefa.Conclusao = DateTime.Now.AddDays(Convert.ToInt16(paramGlobal.Valor));

                        novaTarefa.ReferenteA = new SDKore.DomainModel.Lookup(canal.ID.Value, "account");

                        novaTarefa.ID = new Domain.Servicos.TarefaService(organizationName, false).Persistir(novaTarefa);
                    }
                }
            }
        }
        public void MonitoramentoPorSolicitacoes()
        {
            Trace       = new SDKore.Helper.Trace("Monitoramento por Solicitação");
            mensagemLog = new List <string>();

            List <CompromissosDoCanal> lstCompCanal = CompromissoDoCanalService.ListarAtivosVencidosCumpridos(Intelbras.CRM2013.Domain.Enum.CompromissoPrograma.TipoMonitoramento.Solicitacoes);

            foreach (var item in lstCompCanal)
            {
                List <Tarefa> tarefas = TarefaService.ListarTarefasAtivas(item.ID.Value);

                var compromissoCanalUpdate = new CompromissosDoCanal(item.OrganizationName, isOffline)
                {
                    ID = item.ID
                };

                if (tarefas.Count > 0)
                {
                    compromissoCanalUpdate.StatusCompromisso = new Lookup(StatusCompromissoNaoCumprido.ID.Value, "");
                }
                else
                {
                    ParametroGlobal paramGlobal = new Domain.Servicos.ParametroGlobalService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline, RepositoryService.Provider)
                                                  .ObterFrequenciaAtividadeChecklist(item.Compromisso.Id);

                    if (paramGlobal != null)
                    {
                        compromissoCanalUpdate.Validade = DateTime.Today.AddDays(int.Parse(paramGlobal.Valor));
                    }
                    else
                    {
                        InserirLogFormat("Parametro global {0} não localizado para o compromisso {1}", Enum.TipoParametroGlobal.FrequenciaChecklist, item.Compromisso.Name);
                        continue;
                    }
                }

                RepositoryService.CompromissosDoCanal.Update(compromissoCanalUpdate);
            }

            this.EnviaEmailDeLog("Monitoramento Por Solicitações");
        }
        private void ExecutaVerificacaoDeValidade_Solicitacoes(CompromissosDoCanal compCanal)
        {
            List <Tarefa> tarefas = TarefaService.ListarTarefasAtivas(compCanal.ID.Value);

            CompromissosDoPrograma compPrograma = RepositoryService.CompromissosPrograma.ObterPorCompCanal(compCanal.ID.Value);


            #region VERIFICA VALIDADE
            if ((compCanal.Validade == null || compCanal.Validade < DateTime.Now) &&
                (compPrograma.TipoMonitoramento != null && compPrograma.TipoMonitoramento.Value == (int)Enum.CompromissoPrograma.TipoMonitoramento.Solicitacoes))
            {
                if (tarefas.Count > 0)
                {
                    if (tarefas[0].Conclusao < DateTime.Now)
                    {
                        compCanal.StatusCompromisso = new Lookup(RepositoryService.StatusCompromissos.ObterPor(Domain.Enum.CompromissoCanal.StatusCompromisso.Nao_Cumprido).ID.Value, "");
                        RepositoryService.CompromissosDoCanal.Update(compCanal);
                    }
                }
                else
                {
                    ParametroGlobal paramGlobal = new Domain.Servicos.ParametroGlobalService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline, RepositoryService.Provider)
                                                  .ObterFrequenciaAtividadeChecklist(compCanal.Compromisso.Id);

                    if (paramGlobal != null)
                    {
                        compCanal.Validade = DateTime.Now.AddDays(int.Parse(paramGlobal.Valor));
                        RepositoryService.CompromissosDoCanal.Update(compCanal);
                    }
                    else
                    {
                        InserirLog("Parametro global " + Enum.TipoParametroGlobal.FrequenciaChecklist + " não localizado para o compromisso " + compCanal.Compromisso.Name);
                    }
                }
            }
            #endregion
        }
Beispiel #7
0
        public void Execute(IServiceProvider serviceProvider)
        {
            lock (thisLock)
            {
                var                         context        = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
                ITracingService             trace          = (ITracingService)serviceProvider.GetService(typeof(ITracingService));
                IOrganizationServiceFactory serviceFactory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
                IOrganizationService        service        = serviceFactory.CreateOrganizationService(null);

                TarefaService ServiceTarefas = new TarefaService(context.OrganizationName, context.IsExecutingOffline, service);
                CompromissosDoCanalService ServiceCompromissosDoCanal = new CompromissosDoCanalService(context.OrganizationName, context.IsExecutingOffline, service);

                try
                {
                    trace.Trace(context.MessageName);

                    Intelbras.CRM2013.Domain.Model.Tarefa mTarefa = null;
                    switch (Util.Utilitario.ConverterEnum <Domain.Enum.Plugin.MessageName>(context.MessageName))
                    {
                    case Domain.Enum.Plugin.MessageName.Create:
                        var entidade = (Entity)context.InputParameters["Target"];
                        mTarefa = ServiceTarefas.BuscaTarefa(entidade.Id);


                        new Intelbras.CRM2013.Domain.Servicos.TarefaService(context.OrganizationName, context.IsExecutingOffline, service).CriarParecerParaSolicitacao(mTarefa);
                        Guid tipoAtividadeExecucao;

                        if (!Guid.TryParse(SDKore.Configuration.ConfigurationManager.GetSettingValue("TipoAtividadeExecucao"), out tipoAtividadeExecucao))
                        {
                            throw new ArgumentException("(CRM) Faltando parâmetro TipoAtividadeExecucao no SDKore");
                        }

                        trace.Trace("Parâmetro do Config: TipoAtividadeExecucao '{0}'", tipoAtividadeExecucao);

                        if (mTarefa.ReferenteA != null && mTarefa.TipoDeAtividade != null && mTarefa.TipoDeAtividade.Id == tipoAtividadeExecucao)
                        {
                            trace.Trace("Tarefa do tipo Execução.");

                            SolicitacaoBeneficio solBenef = new Intelbras.CRM2013.Domain.Servicos.SolicitacaoBeneficioService(context.OrganizationName, context.IsExecutingOffline, service).ObterPor(mTarefa.ReferenteA.Id);

                            if (solBenef == null)
                            {
                                throw new ArgumentException("(CRM) Solicitação não encontrada.");
                            }

                            if (solBenef.TipoSolicitacao != null && solBenef.AjusteSaldo.Value)
                            {
                                trace.Trace("Solicitação do tipo Ajuste.");

                                Tarefa _mTarefa = new Intelbras.CRM2013.Domain.Model.Tarefa(context.OrganizationName, context.IsExecutingOffline, service);
                                _mTarefa.ID        = context.PrimaryEntityId;
                                _mTarefa.Resultado = (int)Domain.Enum.Tarefa.Resultado.PagamentoEfetuadoPedidoGerado;
                                _mTarefa.State     = 1;
                                string retorno;

                                TarefaService tarefaService = new Intelbras.CRM2013.Domain.Servicos.TarefaService(context.OrganizationName, context.IsExecutingOffline, service);
                                tarefaService.Persistir(_mTarefa, out retorno);

                                trace.Trace(tarefaService.Trace.StringTrace.ToString());
                                tarefaService.Trace.Save();
                            }
                        }

                        mTarefa.TempoAtuacao = 0;
                        break;

                    case Domain.Enum.Plugin.MessageName.SetStateDynamicEntity:

                        if (context.PostEntityImages.Contains("imagem") && context.PostEntityImages["imagem"] is Entity)
                        {
                            Tarefa Tarefa = context.PostEntityImages["imagem"].Parse <Tarefa>(context.OrganizationName, context.IsExecutingOffline, service);

                            if (Tarefa.ReferenteA == null || Tarefa.State.Value != (int)Domain.Enum.Tarefa.StateCode.Fechada)
                            {
                                break;
                            }

                            if (Tarefa.ReferenteA.Type.ToLower() == SDKore.Crm.Util.Utility.GetEntityName <SolicitacaoBeneficio>().ToLower())
                            {
                                new ProcessoDeSolicitacoesService(context.OrganizationName, context.IsExecutingOffline, service)
                                .ConcluirTarefaSolicitacaoBeneficio(Tarefa, context.UserId);
                            }
                            else if (Tarefa.ReferenteA.Type.ToLower() == SDKore.Crm.Util.Utility.GetEntityName <SolicitacaoCadastro>().ToLower())
                            {
                                new ProcessoDeSolicitacoesService(context.OrganizationName, context.IsExecutingOffline, service)
                                .ConcluirTarefaSolicitacaoDeCadastro(Tarefa, context.UserId);
                            }
                            else if (Tarefa.ReferenteA.Type.ToLower() == SDKore.Crm.Util.Utility.GetEntityName <CompromissosDoCanal>().ToLower())
                            {
                                new ProcessoDeSolicitacoesService(context.OrganizationName, context.IsExecutingOffline, service)
                                .ConcluirTarefaCompromissoCanal(Tarefa);
                            }
                            else if (Tarefa.ReferenteA.Type.ToLower() == SDKore.Crm.Util.Utility.GetEntityName <Conta>().ToLower())
                            {
                                if (Tarefa.TipoDeAtividade.Name.Contains("Checklist"))
                                {
                                    #region Pendencia Key-Account comentada

                                    Conta canal = new Intelbras.CRM2013.Domain.Servicos.ContaService(context.OrganizationName, context.IsExecutingOffline, service).BuscaConta(Tarefa.ReferenteA.Id);
                                    if (canal == null || canal.Classificacao == null)
                                    {
                                        throw new ArgumentException("(CRM) Conta cadastrada no campo 'Referente a' não encontrada!");
                                    }

                                    ParametroGlobal paramGlobal = new Intelbras.CRM2013.Domain.Servicos.ParametroGlobalService(context.OrganizationName, context.IsExecutingOffline, service).ObterPor((int)Domain.Enum.TipoParametroGlobal.FrequenciaChecklist, null, canal.Classificacao.Id, null, null, null, null, (int)Domain.Enum.ParametroGlobal.Parametrizar.VisitaComercial);
                                    ParametroGlobal paramGlobalListaAtividades = new Intelbras.CRM2013.Domain.Servicos.ParametroGlobalService(context.OrganizationName, context.IsExecutingOffline, service).ObterPor((int)Domain.Enum.TipoParametroGlobal.AtividadesChecklist, null, canal.Classificacao.Id, null, null, null, null, (int)Domain.Enum.ParametroGlobal.Parametrizar.VisitaComercial);

                                    List <String> lstAtividades = new Intelbras.CRM2013.Domain.Servicos.TarefaService(context.OrganizationName, context.IsExecutingOffline, service).ConverterParametroParaLista(paramGlobalListaAtividades.Valor);

                                    if (lstAtividades.Count > 0)
                                    {
                                        string atividade = ServiceTarefas.ObterProximaAtividadeCheckup(lstAtividades, Tarefa.Assunto);

                                        if (!string.IsNullOrEmpty(atividade))
                                        {
                                            Domain.Model.Tarefa novaTarefa = new Domain.Model.Tarefa(context.OrganizationName, context.IsExecutingOffline, service);

                                            Domain.Model.TipoDeAtividade tipoAtividade = new Domain.Servicos.TarefaService(context.OrganizationName, context.IsExecutingOffline, service).BuscarTipoTarefa("Checklist");
                                            if (tipoAtividade != null)
                                            {
                                                novaTarefa.TipoDeAtividade = new SDKore.DomainModel.Lookup(tipoAtividade.ID.Value, tipoAtividade.Nome, "");
                                            }

                                            novaTarefa.Assunto    = atividade;
                                            novaTarefa.Conclusao  = DateTime.Now.AddDays(Convert.ToInt16(paramGlobal.Valor));
                                            novaTarefa.ReferenteA = new SDKore.DomainModel.Lookup(canal.ID.Value, "account");

                                            novaTarefa.ID = new Domain.Servicos.TarefaService(context.OrganizationName, context.IsExecutingOffline, service).Persistir(novaTarefa);
                                            if (novaTarefa.ID.HasValue)
                                            {
                                                Usuario proprietario = new Domain.Servicos.UsuarioService(context.OrganizationName, context.IsExecutingOffline, service).BuscarProprietario("task", "activityid", Tarefa.Id);
                                                if (proprietario != null)
                                                {
                                                    new Domain.Servicos.UtilService(context.OrganizationName, context.IsExecutingOffline, service).MudarProprietarioRegistro("systemuser", proprietario.ID.Value, "task", novaTarefa.ID.Value);
                                                }
                                            }
                                        }
                                    }
                                    else
                                    {
                                        Domain.Model.CompromissosDoCanal CompromissoCanal = ServiceCompromissosDoCanal.BuscarPorGuid(Tarefa.ReferenteA.Id);

                                        if (CompromissoCanal != null && CompromissoCanal.Compromisso != null)
                                        {
                                            List <string> listaAtividadesCheckup2 = ServiceTarefas.ListarAtividadesCheckup(CompromissoCanal.Compromisso.Id);

                                            if (listaAtividadesCheckup2.Count > 0)
                                            {
                                                string atividade = ServiceTarefas.ObterProximaAtividadeCheckup(listaAtividadesCheckup2, Tarefa.Assunto);

                                                if (!string.IsNullOrEmpty(atividade))
                                                {
                                                    Domain.Model.Usuario proprietario = new Domain.Servicos.UsuarioService(context.OrganizationName, context.IsExecutingOffline, service).BuscarProprietario("itbc_compdocanal", "itbc_compdocanalid", CompromissoCanal.Id);
                                                    if (proprietario != null)
                                                    {
                                                        new Intelbras.CRM2013.Domain.Servicos.CompromissosDoCanalService(context.OrganizationName, context.IsExecutingOffline, service).GerarAtividadeChecklist(atividade, CompromissoCanal, proprietario);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    #endregion
                                }
                            }
                        }
                        break;
                    }
                }
                catch (Exception ex)
                {
                    string message = SDKore.Helper.Error.Handler(ex);

                    trace.Trace(SDKore.Helper.Error.GetMessageError(ex));
                    throw new InvalidPluginExecutionException(message, ex);
                }
            }
        }
 private void ExecutaVerificacaoDeValidade_Tarefas(CompromissosDoCanal compCanal)
 {
     TarefaService tarefa = new TarefaService(OrganizationName, isOffline);
     //tarefa.MonitoramentoPorTarefas(compCanal); //TODO: GABRIEL
 }
        public void EnvioDeEvidenciaShowRoom(Tarefa Task)
        {
            SolicitacaoBeneficio solBen = RepositoryService.SolicitacaoBeneficio.Retrieve(Task.ReferenteA.Id);

            CompromissosDoCanal compromissoCanal = RepositoryService.CompromissosDoCanal.ObterPorNome(Enum.CompromissoCanal.Compromisso.EnvioShowroom.ToString(), solBen.Canal.Id, solBen.UnidadedeNegocio.Id);

            if (compromissoCanal != null)
            {
                if (compromissoCanal.Compromisso.Name == Enum.CompromissoCanal.Compromisso.EnvioShowroom)
                {
                    if (!Task.ReferenteA.Type.ToLower().Equals(SDKore.Crm.Util.Utility.GetEntityName <SolicitacaoBeneficio>().ToLower()))
                    {
                        return;
                    }

                    compromissoCanal.StatusCompromisso = new Lookup(RepositoryService.StatusCompromissos.ObterPor(Domain.Enum.CompromissoCanal.StatusCompromisso.Cumprido).ID.Value, "");
                    RepositoryService.CompromissosDoCanal.Update(compromissoCanal);

                    SolicitacaoBeneficio mSolicitacaoBeneficio = RepositoryService.SolicitacaoBeneficio.Retrieve(Task.ReferenteA.Id);

                    if (mSolicitacaoBeneficio == null)
                    {
                        throw new ArgumentException("Solicitação de benefício no campo 'Referente a' não encontrada ou Desativada.");
                    }

                    ParametroGlobal parametroAtividadeQtdeEvidencia = RepositoryService.ParametroGlobal.ObterPor((int)Enum.TipoParametroGlobal.QuatidadeEvidenciaShowRoom, mSolicitacaoBeneficio.UnidadedeNegocio.Id, null, null, null, compromissoCanal.Compromisso.Id, null, null);
                    if (parametroAtividadeQtdeEvidencia == null)
                    {
                        throw new ArgumentException("(CRM)  Parâmetro Global Quantidade de Evidências Show Room não encontrado para o Compromisso Envio de evidências de Showroom e Unidade de Negócio [" + mSolicitacaoBeneficio.UnidadedeNegocio.Name + "].");
                    }

                    ParametroGlobal parametroAtividadeChacklist = RepositoryService.ParametroGlobal.ObterPor((int)Enum.TipoParametroGlobal.AtividadesChecklist, mSolicitacaoBeneficio.UnidadedeNegocio.Id, null, null, null, compromissoCanal.Compromisso.Id, null, null);
                    if (parametroAtividadeChacklist == null)
                    {
                        throw new ArgumentException("(CRM) Parâmetro Global Atividade de Checklist não encontrado para o Compromisso Envio de evidências de Showroom e Unidade de Negócio [" + mSolicitacaoBeneficio.UnidadedeNegocio.Name + "].");
                    }

                    ParametroGlobal parametroFrequenciaChecklist = RepositoryService.ParametroGlobal.ObterPor((int)Enum.TipoParametroGlobal.FrequenciaChecklist, mSolicitacaoBeneficio.UnidadedeNegocio.Id, null, null, null, compromissoCanal.Compromisso.Id, null, null);
                    if (parametroFrequenciaChecklist == null)
                    {
                        throw new ArgumentException("(CRM) Parâmetro Global Frequencia de Checklist não encontrado para o Compromisso Envio de evidências de Showroom e Unidade de Negócio [" + mSolicitacaoBeneficio.UnidadedeNegocio.Name + "].");
                    }

                    Tarefa task = new Tarefa(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline);

                    task.ReferenteA = new Lookup(compromissoCanal.ID.Value, SDKore.Crm.Util.Utility.GetEntityName <CompromissosDoPrograma>());
                    task.Assunto    = parametroAtividadeChacklist.GetValue <string>();
                    task.Ordem      = Task.Ordem + 1;
                    task.Conclusao  = DateTime.Now.AddDays(parametroFrequenciaChecklist.GetValue <int>());

                    var tipoTarefa = new TarefaService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline).BuscarTipoTarefa("Checklist");

                    if (tipoTarefa != null)
                    {
                        task.TipoDeAtividade = new Lookup(tipoTarefa.ID.Value, SDKore.Crm.Util.Utility.GetEntityName(tipoTarefa));
                    }

                    Conta canal = RepositoryService.Conta.Retrieve(mSolicitacaoBeneficio.Canal.Id, "ownerid");

                    Guid idTarefa = RepositoryService.Tarefa.Create(task);
                    if (idTarefa != Guid.Empty)
                    {
                        if (canal != null)
                        {
                            Domain.Model.Usuario proprietario = new Domain.Servicos.UsuarioService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline).BuscarProprietario("account", "accountid", canal.Id);

                            if (proprietario != null)
                            {
                                new Domain.Servicos.UtilService(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline).MudarProprietarioRegistro("systemuser", proprietario.ID.Value, "task", idTarefa);
                            }
                        }
                    }
                }
            }
        }