Esempio n. 1
0
        public async Task <IActionResult> PostDisponibilite([FromBody] DisponibilitéDTO disponibilitéDTO)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            var disponibilite = await DispoBuilder(disponibilitéDTO);

            await _context.Disponibilites.AddAsync(disponibilite);

            await _context.SaveChangesAsync();

            return(CreatedAtAction("GetDisponibilite", new { id = disponibilite.DisponibiliteId }, disponibilite));
        }
        private async Task <ICollection <DisponibilitéDTO> > GetDisponibilitéDTO(ComplexeSportif complexe)
        {
            var disponibilites = new HashSet <DisponibilitéDTO>();

            foreach (var dispo in _context.Disponibilites)
            {
                if (dispo.ComplexeSportifId != null && dispo.ComplexeSportifId.Equals(complexe.ComplexeSportifId))
                {
                    var dispoDTO = new DisponibilitéDTO();
                    var sport    = await _context.Sports.FindAsync(dispo.SportId);

                    dispoDTO.LibelléSport = sport.Libellé;
                    disponibilites.Add(dispoDTO);
                }
            }
            return(disponibilites);
        }
Esempio n. 3
0
        public async Task <IActionResult> DeleteDisponibilite([FromBody] DisponibilitéDTO disponibilitéDTO)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var disponibilite = await DispoToDelete(disponibilitéDTO);

            foreach (var dispo in disponibilite)
            {
                _context.Disponibilites.Remove(dispo);
            }
            await _context.SaveChangesAsync();

            return(Ok(disponibilite));
        }
Esempio n. 4
0
        private async Task <Disponibilite> DispoBuilder(DisponibilitéDTO disponibilitéDTO)
        {
            var dispo = new Disponibilite();

            if (disponibilitéDTO.Username != null)
            {
                var user = await _context.Utilisateurs.FirstOrDefaultAsync(u => u.UserName.Equals(disponibilitéDTO.Username));

                dispo.UtilisateurId = user.Id;
            }
            if (disponibilitéDTO.ComplexeSportif != null)
            {
                var comp = await _context.ComplexeSportifs.FirstOrDefaultAsync(c => c.Libellé.Equals(disponibilitéDTO.ComplexeSportif));

                dispo.ComplexeSportifId = comp.ComplexeSportifId;
            }
            var sport = await _context.Sports.FirstOrDefaultAsync(s => s.Libellé.Equals(disponibilitéDTO.LibelléSport));

            dispo.SportId = sport.SportId;
            return(dispo);
        }
Esempio n. 5
0
        private async Task <ICollection <Disponibilite> > DispoToDelete(DisponibilitéDTO disponibilitéDTO)
        {
            var disponibilite = new HashSet <Disponibilite>();

            foreach (var dispo in _context.Disponibilites)
            {
                if (dispo.UtilisateurId != null)
                {
                    var user = await _context.Utilisateurs.FirstOrDefaultAsync(s => s.UserName.Equals(disponibilitéDTO.Username));

                    if (dispo.UtilisateurId.Equals(user.Id))
                    {
                        if (disponibilitéDTO.LibelléSport != null)
                        {
                            var sport = await _context.Sports.FirstOrDefaultAsync(u => u.Libellé.Equals(disponibilitéDTO.LibelléSport));

                            if (dispo.SportId.Equals(sport.SportId))
                            {
                                disponibilite.Add(dispo);
                            }
                        }
                        else
                        {
                            if (dispo.ComplexeSportifId != null)
                            {
                                var comp = await _context.ComplexeSportifs.FirstOrDefaultAsync(u => u.Libellé.Equals(disponibilitéDTO.ComplexeSportif));

                                if (dispo.ComplexeSportifId.Equals(comp.ComplexeSportifId))
                                {
                                    disponibilite.Add(dispo);
                                }
                            }
                        }
                    }
                }
            }
            return(disponibilite);
        }
Esempio n. 6
0
        private async Task <ICollection <DisponibilitéDTO> > GetDisponibilitéDTO(Utilisateur utilisateur)
        {
            var disponibilites = new HashSet <DisponibilitéDTO>();

            foreach (var dispo in _context.Disponibilites)
            {
                if (dispo.UtilisateurId != null && dispo.UtilisateurId.Equals(utilisateur.Id))
                {
                    var dispoDTO = new DisponibilitéDTO();
                    if (dispo.ComplexeSportifId != null)
                    {
                        var comp = await _context.ComplexeSportifs.FindAsync(dispo.ComplexeSportifId);

                        dispoDTO.ComplexeSportif = comp.Libellé;
                    }
                    var sport = await _context.Sports.FindAsync(dispo.SportId);

                    dispoDTO.LibelléSport = sport.Libellé;
                    disponibilites.Add(dispoDTO);
                }
            }
            return(disponibilites);
        }