Ejemplo n.º 1
0
        public ActionResult <IEnumerable <HistoriqueDTO> > GetHistorique(HistoriqueCriteria historique)
        {
            ServiceResponse <IEnumerable <HistoriqueDTO> > Data = new ServiceResponse <IEnumerable <HistoriqueDTO> >();

            try
            {
                var visites = _visiteRepository.VisiteRepository.GetHistorique(historique);
                Data.Data = _mapper.Map <IEnumerable <HistoriqueDTO> >(visites);
            }
            catch (Exception ex)
            {
                Data.Success  = false;
                Data.Messages = ex.Message;
            }

            return(Ok(Data));
        }
Ejemplo n.º 2
0
        public async Task  getHistorique_Visite()
        {
            // Arrange
            VisiteDTO visiteDTO = new VisiteDTO();
            var       es        = new List <EntrepriseDTO>();

            visiteDTO.Client = new ClientDTO
            {
                Courriel       = "*****@*****.**",
                DateCreation   = DateTime.Now,
                Immaticulation = "789654",
                Nom            = Guid.NewGuid().ToString(),
                Prenom         = "Talla",
                Telephone      = "8197891878",
                Entreprises    = es
            };

            visiteDTO.Provenance = new ProvenanceDTO
            {
                Adresse             = "96 Rue Notre-Dame Est, bur. R.134 QC",
                Quantite_Disponible = 1500,
            };

            visiteDTO.Transaction = new TransactionDTO
            {
                Hauteur           = 25,
                Largeur           = 50,
                Longueur          = 12,
                IdModePaiement    = 2,
                Quantite_Utilisee = 0,
                Volume            = 1500
            };

            var mt = new List <Matiere_VisiteDTO> {
                new Matiere_VisiteDTO
                {
                    Comptable   = false,
                    Description = "Vetement et textiles"
                },
                new Matiere_VisiteDTO
                {
                    Comptable   = true,
                    Description = "Chaussures"
                }
            };

            visiteDTO.Matieres = mt;

            //// Creation de l'ecocentre
            var ecocentre = new EcocentreDTO
            {
                Adresse     = "Coaticook, QC",
                Codepostal  = "J1J3V3",
                Nom         = "Ecocentre Test",
                Rue         = "75 Rue",
                Ville       = "Laval",
                IdEcocentre = 0,
            };

            var m = new List <Ecocentre_MatiereDTO>
            {
                new Ecocentre_MatiereDTO
                {
                    Comptable   = false,
                    Description = "Vetement et textiles",
                },
                new Ecocentre_MatiereDTO
                {
                    Comptable   = true,
                    Description = "Chaussures",
                },
            };

            ecocentre.Matieres = m;

            var request = new HttpRequestMessage(HttpMethod.Post, baseUrl + "ecocentre");

            request.Content = new StringContent(JsonConvert.SerializeObject(ecocentre), Encoding.UTF8, "application/json");
            var response = await httpClient.PostAsync(request.RequestUri, request.Content);

            var result = await response.Content.ReadAsAsync <ServiceResponse <EcocentreDTO> >();


            visiteDTO.IdEcocentre = result.Data.IdEcocentre;
            visiteDTO.Employe     = "Test Fact22";

            request         = new HttpRequestMessage(HttpMethod.Post, baseUrl + "Visite");
            request.Content = new StringContent(JsonConvert.SerializeObject(visiteDTO), Encoding.UTF8, "application/json");
            response        = await httpClient.PostAsync(request.RequestUri, request.Content);

            var result_visite = await response.Content.ReadAsAsync <ServiceResponse <VisiteDTO> >();

            var h = new HistoriqueCriteria
            {
                Employe   = result_visite.Data.Employe,
                ClientNom = result_visite.Data.Client.Nom,
                Courriel  = result_visite.Data.Client.Courriel,
                Ecocentre = result_visite.Data.Ecocentre.Nom,
            };

            request         = new HttpRequestMessage(HttpMethod.Post, baseUrl + "Visite/GetHistorique");
            request.Content = new StringContent(JsonConvert.SerializeObject(h), Encoding.UTF8, "application/json");
            response        = await httpClient.PostAsync(request.RequestUri, request.Content);

            var result_hist = await response.Content.ReadAsAsync <ServiceResponse <IEnumerable <HistoriqueDTO> > >();

            var hist = result_hist.Data as List <HistoriqueDTO>;
            int cpt  = 1;

            Assert.Equal(cpt, hist.Count);
        }
Ejemplo n.º 3
0
        public IEnumerable <Visite> GetHistorique(HistoriqueCriteria historique)
        {
            DateTime deteDebut;
            DateTime deteFin;
            int      skipPage = (historique.PageNo - 1) * historique.RowsPerPage;

            historique.DefaultNumber = historique.DefaultNumber == 0 ? 5000 : historique.DefaultNumber;

            if ((historique.DateDebut.HasValue && historique.DateFin.HasValue))
            {
                deteDebut = new DateTime(historique.DateDebut.Value.Year, historique.DateDebut.Value.Month, historique.DateDebut.Value.Day, 0, 0, 0);
                deteFin   = new DateTime(historique.DateFin.Value.Year, historique.DateFin.Value.Month, historique.DateFin.Value.Day, 23, 59, 59);
            }
            else
            {
                deteDebut = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0, 0, 0);
                deteFin   = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 23, 59, 59);
            }

            var Data = _context.Visite.Include(c => c.Client).Include(p => p.Provenance)
                       .Include(e => e.Ecocentre)
                       .Include(t => t.Transaction).ThenInclude(c => c.ModePaiement)
                       .Include(m => m.Matieres).Where(v => v.DateCreation >= deteDebut.Date && v.DateCreation <= deteFin).OrderByDescending(s => s.DateCreation).ToList();


            if (!string.IsNullOrWhiteSpace(historique.Adresse))
            {
                Data = Data.Where(x => !string.IsNullOrEmpty(x.Provenance.Adresse) && x.Provenance.Adresse.ToLower().Contains(historique.Adresse.ToLower())).ToList();
            }

            if (!string.IsNullOrWhiteSpace(historique.Employe))
            {
                Data = Data.Where(x => !string.IsNullOrEmpty(x.Employe) && x.Employe.ToLower().Contains(historique.Employe.ToLower())).ToList();
            }

            if (!string.IsNullOrWhiteSpace(historique.Commerce))
            {
                Data = Data.Where(x => !string.IsNullOrEmpty(x.Client.NomCommerce) && x.Client.NomCommerce.ToLower().Contains(historique.Commerce.ToLower())).ToList();
            }

            if (!string.IsNullOrWhiteSpace(historique.Courriel))
            {
                Data = Data.Where(x => !string.IsNullOrEmpty(x.Client.Courriel) && x.Client.Courriel.ToLower().Contains(historique.Courriel.ToLower())).ToList();
            }

            if (!string.IsNullOrWhiteSpace(historique.Plaque))
            {
                Data = Data.Where(x => !string.IsNullOrEmpty(x.Client.Immaticulation) && x.Client.Immaticulation.ToLower().Contains(historique.Plaque.ToLower())).ToList();
            }

            if (!string.IsNullOrWhiteSpace(historique.Tel))
            {
                Data = Data.Where(x => !string.IsNullOrEmpty(x.Client.Telephone) && x.Client.Telephone.ToLower().Contains(historique.Tel.ToLower())).ToList();
            }

            if (!string.IsNullOrWhiteSpace(historique.ClientNom))
            {
                Data = Data.Where(x => !string.IsNullOrEmpty(x.Client.Nom) && x.Client.Nom.ToLower().Contains(historique.ClientNom.ToLower())).ToList();
            }

            if (!string.IsNullOrWhiteSpace(historique.Ecocentre))
            {
                Data = Data.Where(x => !string.IsNullOrEmpty(x.Ecocentre.Nom) && x.Ecocentre.Nom.ToLower().Contains(historique.Ecocentre.ToLower())).ToList();
            }

            return(Data.OrderByDescending(p => p.IdVisite).Skip(skipPage).Take(historique.DefaultNumber));
        }