コード例 #1
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="Mercante"></param>
 /// <param name="Cliente"></param>
 /// <returns></returns>
 public static int UnFollowMercante(int Mercante, int Cliente)
 {
     try
     {
         using (MsSqlFacade<ClientesMercantes, ClientesMercantesMapper> facade = new MsSqlFacade<ClientesMercantes, ClientesMercantesMapper>())
         {
             /// client facade read from the list
             ClientesMercantes entity = facade.Read().Single(p => p.Cliente == Cliente && p.Mercante == Mercante);
             /// we now check if the entity is null
             if (entity != null)
             {
                 /// if is null we deleted form the merchant list of followers
                 return facade.Delete(entity.ID);
             }
             else
             {
                 /// we return a -1 if error
                 return -1;
             }
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return -1;
     }
 }
コード例 #2
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="id"></param>
 /// <returns></returns>
 public static Promociones Get(int id)
 {
     using (MsSqlFacade<Promociones, PromocionesMapper> facade = new MsSqlFacade<Promociones, PromocionesMapper>())
     {
         //// we use the Collection to build the broker entity on an abstract phase to manage it as a all
         return facade.Read().Single(p => p.ID == id);
     }
 }
コード例 #3
0
 /// <summary>
 /// 
 /// </summary>
 /// <returns></returns>
 public static List<Promociones> Read()
 {
     using (MsSqlFacade<Promociones, PromocionesMapper> facade = new MsSqlFacade<Promociones, PromocionesMapper>())
     {
         //// we use the Collection to build the broker entity on an abstract phase to manage it as a all
         return facade.Read();
     }
 }
コード例 #4
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="Mercante"></param>
 /// <returns></returns>
 public static List<data.entities.Categorias> ReadCategories()
 {
     try
     {
         using (MsSqlFacade<Categorias, CategoriasMapper> facade = new MsSqlFacade<Categorias, CategoriasMapper>())
         {
             //// we use the Collection to build the broker entity on an abstract phase to manage it as a all
             return facade.Read();
         }
     }
     catch
     {
         return null;
     }
 }
コード例 #5
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="axis"></param>
 /// <param name="cliente"></param>
 public static string getCiudadPorID(int id)
 {
     try
     {
         using (MsSqlFacade<Ciudad, CiudadMapper> facade = new MsSqlFacade<Ciudad, CiudadMapper>())
         {
             //// we use the Collection to build the broker entity on an abstract phase to manage it as a all
             return facade.Read().Single(p => p.ID == id).Nombre;
         }
     }
     catch
     {
         return null;
     }
 }
コード例 #6
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="Mercante"></param>
 /// <param name="Cliente"></param>
 /// <returns></returns>
 public static int CheckFollower(int Mercante, int Cliente)
 {
     try
     {
         using (MsSqlFacade<ClientesMercantes, ClientesMercantesMapper> facade = new MsSqlFacade<ClientesMercantes, ClientesMercantesMapper>())
         {
             // we now select all the promotions that are active but we make it into a linear research
             // thus is not woow efficient is enought for it's end. 
             return facade.Read().Where(p=> p.Cliente == Cliente && p.Mercante == Mercante).Count();
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return -1;
     }
 }
コード例 #7
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="client"></param>
 /// <returns></returns>
 public static List<data.entities.CategoriasClientes> ReadClientCategories(int client)
 {
     try
     {
         using (MsSqlFacade<CategoriasClientes, CategoriasClientesMapper> facade = new MsSqlFacade<CategoriasClientes, CategoriasClientesMapper>())
         {
             //// we use the Collection to build the broker entity on an abstract phase to manage it as a all
             return facade.Read().Where(p=>p.Cliente == client).ToList<CategoriasClientes>();
         }
     }
     catch
     {
         return null;
     }
 }
コード例 #8
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="Collection"></param>
 /// <returns></returns>
 public static string GetPositionsPorMercante(int id)
 {
     try
     {
         using (MsSqlFacade<Positions, PositionsMapper> facade = new MsSqlFacade<Positions, PositionsMapper>())
         {
             // we now select all the promotions that are active but we make it into a linear research
             // thus is not woow efficient is enought for it's end. 
             return facade.Read().Single(p => p.Mercante == id).Axis;
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return null;
     }
 }
コード例 #9
0
 /// <summary>
 /// 
 /// </summary>
 /// <returns></returns>
 public static List<data.entities.Membresias> ReadMembresias()
 {
     try
     {
         using (MsSqlFacade<Membresias, MembresiasMapper> facade = new MsSqlFacade<Membresias, MembresiasMapper>())
         {
             // we now select all the promotions that are active but we make it into a linear research
             // thus is not woow efficient is enought for it's end. 
             return facade.Read();
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return null;
     }
 }
コード例 #10
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="Collection"></param>
 /// <returns></returns>
 public static List<data.entities.Promociones> ReadPromocionesPorCategorias(List<int> Collection, int Barrio)
 {
     try
     {
         using (MsSqlFacade<Promociones, PromocionesMapper> facade = new MsSqlFacade<Promociones, PromocionesMapper>())
         {
             // we now select all the promotions that are active but we make it into a linear research
             // thus is not woow efficient is enought for it's end. 
             return facade.Read().Where(p => Collection.Contains(p.Categoria) && p.Barrio == Barrio).ToList<Promociones>();
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return null;
     }
 }
コード例 #11
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="id"></param>
 /// <returns></returns>
 public static List<Clientes> GetSeguidoresPorMercante(int id)
 {
     try
     {
         using (MsSqlFacade<ClientesMercantes, ClientesMercantesMapper> facade = new MsSqlFacade<ClientesMercantes, ClientesMercantesMapper>())
         {
             /// client list to fill
             List<Clientes> clientes = new List<Clientes>();
             /// first thing is to get the clients form the merchant so we lookup
             List<ClientesMercantes> list =  facade.Read().Where(p => p.Mercante == id).ToList<ClientesMercantes>();
             /// we now iterate to get the clients
             foreach (ClientesMercantes parent in list)
             {
                 /// we release and use disposable
                 using (MsSqlFacade<Clientes, ClientesMapper> facade1 = new MsSqlFacade<Clientes, ClientesMapper>())
                 {
                     /// we now get the client form db
                     Clientes cliente = facade1.Get(parent.Cliente);
                     /// we now check for null
                     if (cliente != null)
                     {
                         /// add to client
                         clientes.Add(cliente);
                     }
                 }
             }
             /// we return the clients
             return clientes;
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return null;
     }
 }
コード例 #12
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="Mercante"></param>
 /// <returns></returns>
 public static List<data.entities.ClientesMercantes> ReadClientesMercantes(int Mercante)
 {
     try
     {
         using (MsSqlFacade<ClientesMercantes, ClientesMercantesMapper> facade = new MsSqlFacade<ClientesMercantes, ClientesMercantesMapper>())
         {
             //// we select all the promotion that are active first
             return facade.Read().Where(p=>p.Mercante == Mercante).ToList<ClientesMercantes>();
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return null;
     }
 }
コード例 #13
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="Mercante"></param>
 /// <returns></returns>
 public static List<data.entities.ItemProductos> ReadItemProductos(int Venta)
 {
     try
     {
         using (MsSqlFacade<ItemProductos, ItemProductosMapper> facade = new MsSqlFacade<ItemProductos, ItemProductosMapper>())
         {
             //// we select all the promotion that are active first
             return facade.Read().Where(p=>p.Venta == Venta).ToList<ItemProductos>();
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return null;
     }
 }
コード例 #14
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="Collection"></param>
 /// <returns></returns>
 public static List<data.entities.Promociones> ReadPromocionesPorCategorias(List<int> Collection)
 {
     try
     {
         using (MsSqlFacade<Promociones, PromocionesMapper> facade = new MsSqlFacade<Promociones, PromocionesMapper>())
         {
             //// we select all the promotion that are active first
             return facade.Read().Where(p=> Collection.Contains(p.Categoria)).ToList<Promociones>();
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return null;
     }
 }
コード例 #15
0
 /// <summary>
 /// 
 /// </summary>
 /// <returns></returns>
 public static List<data.entities.Productos> ReadProductos()
 {
     try
     {
         using (MsSqlFacade<Productos, ProductosMapper> facade = new MsSqlFacade<Productos, ProductosMapper>())
         {
             //// we select all the promotion that are active first
             return facade.Read();
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return null;
     }
 }
コード例 #16
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="Cliente"></param>
 /// <returns></returns>
 public static List<ComprasPromociones> getComprasPorCliente(int Cliente)
 {
     try
     {
         using (MsSqlFacade<ComprasPromociones, ComprasPromocionesMapper> facade = new MsSqlFacade<ComprasPromociones, ComprasPromocionesMapper>())
         {
             return facade.Read().Where(p => p.Cliente == Cliente).ToList<ComprasPromociones>();
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return null;
     }
 }
コード例 #17
0
 /// <summary>
 /// 
 /// </summary>
 /// <returns></returns>
 public static List<data.entities.Promociones> ReadPromociones(int estado)
 {
     try
     {
         using (MsSqlFacade<Promociones, PromocionesMapper> facade = new MsSqlFacade<Promociones, PromocionesMapper>())
         {
             //// we select all the promotion that are active first
             return facade.Read().Where(p=>p.Estado == estado).ToList<Promociones>();
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return null;
     }
 }
コード例 #18
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="Mercante"></param>
 /// <returns></returns>
 public static List<data.entities.Barrios> ReadBarriosPorCiudad(int Ciudad)
 {
     try
     {
         using (MsSqlFacade<Barrios, BarriosMapper> facade = new MsSqlFacade<Barrios, BarriosMapper>())
         {
             //// we use the Collection to build the broker entity on an abstract phase to manage it as a all
             return facade.Read().Where(p => p.Ciudad == Ciudad).ToList<Barrios>();
         }
     }
     catch
     {
         return null;
     }
 }
コード例 #19
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="axis"></param>
 /// <returns></returns>
 public static List<data.entities.Promociones> ReadPromocionesPorGeolocation(string axis, double tolerance, int Barrio)
 {
     try
     {
         /// this is the list of merchants near my location
         List<int> MerchantCandidatesNear = new List<int>();
         /// this is the full collection for the merchants positions
         List<Positions> PositionsCollection = new List<Positions>();
         /// first we get the lat and lon in terms of (x,y) -> (lat, lon)
         string[] geo = axis.Split(',');
         /// latitude
         double lat1 = double.Parse(geo[0]);
         /// longitude
         double lon1 = double.Parse(geo[1]);
         /// Geo Location for the one we are looking for 
         GeoCoordinate coord1 = new GeoCoordinate(lat1, lon1);
         /// we now prepare the object to be used
         GeoCoordinate coord2;
         /// facade call so it's O(n) = n^2
         using (MsSqlFacade<Positions, PositionsMapper> facade = new MsSqlFacade<Positions, PositionsMapper>())
         {
             /// this is the full collection for the merchants positions
             PositionsCollection = facade.Read();
         }
         /// this is only valid if the number of monkey is higher than zero
         if (PositionsCollection.Count > 0)
         {
             /// now we iterate to search the candidates
             foreach (Positions parent in PositionsCollection)
             {
                 /// we now get the axis comma separated
                 string[] g = parent.Axis.Split(',');
                 /// latitude
                 double lat2 = double.Parse(g[0]);
                 /// longitude
                 double lon2 = double.Parse(g[1]);
                 /// we now set the object
                 coord2 = new GeoCoordinate(lat2, lon2);
                 /// this gives me the distance of 
                 /// how long is the current actor's position to it destination
                 /// this distance is measured in meters !! 
                 double distance = coord1.GetDistanceTo(coord2);
                 /// if my candidate is near my location
                 if (distance <= tolerance)
                 {
                     MerchantCandidatesNear.Add(parent.Mercante);
                 }
                 else
                 {
                     /// DO NOTHING ::
                 }
             }
             if (MerchantCandidatesNear.Count >= 0)
             {
                 /// another facade call O(n) = n^2 + 1
                 using (MsSqlFacade<Promociones, PromocionesMapper> facade = new MsSqlFacade<Promociones, PromocionesMapper>())
                 {
                     /// this returns the promotions whre the merchant are near the tolerance given by the user
                     return facade.Read().Where(p => MerchantCandidatesNear.Contains(p.Mercante) && p.Barrio == Barrio).ToList<Promociones>();
                 }
             }
             else
             {
                 /// we only open the facade if the candidates are higher than zero, else 
                 /// we get out
                 return null;
             }
         }
         else
         {
             /// no candidates near so you are so f****d !!
             /// Maybe should reduce tolerance
             return null;
         }
     }
     catch(Exception ex)
     {
         /// in case that fails, we give an empty list
         return new List<Promociones>() { new Promociones(){ Mercante = -1, Cuerpo = ex.ToString() }};
     }
 }
コード例 #20
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="axis"></param>
        /// <param name="cliente"></param>
        public static double getDistanceToPromociones(int mercante, string axis)
        {
            try
            {

                /// this is the full collection for the merchants positions
                List<Positions> PositionsCollection = new List<Positions>();
                /// first we get the lat and lon in terms of (x,y) -> (lat, lon)
                string[] geo = axis.Split(',');
                string[] geo1 = null;
                /// latitude
                double lat1 = double.Parse(geo[0]);
                /// longitude
                double lon1 = double.Parse(geo[1]);
                /// Geo Location for the one we are looking for 
                GeoCoordinate coord1 = new GeoCoordinate(lat1, lon1);
                /// facade call so it's O(n) = n^2
                using (MsSqlFacade<Positions, PositionsMapper> facade = new MsSqlFacade<Positions, PositionsMapper>())
                {
                    /// this is the full collection for the merchants positions
                    geo1 = facade.Read().Single(p=>p.Mercante == mercante).Axis.Split(',');
                }
                /// latitude
                double lat2 = double.Parse(geo1[0]);
                /// longitude
                double lon2 = double.Parse(geo1[1]);
                /// Geo Location for the one we are looking for 
                GeoCoordinate coord2 = new GeoCoordinate(lat2, lon2);

                return coord1.GetDistanceTo(coord2);;
            }
            catch (Exception ex)
            {
                return -1;
            }
        }
コード例 #21
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="Cliente"></param>
 /// <returns></returns>
 public static List<data.entities.CategoriasClientes> ReadCategoriasClientes(int Cliente)
 {
     try
     {
         using (MsSqlFacade<CategoriasClientes, CategoriasClientesMapper> facade = new MsSqlFacade<CategoriasClientes, CategoriasClientesMapper>())
         {
             // we now select all the promotions that are active but we make it into a linear research
             // thus is not woow efficient is enought for it's end. 
             return facade.Read().Where(p => p.Cliente == Cliente).ToList<CategoriasClientes>();
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return null;
     }
 }
コード例 #22
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="Mercante"></param>
 /// <returns></returns>
 public static List<data.entities.Rutas> ReadRutas(int Cliente)
 {
     try
     {
         using (MsSqlFacade<Rutas, RutasMapper> facade = new MsSqlFacade<Rutas, RutasMapper>())
         {
             //// we use the Collection to build the broker entity on an abstract phase to manage it as a all
             return facade.Read().Where(p=>p.Cliente == Cliente).ToList<Rutas>();
         }
     }
     catch
     {
         return null;
     }
 }
コード例 #23
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="Mercante"></param>
 /// <returns></returns>
 public static List<data.entities.Positions> ReadPositionsPorMercante(int Mercante)
 {
     try
     {
         using (MsSqlFacade<Positions, PositionsMapper> facade = new MsSqlFacade<Positions, PositionsMapper>())
         {
             //// we use the Collection to build the broker entity on an abstract phase to manage it as a all
             return facade.Read().Where(p => p.Mercante == Mercante).ToList<Positions>();
         }
     }
     catch
     {
         return null;
     }
 }
コード例 #24
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="id"></param>
 /// <returns></returns>
 public static int GetNumeroSeguidoresPorMercante(int id)
 {
     try
     {
         using (MsSqlFacade<ClientesMercantes, ClientesMercantesMapper> facade = new MsSqlFacade<ClientesMercantes, ClientesMercantesMapper>())
         {
             // we now select all the promotions that are active but we make it into a linear research
             // thus is not woow efficient is enought for it's end. 
             return facade.Read().Where(p=>p.Mercante == id).Count();
         }
     }
     catch
     {
         /// in case that fails, we give an empty list
         return 0;
     }
 }