private AcessoKonviva ProcessaAcessoKonviva(Contato contatoAtual, AcessoKonviva entradaExistente)
{
AcessoKonviva novo = null;
//if (contatoAtual.AssociadoA != null && entradaExistente.Conta != null)
if (contatoAtual.AssociadoA != null)
{
Conta canal = RepositoryService.Conta.Retrieve(contatoAtual.AssociadoA.Id);
novo = ObterUnidadeKonvivaDeParaCom(entradaExistente, canal, null);
}
else
{
novo = ObterUnidadeKonvivaDeParaCom(entradaExistente, null, contatoAtual);
}
using (StreamWriter w = File.AppendText(@"c:\logkonviva.txt"))
{
w.WriteLine("ATUAL;" + contatoAtual.NomeCompleto + ";" + entradaExistente.UnidadeKonviva.Id + ";" + entradaExistente.DeParaUnidadeKonviva.Id + ";" + novo.UnidadeKonviva.Id + ";" + (novo.DeParaUnidadeKonviva != null ? novo.DeParaUnidadeKonviva.Id.ToString() : "NULL"));
}
if (entradaExistente.UnidadeKonviva != novo.UnidadeKonviva ||
entradaExistente.DeParaUnidadeKonviva != novo.DeParaUnidadeKonviva)
{
entradaExistente.UnidadeKonviva = novo.UnidadeKonviva;
entradaExistente.DeParaUnidadeKonviva = novo.DeParaUnidadeKonviva;
return(entradaExistente);
}
else
{
return(null);
}
}
public AcessoKonviva Persistir(Model.AcessoKonviva objAcessoKonviva)
{
AcessoKonviva TmpAcessoKonviva = null;
if (objAcessoKonviva.ID.HasValue)
{
TmpAcessoKonviva = RepositoryService.AcessoKonviva.ObterPor(objAcessoKonviva.ID.Value);
if (TmpAcessoKonviva != null)
{
RepositoryService.AcessoKonviva.Update(objAcessoKonviva);
//Altera Status - Se necessário
if (objAcessoKonviva.Status.HasValue && !TmpAcessoKonviva.Status.Equals(objAcessoKonviva.Status))
{
this.MudarStatus(TmpAcessoKonviva.ID.Value, objAcessoKonviva.Status.Value);
}
return(TmpAcessoKonviva);
}
else
{
return(null);
}
}
else
{
objAcessoKonviva.ID = RepositoryService.AcessoKonviva.Create(objAcessoKonviva);
return(objAcessoKonviva);
}
}
public AcessoKonviva RetornarUnidadeCorreta(AcessoKonviva acessoKonviva)
{
var deParaService = new DeParaDeUnidadeDoKonvivaService(RepositoryService);
if (acessoKonviva.Conta != null)
{
var canal = RepositoryService.Conta.Retrieve(acessoKonviva.Conta.Id);
return(deParaService.ObterUnidadeKonvivaDeParaCom(acessoKonviva, canal, null));
}
else
{
var contato = RepositoryService.Contato.Retrieve(acessoKonviva.Contato.Id);
return(deParaService.ObterUnidadeKonvivaDeParaCom(acessoKonviva, null, contato));
}
}
public void CriarAcessoKonvivaPadrao(Guid contatoId)
{
Contato contatoM = RepositoryService.Contato.Retrieve(contatoId);
if (contatoM == null)
{
throw new ArgumentException("(CRM) Contato não existente");
}
AcessoKonviva acessoKonviva = RepositoryService.AcessoKonviva.ObterPorContato(contatoId, Domain.Enum.StateCode.Ativo);
if (acessoKonviva != null)
{
throw new ArgumentException("(CRM) Usuário Konviva Duplicado!");
}
acessoKonviva = new AcessoKonviva(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline);
acessoKonviva.Contato = new Lookup(contatoM.ID.Value, "");
//Nova regra de atribuição de Unidade Konviva
if (contatoM.AssociadoA != null && contatoM.AssociadoA.Type == SDKore.Crm.Util.Utility.GetEntityName <Conta>())
{
acessoKonviva.Conta = new Lookup(contatoM.AssociadoA.Id, contatoM.AssociadoA.Type);
acessoKonviva = new DeParaDeUnidadeDoKonvivaService(RepositoryService).ObterUnidadeKonvivaDeParaCom(acessoKonviva, RepositoryService.Conta.Retrieve(acessoKonviva.Conta.Id), null);
}
else
{
acessoKonviva = new DeParaDeUnidadeDoKonvivaService(RepositoryService).ObterUnidadeKonvivaDeParaCom(acessoKonviva, null, contatoM);
}
if (acessoKonviva.UnidadeKonviva == null && this.organizacaoPadrao.HasValue)
{
acessoKonviva.UnidadeKonviva = new Lookup(this.organizacaoPadrao.Value, "");
acessoKonviva.DeParaUnidadeKonviva = null;
}
//reseta o perfil para apenas aluno selecionado
acessoKonviva = this.ResetarPerfilKonviva(acessoKonviva);
//TODO NOME KONVIVA VER PADRAO DO DOCUMENTOS
acessoKonviva.Nome = acessoKonviva.Contato.Name;
RepositoryService.AcessoKonviva.Create(acessoKonviva);
}
/// <summary>
/// Valida se o usuário que não é vinculado a intelbras possui um perfil que nao poderia ter
/// </summary>
/// <param name="acessoKonviva"></param>
/// <returns>Retorna true se estiver Ok, e falso se estiver inválido</returns>
public Boolean ValidarTipoAcesso(AcessoKonviva acessoKonviva)
{
string cnpjMatrizIntelbras = SDKore.Configuration.ConfigurationManager.GetSettingValue("Intelbras.Conta.CnpjMatriz");
if (string.IsNullOrWhiteSpace(cnpjMatrizIntelbras))
{
throw new ArgumentException("(CRM) CNPJ da Matriz Intelbras não está configurado!");
}
Conta conta = new ContaService(RepositoryService).BuscaContaPorCpfCnpj(cnpjMatrizIntelbras);
if (conta == null)
{
throw new ArgumentException("(CRM) Conta Intelbras não encontrada");
}
if (acessoKonviva.Contato == null)
{
throw new ArgumentException("(CRM) Acesso Konviva não possui contato");
}
Contato contato = RepositoryService.Contato.Retrieve(acessoKonviva.Contato.Id);
if (contato == null)
{
throw new ArgumentException("(CRM) Contato não existente");
}
List <AcessoKonviva> listaAcessoKonviva = RepositoryService.AcessoKonviva.ListarPor(contato.ID.Value);
if (listaAcessoKonviva.Count > 1)
{
throw new ArgumentException("(CRM) Acesso Konviva duplicado no sistema !");
}
if (contato.AssociadoA == null || contato.AssociadoA.Id != conta.ID.Value)
{
if (acessoKonviva.PerfilAdministrador == true)
{
return(false);
}
}
return(true);
}
public AcessoKonviva ResetarPerfilKonviva(AcessoKonviva acessoKonviva)
{
if (acessoKonviva == null)
{
throw new ArgumentNullException("AcessoKonviva não fornecido");
}
acessoKonviva.PerfilAdministrador = false;
acessoKonviva.PerfilAluno = true;
acessoKonviva.PerfilAnalista = false;
acessoKonviva.PerfilAutor = false;
acessoKonviva.PerfilGestor = false;
acessoKonviva.PerfilInstrutor = false;
acessoKonviva.PerfilModerador = false;
acessoKonviva.PerfilMonitor = false;
acessoKonviva.PerfilTutor = false;
return(acessoKonviva);
}
public void AtualizarUnidadeKonvivaDosContatosDoCanal(Guid?canalId)
{
if (canalId.HasValue)
{
var aKService = new AcessoKonvivaService(RepositoryService);
Conta canal = RepositoryService.Conta.Retrieve(canalId.Value);
AcessoKonviva acessoKonviva = new AcessoKonviva(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline);
var listaDeContatos = RepositoryService.Contato.ListarPor(canal);
var novo = new AcessoKonviva(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline);
novo = ObterUnidadeKonvivaDeParaCom(acessoKonviva, canal, null);
foreach (var contato in listaDeContatos)
{
acessoKonviva = aKService.ObterPorContato(contato.ID.Value, Enum.StateCode.Ativo);
acessoKonviva.UnidadeKonviva = novo.UnidadeKonviva;
acessoKonviva.DeParaUnidadeKonviva = novo.DeParaUnidadeKonviva;
aKService.Persistir(acessoKonviva);
}
}
}
public string Enviar(AcessoKonviva objModel)
{
string retMsg = String.Empty;
Intelbras.Message.Helper.MSG0105 mensagem = this.DefinirPropriedades(objModel);
Domain.Servicos.Integracao integracao = new Servicos.Integracao(this.Organizacao, this.IsOffline);
if (integracao.EnviarMensagemBarramento(mensagem.GenerateMessage(true), "1", "1", out retMsg))
{
Intelbras.Message.Helper.MSG0105R1 retorno = CarregarMensagem <Pollux.MSG0105R1>(retMsg);
if (!retorno.Resultado.Sucesso)
{
throw new ArgumentException("(CRM) " + string.Concat(retorno.Resultado.Mensagem));
}
}
else
{
Intelbras.Message.Helper.ERR0001 erro001 = CarregarMensagem <Pollux.ERR0001>(retMsg);
throw new ArgumentException("(CRM) " + string.Concat("Erro de Integração \n", erro001.GenerateMessage(false)));
}
return(retMsg);
}
public AcessoKonviva ObterUnidadeKonvivaDeParaCom(AcessoKonviva acessoKonviva, Conta canal, Contato contato)
{
if (acessoKonviva == null)
{
return(null);
}
List <DeParaDeUnidadeDoKonviva> listaRegistrosDePara = null;
if (canal != null)
{
listaRegistrosDePara = RepositoryService.DeParaDeUnidadeDoKonviva.ListarPor(CapturarCampos(canal), null);
}
else
{
listaRegistrosDePara = RepositoryService.DeParaDeUnidadeDoKonviva.ListarPor(CapturarCampos(contato), null);
}
AcessoKonviva acessoKonvivaNovo = (AcessoKonviva)acessoKonviva.Clone();
if (listaRegistrosDePara.Count > 0)
{
acessoKonvivaNovo.UnidadeKonviva = listaRegistrosDePara.First().UnidadeDoKonviva;
acessoKonvivaNovo.DeParaUnidadeKonviva = new Lookup(listaRegistrosDePara.First().ID.Value, "");
}
else if (this.unidadeKonvivaPadrao.HasValue)
{
acessoKonvivaNovo.UnidadeKonviva = new Lookup(this.unidadeKonvivaPadrao.Value, "");
acessoKonvivaNovo.DeParaUnidadeKonviva = null;
}
else
{
acessoKonvivaNovo.UnidadeKonviva = null;
acessoKonvivaNovo.DeParaUnidadeKonviva = null;
}
return(acessoKonvivaNovo);
}
public void MudarCanal(Contato contato, Guid?canalId)
{
AcessoKonviva acessoKonviva = this.ObterPorContato(contato.ID.Value, Enum.StateCode.Ativo);
if (acessoKonviva != null)
{
acessoKonviva = this.ResetarPerfilKonviva(acessoKonviva);
acessoKonviva.IntegrarNoPlugin = false;
if (canalId.HasValue)
{
acessoKonviva.Conta = new SDKore.DomainModel.Lookup(canalId.Value, SDKore.Crm.Util.Utility.GetEntityName <Conta>());
acessoKonviva = new DeParaDeUnidadeDoKonvivaService(RepositoryService).ObterUnidadeKonvivaDeParaCom(acessoKonviva, RepositoryService.Conta.Retrieve(canalId.Value), null);
}
else
{
acessoKonviva.AddNullProperty("Conta");
acessoKonviva = new DeParaDeUnidadeDoKonvivaService(RepositoryService).ObterUnidadeKonvivaDeParaCom(acessoKonviva, null, contato);
}
this.Persistir(acessoKonviva);
}
}
protected override void Execute(IPluginExecutionContext context, IOrganizationServiceFactory serviceFactory, IOrganizationService adminService, IOrganizationService userService)
{
switch (context.GetMessageName())
{
case PluginBase.MessageName.Update:
if (context.PostEntityImages.Contains("imagem") && context.PostEntityImages["imagem"] is Entity &&
context.PreEntityImages.Contains("imagem") && context.PreEntityImages["imagem"] is Entity)
{
var ContatoPre = ((Entity)context.PreEntityImages["imagem"]).Parse <Contato>(context.OrganizationName, context.IsExecutingOffline, adminService);
var ContatoPos = ((Entity)context.PostEntityImages["imagem"]).Parse <Contato>(context.OrganizationName, context.IsExecutingOffline, adminService);
var contatoService = new ContatoService(context.OrganizationName, context.IsExecutingOffline, adminService);
var contaService = new ContaService(context.OrganizationName, context.IsExecutingOffline, adminService);
//Atualização de Treinamento
new BeneficioDoCanalService(context.OrganizationName, context.IsExecutingOffline, adminService).MudarEmpresa(ContatoPos);
#region Integração
if (context.Depth > 1)
{
return;
}
//Valida se contato tem acesso a Extranet e está sem e-mail
if (string.IsNullOrEmpty(ContatoPos.Email1))
{
ValidaEmailAcessoEXtranet(ContatoPos);
}
if (!ContatoPos.IntegrarNoPlugin && contatoService.ContatoPossuiTodosCamposParaIntegracao(ContatoPos) && (bool)ContatoPos.IntegrarNoBarramento)
{
Guid idContatoEmail = new RepositoryService().AcessoExtranetContato.VerificarEmail(ContatoPos.Email1);
if (idContatoEmail != Guid.Empty && idContatoEmail != ContatoPos.Id)
{
throw new ArgumentException(string.Format("(CRM) Duplicidade encontrada, existe outro contato com acesso a extranet com o mesmo e-mail: [{0}].", ContatoPos.Email1));
}
string xmlResposta = contatoService.IntegracaoBarramento(ContatoPos);
}
//Caso ele mude a associação tem que resetar o perfil do Konviva
//E consequentemente mudar a Unidade do Konviva
if (ContatoPre.AssociadoA == null && ContatoPos.AssociadoA != null ||
(ContatoPre.AssociadoA != null && ContatoPos.AssociadoA != null &&
ContatoPre.AssociadoA.Id != ContatoPos.AssociadoA.Id) ||
ContatoPre.AssociadoA != null && ContatoPos.AssociadoA == null)
{
Guid?guidTmp = ContatoPos.AssociadoA == null ? Guid.Empty : ContatoPos.AssociadoA.Id;
guidTmp = guidTmp == Guid.Empty ? null : guidTmp;
var acessoKonvivaService = new AcessoKonvivaService(context.OrganizationName, context.IsExecutingOffline, adminService);
var acessoExtranetContatoService = new AcessoExtranetContatoService(context.OrganizationName, context.IsExecutingOffline, adminService);
acessoKonvivaService.MudarCanal(ContatoPos, guidTmp);
acessoExtranetContatoService.MudarCanal(ContatoPos.ID.Value, guidTmp, ContatoPos.IntegrarNoPlugin);
if (ContatoPos.AssociadoA == null)
{
contatoService.AlteraTipoRelacao(ContatoPos);
}
}
if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)
{
var entidade = context.GetContextEntity();
Object papelCanalTmp = null;
if (entidade.Attributes.Contains("itbc_papelnocanal") && entidade.Attributes.TryGetValue("itbc_papelnocanal", out papelCanalTmp) && papelCanalTmp != null)
{
if (ContatoPos.AssociadoA == null || entidade.GetAttributeValue <OptionSetValue>("itbc_papelnocanal").Value == (int)Intelbras.CRM2013.Domain.Enum.Contato.PapelNoCanal.Representante)
{
var postImage = (Entity)context.PostEntityImages["imagem"];
postImage = UpdateImage(postImage, entidade);
ContatoPos = postImage.Parse <Contato>(context.OrganizationName, context.IsExecutingOffline, adminService);
var aKService = new AcessoKonvivaService(context.OrganizationName, context.IsExecutingOffline, adminService);
AcessoKonviva acessoKonviva = aKService.ObterPorContato(ContatoPos.ID.Value, Domain.Enum.StateCode.Ativo);
if (acessoKonviva != null)
{
acessoKonviva = new DeParaDeUnidadeDoKonvivaService(context.OrganizationName, context.IsExecutingOffline, adminService).ObterUnidadeKonvivaDeParaCom(acessoKonviva, null, ContatoPos);
aKService.Persistir(acessoKonviva);
}
}
}
}
if ((ContatoPos.Email1 != ContatoPre.Email1) && ContatoPos.AcessoAoPortal == true && ContatoPos.Login != null)
{
if (ContatoPre.Email1 == string.Empty)
{
(new RepositoryService(context.OrganizationName, context.IsExecutingOffline)).Contato.EnviaEmailAcessoPortalCorporativo(ContatoPos);
}
(new RepositoryService(context.OrganizationName, context.IsExecutingOffline)).Contato.UpdateEmailFBA(ContatoPos);
}
//new Domain.Services.PortalFidelidade().RemoverUsuarioDoSharepoint(contato);
//if (contato.ParticipaFidelidade.HasValue && contato.ParticipaFidelidade.Value)
//{
// new Domain.Services.PortalFidelidade().AdicionarAoGrupoSharePoint(contato);
//}
#endregion
}
break;
}
}
public string IntegracaoBarramento(AcessoKonviva objKonviva)
{
Domain.Integracao.MSG0105 msgProdEstab = new Domain.Integracao.MSG0105(RepositoryService.NomeDaOrganizacao, RepositoryService.IsOffline);
return(msgProdEstab.Enviar(objKonviva));
}
public AcessoKonviva DefinirPropriedades(Intelbras.Message.Helper.MSG0105 xml)
{
var crm = new AcessoKonviva(this.Organizacao, this.IsOffline);
Guid idClassificacaoKonviva = Guid.Empty;
Lookup classificacaoKonviva;
Guid organizacaoPadrao;
Guid conta = Guid.Empty;
#region Propriedades Crm->Xml
if (!String.IsNullOrEmpty(xml.NomeAcessoKonviva))
{
crm.Nome = xml.NomeAcessoKonviva;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "NomeAcessoKonviva não enviado!";
return(crm);
}
xml.Situacao = (crm.Status.HasValue ? crm.Status.Value : 0);
//if (xml.Situacao == 1 || xml.Situacao == 0)
// crm.Status = xml.Situacao;
//else
//{
// resultadoPersistencia.Sucesso = false;
// resultadoPersistencia.Mensagem = "Situação não enviada!";
// return crm;
//}
if (!String.IsNullOrEmpty(xml.CodigoAcessoKonviva))
{
Guid konviva;
if (Guid.TryParse(xml.CodigoAcessoKonviva, out konviva))
{
crm.ID = konviva;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "Guid AcessoKonviva Formato incorreto";
return(crm);
}
}
//Seção comentada enquanto não é decidido a documentação
//Conta não é obrigatório então caso nao tenha preenchido a classificação assume um default
//if (String.IsNullOrEmpty(xml.CodigoConta))
//{
// if (false == Guid.TryParse(SDKore.Configuration.ConfigurationManager.GetSettingValue("ClassificacaoPadraoKonviva"), out idClassificacaoKonviva))
// {
// resultadoPersistencia.Sucesso = false;
// resultadoPersistencia.Mensagem = "Guid Classificação Konviva padrão em formato incorreto";
// return crm;
// }
// Classificacao classif = new Intelbras.CRM2013.Domain.Servicos.ClassificacaoService(this.Organizacao,this.IsOffline).BuscaClassificacao(idClassificacaoKonviva);
// if(classif == null)
// {
// resultadoPersistencia.Sucesso = false;
// resultadoPersistencia.Mensagem = "Classificação do Canal não encontrada.";
// return crm;
// }
// classificacaoKonviva = new Lookup(classif.ID.Value,classif.Nome,"");
//}
//else
//{
// if (false == Guid.TryParse(xml.CodigoConta,out conta))
// {
// resultadoPersistencia.Sucesso = false;
// resultadoPersistencia.Mensagem = "Guid conta em formato incorreto";
// return crm;
// }
// Model.Conta mConta = new Intelbras.CRM2013.Domain.Servicos.ContaService(this.Organizacao, this.IsOffline).BuscaConta(conta);
// if (conta == null)
// {
// resultadoPersistencia.Sucesso = false;
// resultadoPersistencia.Mensagem = "Conta não encontrada.";
// return crm;
// }
// if (mConta.Classificacao == null)
// {
// resultadoPersistencia.Sucesso = false;
// resultadoPersistencia.Mensagem = "Classificação da conta obrigatório.";
// return crm;
// }
// classificacaoKonviva = mConta.Classificacao;
//}
if (!Guid.TryParse(SDKore.Configuration.ConfigurationManager.GetSettingValue("organizacaoPadraoKonviva"), out organizacaoPadrao))
{
throw new Exception("Variável organizacaoPadraoKonviva do SDKore.config não foi configurada corretamente.");
}
UnidadeKonviva unKonviva = new Intelbras.CRM2013.Domain.Servicos.UnidadeKonvivaService(this.Organizacao, this.IsOffline).ObterPor(organizacaoPadrao);
if (unKonviva == null)
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "Unidade Konviva não encontrada.";
return(crm);
}
crm.UnidadeKonviva = new Lookup(unKonviva.ID.Value, "");
if (unKonviva.IdInterno.HasValue)
{
crm.IdUnidadeAcessoKonviva = unKonviva.IdInterno;
}
//if (xml.IdentificadorUnidadeKonviva.HasValue)
//{
// UnidadeKonviva unidadeKonviva = new Servicos.UnidadeKonvivaService(this.Organizacao, this.IsOffline).ObterPor(xml.IdentificadorUnidadeKonviva.Value);
// if (unidadeKonviva != null)
// {
// crm.UnidadeKonviva = new Lookup(unidadeKonviva.ID.Value, "");
// crm.IdUnidadeAcessoKonviva = xml.IdentificadorUnidadeKonviva;
// }
// else
// {
// resultadoPersistencia.Sucesso = false;
// resultadoPersistencia.Mensagem = "UnidadeKonviva não cadastrado no Crm!";
// return crm;
// }
//}
//else
//{
// resultadoPersistencia.Sucesso = false;
// resultadoPersistencia.Mensagem = "IdentificadorUnidadeKonviva não enviado!";
// return crm;
//}
if (!String.IsNullOrEmpty(xml.CodigoConta))
{
crm.Conta = new Lookup(new Guid(xml.CodigoConta), "");
}
if (!String.IsNullOrEmpty(xml.CodigoContato) && xml.CodigoContato.Length == 36)
{
crm.Contato = new Lookup(new Guid(xml.CodigoContato), "");
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "CodigoContato inválido ou não enviado!";
return(crm);
}
if (xml.PerfilAluno.HasValue)
{
crm.PerfilAluno = xml.PerfilAluno;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "PerfilAluno não enviado!";
return(crm);
}
if (xml.PerfilGestor.HasValue)
{
crm.PerfilGestor = xml.PerfilGestor;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "PerfilGestor não enviado!";
return(crm);
}
if (xml.PerfilAutor.HasValue)
{
crm.PerfilAutor = xml.PerfilAutor;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "PerfilAutor não enviado!";
return(crm);
}
if (xml.PerfilAdministrador.HasValue)
{
crm.PerfilAdministrador = xml.PerfilAdministrador;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "PerfilAdministrador não enviado!";
return(crm);
}
if (xml.PerfilMonitor.HasValue)
{
crm.PerfilMonitor = xml.PerfilMonitor;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "PerfilMonitor não enviado!";
return(crm);
}
if (xml.PerfilModerador.HasValue)
{
crm.PerfilModerador = xml.PerfilModerador;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "PerfilModerador não enviado!";
return(crm);
}
if (xml.PerfilInstrutor.HasValue)
{
crm.PerfilInstrutor = xml.PerfilInstrutor;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "PerfilInstrutor não enviado!";
return(crm);
}
if (xml.PerfilAnalista.HasValue)
{
crm.PerfilAnalista = xml.PerfilAnalista;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "PerfilAnalista não enviado!";
return(crm);
}
if (xml.PerfilTutor.HasValue)
{
crm.PerfilTutor = xml.PerfilTutor;
}
else
{
resultadoPersistencia.Sucesso = false;
resultadoPersistencia.Mensagem = "PerfilTutor não enviado!";
return(crm);
}
crm.IntegrarNoPlugin = true;
#endregion
return(crm);
}
public Pollux.MSG0105 DefinirPropriedades(AcessoKonviva objModel)
{
#region Propriedades Crm->Xml
if (String.IsNullOrEmpty(objModel.Nome))
{
objModel.Nome = (string)this.PreencherAtributoVazio("string");
}
Pollux.MSG0105 msg0105 = new Pollux.MSG0105(itb.RetornaSistema(itb.Sistema.CRM), Intelbras.CRM2013.Domain.Servicos.Helper.Truncate(objModel.Nome, 40));
if (objModel.Conta != null)
{
msg0105.CodigoConta = objModel.Conta.Id.ToString();
}
if (objModel.Contato != null)
{
msg0105.CodigoContato = objModel.Contato.Id.ToString();
}
msg0105.CodigoAcessoKonviva = objModel.ID.Value.ToString();
if (objModel.UnidadeKonviva != null)
{
Model.UnidadeKonviva uniAcessoKonviva = new Intelbras.CRM2013.Domain.Servicos.UnidadeKonvivaService(this.Organizacao, this.IsOffline).ObterPor(objModel.UnidadeKonviva.Id);
if (uniAcessoKonviva != null && uniAcessoKonviva.IdInterno.HasValue)
{
msg0105.IdentificadorUnidadeKonviva = uniAcessoKonviva.IdInterno.Value;
}
}
if (!string.IsNullOrEmpty(objModel.Nome))
{
msg0105.NomeAcessoKonviva = objModel.Nome;
}
else
{
msg0105.NomeAcessoKonviva = (string)this.PreencherAtributoVazio("string");
}
if (objModel.PerfilAdministrador.HasValue)
{
msg0105.PerfilAdministrador = objModel.PerfilAdministrador;
}
if (objModel.PerfilAluno.HasValue)
{
msg0105.PerfilAluno = objModel.PerfilAluno;
}
if (objModel.PerfilAnalista.HasValue)
{
msg0105.PerfilAnalista = objModel.PerfilAnalista;
}
if (objModel.PerfilAutor.HasValue)
{
msg0105.PerfilAutor = objModel.PerfilAutor;
}
if (objModel.PerfilGestor.HasValue)
{
msg0105.PerfilGestor = objModel.PerfilGestor;
}
if (objModel.PerfilInstrutor.HasValue)
{
msg0105.PerfilInstrutor = objModel.PerfilInstrutor;
}
if (objModel.PerfilModerador.HasValue)
{
msg0105.PerfilModerador = objModel.PerfilModerador;
}
if (objModel.PerfilMonitor.HasValue)
{
msg0105.PerfilMonitor = objModel.PerfilMonitor;
}
if (objModel.PerfilTutor.HasValue)
{
msg0105.PerfilTutor = objModel.PerfilTutor;
}
if (usuarioIntegracao != null)
{
msg0105.Proprietario = usuarioIntegracao.ID.Value.ToString();
msg0105.TipoProprietario = "systemuser";
}
else
{
msg0105.Proprietario = "259A8E4F-15E9-E311-9420-00155D013D39";
msg0105.TipoProprietario = "systemuser";
}
msg0105.Situacao = (objModel.Status.HasValue ? objModel.Status.Value : (int)Enum.StateCode.Ativo);
#endregion
return(msg0105);
}
public List <KeyValuePair <ExecuteMultipleResponse, ExecuteMultipleRequest> > AtualizarAcessosKonvivaInconsistentes(DateTime dataInicial)
{
var listaDePara = RepositoryService.DeParaDeUnidadeDoKonviva.ListarPor(new Dictionary <string, object>(), dataInicial, false);
var listaAcessosKonviva = new List <AcessoKonviva>();
var listaAcessosKonvivaPadrao = new List <AcessoKonviva>();
var novaListaKonvivaUpdate = new List <AcessoKonviva>();
var novaListaKonvivaAdd = new List <AcessoKonviva>();
var retornosPaginacao = new List <KeyValuePair <ExecuteMultipleResponse, ExecuteMultipleRequest> >();
List <object> deParaUnidadesKonviva = new List <object>();
if (listaDePara.Count > 0)
{
foreach (var item in listaDePara)
{
deParaUnidadesKonviva.Add(item.ID.Value);
}
listaAcessosKonviva = RepositoryService.AcessoKonviva.ListarPor(deParaUnidadesKonviva.ToArray());
var aKService = new AcessoKonvivaService(RepositoryService);
#region Correção de entradas de Acesso do Konviva que tiveram critérios alterados
foreach (var item in listaAcessosKonviva)
{
if (item.Contato != null)
{
var contato = new ContatoService(RepositoryService).BuscaContato(item.Contato.Id);
AcessoKonviva akTmp = this.ProcessaAcessoKonviva(contato, item);
if (akTmp != null)
{
novaListaKonvivaUpdate.Add(akTmp);
}
}
}
#endregion
#region Correção de entradas de acesso padrão do Konviva, avaliando se algum dos novos critérios se enquadram
listaDePara = RepositoryService.DeParaDeUnidadeDoKonviva.ListarPor(new Dictionary <string, object>(), dataInicial, true);
foreach (var item in listaDePara)
{
var listaMudar = new List <AcessoKonviva>();
if (item.Categoria != null || item.TipoDeRelacao == null)
{
listaMudar = RepositoryService.AcessoKonviva.ListarPorCriterioDeParaContas(item, this.unidadeKonvivaPadrao.Value);
}
else
{
if (item.PapelNoCanalIntelbras.HasValue)
{
listaMudar = RepositoryService.AcessoKonviva.ListarPorCriterioDeParaContatos(item, this.unidadeKonvivaPadrao.Value);
}
}
foreach (var itemMudar in listaMudar)
{
itemMudar.UnidadeKonviva = item.UnidadeDoKonviva;
itemMudar.DeParaUnidadeKonviva = new Lookup(item.ID.Value, "");
novaListaKonvivaUpdate.Add(itemMudar);
}
}
#endregion
List <AcessoKonviva> acessosTimeout = new List <AcessoKonviva>();
for (int i = 0; i < novaListaKonvivaUpdate.Count; i += 10)
{
try
{
retornosPaginacao.Add(RepositoryService.AcessoKonviva.ExecuteMultiple(novaListaKonvivaUpdate.Skip(i).Take(10).ToList(), new UpdateRequest()));
}
catch (TimeoutException e)
{
Console.WriteLine("Erro de Timeout nos seguintes GUIDs:");
foreach (var itemTimeout in novaListaKonvivaUpdate.Skip(i).Take(10).ToList())
{
Console.WriteLine(itemTimeout.ID.ToString());
}
Console.WriteLine("------------------------------------");
acessosTimeout.AddRange(novaListaKonvivaUpdate.Skip(i).Take(10).ToList());
}
}
for (int i = 0; i < acessosTimeout.Count; i += 10)
{
try
{
retornosPaginacao.Add(RepositoryService.AcessoKonviva.ExecuteMultiple(acessosTimeout.Skip(i).Take(10).ToList(), new UpdateRequest()));
}
catch (TimeoutException e)
{
Console.WriteLine("Erro de Timeout nos seguintes GUIDs (2a):");
foreach (var itemTimeout in novaListaKonvivaUpdate.Skip(i).Take(10).ToList())
{
Console.WriteLine(itemTimeout.ID.ToString());
}
Console.WriteLine("------------------------------------");
}
}
}
return(retornosPaginacao);
}
