Example #1
0
        // GET: Concursos
        public async Task <IActionResult> Index()
        {
            IEnumerable <Concurso> lista = await _repository.FindAll();

            var lista_vm = new List <ConcursoViewModel>();


            foreach (Concurso c in lista)
            {
                var vm = new ConcursoViewModel(c);
                lista_vm.Add(vm);
            }
            return(View(lista_vm));
        }
        public async Task <IEnumerable <ConcursoViewModel> > GetConcursos()
        {
            IEnumerable <Concurso> lista = await _repository.FindAll();

            IEnumerable <Link> lista_links = await _linkRepository.FindAll();

            var lista_vm = new List <ConcursoViewModel>();

            foreach (var concurso in lista)
            {
                concurso.Link = lista_links.Single(l => l.Id == concurso.LinkId);
                var vm = new ConcursoViewModel(concurso);
                lista_vm.Add(vm);
            }
            return(lista_vm);
        }
Example #3
0
        public ActionResult Create(ConcursoViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(View(viewModel));
            }
            else
            {
                var id = ConcursoRepositorio.Salvar(Mapper.Map <Concurso>(viewModel));

                if (id == null)
                {
                    return(View(viewModel));
                }

                return(RedirectToAction("Index", "ConcursoAdmin"));
            }
        }
Example #4
0
        // GET: Concursos/Edit/5
        public async Task <IActionResult> Edit(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var concurso = await _repository.Get(id.Value);

            if (concurso == null)
            {
                return(NotFound());
            }
            concurso.Link = await _linkRepository.Get(concurso.LinkId);

            ConcursoViewModel vm = new ConcursoViewModel(concurso);

            return(View(vm));
        }
Example #5
0
        // GET: Concursos/Details/5
        public async Task <IActionResult> Details(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var concurso = await _repository.Get(id.Value);

            if (concurso == null)
            {
                return(NotFound());
            }
            concurso.Link = await _linkRepository.Get(concurso.LinkId);

            ConcursoViewModel vm = new ConcursoViewModel(concurso);

            ViewBag.ImagemPath = vm.ImagemPath;
            ViewBag.Alt        = "Não tem imagem associada";
            return(View(vm));
        }
Example #6
0
        // GET: Concursos/Delete/5
        public async Task <IActionResult> Delete(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var concurso = await _repository.Get(id.Value);

            if (concurso == null)
            {
                return(NotFound());
            }
            var  vm   = new ConcursoViewModel(concurso);
            Link link = await _linkRepository.Get(concurso.LinkId);

            vm.Link   = link;
            vm.LinkId = link.Id;

            return(View(vm));
        }
        public async Task <IActionResult> GetConcursos([FromRoute] int id)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            Concurso concurso = await _repository.Get(id);

            Link link = await _linkRepository.Get(concurso.LinkId);

            concurso.Link = link;
            ConcursoViewModel vm = new ConcursoViewModel(concurso);

            if (concurso == null)
            {
                return(NotFound());
            }

            return(Ok(vm));
        }
Example #8
0
        public async Task <IActionResult> Create([Bind("Id,DataFim,DataInicio,Descricao,TipoConcurso,Url")] ConcursoViewModel vm, IFormFile Imagem)
        {
            Concurso concurso = new Concurso();

            // Só pode existir um concurso de cada tipo na base de dados
            var query = await _repository.FindAll();

            foreach (Concurso c in query)
            {
                if (c.TipoConcurso == vm.TipoConcurso && vm.TipoConcurso != TipoConcurso.Passatempo)
                {
                    return(Content("Só pode existir uma gravação de concursos dos tipos: DJ, Cartaz e Bandas)"));
                }
            }
            /*************************************************************/

            if (ModelState.IsValid && Imagem != null && Imagem.Length > 0 && FilesHelper.VerifyFileSize(Imagem) && FilesHelper.VerifyFileExtension(Imagem.FileName))
            {
                var upload = Path.Combine(_env.WebRootPath, "imagens", "concursos");

                // guardar imagem
                using (var fileStream = new FileStream(Path.Combine(upload, Imagem.FileName), FileMode.Create))
                {
                    await Imagem.CopyToAsync(fileStream);
                }

                // guardar imagem thumbnail
                var thumbnail = Path.GetFileNameWithoutExtension(Path.Combine(upload, Imagem.FileName));
                thumbnail += "_tb";
                using (var stream = new FileStream(Path.Combine(upload, Imagem.FileName), FileMode.Open))
                    using (var output = new FileStream(Path.Combine(upload, thumbnail + ".jpg"), FileMode.OpenOrCreate))
                    {
                        Image image = new Image(stream);
                        image.Resize(image.Width / 2, image.Height / 2)
                        .Save(output);
                    }

                concurso.TipoConcurso = vm.TipoConcurso;
                concurso.Descricao    = vm.Descricao;
                concurso.DataInicio   = DateTime.Parse(vm.DataInicio);
                concurso.DataFim      = DateTime.Parse(vm.DataFim);
                concurso.ImagemPath   = "\\imagens\\concursos\\" + Imagem.FileName;
                concurso.ImagemUrl    = HttpContext.Request.Host.Host + "/imagens/concursos/" + Imagem.FileName;

                // guardar link
                if (vm.Url != null)
                {
                    Link link = new Link {
                        Categoria = Categoria.Concurso, Descricao = vm.Descricao, Url = vm.Url
                    };
                    await _linkRepository.Save(link);

                    concurso.Link   = link;
                    concurso.LinkId = link.Id;
                }



                await _repository.Save(concurso);

                return(RedirectToAction("Index"));
            }
            return(View(vm));
        }
Example #9
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,DataFim,DataInicio,Descricao,ImagemUrl,ImagemPath,TipoConcurso,Url")] ConcursoViewModel vm, IFormFile Imagem)
        {
            if (id != vm.Id)
            {
                return(NotFound());
            }
            Concurso concurso = await _repository.Get(id);

            // Só pode existir um concurso de cada tipo na base de dados
            var query = await _repository.FindAll();

            int count = 0;

            foreach (Concurso c in query)
            {
                if (c.TipoConcurso == vm.TipoConcurso && vm.TipoConcurso != TipoConcurso.Passatempo && c.Id != concurso.Id)
                {
                    count++;
                }
            }
            if (count >= 1)
            {
                return(Content("Só pode existir uma gravação de concursos dos tipos: DJ, Cartaz e Bandas)"));
            }
            /*************************************************************/
            if (ModelState.IsValid)
            {
                try
                {
                    // editar imagem
                    if (Imagem != null && Imagem.Length > 0 && FilesHelper.VerifyFileSize(Imagem) && FilesHelper.VerifyFileExtension(Imagem.FileName))
                    {
                        var upload = Path.Combine(_env.WebRootPath, "imagens", "concursos");

                        // guardar imagem tamanho normal
                        using (var fileStream = new FileStream(Path.Combine(upload, Imagem.FileName), FileMode.Create))
                        {
                            await Imagem.CopyToAsync(fileStream);
                        }

                        // guardar imagem thumbnail
                        var thumbnail = Path.GetFileNameWithoutExtension(Path.Combine(upload, Imagem.FileName));
                        thumbnail += "_tb";
                        using (var stream = new FileStream(Path.Combine(upload, Imagem.FileName), FileMode.Open))
                            using (var output = new FileStream(Path.Combine(upload, thumbnail + ".jpg"), FileMode.OpenOrCreate))
                            {
                                Image image = new Image(stream);
                                image.Resize(image.Width / 2, image.Height / 2)
                                .Save(output);
                            }


                        // apagar imagem antiga
                        var path    = _env.WebRootPath + vm.ImagemPath;
                        var tb_path = _env.WebRootPath + "\\imagens\\concursos\\" + Path.GetFileNameWithoutExtension(concurso.ImagemPath);
                        tb_path += "_tb.jpg";
                        if (System.IO.File.Exists(path) && System.IO.File.Exists(tb_path))
                        {
                            System.IO.File.Delete(path);
                            System.IO.File.Delete(tb_path);
                        }
                        concurso.ImagemPath = "\\imagens\\concursos\\" + Imagem.FileName;
                        concurso.ImagemUrl  = HttpContext.Request.Host.Host + "/imagens/concursos/" + Imagem.FileName;
                    }

                    concurso.TipoConcurso = vm.TipoConcurso;
                    concurso.Descricao    = vm.Descricao;
                    concurso.DataInicio   = DateTime.Parse(vm.DataInicio);
                    concurso.DataFim      = DateTime.Parse(vm.DataFim);
                    if (vm.Url != null)
                    {
                        Link link = await _linkRepository.Get(concurso.LinkId);

                        link.Descricao = vm.Descricao;
                        link.Url       = vm.Url;

                        await _linkRepository.Update(link);
                    }
                    await _repository.Update(concurso);
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ConcursoExists(concurso.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction("Index"));
            }

            return(View(vm));
        }