public void Execute(IPluginExecutionContext context)
{
try
{
if ((context.InputParameters.Properties.Contains("Target") && context.InputParameters.Properties["Target"] is DynamicEntity))
{
this.EntidadeDoContexto = context.InputParameters.Properties["Target"] as DynamicEntity;
}
else
{
return;
}
this.Organizacao = new Organizacao(context.OrganizationName);
var ocorrencia = DomainService.RepositoryOcorrencia.RetrieveBasico(PluginHelper.GetEntityId(context)
, "statuscode"
, "incidentid"
, "createdon");
this.VerificaIntervencao(ocorrencia, context);
}
catch (Exception ex)
{
LogHelper.Process(ex, ClassificacaoLog.PluginIncident);
}
}
public void Execute(IPluginExecutionContext context)
{
try
{
this.Organizacao = new Organizacao(context.OrganizationName);
if (!context.PreEntityImages.Contains("Target"))
{
return;
}
DynamicEntity entity = (DynamicEntity)context.PreEntityImages["Target"];
if (!entity.Properties.Contains("new_extratoid"))
{
return;
}
Guid extratoId = ((Lookup)entity.Properties["new_extratoid"]).Value;
Extrato extrato = new Extrato(this.Organizacao)
{
Id = extratoId
};
extrato.AtualizarValor();
DomainService.RepositoryExtrato.Update(extrato);
}
catch (Exception ex) { LogService.GravaLog(ex, TipoDeLog.PluginNew_lancamento_avulso, "PostDelete"); }
}
private void CriaLinhaDeContrato(DynamicEntity entity, Organizacao organizacao)
{
var contratoId = entity.Properties["new_contractid"] ?? null;
if (contratoId != null)
{
var contrato = new Contrato(organizacao);
contrato.Id = new Guid(contratoId.ToString());
var inicioVigenciaContrato = entity.Properties["activeon"] ?? null;
if (inicioVigenciaContrato != null)
{
contrato.InicioVigencia = Convert.ToDateTime(inicioVigenciaContrato);
}
else
{
contrato.InicioVigencia = DateTime.Now;
}
contrato.CriarLinhaDeContrato(contrato);
}
else
{
throw new ArgumentException("O ID do contrato não está preenchido.");
}
}
public IActionResult FormUpdateOrganizacao(OrganizacaoViewModel entrada)
{
Organizacao modelo = new Organizacao();
entrada.contexto = this.contexto;
try
{
if (entrada.organizacao != null)
{
if (OrganizacaoRules.MontaOrganizacaoUpdate(entrada, out modelo))
{
organizacaoData.Update(modelo);
StatusMessage = "Registro Atualizado com Sucesso!";
return(RedirectToAction("FormUpdateOrganizacao", null));
}
}
}
catch (Exception ex)
{
LogOsca log = new LogOsca();
log.GravaLog(1, 1000, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormUpdateOrganizacao-post", ex.Message);
}
return(RedirectToAction("FormUpdateOrganizacao", null));
}
public ViewResult VisualizaURLCaptura()
{
PaginaClienteViewModel modelo = new PaginaClienteViewModel();
SqlGenericManager sqlService = new SqlGenericManager();
Organizacao org = sqlService.RetornaOrganizacao(this.contexto.idOrganizacao);
if (org.servicoPaginaCapturaLead > 0)
{
if (urlAmbiente == "desenv")
{
modelo.urlPaginaCaptura = "http://www.app.desenv.oscas.com.br/paginaCliente/FormularioEntrada?id=" + this.contexto.idOrganizacao.ToString();
}
if (urlAmbiente == "prod")
{
modelo.urlPaginaCaptura = "http://www.app.oscas.com.br/paginaCliente/FormularioEntrada?id=" + this.contexto.idOrganizacao.ToString();
}
}
else
{
modelo.urlPaginaCaptura = "Adquira o nosso Produto em www.loja.oscas.com.br";
}
return(View(modelo));
}
public void Execute(IPluginExecutionContext context)
{
try
{
DynamicEntity entity = null;
var isDynamicEntity = (context.InputParameters.Properties.Contains("Target") && context.InputParameters.Properties["Target"] is DynamicEntity);
if (isDynamicEntity)
{
entity = context.InputParameters.Properties["Target"] as DynamicEntity;
if (!entity.Properties.Contains("new_custosid"))
{
return;
}
var organizacao = new Organizacao(context.OrganizationName);
Guid agendaId = ((Lookup)entity.Properties["new_custosid"]).Value;
Agenda agenda = new Agenda(new Organizacao(context.OrganizationName))
{
Id = agendaId
};
agenda.Custo = agenda.ObterTotalDeCustos();
agenda.Update();
}
}
catch (Exception ex) { LogService.GravaLog(ex, TipoDeLog.PluginNew_calendario_custos, "Intelbras.Crm.Application.Plugin.new_calendario_custos.PostUpdate"); }
}
public OrganizacaoModeloNegocio PesquisarPatriarca(string guid)
{
OrganizacaoModeloNegocio organizacaoNegocio = new OrganizacaoModeloNegocio();
Guid g = new Guid(guid);
Organizacao organizacao = repositorioOrganizacoes.Where(o => o.IdentificadorExterno.Guid.Equals(g))
.SingleOrDefault();
validacao.NaoEncontrado(organizacao);
int idOrganizacaoPatriarca = ObterOrganizacaoPatriarca(organizacao);
Organizacao organizacaoPatriarca = repositorioOrganizacoes.Where(o => o.Id == idOrganizacaoPatriarca)
.Include(e => e.Endereco).ThenInclude(m => m.Municipio).ThenInclude(m => m.IdentificadorExterno)
.Include(e => e.Esfera)
.Include(p => p.Poder)
.Include(c => c.ContatosOrganizacao).ThenInclude(co => co.Contato).ThenInclude(tc => tc.TipoContato)
.Include(eo => eo.EmailsOrganizacao).ThenInclude(e => e.Email)
.Include(so => so.SitesOrganizacao).ThenInclude(s => s.Site)
.Include(to => to.TipoOrganizacao)
.Include(to => to.IdentificadorExterno)
.SingleOrDefault();
return(Mapper.Map(organizacaoPatriarca, organizacaoNegocio));
}
private Organizacao PreparaInsercao(OrganizacaoModeloNegocio organizacaoNegocio)
{
organizacaoNegocio.Guid = Guid.NewGuid().ToString("D");
if (organizacaoNegocio.OrganizacaoPai != null)
{
var organizacaoPai = Pesquisar(organizacaoNegocio.OrganizacaoPai.Guid);
organizacaoNegocio.OrganizacaoPai.Id = organizacaoPai.Id;
organizacaoNegocio.Esfera = new EsferaOrganizacaoModeloNegocio {
Id = organizacaoPai.Esfera.Id
};
organizacaoNegocio.Poder = new PoderModeloNegocio {
Id = organizacaoPai.Poder.Id
};
}
if (organizacaoNegocio.Endereco != null)
{
organizacaoNegocio.Endereco.Municipio.Id = BuscarIdMunicipio(organizacaoNegocio.Endereco.Municipio.Guid);
}
Organizacao organizacao = new Organizacao();
organizacao = Mapper.Map <OrganizacaoModeloNegocio, Organizacao>(organizacaoNegocio);
return(organizacao);
}
public void ExcluirSemSalvar(string guid)
{
validacao.GuidValido(guid);
validacao.Existe(guid);
Guid g = new Guid(guid);
validacao.UsuarioTemPermissao(_currentUser.UserGuidsOrganizacao, guid);
Organizacao organizacao = repositorioOrganizacoes.Where(o => o.IdentificadorExterno.Guid.Equals(g))
.Include(o => o.IdentificadorExterno)
.Include(i => i.Endereco)
.Include(i => i.ContatosOrganizacao).ThenInclude(c => c.Contato)
.Include(i => i.SitesOrganizacao).ThenInclude(s => s.Site)
.Include(i => i.EmailsOrganizacao).ThenInclude(s => s.Email).Single();
validacao.PossuiFilho(organizacao.Id);
validacao.PossuiUnidade(organizacao.Id);
InserirHistorico(organizacao, "Exclusão", null);
ExcluiContatos(organizacao);
ExcluiEndereco(organizacao);
ExcluiEmails(organizacao);
ExcluiSites(organizacao);
repositorioOrganizacoes.Remove(organizacao);
}
internal void NaoEncontrado(Organizacao organizacao)
{
if (organizacao == null)
{
throw new OrganogramaNaoEncontradoException("Organização não encontrada.");
}
}
public void Execute(IPluginExecutionContext context)
{
DateTime inicioExecucao = DateTime.Now;
try
{
var prop = context.InputParameters.Properties;
if ((prop.Contains("Target") && prop["Target"] is DynamicEntity))
{
this.EntidadeDoContexto = context.InputParameters.Properties["Target"] as DynamicEntity;
}
if (this.EntidadeDoContexto == null)
{
return;
}
this.Organizacao = new Organizacao(context.OrganizationName);
var id = PluginHelper.GetEntityId(context);
var ocorrencia = DomainService.RepositoryOcorrencia.Retrieve(id);
this.VerificaIntervencao(ocorrencia, context);
}
catch (Exception ex)
{
PluginHelper.TratarExcecao(ex, TipoDeLog.PluginIncident);
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nome,CNPJ,DataCriacao")] Organizacao organizacao)
{
if (id != organizacao.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(organizacao);
// Desabilita a alteração deste campo na edição
_context.Entry(organizacao).Property(x => x.DataCriacao).IsModified = false;
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrganizacaoExists(organizacao.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(organizacao));
}
public async Task <IActionResult> Criar(OrganizacaoViewModel model, IList <IFormFile> file)
{
if (file.Count > 0)
{
IFormFile imgOrganizacao = file.FirstOrDefault();
if (imgOrganizacao != null || imgOrganizacao.ContentType.ToLower().StartsWith("image/"))
{
MemoryStream ms = new MemoryStream();
imgOrganizacao.OpenReadStream().CopyTo(ms);
model.ImgOrganizacao = ms.ToArray();
}
}
Organizacao organizacao = new Organizacao
{
NomeOrganizacao = model.NomeOrganizacao,
ImgOrganizacao = model.ImgOrganizacao,
Limite = model.Limite
};
if (organizacao != null)
{
_context.Add(organizacao);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(organizacao.ImgOrganizacao));
}
/// <summary>
/// Enviar para salvar ou atualizar um registro no banco de dados e salvar o logotipo da Organizacao
/// </summary>
public bool salvar(Organizacao OOrganizacao, HttpPostedFileBase Logotipo)
{
OOrganizacao.Pessoa = OOrganizacao.Pessoa.limparAtributos();
bool flagSucesso = false;
if (OOrganizacao.id > 0)
{
flagSucesso = this.atualizar(OOrganizacao);
}
if (OOrganizacao.id == 0)
{
flagSucesso = this.inserir(OOrganizacao);
}
if (flagSucesso && Logotipo != null)
{
var OArquivo = new ArquivoUpload();
OArquivo.idReferenciaEntidade = OOrganizacao.id;
OArquivo.entidade = EntityTypes.ORGANIZACAO;
this.OArquivoUploadPadraoBL.salvar(OArquivo, Logotipo);
}
return(flagSucesso);
}
//Atualizar os dados de um associado e os objetos relacionados
private bool atualizar(Organizacao OOrganizacao)
{
Organizacao dbOrganizacao = this.carregar(OOrganizacao.id);
var entryOrganizacao = db.Entry(dbOrganizacao);
OOrganizacao.setDefaultUpdateValues();
entryOrganizacao.CurrentValues.SetValues(OOrganizacao);
entryOrganizacao.State = EntityState.Modified;
entryOrganizacao.ignoreFields(new[] { "idPessoa", "ativo" });
var entryPessoa = db.Entry(dbOrganizacao.Pessoa);
OOrganizacao.Pessoa.setDefaultUpdateValues();
OOrganizacao.Pessoa.id = dbOrganizacao.Pessoa.id;
OOrganizacao.Pessoa.idUsuarioAlteracao = UtilNumber.toInt32(OOrganizacao.idUsuarioAlteracao);
entryPessoa.CurrentValues.SetValues(OOrganizacao.Pessoa);
entryPessoa.State = EntityState.Modified;
entryPessoa.ignoreFields <Pessoa>();
this.atualizarEnderecos(OOrganizacao, dbOrganizacao);
db.SaveChanges();
return(OOrganizacao.id > 0);
}
public async Task <IActionResult> Edit(int id, [Bind("OrgId,OrgNome,OrgCnpj,OrgEmail,OrgTelefone,OrgEndereco,OrgSituacao,OrgObs")] Organizacao organizacao)
{
if (id != organizacao.OrgId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(organizacao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrganizacaoExists(organizacao.OrgId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(organizacao));
}
// GET: OrganizacaoController/Delete/5
public ActionResult Delete(int id)
{
Organizacao organizacao = _organizacaoService.Obter(id);
OrganizacaoModel organizacaoModel = _mapper.Map <OrganizacaoModel>(organizacao);
return(View(organizacaoModel));
}
public void Send(string organizationName, string type, string xmlIntegration, DynamicEntity entity, IPluginExecutionContext context)
{
try
{
if (string.IsNullOrEmpty(xmlIntegration))
{
return;
}
organizacao = new Organizacao(organizationName);
switch (entity.Name)
{
case "account":
SalvarClienteNoEMS(type, xmlIntegration, entity);
break;
case "contact":
SalvarContatoNoEMS(type, xmlIntegration, context);
break;
case "customeraddress":
SalvarEnderecoNoEMS(type, xmlIntegration, entity);
break;
case "new_relacionamento":
SalvarRelacionamentoNoEMS(type, xmlIntegration, entity);
break;
}
}
catch (Exception ex) { LogService.GravaLog(ex, TipoDeLog.PluginIntegradorERP); }
}
public void Update(Organizacao organizacao)
{
db.Attach(organizacao);
db.Entry(organizacao).Property("nomeAmigavel").IsModified = true;
db.Entry(organizacao).Property("cpf_cnpj").IsModified = true;
db.Entry(organizacao).Property("tipoPessoa").IsModified = true;
db.Entry(organizacao).Property("nomeAdministrador").IsModified = true;
db.Entry(organizacao).Property("emailAdministrador").IsModified = true;
db.Entry(organizacao).Property("telefoneAdministrador").IsModified = true;
db.Entry(organizacao).Property("celularAdministrador").IsModified = true;
db.Entry(organizacao).Property("cargo").IsModified = true;
db.Entry(organizacao).Property("logradouro").IsModified = true;
db.Entry(organizacao).Property("estado").IsModified = true;
db.Entry(organizacao).Property("cidade").IsModified = true;
db.Entry(organizacao).Property("pais").IsModified = true;
db.Entry(organizacao).Property("cep").IsModified = true;
db.Entry(organizacao).Property("numero").IsModified = true;
db.Entry(organizacao).Property("bairro").IsModified = true;
db.Entry(organizacao).Property("complemento").IsModified = true;
db.Entry(organizacao).Property("emailEmpresa").IsModified = true;
db.Entry(organizacao).Property("TelefoneEmpresa").IsModified = true;
db.Entry(organizacao).Property("anotacao").IsModified = true;
db.Entry(organizacao).Property("modificadoPor").IsModified = true;
db.Entry(organizacao).Property("modificadoPorName").IsModified = true;
db.Entry(organizacao).Property("modificadoEm").IsModified = true;
db.SaveChanges();
}
public Organizacao Get(Guid idOrg)
{
Organizacao retorno = new Organizacao();
retorno = db.Organizacao.Single(A => A.id.Equals(idOrg));
return(retorno);
}
public void Execute(IPluginExecutionContext context)
{
try
{
bool isDynamicEntity = (context.InputParameters.Properties.Contains("Target") && context.InputParameters.Properties["Target"] is DynamicEntity);
if (isDynamicEntity)
{
this.organizacao = new Organizacao(context.OrganizationName);
DynamicEntity entity = context.InputParameters.Properties["Target"] as DynamicEntity;
if (!entity.Properties.Contains("new_participantesid"))
{
throw new ArgumentException("O campo Agenda é Obrigatório!");
}
Guid agendaId = ((Lookup)entity.Properties["new_participantesid"]).Value;
Agenda agenda = new Agenda(this.organizacao)
{
Id = agendaId
};
if (agenda.PodeAdicionarParticipantes())
{
context.SharedVariables.Properties.Add(new PropertyBagEntry("inscritos", agenda.Inscritos));
}
else
{
throw new InvalidPluginExecutionException("Operação não realizada. Não é possível adicionar participantes à Agenda selecionada. Ela está finalizada ou já atingiu o número de vagas.");
}
}
}
catch (Exception ex) { PluginHelper.TratarExcecao(ex, TipoDeLog.PluginNew_calendario_participante); }
}
private List <Organizacao> ObterOrganizacoesFilhas(Organizacao organizacao)
{
if (organizacao == null)
{
throw new ArgumentNullException("organizacao");
}
List <Organizacao> organizacoesFilhas = new List <Organizacao>();
if (organizacao.OrganizacoesFilhas != null && organizacao.OrganizacoesFilhas.Count > 0)
{
foreach (Organizacao organizacaoFilha in organizacao.OrganizacoesFilhas)
{
Organizacao org = repositorioOrganizacoes.Where(o => o.Id == organizacaoFilha.Id)
.Include(o => o.OrganizacoesFilhas)
.Include(o => o.Esfera)
.Include(o => o.Poder)
.Include(o => o.IdentificadorExterno)
.Single();
organizacoesFilhas.AddRange(ObterOrganizacoesFilhas(org));
}
}
organizacoesFilhas.Add(organizacao);
return(organizacoesFilhas.OrderBy(o => o.RazaoSocial).ToList());
}
private void ExcluiEndereco(Organizacao organizacao)
{
if (organizacao.Endereco != null)
{
repositorioEnderecos.Remove(organizacao.Endereco);
}
}
private static Organizacao SetEntity(OrganizacaoModel model, Organizacao entity)
{
entity.Id = model.Id;
entity.RazaoSocial = model.RazaoSocial;
entity.Cnpj = model.Cnpj;
return(entity);
}
private void RazaoSocialExiste(OrganizacaoModeloNegocio organizacaoNegocio)
{
Organizacao organizacao = repositorioOrganizacoes.Where(o => o.RazaoSocial.Equals(organizacaoNegocio.RazaoSocial) && o.Id != organizacaoNegocio.Id).SingleOrDefault();
if (organizacao != null)
{
throw new OrganogramaRequisicaoInvalidaException("A Razão Social informada já pertence a uma organização.");
}
}
private void PreencheOrganizacaoPai(Organizacao organizacao)
{
if (organizacao.IdOrganizacaoPai.HasValue)
{
organizacao.OrganizacaoPai = repositorioOrganizacoes.Where(op => op.Id == organizacao.IdOrganizacaoPai.Value)
.Include(op => op.IdentificadorExterno)
.Single();
}
}
internal void CnpjExiste(OrganizacaoModeloNegocio organizacaoNegocio)
{
Organizacao organizacao = repositorioOrganizacoes.Where(o => o.Cnpj == organizacaoNegocio.Cnpj && o.Id != organizacaoNegocio.Id).SingleOrDefault();
if (organizacao != null)
{
throw new OrganogramaRequisicaoInvalidaException("O Cnpj informado já pertence a uma organização.");
}
}
// GET: OrganizacaoController/Details/5
public ActionResult Details(int id)
{
Organizacao organizacao = _organizacaoService.Obter(id);
ViewBag.Organizacao = organizacao.Nome;
OrganizacaoModel organizacaoModel = _mapper.Map <OrganizacaoModel>(organizacao);
return(View(organizacaoModel));
}
public void UpdateOrganizacao(Organizacao obj)
{
try
{
}
catch
{
}
throw new NotImplementedException();
}
public void Atualizar(Organizacao organizacao)
{
using (var unidadeDeTrabalho = _fabricaDeUnidadeDeTrabalho.Criar())
{
unidadeDeTrabalho.Iniciar();
_OrganizacaoRepositorio.Update(organizacao);
unidadeDeTrabalho.Completar();
}
}
public void Autenticar(Usuario usuario, Organizacao organizacao)
{
if (usuario == null)
throw new ArgumentNullException("usuario");
if (organizacao == null)
throw new ArgumentNullException("organizacao");
Usuario = usuario;
Organizacao = organizacao;
}
public virtual void Entrar(string email, string senha, Organizacao organizacao)
{
var admin = _usuarios.PorEmail("*****@*****.**");
if (admin == null)
{
admin = new Usuario("*****@*****.**", "sanlex");
_usuarios.Save(admin);
}
var u = _usuarios.PorEmail(email);
if (!u.IsSenhaValida(senha))
throw new Exception("Usuário inválido.");
_sessao.Autenticar(u, organizacao);
}
private string GerarCodigo(Type type, Organizacao organizacao)
{
var sf = (ISessionFactory)ContextRegistry.GetContext().GetObject("SessionFactory");
using (var ss = sf.OpenSession())
{
ss.BeginTransaction();
var seq = ss.CreateQuery("from SequenciaCodigo " +
"where (Organizacao = ? or Organizacao is null) " +
"and NomeEntidade = ?")
.SetParameter(0, organizacao)
.SetParameter(1, type.Name)
.UniqueResult<SequenciaCodigo>();
if (seq == null)
seq = new SequenciaCodigo(organizacao, type.Name);
var result = seq.CodigoAtual++;
ss.SaveOrUpdate(seq);
ss.Transaction.Commit();
return result.ToString();
}
}
public Organizacao(Organizacao superior, string nome, Endereco endereco)
: this(nome)
{
Superior = superior;
Endereco = endereco;
}
public SequenciaCodigo(Organizacao organizacao, string entidade)
{
Organizacao = organizacao;
NomeEntidade = entidade;
CodigoAtual = 1;
}
