public Ligacao adicionaLigacao([FromBody] Solicitacao solicitacaoJson)
{
solicitacao = solicitacaoJson;
Ligacao ligacao = new Ligacao();
if (ValidarCaptcha())
{
try
{
ligacao.DDD = Parametros.BuscarValor("DDD", _parametros);
ligacao.adicionaNumero(solicitacao.numero);
ligacao.Fila = BuscarFila(solicitacao.fila);
ChamaURLCentralTelefonica(ligacao);
RegistraLigacao(ligacao);
addLogMessage(1, "Ligação solicitada: " + ligacao.Telefone, "");
}
catch (Exception ex)
{
addLogMessage(3, ex.Message, "");
//throw ex;
}
}
else
{
addLogMessage(1, "ErrorCaptcha: " + ligacao.Telefone, errorMsgCaptcha);
errorMsgCaptcha = "";
}
return(ligacao);
}
public AtendimentoViewModel(Atendimento atendimento, Ligacao ligacao)
{
numeroOriginal = ligacao.NumeroOriginal;
numeroProtocolo = atendimento.Protocolo;
atendimentoID = atendimento.Id;
CriadoEm = atendimento.CriadoEm;
}
public _LigacaoViewModel(Ligacao ligacao, IEnumerable <Midia> midias, IEnumerable <StatusAtividade> statusAtividades)
{
Midias = new SelectList(midias, "id", "nome");
StatusAtividades = statusAtividades;
LigacaoId = ligacao.Id;
NumeroTelefone = ligacao.NumeroOriginal;
Sentido = ligacao.Receptiva == null ? "--" : (ligacao.Receptiva.Value ? "Receptivo" : "Ativo");
Receptiva = ligacao.Receptiva;
FilaNome = "Sem fila atribuída";
if (ligacao.Receptiva.HasValue)
{
Numero = ligacao.Receptiva.Value
? ligacao.NumeroOriginal
: (ligacao.Telefone != null ? ligacao.Telefone.ToString() : "--");
}
if (string.IsNullOrEmpty(Numero))
{
Numero = "Não Informado";
}
if (ligacao.Fila != null)
{
FilaNome = ligacao.Fila.Nome;
FilaId = ligacao.Fila.Id;
}
if (ligacao.Atividade != null)
{
AtendimentoFinalizado = ligacao.Atividade.FinalizadoEm.HasValue;
DataPrevisao = ligacao.Atividade.PrevisaoDeExecucao.HasValue
? ligacao.Atividade.PrevisaoDeExecucao.ToString()
: "--";
DetalheContato = ligacao.Atividade.Descricao;
if (ligacao.Atividade.Ocorrencia != null)
{
OcorrenciaId = ligacao.Atividade.Ocorrencia.Id;
}
if (ligacao.Atividade.Atendimento != null)
{
AtendimentoId = ligacao.Atividade.Atendimento.Id;
Protocolo = ligacao.Atividade.Atendimento.Protocolo;
MidiaId = ligacao.Atividade.Atendimento.MidiasId ?? ligacao.Atividade.MidiasId;
}
PessoaFisicaIdTratativa = ligacao.Atividade.PessoasFisicasId;
PessoaJuridicaIdTratativa = ligacao.Atividade.PessoasJuridicasId;
if (ligacao.Atividade.StatusAtividade != null)
{
StatusNome = ligacao.Atividade.StatusAtividade.FinalizaAtividade
? ligacao.Atividade.StatusAtividade.Descricao
: null;
}
}
}
public void CriarLigacoes(string[] names)
{
Ligacao item = new Ligacao();
foreach (string name in names)
{
item.NovaLigacao(name);
}
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Ligacao ligacao = await db.Ligacoes.FindAsync(id);
db.Ligacoes.Remove(ligacao);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public void ConsultaLigacaoItemSelecionado(Ligacao obj)
{
LigacaoAtual = obj;
Codigo.Text = obj.Codigo.ToString();
DataHora.Text = obj.DataHora.ToString("HH:mm:ss dd/MM/yyyy");
Cliente.Text = obj.Cliente.RazaoSocial;
Cliente.Tag = obj.Cliente;
Observacoes.Text = obj.Observacoes;
CarregarDados();
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Origem,Destino,Tempo,Plano,ValorMinuto")] Ligacao ligacao)
{
if (ModelState.IsValid)
{
db.Entry(ligacao).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(ligacao));
}
public async Task <ActionResult> Create([Bind(Include = "Id,Origem,Destino,Tempo,Plano,ValorMinuto")] Ligacao ligacao)
{
if (ModelState.IsValid)
{
db.Ligacoes.Add(ligacao);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(ligacao));
}
public void Salvar()
{
using (LigacoesContext context = new LigacoesContext())
{
Ligacao instancia = LigacaoAtual == null
? null
: context.Ligacoes.FirstOrDefault(c => c.Id.Equals(LigacaoAtual.Id));
bool isInsert = false;
if (instancia == null)
{
isInsert = true;
instancia = new Ligacao {
Id = Guid.NewGuid()
};
}
if (UsuarioLogado is Usuario usuario)
{
instancia.Usuario = new Usuario {
Id = usuario.Id
};
context.Usuarios.Attach(instancia.Usuario);
}
instancia.Cliente = Cliente.Tag as Cliente;
instancia.DataHora = DateTime.Now;
instancia.Observacoes = Observacoes.Text;
if (instancia.Cliente != null)
{
context.Clientes.Attach(instancia.Cliente);
}
if (instancia.Usuario != null)
{
context.Usuarios.Attach(instancia.Usuario);
}
if (isInsert)
{
context.Ligacoes.Add(instancia);
}
context.SaveChanges();
}
LimparCampos();
}
// cria uma ligação entre dois atomos (primeiro e segundo) da "Atomos[] lista"
public static Ligacao criarLigacao(Atomos[] lista, int primeiro, int segundo)
{
Ligacao novaLigacao = new Ligacao();
int mudanca = 0;
if ((lista[primeiro].eletronsDisponiveis == 0 || lista[segundo].eletronsDisponiveis == 0) ||
(lista[primeiro].eletronsAtuais >= 8 || lista[segundo].eletronsAtuais >= 8 ||
lista[primeiro].eletronsAtuais <= 0 || lista[segundo].eletronsAtuais <= 0))
{
// erro
novaLigacao.tipo = TipoLigacao.ERRO;
return(novaLigacao);
}
// ligação tripla
else if (lista[primeiro].eletronsDisponiveis >= 3 && lista[segundo].eletronsDisponiveis >= 3 &&
(lista[primeiro].eletronsAtuais <= 5 && lista[segundo].eletronsAtuais <= 5))
{
novaLigacao.tipo = TipoLigacao.TRIPLA;
mudanca = 3;
}
// ligação dupla
else if (lista[primeiro].eletronsDisponiveis >= 2 && lista[segundo].eletronsDisponiveis >= 2 &&
(lista[primeiro].eletronsAtuais <= 6 && lista[segundo].eletronsAtuais <= 6))
{
novaLigacao.tipo = TipoLigacao.DUPLA;
mudanca = 2;
}
// ligação simples
else if (lista[primeiro].eletronsDisponiveis >= 1 && lista[segundo].eletronsDisponiveis >= 1 &&
(lista[primeiro].eletronsAtuais <= 7 && lista[segundo].eletronsAtuais <= 7))
{
novaLigacao.tipo = TipoLigacao.SIMPLES;
mudanca = 1;
}
// atualiza as informações para a ligação
lista[primeiro].eletronsAtuais += mudanca;
lista[segundo].eletronsAtuais += mudanca;
lista[primeiro].eletronsDisponiveis -= mudanca;
lista[segundo].eletronsDisponiveis -= mudanca;
// colocq informações em "novaLigação"
novaLigacao.primeiro = lista[primeiro];
novaLigacao.segundo = lista[segundo];
novaLigacao.primeiro.ligado++;
novaLigacao.segundo.ligado++;
return(novaLigacao);
}
// GET: Ligacoes/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Ligacao ligacao = await db.Ligacoes.FindAsync(id);
if (ligacao == null)
{
return(HttpNotFound());
}
return(View(ligacao));
}
public string Index()
{
var caminho = HttpContext.Request.Path.Split('/');
var empresa = caminho[caminho.Length - 1];
Cliente cliente = OperacaoClientes.ObtemClientes().Find(x => x.Nome.ToUpper() == empresa.ToUpper());
if (cliente == null)
{
return("Cliente não encontrado!");
}
var parametros = HttpContext.Request.Params;
//string stringParametros = string.Join(",", parametros.AllKeys.SelectMany(key => parametros.GetValues(key)));
//return stringParametros;
Ligacao ligacao = new Ligacao();
ligacao.calldate = parametros["calldate"];
ligacao.src = parametros["src"];
ligacao.dst = parametros["dst"];
ligacao.duration = parametros["duration"];
ligacao.billsec = parametros["billsec"];
ligacao.disposition = parametros["disposition"];
ligacao.userfield = parametros["userfield"];
ligacao.callid = parametros["callid"];
string connectionString = String.Format("Server={0};User Id={1};Password={2};Database={3};", cliente.Endereco, "agilus", "awrpu07!@$AFAFAsdfqrasfafJMYJYJ&* $%", cliente.Database);
using (SqlConnection conexao = new SqlConnection(connectionString)) {
var comand = new SqlCommand(String.Format(@"INSERT INTO ligacao_telefonica (lit_nome_empresa, lit_data, lit_origem, lit_destino, lit_duracao_total, lit_duracao_conversacao, lit_status, lit_identificador_gravacao, lit_codigo_agilus)
VALUES ('VCOM', '{0}', '{1}', '{2}', {3}, {4}, '{5}', '{6}', '{7}')", ligacao.calldate, ligacao.src, ligacao.dst, ligacao.duration, ligacao.billsec,
ligacao.disposition, ligacao.userfield, ligacao.callid), conexao);
try
{
conexao.Open();
comand.ExecuteNonQuery();
return("Ligação registrada com sucesso na empresa " + cliente.Nome);
}
catch (Exception e) {
var erroEmail = "<p><b>cliente</b>: " + cliente.Nome + "</p><p><b>db</b>: " + cliente.Database + "</p><p><b>Endereço</b>: " + cliente.Endereco +
"</p><p><b>Comando</b>: " + comand.CommandText +
"</p><p><b>Url</b>: " + HttpContext.Request.Url.AbsoluteUri +
"</p><p><b>Mensagem da Exceção</b>: " + e.Message;
Email.EnviarEmail("Erro LogVcom", erroEmail);
return("Ligação não registrada. Erro: " + e.Message);
}
}
}
private DtoLigacao ConvertaParaDto(Ligacao ligacao)
{
return(new DtoLigacao
{
position = ligacao.position,
DataHora = ligacao.Data.ToString("dd/MM/yyyy HH:mm:ss"),
Duracao = ligacao.Duracao.ToString(),
Numero = ligacao.Tipo == "Recebida"
? ligacao.Origem
: ligacao.Destino,
Ramal = ligacao.Tipo == "Originada"
? ligacao.Origem
: ligacao.Destino,
Tipo = ligacao.Tipo,
UniqueId = ligacao.UniqueId
});
}
static void Main(string[] args)
{
char continua = 's';
while (continua == 's' || continua == 'S')
{
using (EfContext context = new EfContext())
{
Ligacao ligacao1 = new Ligacao {
Duracao = GetDuracao("Digite o tempo da primeira ligação: ")
};
Ligacao ligacao2 = new Ligacao {
Duracao = GetDuracao("Digite o tempo da segunda ligação: ")
};
Fatura fatura = new Fatura()
{
Ligacoes = new List <Ligacao> {
ligacao1, ligacao2
}
};
ligacao1.Fatura = fatura;
ligacao2.Fatura = fatura;
context.Ligacoes.AddRange(new[] { ligacao1, ligacao2 });
context.Faturas.Add(fatura);
context.SaveChanges();
Console.WriteLine("Primeira ligação registrada com o ID {0}", ligacao1.Id);
Console.WriteLine("Segunda ligação registrada com o ID {0}", ligacao2.Id);
Console.WriteLine("Fatura registrada com o ID {0}", fatura.Id);
Console.WriteLine("Repetir? (S/N) ");
continua = Console.ReadKey().KeyChar;
Console.WriteLine();
Console.WriteLine();
}
}
}
public static bool reacao(Atomos[] lista, int tamanho)
{
int separador = 0;
// se existirem dois grupos de elementos
if (lista[0].nome != lista[tamanho - 1].nome)
{
// varre o array e encontra o início do segundo grupo
for (separador = 0; ; separador++)
{
if (!lista[separador].nome.Equals(lista[0].nome))
{
break;
}
}
}
// separador = inicio do segundo grupo, ou zero se não houver
int sucessos = 0;
int fracassos = 0;
Ligacao[] listaLigacao = new Ligacao[20];
Ligacao novaLigacao = new Ligacao();
// se existirem dois grupos
if (separador != 0)
{
int grupo1_atual = 0;
int grupo2_atual = separador;
while ((lista[separador - 1].eletronsAtuais != 8 || lista[separador - 1].eletronsAtuais != 2) && (lista[tamanho - 1].eletronsAtuais != 8 || lista[tamanho - 1].eletronsAtuais != 2) && fracassos < 10)
{
novaLigacao = criarLigacao(lista, grupo1_atual, grupo2_atual);
//Debug.Log(novaLigacao.primeiro.eletronsAtuais);
//Debug.Log(novaLigacao.segundo.eletronsDisponiveis);
if (novaLigacao.tipo != TipoLigacao.ERRO)
{
listaLigacao[sucessos] = novaLigacao;
sucessos++;
}
else
{
fracassos++;
}
// checa se os indices são maiores que seus limites
// se sim, retornar ao valor original
if ((lista[grupo1_atual].eletronsAtuais == 8 || lista[grupo1_atual].eletronsAtuais == 2) ||
lista[grupo1_atual].ligado == 2)
{
++grupo1_atual;
}
if (grupo1_atual >= separador)
{
grupo1_atual = 0;
}
if ((lista[grupo2_atual].eletronsAtuais == 8 || lista[grupo2_atual].eletronsAtuais == 2) ||
lista[grupo1_atual].ligado == 2)
{
++grupo2_atual;
}
if (grupo2_atual >= tamanho)
{
grupo2_atual = separador;
}
}
}
// dativa
if (separador != 0 && (!lista[0].nome.Equals("H") && !lista[tamanho - 1].nome.Equals("H")))
{
// checa a existência de elementos não ligados
Atomos[] resto = new Atomos[10];
int indiceResto = 0;
for (int i = 0; i < tamanho; i++)
{
if (lista[i].eletronsAtuais != 8 && lista[i].eletronsAtuais != 2)
{
resto[indiceResto] = lista[i];
indiceResto++;
}
}
// dativa com o primeiro recebendo
if (indiceResto != 0 && ((lista[0].eletroNeg > lista[tamanho - 1].eletroNeg && resto[0].nome == lista[0].nome) ||
(lista[0].nome.Equals("C") && lista[0].eletronsDisponiveis >= 2)))
{
int recebeAtual = 0;
int daAtual = separador;
while ((resto[recebeAtual].ligado == 0 || resto[recebeAtual].eletronsAtuais != 8) && lista[daAtual].eletronsDisponiveis >= 2)
{
resto[recebeAtual].eletronsAtuais += 2;
lista[daAtual].eletronsDisponiveis -= 2;
resto[recebeAtual].ligado++;
lista[daAtual].ligado++;
listaLigacao[sucessos].primeiro = resto[recebeAtual];
listaLigacao[sucessos].segundo = lista[daAtual];
listaLigacao[sucessos].tipo = TipoLigacao.DATIVA;
sucessos++;
// checa se os indices são maiores que seus limites
// se sim, retornar ao valor original
if (daAtual < tamanho)
{
daAtual++;
}
if (daAtual >= tamanho)
{
daAtual = separador;
}
if (recebeAtual < indiceResto)
{
recebeAtual++;
}
if (recebeAtual >= indiceResto)
{
recebeAtual = 0;
}
}
}
// dativa com o segundo recebendo
if (indiceResto != 0 && ((lista[0].eletroNeg < lista[tamanho - 1].eletroNeg && resto[0].nome == lista[tamanho - 1].nome) ||
(lista[tamanho - 1].nome.Equals("C") && lista[0].eletronsDisponiveis >= 2)))
{
int recebeAtual = 0;
int daAtual = 0;
while ((lista[recebeAtual].ligado == 0 || lista[recebeAtual].eletronsAtuais != 8) && resto[daAtual].eletronsDisponiveis >= 2)
{
resto[daAtual].eletronsAtuais -= 2;
lista[recebeAtual].eletronsDisponiveis += 2;
resto[daAtual].ligado++;
lista[recebeAtual].ligado++;
listaLigacao[sucessos].primeiro = resto[daAtual];
listaLigacao[sucessos].segundo = lista[recebeAtual];
listaLigacao[sucessos].tipo = TipoLigacao.DATIVA;
sucessos++;
// checa se os indices são maiores que seus limites
// se sim, retornar ao valor original
if (daAtual < indiceResto)
{
daAtual++;
}
if (daAtual >= indiceResto)
{
daAtual = 0;
}
if (recebeAtual < separador)
{
recebeAtual++;
}
if (recebeAtual >= separador)
{
recebeAtual = 0;
}
}
}
}
int grupo = -1;
int[] naoBalanceado = new int[4];
naoBalanceado[0] = -1;
naoBalanceado[1] = -1;
naoBalanceado[2] = -1;
naoBalanceado[3] = -1;
// se existe apenas um grupo de elementos
if (separador == 0)
{
for (int i = 0, j = 0; i < tamanho; i++)
{
if (lista[i].eletronsDisponiveis > 0 && lista[i].eletronsAtuais != 8)
{
grupo = 0;
naoBalanceado[j] = i;
j++;
}
}
}
// se um grupo já está balanceado, varrer ambos os grupos, encontrando
// quaisquer elementos não balanceados, e adicionando eles a um array
else
{
int j = 0;
for (int i = 0; i < separador; i++)
{
if (lista[i].eletronsDisponiveis > 0 && lista[i].eletronsAtuais != 8 && lista[i].eletronsAtuais != 2)
{
grupo = 0;
naoBalanceado[j] = i;
j++;
}
}
if (grupo == -1)
{
j = 0;
for (int i = separador; i < tamanho; i++)
{
if (lista[i].eletronsDisponiveis > 0 && lista[i].eletronsAtuais != 8 && lista[i].eletronsAtuais != 2)
{
grupo = separador;
naoBalanceado[j] = i;
j++;
}
}
}
}
// criar uma ligação entre os elementos de mesmo tipo se necessário
if (grupo != -1 && naoBalanceado[0] != -1 && naoBalanceado[1] != -1 &&
lista[naoBalanceado[0]].ligado == 0 && lista[naoBalanceado[1]].ligado == 0)
{
novaLigacao = criarLigacao(lista, grupo + naoBalanceado[0], grupo + naoBalanceado[1]);
if (novaLigacao.tipo != TipoLigacao.ERRO)
{
listaLigacao[sucessos++] = novaLigacao;
}
}
int numeroUm = separador;
int numeroDois = tamanho - separador;
int numeroLig = sucessos;
int div;
for (div = 6; div > 1; div--)
{
if (separador % div == 0 && (tamanho - separador) % div == 0 && sucessos % div == 0)
{
numeroUm = numeroUm / div;
numeroDois = numeroDois / div;
numeroLig = numeroLig / div;
break;
}
}
int numeroDativa = 0;
for (int i = 0; i < sucessos; i++)
{
if (listaLigacao[i].tipo == TipoLigacao.DATIVA)
{
numeroDativa++;
}
}
Ligacao[] listaLigacaoFinal = new Ligacao[20];
int k = 0;
for (int i = 0; i < numeroLig - numeroDativa; i++)
{
listaLigacaoFinal[k] = listaLigacao[i];
k++;
}
for (int i = numeroLig - numeroDativa; i < numeroLig - (numeroDativa / div); i++)
{
listaLigacaoFinal[k] = listaLigacao[i];
k++;
}
for (int i = 0; i < tamanho; i++)
{
if ((lista[i].eletronsDisponiveis != 0 &&
lista[i].eletronsAtuais < 8) ||
lista[i].ligado == 0)
{
return(false);
}
}
return(true);
}
public static IList<Ligacao> trataListas(IList<string> ligacoes1, string username, ModuloIAProlog.ModuloIaClient prologService, int numTagsTotal)
{
IList<string> ligacoes = new List<string>();
IList<string> tags = new List<string>();
foreach (string lig in ligacoes1)
{
if (!lig.Equals(""))
{
ligacoes.Add(lig);
}
}
IList<User> users = new List<User>();
IList<string> usernames = new List<string>();
IList<Ligacao> ligacoesRetornadas = new List<Ligacao>();
IList<Ligacao> ligacoesDirectas = new List<Ligacao>();
users.Add(new User(username,0,prologService,numTagsTotal));
usernames.Add(username);
int id = 1;
for(int k=0;k<ligacoes.Count-1;k=k+3)
{
if (!usernames.Contains(ligacoes[k + 1]))
{
usernames.Add(ligacoes[k + 1]);
users.Add(new User(ligacoes[k + 1], id, prologService, numTagsTotal));
id++;
}
if (usernames.IndexOf(ligacoes[k]) == 0)
{
ligacoesDirectas.Add(new Ligacao(users[0], users[usernames.IndexOf(ligacoes[k + 1])], Convert.ToInt32(ligacoes[k + 2])));
}
else
{
ligacoesRetornadas.Add(new Ligacao(users[usernames.IndexOf(ligacoes[k])], users[usernames.IndexOf(ligacoes[k + 1])], Convert.ToInt32(ligacoes[k + 2])));
}
}
Ligacao aux;
// Depois fazemos sort
for(int i = 0;i< ligacoesDirectas.Count-1; i++)
{
if(ligacoesDirectas[i].Forca < ligacoesDirectas[i+1].Forca){
aux = ligacoesDirectas[i];
ligacoesDirectas[i] = ligacoesDirectas[i + 1];
ligacoesDirectas[i + 1] = aux;
i = 0;
}
}
Ligacao[] arraytemp = new Ligacao[ligacoesDirectas.Count+ligacoesRetornadas.Count];
ligacoesDirectas.CopyTo(arraytemp, 0);
ligacoesRetornadas.CopyTo(arraytemp, ligacoesDirectas.Count);
ligacoesRetornadas = arraytemp.ToList();
ligacoesDirectas = new List<Ligacao>();
foreach (Ligacao lig in ligacoesRetornadas)
{
if (lig.User2.Id > lig.User1.Id)
{
ligacoesDirectas.Add(lig);
}
}
return ligacoesDirectas;
}
public static string URLCentralTelefonica(IEnumerable <Parametros> _parametros, Ligacao ligacao)
{
string url = Parametros.BuscarValor("URL", _parametros);
url = url.Replace("{RAMAL}", ligacao.Fila.Ramal);
url = url.Replace("{FONE}", ligacao.Telefone);
return(url);
}
private void RegistraLigacao(Ligacao ligacao)
{
_context.Ligacoes.Add(ligacao);
_context.SaveChanges();
}
private void ChamaURLCentralTelefonica(Ligacao ligacao)
{
new HttpClient().PostAsync(URLHelper.URLCentralTelefonica(_parametros, ligacao), null);
}
public Ligacao getLigacao(int userreg, int user1, int user2)
{
if (userreg == user1)
{
Ligacao lig = new Ligacao(user1, user2, Rede.Relacao.getTagsByUsers(user1, user2));
return lig;
}
else
{
return null;
}
}
public Consulta()
{
InitializeComponent();
dataGridView1.AutoGenerateColumns = true;
dataGridView1.MultiSelect = false;
dataGridView1.AllowUserToDeleteRows = false;
dataGridView1.ReadOnly = true;
dataGridView1.RowHeadersVisible = false;
dataGridView1.AllowUserToAddRows = false;
dataGridView1.AllowUserToResizeRows = false;
dataGridView1.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
dataGridView1.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;
dataGridView1.CellDoubleClick += DataGridView1_CellContentDoubleClick;
if (typeof(T) == typeof(Cliente))
{
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn {
HeaderText = "Código", Name = "CodCli"
});
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn
{
HeaderText = "Razão Social",
Name = "RazaoSocial"
});
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn
{
HeaderText = "Nome Fantasia",
Name = "NomeFantasia"
});
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn {
HeaderText = "CNPJ", Name = "Cnpj"
});
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn {
HeaderText = "Telefone", Name = "Telefone"
});
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn {
HeaderText = "E-mail", Name = "Email"
});
CreateCells = obj =>
{
Cliente cliente = obj as Cliente;
if (cliente == null)
{
return(null);
}
return(new object[]
{
cliente.Codigo, cliente.RazaoSocial, cliente.NomeFantasia,
cliente.Cnpj, cliente.Telefone, cliente.Email
});
};
Carregar = () =>
{
using (LigacoesContext context = new LigacoesContext())
{
return(context.Clientes.OfType <T>().ToList());
}
};
}
else if (typeof(T) == typeof(Usuario))
{
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn {
HeaderText = "Código", Name = "Codigo"
});
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn {
HeaderText = "Nome", Name = "Nome"
});
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn {
HeaderText = "Login", Name = "Login"
});
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn
{
HeaderText = "Tipo de Usuário",
Name = "TipoUsuario"
});
CreateCells = obj =>
{
//return usuario == null ? null : new object[] { usuario.Codigo, usuario.Nome, usuario.Login, usuario.Tipo };
Usuario usuario = obj as Usuario;
if (usuario == null)
{
return(null);
}
return(new object[] { usuario.Codigo, usuario.Nome, usuario.Login, usuario.Tipo });
};
Carregar = () =>
{
using (LigacoesContext context = new LigacoesContext())
{
return(context.Usuarios.OfType <T>().ToList());
}
};
}
if (typeof(T) == typeof(Ligacao))
{
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn {
HeaderText = "Código", Name = "Codigo"
});
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn
{
HeaderText = "Data e Hora",
Name = "DataHora"
});
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn {
HeaderText = "Cliente", Name = "Cliente"
});
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn {
HeaderText = "Usuário", Name = "Usuario"
});
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn
{
HeaderText = "Observações",
Name = "Observacoes",
});
CreateCells = obj =>
{
Ligacao ligacao = obj as Ligacao;
if (ligacao == null)
{
return(null);
}
return(new object[]
{
ligacao.Codigo, ligacao.DataHora, ligacao.Cliente.RazaoSocial,
ligacao.Usuario.Nome, ligacao.Observacoes
});
};
Carregar = () =>
{
using (LigacoesContext context = new LigacoesContext())
{
return(context.Ligacoes.Include(nameof(Ligacao.Cliente))
.Include(nameof(Ligacao.Usuario))
.OfType <T>().ToList());
}
};
}
}
protected void SalvarAtividadeLigacao(AtividadeNewViewModel model, string userId)
{
if (model.id == null) // Adicionar
{
if (model.statusAtividadeID == null)
{
model.statusAtividadeID = _statusAtividadeServico.ObterStatusAtividadePadraoParaLigacao().Id;
}
int?canalId = null;
var canal = _canalServico.ObterCanalTelefone();
if (canal.ValidationResult.IsValid)
{
canalId = canal.Id;
}
if (model.atendimentoID == null)
{
var atendimento = _atendimentoServico.AdicionarNovoAtendimento(canalId, userId, null);
if (atendimento.ValidationResult.IsValid)
{
model.atendimentoID = atendimento.Id;
}
}
var atividade = new Atividade(userId, (int)model.statusAtividadeID, model.atividadeTipoID, model.titulo,
model.pessoaFisicaID, model.pessoaJuridicaID, model.potencialClienteID, model.ocorrenciaID,
model.descricao, model.atendimentoID, model.midiaID, null, null, null, model.previsaoDeExecucao,
canalId, userId)
{
PrevisaoDeExecucao = model.previsaoDeExecucao
};
model.ValidationResult = _atividadeServico.Adicionar(atividade);
if (model.ValidationResult.IsValid)
{
model.id = atividade.Id;
var ligacao = new Ligacao(atividade.PessoasFisicasId, atividade.PessoasJuridicasId,
atividade.PotenciaisClientesId, userId, model.Ligacao.sentido, atividade.Id,
model.Ligacao.telefoneID, null, null, null);
model.ValidationResult = _ligacaoServico.Adicionar(ligacao);
if (model.ValidationResult.IsValid)
{
if (model.filaID != null)
{
ColocarAtividadeFila((int)model.filaID, atividade.Id);
}
}
_servicoAtividadeParteEnvolvidaServico.Adicionar(new AtividadeParteEnvolvida(atividade.Id,
atividade.PessoasFisicasId, atividade.PessoasJuridicasId, null, userId,
TipoParteEnvolvida.ClienteTratado.Value, null, null));
}
}
else //Atualizar
{
var atividade = _atividadeServico.ObterPorId((long)model.id);
if (atividade != null && atividade.FinalizadoEm == null)
{
if (model.statusAtividadeID != null)
{
var statusAtividade = _statusAtividadeServico.ObterPorId((long)model.statusAtividadeID);
if (statusAtividade != null)
{
if (statusAtividade.FinalizaAtividade)
{
atividade.FinalizadoEm = DateTime.Now;
atividade.FinalizadoPorUserId = userId;
}
}
atividade.StatusAtividadeId = (int)model.statusAtividadeID;
}
atividade.Descricao = model.descricao;
if (model.atendimentoID != null)
{
atividade.AtendimentoId = (long)model.atendimentoID;
}
_atividadeServico.Atualizar(atividade);
}
if (model.dataAgendamento != null)
{
if (model.statusAtividadeID == null)
{
model.statusAtividadeID =
_statusAtividadeServico.ObterStatusAtividadeLigacaoReceptiva().FirstOrDefault().Id;
}
var novaAtividade = new Atividade()
{
PessoasFisicasId = atividade.PessoasFisicasId,
PessoasJuridicasId = atividade.PessoasJuridicasId,
PotenciaisClientesId = atividade.PotenciaisClientesId,
OcorrenciaId = atividade.OcorrenciaId,
CriadoPorUserId = userId,
ContratoId = atividade.ContratoId,
Descricao = model.descricao,
MidiasId = atividade.MidiasId,
StatusAtividadeId = _statusAtividadeServico.ObterStatusAtividadePadraoParaLigacao().Id,
AtividadeTipoId = 3,
Titulo = atividade.Titulo,
//atendimentoID = model.atendimentoID,
PrevisaoDeExecucao = model.dataAgendamento
};
if (model.agendamentoPrivado != null)
{
if ((bool)model.agendamentoPrivado)
{
novaAtividade.ResponsavelPorUserId = novaAtividade.CriadoPorUserId;
}
}
model.ValidationResult = _atividadeServico.Adicionar(novaAtividade);
if (model.ValidationResult.IsValid)
{
var ligacao = _ligacaoServico.BuscarPorAtividadeId(atividade.Id);
model.id = novaAtividade.Id;
var novaligacao = new Ligacao(novaAtividade.PessoasFisicasId, novaAtividade.PessoasJuridicasId,
novaAtividade.PotenciaisClientesId, userId, "S", novaAtividade.Id, ligacao.TelefoneId,
ligacao.NumeroOriginal, null, null);
model.ValidationResult = _ligacaoServico.Adicionar(novaligacao);
if (model.ValidationResult.IsValid)
{
var filaID = _atividadeFilaServico.ObterUltimoVinculoPraAtividade(atividade.Id);
if (filaID != null)
{
ColocarAtividadeFila(filaID.FilaId, novaAtividade.Id, novaAtividade.ResponsavelPorUserId);
}
}
}
}
}
}
public ReceptivoViewModel NovaLigacaoReceptiva(string userId, string informacaoUra, string numeroTelefone,
string codLigacao, string terminal)
{
var statusUra = false;
var ligacao = new Ligacao();
if (!string.IsNullOrEmpty(numeroTelefone))
{
ligacao = _servicoLigacao.ObterLigacaoReceptivaUra(numeroTelefone);
statusUra = true;
if (ligacao.Id > 0)
{
if (ligacao.Atividade != null)
{
if (ligacao.Atividade.Id > 0)
{
if (ligacao.Atividade.Atendimento != null)
{
if (ligacao.Atividade.Atendimento.Id > 0)
{
_servicoLigacao.AtualizarLigacaoGeradorProtocoloUra(userId, ligacao.Id,
ligacao.Atividade.Id, ligacao.Atividade.Atendimento.Id);
}
}
}
}
}
}
if (ligacao.Id == 0)
{
ligacao = _servicoLigacao.AdicionarLigacaoReceptiva(userId, numeroTelefone, null);
}
if (ligacao.ValidationResult.IsValid)
{
if (!string.IsNullOrEmpty(ligacao.Documento))
{
informacaoUra = ligacao.Documento;
}
var canalTelefoneId = Convert.ToInt32(CanalEnum.Telefone);
var listaMidias = new SelectList(_servicoMidia.ObterPor(null, canalTelefoneId), "id", "nome");
var listaStatusAtividade =
new SelectList(_servicoStatusAtividade.ObterStatusAtividadeLigacaoReceptiva(), "id", "descricao");
if (ligacao.Atividade == null || ligacao.Atividade.AtendimentoId == null)
{
return(null);
}
if (ligacao.Atividade.Atendimento != null)
{
return(new ReceptivoViewModel((long)ligacao.Atividade.AtendimentoId, ligacao.Id,
ligacao.AtividadeId, informacaoUra, numeroTelefone, ligacao.Atividade.Atendimento.Protocolo,
null, null, null, null, null, listaMidias, listaStatusAtividade, null, statusUra, false, null));
}
}
else
{
var retorno = new ReceptivoViewModel {
ValidationResult = ligacao.ValidationResult
};
return(retorno);
}
return(null);
}
// Username apenas para grafo simples.
// Ambos usernames definidos para grafo de amigos em comum
public Grafo(string username, string username1)
{
ModuloIAProlog.ModuloIaClient prologService = new ModuloIAProlog.ModuloIaClient();
Users = new List <User>();
Ligacoes = new List <Ligacao>();
int numTagsTotal = Graphs4Social_AR.Tag.LoadAllTag().Count;
//
if (!username1.Equals(""))
{
string pedidosuser = prologService.redeNivel(2, username);
string pedidosuser1 = prologService.redeNivel(2, username1);
char[] separator = new char[3];
separator[0] = ']';
separator[1] = ',';
separator[2] = '[';
string[] arraytemp = new string[pedidosuser.Length + pedidosuser1.Length];
IList <string> ligacoes = pedidosuser.Split(separator);
IList <string> ligacoes1 = pedidosuser1.Split(separator);
ligacoes.CopyTo(arraytemp, 0);
ligacoes1.CopyTo(arraytemp, ligacoes.Count);
ligacoes = new List <string>();
for (int i = 0; i < arraytemp.Length; i++)
{
if (!ligacoes.Contains(arraytemp[i]) && !(arraytemp[i].Equals("") || arraytemp[i] == null))
{
ligacoes.Add(arraytemp[i]);
}
}
// Carrega o user "dono" do grafo
Users.Add(new User(username, 0, prologService, numTagsTotal));
Users[0].Definido = true;
Users[0].X = -50;
Users[0].Y = -50;
// Carrega as ligações do user
// IList<string> ligacoes = RedeNivel2(userdono,U)
Users.Add(new User(username1, 1, prologService, numTagsTotal));
Users[1].Definido = true;
Users[1].X = 50;
Users[1].Y = 50;
}
else
{
// Carrega as ligações do grafo do username a nível 3
string pedidoLigacoes = prologService.grafoNivel3(username);
pedidoLigacoes = pedidoLigacoes.Substring(1, pedidoLigacoes.Length - 2);
char [] separator = new char [3];
separator[0] = ']';
separator[1] = ',';
separator[2] = '[';
IList <string> ligacoes = pedidoLigacoes.Split(separator);
while (true)
{
if (!(ligacoes.Count < 2))
{
Ligacoes = Ligacao.trataListas(ligacoes, username, prologService, numTagsTotal);
break;
}
pedidoLigacoes = prologService.grafoNivel3(username);
pedidoLigacoes = pedidoLigacoes.Substring(1, pedidoLigacoes.Length - 2);
ligacoes = pedidoLigacoes.Split(separator);
prologService.Close();
}
foreach (Ligacao lig in Ligacoes)
{
if (!Users.Contains(lig.User1))
{
Users.Add(lig.User1);
}
if (!Users.Contains(lig.User2))
{
Users.Add(lig.User2);
}
}
// Carrega o user "dono" do grafo
Users[0].Definido = true;
Users[0].X = 0;
Users[0].Y = 0;
}
prologService.Close();
NrNos = Users.Count;
NrArcos = Ligacoes.Count;
int tentativas = 0;
bool notDone = true;
bool flagBreak = false;
int max = 8 * NrArcos;
Random valor = new Random();
while (notDone)
{
for (int k = 0; k < Ligacoes.Count; k++)
{
if (!Ligacoes[k].User2.Definido)
{
if (valor.NextDouble() >= 0.5)
{
Ligacoes[k].User2.X = valor.Next(10, max) * -1;
}
else
{
Ligacoes[k].User2.X = valor.Next(10, max);
}
//
if (valor.NextDouble() >= 0.5)
{
Ligacoes[k].User2.Y = valor.Next(10, max) * -1;
}
else
{
Ligacoes[k].User2.Y = valor.Next(10, max);
}
}
else
{
tentativas = 49;
}
for (int j = 0; j < NrArcos; j++)
{
if (!(tentativas >= 50))
{
if (!(Ligacoes[j].User1.Id == Ligacoes[k].User1.Id && Ligacoes[j].User2.Id == Ligacoes[k].User2.Id))
{
if (intersecta(Ligacoes[j].User1, Ligacoes[j].User2, Ligacoes[k].User1, Ligacoes[k].User2))
{
tentativas++;
flagBreak = true;
break;
}
}
}
else
{
break;
}
}
if (tentativas >= 50)
{
flagBreak = false;
break;
}
else if (!flagBreak)
{
Ligacoes[k].User2.Definido = true;
}
else
{
flagBreak = false;
k--;
}
}
if (!(tentativas >= 50))
{
notDone = false;
}
else
{
tentativas = 0;
for (int j = 0; j < NrNos; j++)
{
Users[j].Definido = false;
}
}
}
}
public static IList <Ligacao> trataListas(IList <string> ligacoes1, string username, ModuloIAProlog.ModuloIaClient prologService, int numTagsTotal)
{
IList <string> ligacoes = new List <string>();
IList <string> tags = new List <string>();
foreach (string lig in ligacoes1)
{
if (!lig.Equals(""))
{
ligacoes.Add(lig);
}
}
IList <User> users = new List <User>();
IList <string> usernames = new List <string>();
IList <Ligacao> ligacoesRetornadas = new List <Ligacao>();
IList <Ligacao> ligacoesDirectas = new List <Ligacao>();
users.Add(new User(username, 0, prologService, numTagsTotal));
usernames.Add(username);
int id = 1;
for (int k = 0; k < ligacoes.Count - 1; k = k + 3)
{
if (!usernames.Contains(ligacoes[k + 1]))
{
usernames.Add(ligacoes[k + 1]);
users.Add(new User(ligacoes[k + 1], id, prologService, numTagsTotal));
id++;
}
if (usernames.IndexOf(ligacoes[k]) == 0)
{
ligacoesDirectas.Add(new Ligacao(users[0], users[usernames.IndexOf(ligacoes[k + 1])], Convert.ToInt32(ligacoes[k + 2])));
}
else
{
ligacoesRetornadas.Add(new Ligacao(users[usernames.IndexOf(ligacoes[k])], users[usernames.IndexOf(ligacoes[k + 1])], Convert.ToInt32(ligacoes[k + 2])));
}
}
Ligacao aux;
// Depois fazemos sort
for (int i = 0; i < ligacoesDirectas.Count - 1; i++)
{
if (ligacoesDirectas[i].Forca < ligacoesDirectas[i + 1].Forca)
{
aux = ligacoesDirectas[i];
ligacoesDirectas[i] = ligacoesDirectas[i + 1];
ligacoesDirectas[i + 1] = aux;
i = 0;
}
}
Ligacao[] arraytemp = new Ligacao[ligacoesDirectas.Count + ligacoesRetornadas.Count];
ligacoesDirectas.CopyTo(arraytemp, 0);
ligacoesRetornadas.CopyTo(arraytemp, ligacoesDirectas.Count);
ligacoesRetornadas = arraytemp.ToList();
ligacoesDirectas = new List <Ligacao>();
foreach (Ligacao lig in ligacoesRetornadas)
{
if (lig.User2.Id > lig.User1.Id)
{
ligacoesDirectas.Add(lig);
}
}
return(ligacoesDirectas);
}
public void CriarLigacao(string name)
{
Ligacao item = new Ligacao();
item.NovaLigacao(name);
}
