public void SqlFunction_passing_function_as_argument_to_another_works()
 {
     using (var context = new ArubaContext())
     {
         var query = context.AllTypes.Select(a => SqlFunctions.Asin(SqlFunctions.Acos(a.c10_float)));
         Assert.Contains("ASIN", query.ToString().ToUpperInvariant());
         Assert.Contains("ACOS", query.ToString().ToUpperInvariant());
     }
 }
 public void SqlFunctions_scalar_function_translated_properly_to_sql_function()
 {
     using (var context = new ArubaContext())
     {
         var query1 = context.AllTypes.Select(a => SqlFunctions.Acos(a.c7_decimal_28_4));
         var query2 = context.AllTypes.Select(a => SqlFunctions.Acos(a.c10_float));
         Assert.Contains("ACOS", query1.ToString().ToUpperInvariant());
         Assert.Contains("ACOS", query2.ToString().ToUpperInvariant());
     }
 }
Exemple #3
0
        public List <Place> GetNearestPlaces(double latitude, double longitude, double radius = 10, int limit = 10)
        {
            MapsContext context = new MapsContext();
            //var datas = context.Places.Select(x => Math.Acos(Math.Sin(deg2rad(lat1)) * Math.Sin(deg2rad(lat2))
            //                + Math.Cos(deg2rad(lat1)) * Math.Cos(deg2rad(lat2)) * Math.Cos(deg2rad(theta))));
            //var datas = context.Places.Select(x => Math.Acos(Math.Sin(deg2rad(latitude)) * Math.Sin(deg2rad(x.Latitude))
            //               + Math.Cos(deg2rad(latitude)) * Math.Cos(deg2rad(x.Latitude)) * Math.Cos(deg2rad(x.Longitude-longitude))));

            //var datas = context.Places.Where(x => Math.Acos(Math.Sin(latitude * Math.PI / 180.0) * Math.Sin(x.Latitude * Math.PI / 180.0)
            //   + Math.Cos(latitude * Math.PI / 180.0) * Math.Cos(x.Latitude * Math.PI / 180.0) * Math.Cos(x.Longitude - longitude * Math.PI / 180.0)) * 6371 <= radius);

            //var datas = context.Places.Where(x => 3959 * Math.Acos(Math.Cos(radians(x.Latitude)) * Math.Cos(radians(latitude))
            //                                * Math.Cos(radians(x.Longitude) - radians(longitude)) + Math.Sin(radians(latitude)) *
            //                                Math.Sin(radians(x.Latitude))) * 1.60934 <= radius).ToList();
            //var datas = context.Places.Where(x => Math.Sin(x.Latitude / 57.2957795130823) * Math.Sin(latitude / 57.2957795130823) + Math.Cos(x.Latitude / 57.2957795130823) * Math.Cos(latitude / 57.2957795130823) * Math.Cos(x.Latitude / 57.2957795130823 - latitude / 57.2957795130823) * 6371 <= radius);



            //var tt = (3959*acos(
            //    cos(radians(@myLat))*cos(radians(Latitude))*cos(radians(Longitude) - radians(@myLong))
            //    + sin(radians(@myLat))*sin(radians(Latitude))))*1.60934 <= 10;

            //var tt2 = select
            //ACOS(
            //    SIN(PI()*@lat1/180.0)*SIN(PI()*@lat2/180.0) +
            //    COS(PI()*@lat1/180.0)*COS(PI()*@lat2/180.0)*COS(PI()*@lon2/180.0 - PI()*@lon1/180.0)
            //)*6371;


            //var center = new GeoCoordinate(latitude, longitude);
            //var result = context.Places.Select(x => new GeoCoordinate(x.Latitude, x.Longitude))
            //                      .Where(x => x.GetDistanceTo(center) < radius);
            //var datas = result.ToList();
            //var datas =  SELECT* FROM Places WHERE
            // (Lat >= 1.2393 AND Lat <= 1.5532) AND(Lon >= -1.8184 AND Lon <= 0.4221)
            // HAVING
            // acos(sin(1.3963) * sin(Lat) + cos(1.3963) * cos(Lat) * cos(Lon - (-0.6981))) <= 0.1570;

            var datas = context.Places.Where(x => SqlFunctions.Acos(SqlFunctions.Sin(latitude * SqlFunctions.Pi() / 180.0)
                                                                    * SqlFunctions.Sin(x.Latitude * SqlFunctions.Pi() / 180.0)
                                                                    + SqlFunctions.Cos(latitude * SqlFunctions.Pi() / 180.0)
                                                                    * SqlFunctions.Cos(x.Latitude * SqlFunctions.Pi() / 180.0)
                                                                    * SqlFunctions.Cos((x.Longitude * SqlFunctions.Pi() / 180.0) - (longitude * SqlFunctions.Pi() / 180.0))) * 6371 <= radius)
                        .Take(limit)
                        .OrderBy(x => SqlFunctions.Acos(SqlFunctions.Sin(latitude * SqlFunctions.Pi() / 180.0)
                                                        * SqlFunctions.Sin(x.Latitude * SqlFunctions.Pi() / 180.0)
                                                        + SqlFunctions.Cos(latitude * SqlFunctions.Pi() / 180.0)
                                                        * SqlFunctions.Cos(x.Latitude * SqlFunctions.Pi() / 180.0)
                                                        * SqlFunctions.Cos((x.Longitude * SqlFunctions.Pi() / 180.0) - (longitude * SqlFunctions.Pi() / 180.0))) * 6371);


            var result = datas.ToList();

            return(result);
        }
Exemple #4
0
 public IEnumerable <Distance <Table> > GetNearbyTables(double Latitude, double Longitude, double Accuracy)
 {
     return(from t in db.Tables
            let d = (SqlFunctions.Acos(SqlFunctions.Sin(Math.PI * t.Latitude / 180.0) * SqlFunctions.Sin(Math.PI * Latitude / 180.0) +
                                       SqlFunctions.Cos(Math.PI * t.Latitude / 180.0) * SqlFunctions.Cos(Math.PI * Latitude / 180.0) *
                                       SqlFunctions.Cos(Math.PI * t.Longitude / 180.0 - Math.PI * Longitude / 180.0)) * EARTH_RADIUS_MTR).Value
                    where d <= t.TableRadius + Accuracy * 2.5
                    orderby d descending
                    select new Distance <Table>()
     {
         Item = t,
         DistanceInMeters = d
     });
 }
Exemple #5
0
 public IEnumerable <Distance <Msq> > GetNearbyMsqs(
     double Latitude,
     double Longitude,
     double Accuracy,
     double?Radius)
 {
     return(from m in db.Msqs.Include("User")
            let d = (SqlFunctions.Acos(SqlFunctions.Sin(Math.PI * m.Latitude / 180.0) * SqlFunctions.Sin(Math.PI * Latitude / 180.0) +
                                       SqlFunctions.Cos(Math.PI * m.Latitude / 180.0) * SqlFunctions.Cos(Math.PI * Latitude / 180.0) *
                                       SqlFunctions.Cos(Math.PI * m.Longitude / 180.0 - Math.PI * Longitude / 180.0)) * EARTH_RADIUS_MTR).Value
                    where !Radius.HasValue || d < Radius.Value + Accuracy
                    orderby m.Entered descending
                    select new Distance <Msq>()
     {
         Item = m,
         DistanceInMeters = d
     });
 }
Exemple #6
0
        public IEnumerable <Station> GetStationsWithinRadiusMiles(double lat, double lng, double radius)
        {
            var result = from outer in
                         (from s in db.Stations
                          select new
            {
                Distance = (3959 * SqlFunctions.Acos(SqlFunctions.Cos(SqlFunctions.Radians(lat)) *
                                                     SqlFunctions.Cos(SqlFunctions.Radians(s.Location.Latitude)) *
                                                     SqlFunctions.Cos(SqlFunctions.Radians(s.Location.Longitude) -
                                                                      SqlFunctions.Radians(lng)) +
                                                     SqlFunctions.Sin(SqlFunctions.Radians(lat)) *
                                                     SqlFunctions.Sin((SqlFunctions.Radians(s.Location.Latitude))))),
                s
            })
                         where outer.Distance < radius
                         where outer.Distance != null
                         orderby outer.Distance
                         select outer.s;

            return(result);
        }
Exemple #7
0
 public static VagaRemocaoVM ToVM(this IQueryable <VagaRemocao> singleModel, FuncionarioOnline user)
 {
     return(singleModel.Select(a => new VagaRemocaoVM
     {
         CargoId = a.CargoId,
         DificilAcesso = a.Unidade.DificilAcesso,
         Endereco = a.Unidade.Endereco.EnderecoCompleto,
         UnidadeId = a.UnidadeId,
         Id = a.Id,
         Unidade = a.Unidade.Nome,
         Distancia =
             (
                 SqlFunctions.Acos(
                     SqlFunctions.Sin(SqlFunctions.Radians(a.Unidade.Endereco.Latitude)) * SqlFunctions.Sin(SqlFunctions.Radians(user.Latitude))
                     +
                     SqlFunctions.Cos(SqlFunctions.Radians(a.Unidade.Endereco.Latitude)) * SqlFunctions.Cos(SqlFunctions.Radians(user.Latitude))
                     *
                     SqlFunctions.Cos(SqlFunctions.Radians(a.Unidade.Endereco.Longitude) - SqlFunctions.Radians(user.Longitude))
                     ) * 6378
             )
     }).Single());
 }
        public IQueryable <Mechanic> GetMechanic(double lati, double longi)
        {
            var GlobalConstant1 = 57.2957795130823D;

            var GlobalConstant2 = 3958.75586574D;

            double latitude  = lati;
            double longitude = longi;
            var    loc       = (from mechanic in db.Mechanics
                                let temp = SqlFunctions.Sin(mechanic.Latitude / GlobalConstant1)
                                           * SqlFunctions.Sin(latitude / GlobalConstant1)
                                           + SqlFunctions.Cos(mechanic.Latitude / GlobalConstant1)
                                           * SqlFunctions.Cos(latitude / GlobalConstant1)
                                           * SqlFunctions.Cos(longitude / GlobalConstant1)
                                           - (mechanic.Longitude / GlobalConstant1)
                                           let calMiles = (GlobalConstant2 * SqlFunctions.Acos(temp > 1 ? 1 : (temp < -1 ? -1 : temp)))
                                                          where (mechanic.Latitude > 0 && mechanic.Longitude > 0)
                                                          orderby calMiles
                                                          select mechanic).Take(5);

            return(loc);
        }
Exemple #9
0
        public Station GetNearestStation(double lat, double lng)
        {
            var result = (from outer in
                          (from s in db.Stations
                           select new
            {
                Distance = (3959 * SqlFunctions.Acos(SqlFunctions.Cos(SqlFunctions.Radians(lat)) *
                                                     SqlFunctions.Cos(SqlFunctions.Radians(s.Location.Latitude)) *
                                                     SqlFunctions.Cos(SqlFunctions.Radians(s.Location.Longitude) -
                                                                      SqlFunctions.Radians(lng)) +
                                                     SqlFunctions.Sin(SqlFunctions.Radians(lat)) *
                                                     SqlFunctions.Sin((SqlFunctions.Radians(s.Location.Latitude))))),
                s
            })
                          orderby outer.Distance
                          where outer.Distance != null
                          select outer.s);

            var value = result.First();

            return(value);
        }
Exemple #10
0
        public List <Restaurant> GetAllNearByRestaurants(string state, string city)
        {
            var coordinates = (from g in db.GeoDatas
                               where g.State == state && g.City == city
                               select g).FirstOrDefault();
            var lat      = (double)coordinates.Latitude;
            var lon      = (double)coordinates.Longitude;
            var location = GeoLocation.FromDegrees(lat, lon);

            GeoLocation[] boundingCoordinates = location.BoundingCoordinates(10);
            var           distance            = location.DistanceTo(boundingCoordinates[1]);
            var           minlat = boundingCoordinates[0].getLatitudeInDegrees();
            var           maxlat = boundingCoordinates[1].getLatitudeInDegrees();
            var           minlon = boundingCoordinates[0].getLongitudeInDegrees();
            var           maxlon = boundingCoordinates[1].getLongitudeInDegrees();

            var restaurants = (from a in db.Restaurants
                               where (a.Address.Latitude >= minlat && a.Address.Latitude <= maxlat) && (a.Address.Longitude >= minlon && a.Address.Longitude <= maxlon) &&
                               SqlFunctions.Acos(SqlFunctions.Sin(lat) * SqlFunctions.Sin((Double)a.Address.Latitude) + SqlFunctions.Cos(lat) * SqlFunctions.Cos((Double)a.Address.Latitude) * SqlFunctions.Cos((Double)a.Address.Longitude - (lon))) <= distance
                               select a).ToList();

            return(restaurants);
        }
Exemple #11
0
        public IQueryable <Membre> RechercheMembreAvecProprietes(RechercheViewModel laRecherche, int noMembre)
        {
            #region trouverAgeEnChiffre
            //DateTime? ageMax = null;
            //DateTime? ageMin = null;

            //if (laRecherche.ageMax != null)
            //{
            //    ageMax = DateTime.Now.AddYears(-(int)laRecherche.ageMax);
            //}

            //if (laRecherche.ageMin != null)
            //{
            //    ageMin = DateTime.Now.AddYears(-(int)laRecherche.ageMin);
            //}
            #endregion

            IQueryable <Membre> membresTrouves = db.Membres;
            Membre membreActuel;
            try
            {
                membreActuel = db.Membres.Where(m => m.noMembre == noMembre).Include(m => m.listeNoire).FirstOrDefault();
            }
            catch (Exception e)
            {
                Dictionary <string, string> parametres = new Dictionary <string, string>()
                {
                    { "noMembre", noMembre.ToString() }
                };
                throw Utilitaires.templateException("(Non-Action) RechercheMembreAvecProprietes", "Membres", "Requête LINQ n'a pas fonctionnée ou la BD est inaccessible.", e, parametres);
            }

            //on doit avoir un membre, sinon on ne peut pas tester la distance en KM
            if (membreActuel != null)
            {
                //Si on veut la recherche par KM
                if (laRecherche.distanceKmDeMoi != null)
                {
                    //La BD doit avoir été bien initialisée
                    if (membreActuel.ville.lat != null || membreActuel.ville.lng != null)
                    {
                        double latMembre = (double)membreActuel.ville.lat;
                        double lngMembre = (double)membreActuel.ville.lng;

                        //on définit la requête LINQ to SQL pour trouver les membres à une distance X
                        membresTrouves =
                            #region RequeteSQLCalculsDistance
                            (from m in db.Membres
                             let membreLatitude = (double)m.ville.lat
                                                  let membreLongitude = (double)m.ville.lng
                                                                        let theta = ((lngMembre - membreLongitude) * Math.PI / 180.0)
                                                                                    let requestLat = (latMembre * Math.PI / 180.0)
                                                                                                     let membreLat = (membreLatitude * Math.PI / 180.0)
                                                                                                                     let dist = (SqlFunctions.Sin(requestLat) * SqlFunctions.Sin(membreLat)) +
                                                                                                                                (SqlFunctions.Cos(requestLat) * SqlFunctions.Cos(membreLat) * SqlFunctions.Cos(theta))
                                                                                                                                let cosDist = SqlFunctions.Acos(dist)
                                                                                                                                              let degDist = (cosDist / Math.PI * 180.0)
                                                                                                                                                            let absoluteDist = degDist * 60 * 1.1515
                                                                                                                                                                               let distInKM = absoluteDist * 1.609344
                                                                                                                                                                                              where distInKM < laRecherche.distanceKmDeMoi
                                                                                                                                                                                              select m);
                        #endregion
                    }
                }

                //On ajoute la partie si le membre est connecté (on l'enlève des recherches pour pas qu'il se voit)
                membresTrouves = membresTrouves
                                 .Where(m => (m.noMembre != noMembre) &&
                                        //BlackListe
                                        (!m.listeMembresQuiMontBloque.Select(x => x.noMembre).Contains(membreActuel.noMembre)) &&
                                        (!m.listeNoire.Select(x => x.noMembre).Contains(membreActuel.noMembre))
                                        );
            }


            //Après avoir ajouté les wheres et calculs possibles, on ajoute la query commune et on retourne le tout!
            //la recherche par age sera aussi implémenter de cette façon dans AdminController pour la liste des membres
            if (laRecherche.ageMin != null)
            {
                membresTrouves = (from m in membresTrouves
                                  let years = DateTime.Now.Year - ((DateTime)m.dateNaissance).Year
                                              let birthdayThisYear = DbFunctions.AddYears(m.dateNaissance, years)

                                                                     where laRecherche.ageMax >= (birthdayThisYear > DateTime.Now ? years - 1 : years)
                                                                     select m
                                  );
            }
            if (laRecherche.ageMax != null)
            {
                membresTrouves = (from m in membresTrouves
                                  let years = DateTime.Now.Year - ((DateTime)m.dateNaissance).Year
                                              let birthdayThisYear = DbFunctions.AddYears(m.dateNaissance, years)

                                                                     where laRecherche.ageMin <= (birthdayThisYear > DateTime.Now ? years - 1 : years)
                                                                     select m
                                  );
            }

            membresTrouves = membresTrouves
                             #region RequeteLINQPourTousLesCriteres
                             .Where(m => //On s'assure que le membre n'est pas supprimé, car on n'en veut pas dans notre recherche.
                                    (m.compteSupprimeParAdmin == null && m.dateSuppressionDuCompte == null) &&

                                    //((ageMax == null ? true : false) || DbFunctions.TruncateTime(m.dateNaissance) >= DbFunctions.TruncateTime(ageMax)) && //Signe = ajouté 2017-11-19 Anthony Brochu
                                    //((ageMin == null ? true : false) || DbFunctions.TruncateTime(m.dateNaissance) <= DbFunctions.TruncateTime(ageMin)) && //Signe = ajouté 2017-11-19 Anthony Brochu
                                    ((laRecherche.homme == null ? true : false) || m.homme == laRecherche.homme) &&
                                    ((laRecherche.noRaisonsSite == null ? true : false) || m.listeRaisonsSurSite.Select(r => r.noRaisonSurSite).Contains((laRecherche.noRaisonsSite ?? 0))) &&
                                    ((laRecherche.chercheHomme == null ? true : false) || m.rechercheHomme == laRecherche.chercheHomme) &&
                                    ((laRecherche.noProvince == null ? true : false) || m.noProvince == laRecherche.noProvince) &&
                                    ((laRecherche.noVille == null ? true : false) || m.noVille == laRecherche.noVille) &&
                                    //Caractéristiques Physiques
                                    ((laRecherche.noYeuxCouleur == null ? true : false) || m.noYeuxCouleur == laRecherche.noYeuxCouleur) &&
                                    ((laRecherche.noCheveuxCouleur == null ? true : false) || m.noCheveuxCouleur == laRecherche.noCheveuxCouleur) &&
                                    ((laRecherche.noSilhouette == null ? true : false) || m.noSilhouette == laRecherche.noSilhouette) &&
                                    ((laRecherche.noTaille == null ? true : false) || m.noTaille == laRecherche.noTaille) &&
                                    //Informations supplémentaires
                                    ((laRecherche.fumeur == null ? true : false) || m.fumeur == laRecherche.fumeur) &&
                                    ((laRecherche.noReligion == null ? true : false) || m.noReligion == laRecherche.noReligion) &&
                                    ((laRecherche.noOrigine == null ? true : false) || m.noOrigine == laRecherche.noOrigine) &&
                                    ((laRecherche.noDesirEnfant == null ? true : false) || m.noDesirEnfant == laRecherche.noDesirEnfant) &&
                                    ((laRecherche.noOccupation == null ? true : false) || m.noOccupation == laRecherche.noOccupation) &&
                                    ((laRecherche.noSituationFinanciere == null ? true : false) || m.noSituationFinanciere == laRecherche.noSituationFinanciere) &&
                                    ((laRecherche.noNiveauEtude == null ? true : false) || m.noNiveauEtude == laRecherche.noNiveauEtude) &&

                                    ((laRecherche.nbEnfantsMax == null ? true : false) || m.nbEnfants <= laRecherche.nbEnfantsMax) && //Signe "=" ajouté 2017-11-19 Anthony Brochu
                                    ((laRecherche.nbEnfantsMin == null ? true : false) || m.nbEnfants >= laRecherche.nbEnfantsMin) && //Signe "=" ajouté 2017-11-19 Anthony Brochu

                                    ((laRecherche.nbAnimauxMax == null ? true : false) || m.nbAnimaux <= laRecherche.nbAnimauxMax) && //Signe "=" ajouté 2017-11-19 Anthony Brochu
                                    ((laRecherche.nbAnimauxMin == null ? true : false) || m.nbAnimaux >= laRecherche.nbAnimauxMin)    //Signe "=" ajouté 2017-11-19 Anthony Brochu
                                    );

            if (laRecherche.noTypeActiviteRecherche != null)
            {
                membresTrouves = membresTrouves
                                 .Where(m => m.listeHobbies.Select(t => t.noType).Contains((int)laRecherche.noTypeActiviteRecherche));
            }

            if (laRecherche.noTypeInterets != null)
            {
                membresTrouves = membresTrouves
                                 .Where(m => m.listeHobbies.Select(t => t.noHobbie).Contains((int)laRecherche.noTypeInterets));
            }
            #endregion

            return(membresTrouves);
        }
Exemple #12
0
        // GET: api/Messages/lan,lgt
        public IEnumerable <Message> GetMessages(double lat, double lng)
        {
            double distance = 0.05;
            var    query    = from it in db.Messages
                              let facilityLatitude = it.Lat
                                                     let facilityLongitude                         = it.Lng
                                                                                         let theta = ((lng - facilityLongitude) * Math.PI / 180.0)
                                                                                                     let requestLat = (lat * Math.PI / 180.0)
                                                                                                                      let facilityLat                       = (facilityLatitude * Math.PI / 180.0)
                                                                                                                                                   let dist = (SqlFunctions.Sin(requestLat) * SqlFunctions.Sin(facilityLat)) + (SqlFunctions.Cos(requestLat) * SqlFunctions.Cos(facilityLat) * SqlFunctions.Cos(theta))
                                                                                                                                                              let cosDist = SqlFunctions.Acos(dist)
                                                                                                                                                                            let degDist = (cosDist / Math.PI * 180.0)
                                                                                                                                                                                          let absoluteDist = degDist * 60 * 1.1515
                                                                                                                                                                                                             let distInKM = absoluteDist * 1.609344
                                                                                                                                                                                                                            where distInKM < distance
                                                                                                                                                                                                                            select it;

            return(query.OrderBy(t => t.LikesNum - t.DislikeNum));
        }