Beispiel #1
0
        public string CadastrarEvento(EventoViewModel evento, List <Foto> fotos)
        {
            try
            {
                if (ValidaDadosDeEntrada(evento) != "")
                {
                    return(JsonConvert.SerializeObject(new { code = 400, message = ValidaDadosDeEntrada(evento) }));
                }
                else
                {
                    bool   podeAdicionar = true;
                    Evento ev            = new Evento();
                    evento.Latitude  = evento.Latitude.Replace(".", ",");
                    evento.Longitude = evento.Longitude.Replace(".", ",");
                    evento.Ativo     = false;
                    evento.Aprovado  = null;

                    var eventoService         = Mapper.Map <EventoViewModel, Evento>(evento);
                    var retornoConsultaEvento = VerificaSeEventoJaExiste(eventoService);

                    foreach (var v in retornoConsultaEvento)
                    {
                        if (
                            podeAdicionar &&
                            (eventoService.DataHoraInicio <= v.DataHoraInicio && eventoService.DataHoraFim <= v.DataHoraInicio) ||
                            (eventoService.DataHoraInicio >= v.DataHoraFim && eventoService.DataHoraFim >= v.DataHoraFim)
                            )
                        {
                            podeAdicionar = true;
                        }
                        else
                        {
                            ev            = v;
                            podeAdicionar = false;
                        }
                    }

                    if (podeAdicionar)
                    {
                        _eventoService.Add(eventoService);
                        int i = 0;

                        try
                        {
                            if (fotos != null)
                            {
                                foreach (var f in fotos)
                                {
                                    if (!string.IsNullOrEmpty(f.Imagem))
                                    {
                                        var fot = new Foto();

                                        //int inicio = f.Imagem.IndexOf(",");
                                        var nomeImagem = eventoService.EventoId.ToString() + eventoService.NomeEvento + i.ToString() + ".jpg";

                                        MD5 md5 = System.Security.Cryptography.MD5.Create();

                                        byte[] inputBytes = System.Text.Encoding.ASCII.GetBytes(nomeImagem);
                                        byte[] hash       = md5.ComputeHash(inputBytes);

                                        StringBuilder sb = new StringBuilder();
                                        for (int z = 0; z < hash.Length; z++)
                                        {
                                            sb.Append(hash[z].ToString("X2"));
                                        }

                                        var nomeCriptografado = sb.ToString();

                                        //if (ConvertStringtoImage(f.Imagem.Substring(inicio + 1), nomeCriptografado))
                                        if (ConvertStringtoImage(f.Imagem, nomeCriptografado))
                                        {
                                            fot.Imagem   = nomeCriptografado;
                                            fot.Tipo     = 1;
                                            fot.EventoId = eventoService.EventoId;

                                            _fotoService.Add(fot);
                                        }
                                        else
                                        {
                                            var evto = _eventoService.GetById(eventoService.EventoId);

                                            if (evto != null)
                                            {
                                                var fo = _fotoService.GetAll().Where(ft => ft.EventoId == evto.EventoId);

                                                foreach (var fto in fo)
                                                {
                                                    _fotoService.Remove(fto);
                                                }

                                                _eventoService.Remove(evto);
                                            }

                                            return(JsonConvert.SerializeObject(new { code = 400, message = "Houve um erro ao enviar as fotos do local do evento e por isso o mesmo não foi cadastrado. Por favor tente novamente." }));
                                        }

                                        i++;
                                    }
                                }
                            }
                        }
                        catch
                        {
                            var evto = _eventoService.GetById(eventoService.EventoId);

                            if (evto != null)
                            {
                                var fot = _fotoService.GetAll().Where(f => f.EventoId == evto.EventoId);

                                foreach (var f in fot)
                                {
                                    _fotoService.Remove(f);
                                }

                                _eventoService.Remove(evto);
                            }

                            return(JsonConvert.SerializeObject(new { code = 400, message = "Houve um erro ao enviar as fotos do local do evento e por isso o mesmo não foi cadastrado. Por favor tente novamente." }));
                        }
                        return(JsonConvert.SerializeObject(new { code = 200, message = "Evento cadastrado com sucesso. Aguarde a aprovação.", id = eventoService.EventoId }));
                    }
                    else
                    {
                        return(JsonConvert.SerializeObject(new { code = 400, message = "Desculpe, mas já existe um evento cadastrado neste local para este horário.", retornoEvento = ev }));
                    }
                }
            }
            catch
            {
                return(JsonConvert.SerializeObject(new { code = 400, message = "Erro no cadastro. Por favor, tente novamente." }));
            }
        }
        public string CadastrarVaga(VagaViewModel vaga, int quantidade, List <Foto> fotos)
        {
            try
            {
                if (ValidaDadosDeEntrada(vaga) != "")
                {
                    return(JsonConvert.SerializeObject(new { code = 400, message = ValidaDadosDeEntrada(vaga) }));
                }
                else
                {
                    vaga.Ativo  = false;
                    vaga.Aceita = null;

                    if (!string.IsNullOrEmpty(vaga.PrecoMensal))
                    {
                        vaga.PrecoMensal = vaga.PrecoMensal.Replace(".", ",");
                    }
                    if (!string.IsNullOrEmpty(vaga.PrecoDiaria))
                    {
                        vaga.PrecoDiaria = vaga.PrecoDiaria.Replace(".", ",");
                    }
                    if (!string.IsNullOrEmpty(vaga.PrecoAvulso))
                    {
                        vaga.PrecoAvulso = vaga.PrecoAvulso.Replace(".", ",");
                    }
                    if (!string.IsNullOrEmpty(vaga.AposPrimeiraHora))
                    {
                        vaga.AposPrimeiraHora = vaga.AposPrimeiraHora.Replace(".", ",");
                    }

                    var vagaService = Mapper.Map <VagaViewModel, Vaga>(vaga);

                    var dadosBancario = _dadosBancarioService.GetByIdUser(vagaService.UsuarioId);

                    if (dadosBancario.Count == 0)
                    {
                        var ga = _garagemService.GetById(vagaService.GaragemId);
                        ga.Vagas = _vagaService.GetByIdGarage(ga.GaragemId);

                        if (ga.Vagas.Count() == 0)
                        {
                            _garagemService.Remove(ga);
                        }
                        return(JsonConvert.SerializeObject(new { code = 400, message = "Não foi possível realizar o cadastro da vaga, é necessário que cadastre seus dados bancários." }));
                    }

                    if (
                        vagaService.PrecoAvulso == 0 &&
                        vagaService.PrecoMensal == 0 &&
                        vagaService.PrecoDiaria == 0 &&
                        vagaService.Mensal == false &&
                        vagaService.Avulso == false &&
                        vagaService.Diaria == false
                        )
                    {
                        var ga = _garagemService.GetById(vagaService.GaragemId);
                        ga.Vagas = _vagaService.GetByIdGarage(ga.GaragemId);

                        if (ga.Vagas.Count() == 0)
                        {
                            _garagemService.Remove(ga);
                        }
                        return(JsonConvert.SerializeObject(new { code = 400, message = "Favor informar ao menos 1 categoria de aluguel e o valor da locação desta categoria." }));
                    }

                    if (vagaService.Mensal == true && vagaService.PrecoMensal == 0)
                    {
                        var ga = _garagemService.GetById(vagaService.GaragemId);
                        ga.Vagas = _vagaService.GetByIdGarage(ga.GaragemId);

                        if (ga.Vagas.Count() == 0)
                        {
                            _garagemService.Remove(ga);
                        }
                        return(JsonConvert.SerializeObject(new { code = 400, message = "Favor informar o valor da locação mensal." }));
                    }

                    if (vagaService.Avulso == true && vagaService.PrecoAvulso == 0)
                    {
                        var ga = _garagemService.GetById(vagaService.GaragemId);
                        ga.Vagas = _vagaService.GetByIdGarage(ga.GaragemId);

                        if (ga.Vagas.Count() == 0)
                        {
                            _garagemService.Remove(ga);
                        }
                        return(JsonConvert.SerializeObject(new { code = 400, message = "Favor informar o valor da locação avulsa." }));
                    }

                    if (vagaService.Avulso == true && vagaService.AposPrimeiraHora == 0)
                    {
                        var ga = _garagemService.GetById(vagaService.GaragemId);
                        ga.Vagas = _vagaService.GetByIdGarage(ga.GaragemId);

                        if (ga.Vagas.Count() == 0)
                        {
                            _garagemService.Remove(ga);
                        }
                        return(JsonConvert.SerializeObject(new { code = 400, message = "Favor informar o valor que deve ser cobrado após a primeira hora de locação." }));
                    }

                    if (vagaService.Diaria == true && vagaService.PrecoDiaria == 0)
                    {
                        var ga = _garagemService.GetById(vagaService.GaragemId);
                        ga.Vagas = _vagaService.GetByIdGarage(ga.GaragemId);

                        if (ga.Vagas.Count() == 0)
                        {
                            _garagemService.Remove(ga);
                        }
                        return(JsonConvert.SerializeObject(new { code = 400, message = "Favor informar o valor da locação diaria." }));
                    }

                    if (vaga.PrecoAvulso == null)
                    {
                        vagaService.PrecoAvulso = null;
                    }
                    if (vaga.PrecoDiaria == null)
                    {
                        vagaService.PrecoDiaria = null;
                    }
                    if (vaga.PrecoMensal == null)
                    {
                        vagaService.PrecoMensal = null;
                    }
                    if (vaga.AposPrimeiraHora == null)
                    {
                        vagaService.AposPrimeiraHora = null;
                    }

                    var usu = _usuarioService.GetById(vagaService.UsuarioId);
                    var gar = _garagemService.GetById(vagaService.GaragemId);

                    if (gar.Condominio && string.IsNullOrEmpty(vaga.NumeroVaga))
                    {
                        return(JsonConvert.SerializeObject(new { code = 400, message = "Como esta Vaga pertence a um condomínio, você precisa fornecer o número da Vaga." }));
                    }
                    if (gar.Condominio && !string.IsNullOrEmpty(vaga.NumeroVaga))
                    {
                        var vagas = _vagaService.GetByIdGarage(vagaService.GaragemId);

                        foreach (var v in vagas)
                        {
                            if (v.NumeroVaga == vagaService.NumeroVaga)
                            {
                                return(JsonConvert.SerializeObject(new { code = 400, message = "Desculpe, mas o número de vaga informado já está cadastrado em outra vaga." }));
                            }
                        }
                    }
                    if (vaga.Avulso && vaga.PrecoAvulso == null)
                    {
                        return(JsonConvert.SerializeObject(new { code = 400, message = "Como você marcou a opção de Locação Avulso, precisa informar o valor para locação avulsa." }));
                    }
                    if (vaga.Avulso && vaga.AposPrimeiraHora == null)
                    {
                        return(JsonConvert.SerializeObject(new { code = 400, message = "Como você marcou a opção de Locação Avulso, precisa informar o valor a ser cobrado após a primeira hora." }));
                    }
                    if (vaga.Mensal && vaga.PrecoMensal == null)
                    {
                        return(JsonConvert.SerializeObject(new { code = 400, message = "Como você marcou a opção de Locação Mensal, precisa informar o valor para locação mensal." }));
                    }
                    if (vaga.Diaria && vaga.PrecoDiaria == null)
                    {
                        return(JsonConvert.SerializeObject(new { code = 400, message = "Como você marcou a opção de Locação Diaria, precisa informar o valor para locação diaria." }));
                    }

                    List <int> ids = new List <int>();

                    for (int i = 0; i < quantidade; i++)
                    {
                        int contador = 0;
                        _vagaService.Add(vagaService);
                        ids.Add(vagaService.VagaId);

                        try
                        {
                            if (fotos != null)
                            {
                                foreach (var f in fotos)
                                {
                                    if (!string.IsNullOrEmpty(f.Imagem))
                                    {
                                        var fot = new Foto();

                                        //int inicio = f.Imagem.IndexOf(",");
                                        var nomeImagem = vagaService.VagaId.ToString() + usu.Email + contador.ToString() + ".jpg";

                                        MD5 md5 = System.Security.Cryptography.MD5.Create();

                                        byte[] inputBytes = System.Text.Encoding.ASCII.GetBytes(nomeImagem);
                                        byte[] hash       = md5.ComputeHash(inputBytes);

                                        StringBuilder sb = new StringBuilder();
                                        for (int z = 0; z < hash.Length; z++)
                                        {
                                            sb.Append(hash[z].ToString("X2"));
                                        }

                                        var nomeCriptografado = sb.ToString();

                                        //if (ConvertStringtoImage(f.Imagem.Substring(inicio + 1), nomeCriptografado))
                                        if (ConvertStringtoImage(f.Imagem, nomeCriptografado))
                                        {
                                            fot.Imagem = nomeCriptografado;
                                            fot.Tipo   = 1;
                                            fot.VagaId = vagaService.VagaId;

                                            _fotoService.Add(fot);
                                            contador++;
                                        }
                                        else
                                        {
                                            foreach (var v in ids)
                                            {
                                                if (_vagaService.GetById(v) != null)
                                                {
                                                    var fo = _fotoService.GetAll().Where(ft => ft.VagaId == v);

                                                    foreach (var ft in fo)
                                                    {
                                                        _fotoService.Remove(ft);
                                                    }

                                                    var vg = _vagaService.GetById(v);
                                                    _vagaService.Remove(vg);
                                                }
                                            }

                                            var g = _garagemService.GetById(vagaService.GaragemId);
                                            g.Vagas = _vagaService.GetByIdGarage(g.GaragemId);

                                            if (g.Vagas.Count() == 0)
                                            {
                                                _garagemService.Remove(g);
                                            }

                                            return(JsonConvert.SerializeObject(new { code = 400, message = "Houve um erro ao cadastrar as fotos da Vaga e por isso ela não foi cadastrada. Por favor tente novamente." }));
                                        }
                                    }
                                }
                            }
                        }
                        catch
                        {
                            foreach (var v in ids)
                            {
                                if (_vagaService.GetById(v) != null)
                                {
                                    var fot = _fotoService.GetAll().Where(f => f.VagaId == v);

                                    foreach (var f in fot)
                                    {
                                        _fotoService.Remove(f);
                                    }

                                    var vg = _vagaService.GetById(v);
                                    _vagaService.Remove(vg);
                                }
                            }

                            var g = _garagemService.GetById(vagaService.GaragemId);
                            g.Vagas = _vagaService.GetByIdGarage(g.GaragemId);

                            if (g.Vagas.Count() == 0)
                            {
                                _garagemService.Remove(g);
                            }
                            return(JsonConvert.SerializeObject(new { code = 400, message = "Houve um erro ao cadastrar as fotos da Vaga e por isso a mesma não foi cadastrada. Por favor tente novamente." }));
                        }
                    }

                    return(JsonConvert.SerializeObject(new { code = 200, message = "Vaga(s) cadastrada(s) com sucesso. Aguarde a nossa aprovação.", id = ids }));
                }
            }
            catch
            {
                return(JsonConvert.SerializeObject(new { code = 400, message = "Erro no cadastro. Por favor, tente novamente." }));
            }
        }