public SincronizadorDTO PegarDadosParaSolicitarSincronia()
        {
            try
            {
                conexao.Open();
                IDbCommand selectGroupCmd = conexao.CreateCommand();
                selectGroupCmd.CommandText = "select Grupo from Mensagem group by Grupo";
                List <GrupoSincronizadoresPaiDTO> ListaGrupoSincronizadores = new List <GrupoSincronizadoresPaiDTO>();
                IDataReader resultadoGroup = selectGroupCmd.ExecuteReader();
                while (resultadoGroup.Read())
                {
                    var grupoSincronizadoresPaiDTO = new GrupoSincronizadoresPaiDTO()
                    {
                        IdGrupo = Convert.ToInt32(resultadoGroup["Grupo"])
                    };
                    if (!grupoSincronizadoresPaiDTO.Equals(null))
                    {
                        ListaGrupoSincronizadores.Add(grupoSincronizadoresPaiDTO);
                    }
                }

                conexao.Close();
                conexao.Open();
                SincronizadorDTO sincronizador = new SincronizadorDTO();
                foreach (GrupoSincronizadoresPaiDTO obj in ListaGrupoSincronizadores)
                {
                    IDbCommand selectCmd = conexao.CreateCommand();
                    selectCmd.CommandText = "select PaiSyncronia,MAX(ContSyncronia) as MaxContSyncronia from Mensagem where Grupo = " + obj.IdGrupo + " group by PaiSyncronia";

                    List <PaiSincronia> listaPaiSincronias = new List <PaiSincronia>();
                    IDataReader         resultado          = selectCmd.ExecuteReader();
                    while (resultado.Read())
                    {
                        var paiSyncronia = new PaiSincronia()
                        {
                            Id           = Convert.ToInt32(resultado["PaiSyncronia"]),
                            MaxSincronia = Convert.ToInt32(resultado["MaxContSyncronia"])
                        };
                        if (!paiSyncronia.Equals(null))
                        {
                            listaPaiSincronias.Add(paiSyncronia);
                        }
                    }

                    obj.SincroniasPai = listaPaiSincronias;
                    sincronizador.ListaDeGruposSincroniaPay.Add(obj);
                    conexao.Close();
                }//fim foreach

                return(sincronizador);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                conexao.Close();
            }
        }
        public SincronizadorDTO Teste1Sincronizador()
        {
            SincronizadorDTO teste1 = new SincronizadorDTO()
            {
                StatusSincroniaMensagem = Status.Perguntando,
                //MaxSincMensagem = 0,
                //MaxSincUsuario = 0,
                //MaxSincContatos = 0,
                //ListaMensagem = null,
                //ListaUsuarios = null,
                //ListaContatos = null

                /* "StatusSincroniaMensagem": 5,
                 * "StatusGrupoSincronia": 1,
                 * "MaxSincMensagem": 0,
                 * "MaxSincUsuario": 0,
                 * "MaxSincContatos": 0,
                 * "ListaMensagem": [
                 * {
                 * "Id": 27,
                 * "Mensagem": "Precisamos resolver um assunto",
                 * "Grupo": 1,
                 * "PaiMensagem": 1,
                 * "PaiSyncronia": 1,
                 * "ContSyncronia": 2
                 * }
                 * ],
                 * "ListaUsuarios": [],
                 * "ListaContatos": [],
                 * "ListaDeGruposSincroniaPay": []
                 * }*/
            };

            return(teste1);
        }
        public List <GrupoSincronizadoresPaiDTO> PegarDadosParaSolicitarSincronia(SincronizadorDTO objSinc)
        {
            try
            {
                conexao.Open();
                List <GrupoSincronizadoresPaiDTO> ListaGrupoSincronizadores = new List <GrupoSincronizadoresPaiDTO>();
                foreach (GrupoSincronizadoresPaiDTO obj in objSinc.ListaDeGruposSincroniaPay)
                {
                    GrupoSincronizadoresPaiDTO grupoSincronizadoresPaiDTO = new GrupoSincronizadoresPaiDTO();
                    foreach (PaiSincronia objPaisSinc in obj.SincroniasPai)
                    {
                        IDbCommand selectCmd = conexao.CreateCommand();
                        selectCmd.CommandText = "select PaiSyncronia, MAX(ContSyncronia) as MaxSincronia from Mensagem where Grupo = " + obj.IdGrupo
                                                + " and ContSyncronia< " + objPaisSinc.MaxSincronia + "  and((select Max(ContSyncronia) from Mensagem) < " + objPaisSinc.MaxSincronia
                                                + ") Group by PaiSyncronia";

                        List <PaiSincronia> listaPaiSincronias = new List <PaiSincronia>();
                        IDataReader         resultado          = selectCmd.ExecuteReader();
                        while (resultado.Read())
                        {
                            var paiSyncronia = new PaiSincronia()
                            {
                                Id           = Convert.ToInt32(resultado["PaiSyncronia"]),
                                MaxSincronia = Convert.ToInt32(resultado["MaxSincronia"])
                            };
                            if (!paiSyncronia.Equals(null))
                            {
                                listaPaiSincronias.Add(paiSyncronia);
                            }
                        }
                        if (listaPaiSincronias.Any())
                        {
                            grupoSincronizadoresPaiDTO.IdGrupo       = obj.IdGrupo;
                            grupoSincronizadoresPaiDTO.SincroniasPai = listaPaiSincronias;
                        }

                        conexao.Close();
                        conexao.Open();
                    }
                    ListaGrupoSincronizadores.Add(grupoSincronizadoresPaiDTO);
                }
                return(ListaGrupoSincronizadores);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                conexao.Close();
            }
        }
        internal SincronizadorDTO PegarDadosUltimaSincronia()
        {
            MensagemDAO      mensagem      = new MensagemDAO();
            SincronizadorDTO sincronizador = mensagem.PegarDadosParaSolicitarSincronia();

            if (sincronizador.ListaDeGruposSincroniaPay.Any())
            {
                sincronizador.StatusGrupoSincronia = Status.Solicitando;
            }
            else
            {
                sincronizador.StatusGrupoSincronia = Status.Ok;
            }
            return(sincronizador);
        }
        private SincronizadorDTO SincronizarMensagem(SincronizadorDTO sincMensagem)
        {
            if (sincMensagem.StatusGrupoSincronia == Status.Solicitando)
            {
                //pegar Mensagens no banco e enviar
                MensagemDAO      objMensagemDao   = new MensagemDAO();
                SincronizadorDTO devolveSincronia = new SincronizadorDTO();
                devolveSincronia.ListaMensagem = objMensagemDao.PegarDadosParaEnviarSincronia(sincMensagem);

                if (devolveSincronia.ListaMensagem.Any())
                {
                    devolveSincronia.StatusSincroniaMensagem = Status.Enviando;
                }
                else
                {
                    devolveSincronia.StatusSincroniaMensagem = Status.Ok;
                }

                List <GrupoSincronizadoresPaiDTO> listaDeGruposSincroniaPay = objMensagemDao.PegarDadosParaSolicitarSincronia(sincMensagem);
                if (!listaDeGruposSincroniaPay.Any() || listaDeGruposSincroniaPay[0].IdGrupo == 0)
                {
                    devolveSincronia.StatusGrupoSincronia = Status.Ok;
                }
                else
                {
                    devolveSincronia.ListaDeGruposSincroniaPay = listaDeGruposSincroniaPay;
                    devolveSincronia.StatusGrupoSincronia      = Status.Solicitando;
                }

                return(devolveSincronia);
            }

            if (sincMensagem.StatusSincroniaMensagem == Status.Enviando)
            {
                //salvar no banco
                MensagemDAO objMensagemDao = new MensagemDAO();
                objMensagemDao.SincronizarMenagens(sincMensagem.ListaMensagem);
                sincMensagem.StatusSincroniaMensagem = Status.Ok;
                sincMensagem.ListaMensagem           = null;
                return(null);
            }
            if (sincMensagem.StatusSincroniaMensagem == Status.Ok)
            {
                return(null);
            }

            return(null);
        }
        public List <MensagemDTO> PegarDadosParaEnviarSincronia(SincronizadorDTO objSinc)
        {
            try
            {
                conexao.Open();
                List <MensagemDTO> listaDeMensagens = new List <MensagemDTO>();
                foreach (GrupoSincronizadoresPaiDTO obj in objSinc.ListaDeGruposSincroniaPay)
                {
                    foreach (PaiSincronia objPaisSinc in obj.SincroniasPai)
                    {
                        IDbCommand selectCmd = conexao.CreateCommand();
                        selectCmd.CommandText = "select * from Mensagem where Grupo = " + obj.IdGrupo + " and PaiSyncronia = " + objPaisSinc.Id + " and ContSyncronia > " + objPaisSinc.MaxSincronia;

                        IDataReader resultado = selectCmd.ExecuteReader();

                        while (resultado.Read())
                        {
                            var mensagem = new MensagemDTO()
                            {
                                Id            = Convert.ToInt32(resultado["Id"]),
                                Mensagem      = Convert.ToString(resultado["Mensagem"]),
                                Grupo         = Convert.ToInt32(resultado["Grupo"]),
                                PaiMensagem   = Convert.ToInt32(resultado["PaiMensagem"]),
                                ContSyncronia = Convert.ToInt32(resultado["ContSyncronia"]),
                                PaiSyncronia  = Convert.ToInt32(resultado["PaiSyncronia"])
                            };
                            listaDeMensagens.Add(mensagem);
                        }
                        conexao.Close();
                        conexao.Open();
                    }
                }
                return(listaDeMensagens);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                conexao.Close();
            }
        }
        private SincronizadorDTO SincronizarMensagem(SincronizadorDTO sincMensagem)
        {
            if (sincMensagem == null)
            {
                sincMensagem = new SincronizadorDTO();
            }
            MensagemDAO mensagem = new MensagemDAO();


            if (sincMensagem.StatusSincroniaMensagem == Status.Enviando)
            {
                foreach (MensagemDTO obj in sincMensagem.ListaMensagem)
                {
                    mensagem.InserirMensagemDB(obj);
                }

                sincMensagem.StatusSincroniaMensagem = Status.Ok;
            }

            if (sincMensagem.StatusGrupoSincronia == Status.Solicitando)
            {
                var listaMensagem = mensagem.PegarDadosParaEnviarSincronia(sincMensagem);

                if (listaMensagem.Any())
                {
                    sincMensagem.ListaMensagem           = listaMensagem;
                    sincMensagem.StatusSincroniaMensagem = Status.Enviando;
                }
                else
                {
                    sincMensagem.StatusSincroniaMensagem = Status.Ok;
                }
                sincMensagem.StatusGrupoSincronia = Status.Ok;
                return(sincMensagem);
            }

            return(sincMensagem);
        }
        public SincronizadorDTO PegarMensagensNaoSincronizadas(SincronizadorDTO listaMensagemSinc)
        {
            List <MensagemDTO> listaMensagens = new List <MensagemDTO>();

            try
            {
                conexao = new SqlConnection(stringConexao);
                conexao.Open();
                IDbCommand selectCmd = conexao.CreateCommand();
                selectCmd.CommandText = "select * from mensagem where grupo = 1 and ContSyncronia > 1";

                IDataReader resultado = selectCmd.ExecuteReader();
                while (resultado.Read())
                {
                    var mensagen = new MensagemDTO()
                    {
                        Id            = Convert.ToInt32(resultado["Id"]),
                        Mensagem      = Convert.ToString(resultado["Mensagem"]),
                        Grupo         = Convert.ToInt32(resultado["Grupo"]),
                        PaiMensagem   = Convert.ToInt32(resultado["PaiMensagem"]),
                        ContSyncronia = Convert.ToInt32(resultado["ContSyncronia"]),
                        PaiSyncronia  = Convert.ToInt32(resultado["PaiSyncronia"])
                    };
                    listaMensagens.Add(mensagen);
                }
                listaMensagemSinc.ListaMensagem = listaMensagens;
                return(listaMensagemSinc);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                conexao.Close();
            }
        }
        public async Task BotaoSincronizar()
        {
            string url = "http://myfirstprogram.gearhostpreview.com/api/Sincronizador";

            string           dados = "";
            SincronizadorDTO obj   = new SincronizadorDTO();

            dados = new JavaScriptSerializer().Serialize(PegarDadosUltimaSincronia());
            HttpContent c = new StringContent(dados, Encoding.UTF8, "application/json");

            using (var client = new HttpClient())
            {
                HttpResponseMessage result = await client.PostAsync(url, c);

                if (result.IsSuccessStatusCode)
                {
                    dados = "";
                    dados = await result.Content.ReadAsStringAsync();

                    DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(SincronizadorDTO));
                    MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(dados));
                    obj = (SincronizadorDTO)serializer.ReadObject(ms);
                    obj = Sincronizar(obj);
                    if (obj.StatusSincroniaMensagem == Status.Enviando)
                    {
                        dados = "";
                        dados = new JavaScriptSerializer().Serialize(obj);
                        c     = new StringContent(dados, Encoding.UTF8, "application/json");
                        using (client)
                        {
                            HttpResponseMessage result2 = await client.PostAsync(url, c);
                        }
                    }
                }
                dados = "";
            }
        }
Exemple #10
0
        // POST: api/Sincronizador
        public SincronizadorDTO Post([FromBody] SincronizadorDTO sincronia)
        {
            SincronizadorModel sincronizadorModel = new SincronizadorModel();

            return(sincronizadorModel.Sincronizar(sincronia));
        }
Exemple #11
0
        internal SincronizadorDTO Sincronizar(SincronizadorDTO sincronizador)
        {
            SincronizadorModel sincronizadorModel = new SincronizadorModel();

            return(sincronizadorModel.Sincronizar(sincronizador));
        }
 public SincronizadorDTO PegaTodasMaxSincronia(SincronizadorDTO sincroniaBase, SincronizadorDTO sincroniaResult)
 {
     //sincroniaResult.MaxSincMensagem = PegarMaxSincMensagem(sincroniaBase.MaxSincMensagem);
     return(sincroniaResult);
 }
        public SincronizadorDTO Teste2Sincronizador()
        {
            SincronizadorDTO sincronizador = new SincronizadorDTO();

            sincronizador.StatusSincroniaMensagem = Status.Solicitando;
            //sincronizador.MaxSincMensagem = 1;
            //sincronizador.MaxSincUsuario = 1;
            //sincronizador.MaxSincContatos = 1;

            List <MensagemDTO> listaMensagem = new List <MensagemDTO>();
            MensagemDTO        m1            = new MensagemDTO()
            {
                Id            = 2,
                Mensagem      = "Teste2",
                Grupo         = 1,
                PaiMensagem   = 1,
                PaiSyncronia  = 1,
                ContSyncronia = 2
            };

            listaMensagem.Add(m1);

            MensagemDTO m2 = new MensagemDTO()
            {
                Id            = 3,
                Mensagem      = "Teste3",
                Grupo         = 1,
                PaiMensagem   = 1,
                PaiSyncronia  = 1,
                ContSyncronia = 3
            };

            listaMensagem.Add(m2);

            MensagemDTO m3 = new MensagemDTO()
            {
                Id            = 4,
                Mensagem      = "Teste4",
                Grupo         = 1,
                PaiMensagem   = 1,
                PaiSyncronia  = 1,
                ContSyncronia = 4
            };

            listaMensagem.Add(m3);
            //sincronizador.ListaMensagem = listaMensagem;
            sincronizador.ListaMensagem = null;

            UsuarioDTO us = new UsuarioDTO();

            us = null;
            sincronizador.ListaUsuarios.Add(us);

            ContatoDTO ct = new ContatoDTO();

            ct = null;
            sincronizador.ListaContatos.Add(ct);

            GrupoSincronizadoresPaiDTO Gs = new GrupoSincronizadoresPaiDTO();

            Gs.IdGrupo = 1;

            PaiSincronia sp1 = new PaiSincronia();

            sp1.Id           = 1;
            sp1.MaxSincronia = 1;
            Gs.SincroniasPai.Add(sp1);

            PaiSincronia sp2 = new PaiSincronia();

            sp2.Id           = 2;
            sp2.MaxSincronia = 2;
            Gs.SincroniasPai.Add(sp2);

            sincronizador.ListaDeGruposSincroniaPay.Add(Gs);
            return(sincronizador);
        }
 public SincronizadorDTO Sincronizar(SincronizadorDTO objSinc)
 {
     return(SincronizarMensagem(objSinc));
 }