protected override void Configure()
        {
            CreateMap <BL.Model.Place, DL.Place>()
            .ForMember(dest => dest.GeoPoint, opt => opt.MapFrom(src => GeographyHelper.PointFromGeoPoint(src.GeoLocation)))
            .ForMember(dest => dest.Offer, opt => opt.Ignore())
            .ForMember(dest => dest.AspNetUsers, opt => opt.Ignore());
            CreateMap <DL.Place, BL.Model.Place>()
            .ForMember(dest => dest.GeoLocation, opt => opt.MapFrom(src => new BL.Model.Geolocation((double)src.GeoPoint.Latitude,
                                                                                                    (double)src.GeoPoint.Longitude)));

            CreateMap <BL.Model.Offer, DL.Offer>()
            .ForMember(dest => dest.OfferTransactions, opt => opt.Ignore())
            .ForMember(dest => dest.Place, opt => opt.Ignore());
            CreateMap <DL.Offer, BL.Model.Offer>()
            .ForMember(dest => dest.AvailableAmount, opt => opt.Ignore());

            CreateMap <BL.Model.OfferTransaction, DL.OfferTransactions>()
            .ForMember(dest => dest.TypeId, opt => opt.MapFrom(src => (int)src.Type))
            .ForMember(dest => dest.OfferTransactionType, opt => opt.Ignore())
            .ForMember(dest => dest.AspNetUsers, opt => opt.Ignore())
            .ForMember(dest => dest.AspNetUsers1, opt => opt.Ignore())
            .ForMember(dest => dest.Offer, opt => opt.Ignore())
            .ForMember(dest => dest.PointTransactions, opt => opt.Ignore())
            .ForMember(dest => dest.UserOfferDelivery, opt => opt.Ignore());

            CreateMap <BL.Model.PointTransaction, DL.PointTransactions>()
            .ForMember(dest => dest.TypeId, opt => opt.MapFrom(src => (int)src.Type))
            .ForMember(dest => dest.AspNetUsers, opt => opt.Ignore())
            .ForMember(dest => dest.AspNetUsers1, opt => opt.Ignore())
            .ForMember(dest => dest.PointTransactionType, opt => opt.Ignore())
            .ForMember(dest => dest.OfferTransactions, opt => opt.Ignore());
        }
Пример #2
0
        private int GetNearestWondersCount(WonderModel model, double mileRadiusTo)
        {
            var usersPosition = GeographyHelper.ConvertLatLonToDbGeography(model.Longitude.Value, model.Latitude.Value);

            //DataContext.TurnOffLazyLoading();

            return(DataContext.Deals.AsNoTracking()
                   .Include(g => g.Gender)
                   .Include(t => t.Tags)
                   .Include(c => c.Company)
                   .Include(c => c.Cost)
                   .Include(c => c.Category)
                   .Include(a => a.Address)
                   .Include(l => l.Location)
                   .Include(s => s.Season)
                   .Include(a => a.Ages)
                   .Include(i => i.Images)
                   .Include(c => c.City)
                   .Include(cl => cl.City.Location)
                   .Where(w => w.Location.Geography.Distance(usersPosition) * .00062 >= 0 &&
                          w.Location.Geography.Distance(usersPosition) * .00062 <= mileRadiusTo
                          &&
                          w.Archived == false &&
                          w.Expired != true &&
                          w.Priority == false &&
                          w.Broadcast == false &&
                          _genders.Contains(w.Gender.Id) &&
                          (w.AlwaysAvailable == true || w.ExpiryDate >= DateTime.Now)).Count());
        }
Пример #3
0
        public async Task <Dictionary <GeoFence, bool> > GetByAssetIdWithIntersectionAsync(string assetId, IPoint[] points)
        {
            var pointsGeography = GeographyHelper.CreateDbMultiPoint(points);

            return(await this.FindBy(g => g.AssetDatas.Any(a => a.Id == assetId))
                   .Select(g => new { GeoFence = g, Intersects = g.Polygon.Intersects(pointsGeography) })
                   .ToDictionaryAsync(r => this.ObjectMapper.Map <GeoFence>(r.GeoFence), r => r.Intersects));
        }
Пример #4
0
        private IEnumerable <DealModel> GetNearestWonders(DbGeography usersPosition, int from, int to)
        {
            return(_wonders.Where(w =>
            {
                var wonderLocation =
                    GeographyHelper.ConvertLatLonToDbGeography(w.Location.Longitude.Value, w.Location.Latitude.Value);

                return wonderLocation.Distance(usersPosition) * .00062 > from &&
                wonderLocation.Distance(usersPosition) * .00062 <= to;
            }).OrderBy(x => Guid.NewGuid()).Take(WonderAppConstants.DefaultNumberOfWondersToTake));
        }
Пример #5
0
        public async Task <IList <PlaceInfo> > GetShortPlaceInAreaAsync(Geolocation geolocation, double radiusMetres, int limit)
        {
            var         radiusSm = radiusMetres * 1000;
            DbGeography area     = GeographyHelper.PointFromGeoPoint(geolocation).Buffer(radiusSm);

            var pointsQuery = (from place in _dbContext.Place
                               where SqlSpatialFunctions.Filter(place.GeoPoint, area) == true
                               select new { place.Id, place.GeoPoint, place.Name }).Take(limit);

            var points = await pointsQuery.ToListAsync();

            return(points.Select(t => new PlaceInfo(t.Id, t.Name, new Geolocation((double)t.GeoPoint.Latitude, (double)t.GeoPoint.Longitude))).ToList());
        }
        public void EuclideanDistancePoint_Test()
        {
            // Arrange
            LocationTimeValue loc1 = new LocationTimeValue(0, 0, 0);
            LocationTimeValue loc2 = new LocationTimeValue(1, 1, 1);

            double expected = 1.732050808;

            // Act
            double dist = GeographyHelper.EuclideanDistance(loc1, loc2);


            // Assert
            Assert.AreEqual(dist, expected, 0.002, "Calculation error.");
        }
Пример #7
0
        private GeoAddress[] FilterGeoCodingResults(GeoAddress[] resultsToFilter)
        {
            if (!ShouldFilterResults())
            {
                return(resultsToFilter);
            }

            // Make sure that the geocoding results are part of the region covered by the app
            return(resultsToFilter.Where(result =>
                                         GeographyHelper.RegionContainsCoordinate(
                                             _appSettings.Data.UpperRightLatitude.Value,  // x1
                                             _appSettings.Data.UpperRightLongitude.Value, // y1
                                             _appSettings.Data.LowerLeftLatitude.Value,   // x2
                                             _appSettings.Data.LowerLeftLongitude.Value,  // y2
                                             result.Latitude, result.Longitude))
                   .ToArray());
        }
Пример #8
0
        private List <DealModel> GetNearestWonders(WonderModel model, double mileRadiusTo, int from, int take)
        {
            var usersPosition = GeographyHelper.ConvertLatLonToDbGeography(model.Longitude.Value, model.Latitude.Value);
            //DataContext.TurnOffLazyLoading();

            var allWonders = DataContext.Deals.AsNoTracking()
                             .Include(g => g.Gender)
                             .Include(t => t.Tags)
                             .Include(c => c.Company)
                             .Include(c => c.Cost)
                             .Include(c => c.Category)
                             .Include(a => a.Address)
                             .Include(l => l.Location)
                             .Include(s => s.Season)
                             .Include(a => a.Ages)
                             .Include(i => i.Images)
                             .Include(c => c.City)
                             .Include(cl => cl.City.Location)
                             .Where(w => w.Location.Geography.Distance(usersPosition) * .00062 >= 0 &&
                                    w.Location.Geography.Distance(usersPosition) * .00062 <= mileRadiusTo
                                    &&
                                    w.Archived == false &&
                                    w.Expired != true &&
                                    w.Priority == false &&
                                    w.Broadcast == false &&
                                    _genders.Contains(w.Gender.Id) &&
                                    (w.AlwaysAvailable == true || w.ExpiryDate >= DateTime.Now))
                             .OrderBy(o => o.Id).Skip(from).Take(take);

            return(Mapper.Map <List <DealModel> >(allWonders));

            //return mappedWonders.Where(w =>
            //{
            //    var wonderLocation =
            //        GeographyHelper.ConvertLatLonToDbGeography(w.Location.Longitude.Value, w.Location.Latitude.Value);

            //    return wonderLocation.Distance(usersPosition) * .00062 > 0 &&
            //           wonderLocation.Distance(usersPosition) * .00062 <= mileRadiusTo;
            //}).ToList();

            //return allWonders.Where(w => w.Location.Geography.Distance(usersPosition) * .00062 >= 0 &&
            //w.Location.Geography.Distance(usersPosition) * .00062 <= mileRadiusTo);

            //return GetNearestWonders(usersPosition, from: 0, to: 1);
        }
Пример #9
0
        protected List <KeyValuePair <string, string> > GetAvailableVehicleParams(string market, double latitude, double longitude, int?searchRadius = null, IList <int> fleetIds = null, bool returnAll = false, bool wheelchairAccessibleOnly = false, bool usePolygon = true)
        {
            if (fleetIds != null && !fleetIds.Any())
            {
                // No fleetId allowed for available vehicles
                return(null);
            }

            var searchRadiusInKm = (searchRadius ?? Settings.ServerData.AvailableVehicles.Radius) / 1000;

            var @params = new List <KeyValuePair <string, string> >
            {
                new KeyValuePair <string, string>("includeEntities", "true"),
                new KeyValuePair <string, string>("market", market),
                new KeyValuePair <string, string>("meterState", ((int)MeterStates.ForHire).ToString()),
                new KeyValuePair <string, string>("logonState", ((int)LogonStates.LoggedOn).ToString())
            };

            if (wheelchairAccessibleOnly)
            {
                @params.Add(new KeyValuePair <string, string>("vehicleType", "1"));
            }

            if (usePolygon)
            {
                var vertices = GeographyHelper.CirclePointsFromRadius(latitude, longitude, searchRadiusInKm, 10)
                               .Select(vertex => string.Format("{0},{1}", vertex.Item1, vertex.Item2))
                               .Select(point => new KeyValuePair <string, string>("poly", point));

                @params.AddRange(vertices);
            }
            else
            {
                @params.Add(new KeyValuePair <string, string>("lat", latitude.ToString(CultureInfo.InvariantCulture)));
                @params.Add(new KeyValuePair <string, string>("lon", longitude.ToString(CultureInfo.InvariantCulture)));
                @params.Add(new KeyValuePair <string, string>("rad", (searchRadiusInKm * 1000).ToString()));
            }

            if (fleetIds != null)
            {
                @params.AddRange(fleetIds.Select(fleetId => new KeyValuePair <string, string>("fleet", fleetId.ToString())));
            }

            return(@params);
        }
Пример #10
0
        internal IEnumerable <Location> GetNearestLocations(double SearchLat, double SearchLong, int QuantityReturned, Guid FilterByLocationTypeKey)
        {
            CurrentCollection.Clear();
            var sql = new Sql();

            sql.Select(string.Format("TOP({0}) *", QuantityReturned))
            .From <LocationDto>()
            .Append(GeographyHelper.GetGeoNearestSql(SearchLat, SearchLong, FilterByLocationTypeKey));

            var dtoResult = Repositories.ThisDb.Query <LocationDto>(sql).ToList();

            var converter = new DtoConverter();

            CurrentCollection.AddRange(converter.ToLocationEntity(dtoResult));

            FillChildren();

            return(CurrentCollection);
        }
Пример #11
0
        internal IEnumerable <Location> GetByGeoSearch(double SearchLat, double SearchLong, int MilesDistance, Guid FilterByLocationTypeKey)
        {
            CurrentCollection.Clear();
            var sql = new Sql();

            sql.Select("*")
            .From <LocationDto>()
            .Append(GeographyHelper.GetGeoSearchSql(SearchLat, SearchLong, MilesDistance, FilterByLocationTypeKey));

            var dtoResult = Repositories.ThisDb.Query <LocationDto>(sql).ToList();

            var converter = new DtoConverter();

            CurrentCollection.AddRange(converter.ToLocationEntity(dtoResult));

            FillChildren();

            return(CurrentCollection);
        }
Пример #12
0
        public async Task <HttpResponseMessage> PostWonderModel(WonderModel model)
        {
            try
            {
                var wonders = new List <DealModel>();

                if (model.Latitude != null && model.Longitude != null)
                {
                    var usersPosition = GeographyHelper.ConvertLatLonToDbGeography(model.Longitude.Value, model.Latitude.Value);

                    wonders = await Task.Run(() =>
                    {
                        return(Mapper.Map <List <DealModel> >(DataContext.Deals
                                                              .Where(w => w.Location.Geography.Distance(usersPosition) * .00062 <= WonderAppConstants.DefaultRadius &&
                                                                     w.Tags.Any(x => model.TagId == x.Id) &&
                                                                     !w.Archived.Value &&
                                                                     w.MyRejectUsers.All(u => u.Id != model.UserId) &&
                                                                     w.MyWonderUsers.All(u => u.Id != model.UserId))
                                                              .Take(WonderAppConstants.DefaultMaxNumberOfWonders)));
                    });
                }
                else
                {
                    wonders = await Task.Run(() =>
                    {
                        return(Mapper.Map <List <DealModel> >(DataContext.Deals
                                                              .Where(w => !w.Archived.Value &&
                                                                     w.MyRejectUsers.All(u => u.Id != model.UserId) &&
                                                                     w.MyWonderUsers.All(u => u.Id != model.UserId) &&
                                                                     w.Tags.Any(x => model.TagId == x.Id))
                                                              .OrderByDescending(x => x.Id)
                                                              .Take(WonderAppConstants.DefaultMaxNumberOfWonders)));
                    });
                }

                return(Request.CreateResponse(HttpStatusCode.OK, wonders));
            }
            catch (Exception ex)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
            }
        }
Пример #13
0
        public IHttpActionResult GetPreviewList(double lat = 28.9721214555, double lng = 118.8898357316, int pageSize = 15, int index = 0)
        {
            var coord  = _sceneService.GetAllPanoramaScenesOrderByDistance(lat, lng, pageSize, index);
            var scenes = coord.ToList().Select(ps =>
            {
                var previewModel        = ps.ToPreviewModel();
                previewModel.Produce    = "衢州市地理信息中心";
                previewModel.ImgPath   += ps.ProductionDate.ToString("yyyyMMdd") + ".tiles";
                previewModel.LocationId = ps.PanoramaLocation.Id;
                previewModel.Lng        = ps.PanoramaLocation.Lng;
                previewModel.Lat        = ps.PanoramaLocation.Lat;
                previewModel.Dist       = Math.Floor(GeographyHelper.GetDistance(ps.PanoramaLocation.Lat, ps.PanoramaLocation.Lng, lat, lng));
                if (previewModel.Dist > 5000)
                {
                    previewModel.Dist = 5000;
                }
                return(previewModel);
            });

            return(Ok(scenes));
        }
Пример #14
0
        private async Task <IList <BL.Model.Offer> > GetOffersAsync(int?offerId, string ownerUserId, Area area, int?placeId, bool?isActive, int?minItemsAmount, int?limit)
        {
            #region query
            var query = from user in _dbContext.AspNetUsers
                        from place in user.Place
                        from offer in place.Offer
                        select new
            {
                User        = user,
                Place       = place,
                Offer       = offer,
                OfferAmount = offer.OfferTransactions.Select(t => t.Amount).DefaultIfEmpty(0).Sum()
            };

            if (area != null)
            {
                var         radiusSm = area.RadiusMeters * 100;
                DbGeography dbArea   = GeographyHelper.PointFromGeoPoint(area).Buffer(radiusSm);

                query = query.Where(t => SqlSpatialFunctions.Filter(t.Place.GeoPoint, dbArea) == true);
            }

            if (offerId != null)
            {
                query = query.Where(t => t.Offer.Id == offerId.Value);
            }

            if (!string.IsNullOrEmpty(ownerUserId))
            {
                query = query.Where(t => t.User.Id == ownerUserId);
            }

            if (placeId != null)
            {
                query = query.Where(t => t.Place.Id == placeId.Value);
            }

            if (isActive != null)
            {
                query = query.Where(t => t.Offer.IsActive == isActive.Value);
            }

            if (minItemsAmount != null)
            {
                query = query.Where(t => t.OfferAmount >= minItemsAmount.Value);
            }

            if (limit != null)
            {
                query = query.Take(limit.Value);
            }

            #endregion

            var dbOffers = await query.Select(t =>
                                              new
            {
                Id              = t.Offer.Id,
                Title           = t.Offer.Title,
                Description     = t.Offer.Description,
                Price           = t.Offer.Price,
                IsActive        = t.Offer.IsActive,
                PlaceId         = t.Offer.PlaceId,
                AvailableAmount = t.OfferAmount,
                LogoUrl         = t.Offer.LogoUrl
            }).ToListAsync().ConfigureAwait(false);

            var offers = dbOffers.Select(t => new BL.Model.Offer()
            {
                Id              = t.Id,
                Title           = t.Title,
                Description     = t.Description,
                Price           = t.Price,
                IsActive        = t.IsActive,
                PlaceId         = t.PlaceId,
                AvailableAmount = t.AvailableAmount,
                LogoUrl         = t.LogoUrl
            });

            return(offers.ToList());
        }
Пример #15
0
        public MappingProfile()
        {
            // Configuration Mappings
            CreateMap <ConfigurationData, Configuration>()
            .ConvertUsing(dest => new Configuration(dest.Key1, dest.Key2, dest.Description, dest.Value));

            CreateMap <Configuration, ConfigurationData>()
            .ForMember(dest => dest.Key1, opt => opt.MapFrom(src => src.Namespace))
            .ForMember(dest => dest.Key2, opt => opt.MapFrom(src => src.Key))
            .ForMember(dest => dest.Value, opt => opt.MapFrom(src => src.SerializedValue))
            .ForMember(dest => dest.Description, opt => opt.MapFrom(src => src.Description));

            // Role Mappings
            CreateMap <RoleData, Role>();
            CreateMap <Role, RoleData>();

            // TrackingDevice Mappings
            CreateMap <TrackingDeviceData, TrackingDevice>()
            .ForMember(dest => dest.AssetId, opt => opt.MapFrom(src => src.Asset.Id));

            CreateMap <TrackingDevice, TrackingDeviceData>()
            .ForMember(dest => dest.Asset, opt => opt.ResolveUsing <TrackingDeviceAssetResolver>());

            // Location Mappings
            CreateMap <LocationData, Location>()
            .ForMember(dest => dest.Latitude, opt => opt.MapFrom(src => src.Location.Latitude.Value))
            .ForMember(dest => dest.Longitude, opt => opt.MapFrom(src => src.Location.Longitude.Value))
            .ForMember(dest => dest.InterestLevel, opt =>
            {
                opt.MapFrom(src => (InterestLevel)(src.InterestLevel ?? 0));
            });

            CreateMap <Location, LocationData>()
            .ForMember(dest => dest.InterestLevel, opt => opt.MapFrom(src => (int)src.InterestLevel))
            .ForMember(dest => dest.Location, opt => opt.MapFrom(src => GeographyHelper.CreateDbPoint(src)));


            // GeoFence Mappings
            CreateMap <GeoFenceData, GeoFence>()
            .ForMember(dest => dest.FenceType, opt => opt.MapFrom(src => (FenceType)src.FenceType))
            .ForMember(dest => dest.Cooldown, opt => opt.MapFrom(src => src.CooldownInMinutes))
            .ForMember(dest => dest.EmailsToNotify, opt => opt.MapFrom(src => src.Emails.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)))
            .ForMember(dest => dest.AssetIds, opt => opt.MapFrom(src => src.AssetDatas.Select(a => a.Id)))
            .ForMember(dest => dest.FencePolygon, opt => opt.MapFrom(src => GeographyHelper.FromPolygon(src.Polygon)));

            CreateMap <GeoFence, GeoFenceData>()
            .ForMember(dest => dest.FenceType, opt => opt.MapFrom(src => (int)src.FenceType))
            .ForMember(dest => dest.CooldownInMinutes, opt => opt.MapFrom(src => src.Cooldown))
            .ForMember(dest => dest.Emails, opt => opt.MapFrom(src => src.EmailsToNotify == null ? string.Empty : string.Join(",", src.EmailsToNotify)))
            .ForMember(dest => dest.Polygon, opt => opt.MapFrom(src => GeographyHelper.CreatePolygon(src.FencePolygon)));

            // GeoFence update Mappings
            CreateMap <GeoFenceUpdateData, GeoFenceUpdate>()
            .ForMember(dest => dest.NotificationStatus, opt => opt.MapFrom(src => (NotificationStatus)src.Status))
            .ForMember(dest => dest.GeoFenceId, opt => opt.MapFrom(src => src.GeoFenceDataId))
            .ForMember(dest => dest.AssetId, opt => opt.MapFrom(src => src.AssetDataId))
            .ForMember(dest => dest.UpdatedAt, opt => opt.MapFrom(src => src.CreatedAtTimeUtc));

            CreateMap <GeoFenceUpdate, GeoFenceUpdateData>()
            .ForMember(dest => dest.Status, opt => opt.MapFrom(src => (int)src.NotificationStatus))
            .ForMember(dest => dest.GeoFenceDataId, opt => opt.MapFrom(src => src.GeoFenceId))
            .ForMember(dest => dest.AssetDataId, opt => opt.MapFrom(src => src.AssetId));

            // Tracking point Mappings
            CreateMap <TrackingPointData, TrackingPoint>()
            .ForMember(dest => dest.CreatedAtUtc, opt => opt.MapFrom(src => src.CreatedAtTimeUtc))
            .ForMember(dest => dest.Latitude, opt => opt.MapFrom(src => src.Location.Latitude))
            .ForMember(dest => dest.Longitude, opt => opt.MapFrom(src => src.Location.Longitude));

            CreateMap <TrackingPoint, TrackingPointData>()
            .ForMember(dest => dest.CreatedAtTimeUtc, opt => opt.MapFrom(src => src.CreatedAtUtc))
            .ForMember(dest => dest.Location, opt => opt.MapFrom(src => GeographyHelper.CreateDbPoint(src)));

            //AssetProperties Mappings
            CreateMap <AssetPropertiesData, AssetProperties>();
            CreateMap <AssetProperties, AssetPropertiesData>();

            // Asset Mappings
            CreateMap <AssetData, Asset>()
            .ForMember(dest => dest.AssetType, opt => opt.MapFrom(src => (AssetType)src.AssetType))
            .ForMember(dest => dest.TrackingDeviceId,
                       opt => opt.MapFrom(src => src.TrackingDevice == null ? null : src.TrackingDevice.Id))
            .ForMember(dest => dest.TrackingDeviceName,
                       opt => opt.MapFrom(src => src.TrackingDevice == null ? null : src.TrackingDevice.Name));

            CreateMap <Asset, AssetData>()
            .ForMember(dest => dest.AssetType, opt => opt.MapFrom(src => (int)src.AssetType));

            // Trip leg mapping
            CreateMap <TripLegData, TripLeg>()
            .ForMember(dest => dest.TripId, opt => opt.MapFrom(src => src.TripDataId))
            .ForMember(dest => dest.Route, opt => opt.MapFrom(src => GeographyHelper.FromDbLine(src.Route)));

            CreateMap <TripLeg, TripLegData>()
            .ForMember(dest => dest.Route, opt => opt.MapFrom(src => GeographyHelper.CreateDbLine(src.Route)));

            // Trip mapping
            CreateMap <TripData, Trip>()
            .ForMember(dest => dest.TripLegs, opt => opt.MapFrom(src => src.TripLegDatas));

            CreateMap <Trip, TripData>()
            .ForMember(dest => dest.TripLegDatas, opt => opt.MapFrom(src => src.TripLegs));

            // User Mapping
            CreateMap <UserData, User>();
            CreateMap <User, UserData>();

            // Deployment Id Mapping
            CreateMap <DeploymentIdData, DeploymentId>();
            CreateMap <DeploymentId, DeploymentIdData>();

            // Jwt Tokens
            CreateMap <TokenData, JwtToken>()
            .ForMember(dest => dest.UserId, opt => opt.MapFrom(src => src.User == null ? default(Guid?) : src.User.Id))
            .ForMember(dest => dest.TrackingDeviceId, opt => opt.MapFrom(src => src.TrackingDevice == null ? null : src.TrackingDevice.Id))
            .ForMember(dest => dest.Claims, opt => opt.MapFrom(src => JsonConvert.DeserializeObject <Dictionary <string, string> >(src.Value).Select(d => new Claim(d.Key, d.Value))));
            CreateMap <JwtToken, TokenData>()
            .ForMember(dest => dest.User, opt => opt.ResolveUsing <TokenUserResolver>())
            .ForMember(dest => dest.TrackingDevice, opt => opt.ResolveUsing <TokenTrackingDeviceResolver>())
            .ForMember(dest => dest.Value, opt => opt.MapFrom(src => JsonConvert.SerializeObject(src.Claims.ToDictionary(c => c.Type, c => c.Value))));
        }
Пример #16
0
        public static void Configure()
        {
            Mapper.CreateMap <Deal, DealModel>()
            .ForMember(m => m.ExpiryDate,
                       opt => opt.MapFrom(e => e.AlwaysAvailable == true
                        ? String.Empty : e.ExpiryDate.ToString("dd-MM-yyyy HH:mm:ss")))
            .ForMember(e => e.Phone, opt => opt.NullSubstitute(String.Empty))
            //.ForMember(dest => dest.Category.Deals, opt => opt.Ignore())
            //.ForMember(dest => dest.Expired, opts => opts.MapFrom(src => src.Expired == null ? src.Expired.Value : false))
            // .ForMember(dest => dest.Archived, opts => opts.MapFrom(src => src.Archived == null ? src.Archived.Value : false))
            //.ForMember(dest => dest.AlwaysAvailable,  opt => opt.Ignore()) //opts => opts.MapFrom(src => src.AlwaysAvailable == null ? src.AlwaysAvailable.Value : false));
            .ForMember(dest => dest.Creator, opts => opts.MapFrom(src => src.AspNetUser));

            Mapper.CreateMap <DealModel, Deal>()
            .ForMember(e => e.Id, opt => opt.Ignore())
            .ForMember(e => e.MyRejectUsers, opt => opt.Ignore())
            .ForMember(e => e.MyWonderUsers, opt => opt.Ignore())
            .ForMember(e => e.Company, opt => opt.Ignore())
            .ForMember(e => e.Tags, opt => opt.Ignore())
            .ForMember(e => e.Cost, opt => opt.Ignore())
            .ForMember(e => e.Category, opt => opt.Ignore())
            .ForMember(e => e.Images, opt => opt.Ignore())
            .ForMember(e => e.City, opt => opt.Ignore())
            .ForMember(e => e.AspNetUser, opt => opt.Ignore())
            .ForMember(e => e.Creator_User_Id, opt => opt.Ignore())
            .ForMember(e => e.Season, opt => opt.Ignore())
            .ForMember(e => e.Gender, opt => opt.Ignore())
            .ForMember(e => e.Ages, opt => opt.Ignore())
            .ForMember(e => e.Likes, opt => opt.Ignore())
            .ForMember(e => e.ExpiryDate, opt => opt.MapFrom(m => m.AlwaysAvailable == true ? DateTime.Now.ToShortDateString() : m.ExpiryDate))
            .ForAllMembers(opt => opt.Condition(srs => !srs.IsSourceValueNull));

            Mapper.CreateMap <GetWonders_Result, DealModel>()
            .ForMember(m => m.ExpiryDate,
                       opt => opt.MapFrom(e => e.AlwaysAvailable == true
                        ? String.Empty : e.ExpiryDate.ToString("dd-MM-yyyy HH:mm:ss")))
            .ForMember(e => e.Company, opt => opt.MapFrom(m => new CompanyModel {
                Id = m.Company_Id, Name = m.CompanyName
            }))
            .ForMember(e => e.Location, opt => opt.MapFrom(m => new LocationModel {
                Id = m.Location_Id, Latitude = m.Latitude, Longitude = m.Longitude
            }))
            .ForMember(e => e.Cost, opt => opt.MapFrom(m => new CostModel {
                Id = m.Cost_Id.Value, Range = m.Range
            }))
            .ForMember(e => e.Category, opt => opt.MapFrom(m => new CategoryModel {
                Id = m.Category_Id.Value, Name = m.CategoryName
            }))
            .ForMember(e => e.Images, opt => opt.ResolveUsing(m =>
            {
                var imageList = new List <ImageModel>();
                var image     = new ImageModel {
                    url = m.ImageURL
                };
                imageList.Add(image);
                return(imageList);
            }))
            .ForMember(e => e.City, opt => opt.MapFrom(m => new CityModel {
                Id = m.CityId, Name = m.CityName
            }))
            .ForMember(e => e.Address, opt => opt.MapFrom(m => new AddressModel {
                Id = m.AddressId.ToString(), AddressLine1 = m.AddressLine1, AddressLine2 = m.AddressLine2, PostCode = m.PostCode
            }))
            .ForMember(e => e.Season, opt => opt.MapFrom(m => new SeasonModel {
                Id = m.Season_Id.Value, Name = m.Season
            }))
            .ForMember(e => e.Gender, opt => opt.MapFrom(m => new GenderModel {
                Id = m.Gender_Id.Value, Name = m.Gender
            }))
            .ForMember(e => e.Creator, opt => opt.Ignore())
            .ForMember(e => e.Ages, opt => opt.Ignore())
            //.ForMember(e => e.Broadcast, opt => opt.Ignore())
            .ForMember(e => e.Tags, opt => opt.Ignore());

            Mapper.CreateMap <Deal, DealSummaryModel>()
            .ForMember(dest => dest.Creator,
                       opts => opts.MapFrom(src => src.AspNetUser))
            .ForMember(e => e.Dislikes, opt => opt.Ignore());
            //.ForMember(m => m.ExpiryDate, opt => opt.ResolveUsing(e => e.ExpiryDate.MapToString()));


            Mapper.CreateMap <Category, CategoryModel>();
            Mapper.CreateMap <CategoryModel, Category>()
            .ForMember(e => e.Deals, opt => opt.Ignore())
            .ForMember(e => e.Users, opt => opt.Ignore());

            Mapper.CreateMap <Company, CompanyModel>();
            Mapper.CreateMap <CompanyModel, Company>()
            .ForMember(e => e.Country, opt => opt.Ignore())
            .ForMember(e => e.Deals, opt => opt.Ignore());

            Mapper.CreateMap <Cost, CostModel>();
            Mapper.CreateMap <CostModel, Cost>()
            .ForMember(e => e.Deals, opt => opt.Ignore());

            Mapper.CreateMap <Location, LocationModel>()
            .ForMember(m => m.Latitude, opt => opt.MapFrom(e => e.Geography.Latitude))
            .ForMember(m => m.Longitude, opt => opt.MapFrom(e => e.Geography.Longitude));

            Mapper.CreateMap <LocationModel, Location>()
            .ForMember(e => e.Geography, opt => opt.MapFrom(m =>
                                                            GeographyHelper.ConvertLatLonToDbGeography(m.Longitude.Value, m.Latitude.Value)))
            .ForMember(e => e.Id, opt => opt.Ignore())
            .ForMember(e => e.Deals, opt => opt.Ignore())
            .ForMember(e => e.Cities, opt => opt.Ignore())
            .ForMember(e => e.AspNetUser, opt => opt.Ignore());

            Mapper.CreateMap <Tag, TagModel>();
            Mapper.CreateMap <GetTags_Result, TagModel>()
            .ForMember(e => e.Id, opt => opt.MapFrom(m => m.TagId))
            .ForMember(e => e.Name, opt => opt.MapFrom(m => m.TagName));
            Mapper.CreateMap <TagModel, Tag>()
            .ForMember(e => e.Deals, opt => opt.Ignore());

            Mapper.CreateMap <AspNetUser, UserModel>();

            Mapper.CreateMap <UserModel, AspNetUser>()
            .ForMember(e => e.AppUserName, opt => opt.Ignore())
            .ForMember(e => e.CityId, opt => opt.Ignore())
            .ForMember(e => e.ShowTutorial, opt => opt.Ignore())
            .ForMember(e => e.ShowInfoRequest, opt => opt.Ignore())
            .ForMember(e => e.YearOfBirth, opt => opt.Ignore())
            .ForMember(e => e.EmailConfirmed, opt => opt.Ignore())
            .ForMember(e => e.PasswordHash, opt => opt.Ignore())
            .ForMember(e => e.SecurityStamp, opt => opt.Ignore())
            .ForMember(e => e.PhoneNumberConfirmed, opt => opt.Ignore())
            .ForMember(e => e.TwoFactorEnabled, opt => opt.Ignore())
            .ForMember(e => e.LockoutEndDateUtc, opt => opt.Ignore())
            .ForMember(e => e.LockoutEnabled, opt => opt.Ignore())
            .ForMember(e => e.AccessFailedCount, opt => opt.Ignore())
            .ForMember(e => e.Name, opt => opt.Ignore())
            .ForMember(e => e.AspNetUserClaims, opt => opt.Ignore())
            .ForMember(e => e.Roles, opt => opt.Ignore())
            .ForMember(e => e.Categories, opt => opt.Ignore())
            .ForMember(e => e.Deals, opt => opt.Ignore())
            .ForMember(e => e.AspNetUserLogins, opt => opt.Ignore())
            .ForMember(e => e.MyWonders, opt => opt.Ignore())
            .ForMember(e => e.MyRejects, opt => opt.Ignore())
            .ForMember(e => e.Locations, opt => opt.Ignore())
            .ForMember(e => e.UserPreference, opt => opt.Ignore());

            Mapper.CreateMap <AspNetUser, UserBasicModel>();

            Mapper.CreateMap <UserBasicModel, AspNetUser>()
            .ForMember(e => e.AppUserName, opt => opt.Ignore())
            .ForMember(e => e.CityId, opt => opt.Ignore())
            .ForMember(e => e.ShowTutorial, opt => opt.Ignore())
            .ForMember(e => e.ShowInfoRequest, opt => opt.Ignore())
            .ForMember(e => e.YearOfBirth, opt => opt.Ignore())
            .ForMember(e => e.EmailConfirmed, opt => opt.Ignore())
            .ForMember(e => e.PasswordHash, opt => opt.Ignore())
            .ForMember(e => e.SecurityStamp, opt => opt.Ignore())
            .ForMember(e => e.PhoneNumberConfirmed, opt => opt.Ignore())
            .ForMember(e => e.TwoFactorEnabled, opt => opt.Ignore())
            .ForMember(e => e.LockoutEndDateUtc, opt => opt.Ignore())
            .ForMember(e => e.LockoutEnabled, opt => opt.Ignore())
            .ForMember(e => e.AccessFailedCount, opt => opt.Ignore())
            .ForMember(e => e.Name, opt => opt.Ignore())
            .ForMember(e => e.AspNetUserClaims, opt => opt.Ignore())
            .ForMember(e => e.AspNetUserLogins, opt => opt.Ignore())
            .ForMember(e => e.Roles, opt => opt.Ignore())
            .ForMember(e => e.Categories, opt => opt.Ignore())
            .ForMember(e => e.UserPreference, opt => opt.Ignore())
            .ForMember(e => e.MyWonders, opt => opt.Ignore())
            .ForMember(e => e.MyRejects, opt => opt.Ignore())
            .ForMember(e => e.Locations, opt => opt.Ignore())
            .ForMember(e => e.Gender, opt => opt.Ignore())
            .ForMember(e => e.Deals, opt => opt.Ignore());

            Mapper.CreateMap <AspNetUserLogin, AspNetUserLoginModel>();
            Mapper.CreateMap <AspNetUserLoginModel, AspNetUserLogin>()
            .ForMember(e => e.AspNetUser, opt => opt.Ignore());

            Mapper.CreateMap <Reminder, ReminderModel>();
            Mapper.CreateMap <ReminderModel, Reminder>()
            .ForMember(e => e.UserPreferences, opt => opt.Ignore());

            Mapper.CreateMap <Gender, GenderModel>();
            Mapper.CreateMap <GenderModel, Gender>()
            .ForMember(e => e.Deals, opt => opt.Ignore())
            .ForMember(e => e.AspNetUsers, opt => opt.Ignore());

            Mapper.CreateMap <Image, ImageModel>();
            Mapper.CreateMap <ImageModel, Image>()
            .ForMember(e => e.Deal, opt => opt.Ignore());

            Mapper.CreateMap <Device, DeviceModel>()
            .ForMember(e => e.Images, opt => opt.Ignore());
            Mapper.CreateMap <DeviceModel, Device>();

            Mapper.CreateMap <City, CityModel>();
            Mapper.CreateMap <CityModel, City>()
            .ForMember(e => e.Companies, opt => opt.Ignore())
            .ForMember(e => e.Deals, opt => opt.Ignore());

            Mapper.CreateMap <Address, AddressModel>()
            .ForMember(e => e.AddressLine2, opt => opt.NullSubstitute(String.Empty));
            Mapper.CreateMap <AddressModel, Address>()
            .ForMember(e => e.Deals, opt => opt.Ignore());

            Mapper.CreateMap <Season, SeasonModel>();
            Mapper.CreateMap <SeasonModel, Season>()
            .ForMember(e => e.Deals, opt => opt.Ignore());

            Mapper.CreateMap <Age, AgeModel>()
            .ForMember(e => e.Deals, opt => opt.Ignore());
            Mapper.CreateMap <GetAges_Result, AgeModel>()
            .ForMember(e => e.Id, opt => opt.MapFrom(m => m.AgeId))
            .ForMember(e => e.Name, opt => opt.MapFrom(m => m.AgeName))
            .ForMember(e => e.Deals, opt => opt.Ignore());
            Mapper.CreateMap <AgeModel, Age>()
            .ForMember(e => e.Deals, opt => opt.Ignore());

            Mapper.CreateMap <UserPreference, UserPreferenceModel>();
            Mapper.CreateMap <UserPreferenceModel, UserPreference>()
            .ForMember(e => e.UserId, opt => opt.Ignore())
            .ForMember(e => e.AspNetUser, opt => opt.Ignore());

            Mapper.CreateMap <AspNetUser, UserInfoModel>()
            .ForMember(e => e.ShowTutorial, opt => opt.NullSubstitute(true))
            .ForMember(e => e.ShowInfoRequest, opt => opt.NullSubstitute(true))
            .ForMember(e => e.CityId, opt => opt.NullSubstitute(0))
            .ForMember(e => e.YearOfBirth, opt => opt.NullSubstitute(0))
            .ForMember(e => e.MyCategories, opt => opt.Ignore());

            Mapper.CreateMap <UserInfoModel, AspNetUser>()
            .ForMember(e => e.EmailConfirmed, opt => opt.Ignore())
            .ForMember(e => e.PasswordHash, opt => opt.Ignore())
            .ForMember(e => e.SecurityStamp, opt => opt.Ignore())
            .ForMember(e => e.PhoneNumberConfirmed, opt => opt.Ignore())
            .ForMember(e => e.TwoFactorEnabled, opt => opt.Ignore())
            .ForMember(e => e.LockoutEndDateUtc, opt => opt.Ignore())
            .ForMember(e => e.LockoutEnabled, opt => opt.Ignore())
            .ForMember(e => e.AccessFailedCount, opt => opt.Ignore())
            .ForMember(e => e.Name, opt => opt.Ignore())
            .ForMember(e => e.AspNetUserClaims, opt => opt.Ignore())
            .ForMember(e => e.AspNetUserLogins, opt => opt.Ignore())
            .ForMember(e => e.Roles, opt => opt.Ignore())
            .ForMember(e => e.Categories, opt => opt.Ignore())
            .ForMember(e => e.UserPreference, opt => opt.Ignore())
            .ForMember(e => e.MyWonders, opt => opt.Ignore())
            .ForMember(e => e.MyRejects, opt => opt.Ignore())
            .ForMember(e => e.Locations, opt => opt.Ignore())
            .ForMember(e => e.Deals, opt => opt.Ignore())
            .ForMember(e => e.Gender, opt => opt.Ignore())
            .ForMember(e => e.PhoneNumber, opt => opt.Ignore())
            .ForMember(e => e.UserName, opt => opt.Ignore())
            .ForMember(e => e.Forename, opt => opt.Ignore())
            .ForMember(e => e.Surname, opt => opt.Ignore());

            Mapper.CreateMap <Template, TemplateModel>();
            Mapper.CreateMap <TemplateModel, Template>()
            .ForMember(e => e.NotificationEmails, opt => opt.Ignore());

            Mapper.CreateMap <NotificationEmail, NotificationEmailModel>()
            .ForMember(e => e.Recipients, opt => opt.Ignore());
            Mapper.CreateMap <NotificationEmailModel, NotificationEmail>()
            .ForMember(e => e.Template, opt => opt.Ignore())
            .ForMember(e => e.RecipientEmail, opt => opt.Ignore())
            .ForMember(e => e.RecipientName, opt => opt.Ignore())
            .ForMember(e => e.Template_Id, opt => opt.Ignore());

            Mapper.AssertConfigurationIsValid();
        }
Пример #17
0
        public ModelMappingProfile()
        {
            // Configuration Mappings
            CreateMap <ConfigurationData, Configuration>()
            .ConvertUsing(dest => new Configuration(dest.Key1, dest.Key2, dest.Description, dest.Value));

            CreateMap <Configuration, ConfigurationData>()
            .ForMember(dest => dest.Key1, opt => opt.MapFrom(src => src.Namespace))
            .ForMember(dest => dest.Key2, opt => opt.MapFrom(src => src.Key))
            .ForMember(dest => dest.Value, opt => opt.MapFrom(src => src.SerializedValue))
            .ForMember(dest => dest.Description, opt => opt.MapFrom(src => src.Description));

            // Role Mappings
            CreateMap <RoleData, Role>();
            CreateMap <Role, RoleData>();

            // TrackingDevice Mappings
            CreateMap <TrackingDeviceData, TrackingDevice>()
            .ForMember(dest => dest.AssetId, opt => opt.MapFrom(src => (src.Asset != null && !src.Asset.Deleted) ? src.Asset.Id : null))
            .ForMember(dest => dest.Tags, opt => opt.MapFrom(src => src.Tags.Select(t => t.TagName)))
            .ForMember(dest => dest.Asset, opt => opt.MapFrom(src => (src.Asset != null && !src.Asset.Deleted) ? src.Asset : null))
            .ForPath(dest => dest.Asset.TrackingDevice, opt => opt.Ignore())
            .AfterMap((src, dst) =>
            {
                // Avoid circular serialization
                if (dst.Asset != null)
                {
                    dst.Asset.TrackingDevice = null;
                }
            });

            CreateMap <TrackingDevice, TrackingDeviceData>()
            .ForMember(dest => dest.Asset, opt => opt.ResolveUsing <TrackingDeviceAssetResolver>())
            .ForMember(dest => dest.Tags, opt => opt.MapFrom(src => src.Tags.Select(t => new TagData {
                TagName = t
            })));

            // Location Mappings
            CreateMap <LocationData, Location>()
            .ForMember(dest => dest.Latitude, opt => opt.MapFrom(src => src.Location.Latitude.Value))
            .ForMember(dest => dest.Longitude, opt => opt.MapFrom(src => src.Location.Longitude.Value))
            .ForMember(dest => dest.InterestLevel, opt =>
            {
                opt.MapFrom(src => (InterestLevel)(src.InterestLevel ?? 0));
            })
            .ForMember(dest => dest.Tags, opt => opt.MapFrom(src => src.Tags.Select(t => t.TagName)));

            CreateMap <Location, LocationData>()
            .ForMember(dest => dest.InterestLevel, opt => opt.MapFrom(src => (int)src.InterestLevel))
            .ForMember(dest => dest.Location, opt => opt.MapFrom(src => GeographyHelper.CreateDbPoint(src)))
            .ForMember(dest => dest.Tags, opt => opt.MapFrom(src => src.Tags.Select(t => new TagData {
                TagName = t
            })));


            // GeoFence Mappings
            CreateMap <GeoFenceData, GeoFence>()
            .ForMember(dest => dest.FenceType, opt => opt.MapFrom(src => (FenceType)src.FenceType))
            .ForMember(dest => dest.Cooldown, opt => opt.MapFrom(src => src.CooldownInMinutes))
            .ForMember(dest => dest.EmailsToNotify, opt => opt.MapFrom(src => src.Emails.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)))
            .ForMember(dest => dest.WebhooksToNotify, opt => opt.MapFrom(src => src.Webhooks.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)))
            .ForMember(dest => dest.AssetIds, opt => opt.MapFrom(src => src.AssetDatas.Select(a => a.Id)))
            .ForMember(dest => dest.GeoFenceArea, opt => opt.MapFrom(src =>
                                                                     (src.AreaType == (int)GeoFenceAreaType.Polygon) ?
                                                                     (IGeoFenceArea) new PolygonGeoFenceArea
            {
                FencePolygon = GeographyHelper.FromDbPolygon(src.Polygon)
            } : (src.AreaType == (int)GeoFenceAreaType.Circular) ?
                                                                     (IGeoFenceArea) new CircularGeoFenceArea
            {
                Center         = new Point(src.Polygon.Latitude.Value, src.Polygon.Longitude.Value),
                RadiusInMeters = src.Radius.Value
            } : null))
            .ForMember(dest => dest.Tags, opt => opt.MapFrom(src => src.Tags.Select(t => t.TagName)));

            CreateMap <GeoFence, GeoFenceData>()
            .ForMember(dest => dest.AssetDatas, opt => opt.ResolveUsing <GeoFenceAssetResolver>())
            .ForMember(dest => dest.FenceType, opt => opt.MapFrom(src => (int)src.FenceType))
            .ForMember(dest => dest.CooldownInMinutes, opt => opt.MapFrom(src => src.Cooldown))
            .ForMember(dest => dest.Emails, opt => opt.MapFrom(src => src.EmailsToNotify == null ? string.Empty : string.Join(",", src.EmailsToNotify)))
            .ForMember(dest => dest.Webhooks, opt => opt.MapFrom(src => src.WebhooksToNotify == null ? string.Empty : string.Join(",", src.WebhooksToNotify)))
            .ForMember(dest => dest.Polygon, opt => opt.MapFrom(src => src.GeoFenceArea.AreaType == GeoFenceAreaType.Polygon ? GeographyHelper.CreateDbPolygon(((PolygonGeoFenceArea)src.GeoFenceArea).FencePolygon) : GeographyHelper.CreateDbPoint(((CircularGeoFenceArea)src.GeoFenceArea).Center)))
            .ForMember(dest => dest.Radius, opt => opt.MapFrom(src => src.GeoFenceArea.AreaType == GeoFenceAreaType.Circular ? (long?)((CircularGeoFenceArea)src.GeoFenceArea).RadiusInMeters : null))
            .ForMember(dest => dest.AreaType, opt => opt.MapFrom(src => src.GeoFenceArea.AreaType))
            .ForMember(dest => dest.Tags, opt => opt.MapFrom(src => src.Tags.Select(t => new TagData
            {
                TagName = t
            })));

            // GeoFence update Mappings
            CreateMap <GeoFenceUpdateData, GeoFenceUpdate>()
            .ForMember(dest => dest.NotificationStatus, opt => opt.MapFrom(src => (NotificationStatus)src.Status))
            .ForMember(dest => dest.GeoFenceId, opt => opt.MapFrom(src => src.GeoFenceDataId))
            .ForMember(dest => dest.AssetId, opt => opt.MapFrom(src => src.AssetDataId))
            .ForMember(dest => dest.UpdatedAt, opt => opt.MapFrom(src => src.CreatedAtTimeUtc));

            CreateMap <GeoFenceUpdate, GeoFenceUpdateData>()
            .ForMember(dest => dest.Status, opt => opt.MapFrom(src => (int)src.NotificationStatus))
            .ForMember(dest => dest.GeoFenceDataId, opt => opt.MapFrom(src => src.GeoFenceId))
            .ForMember(dest => dest.AssetDataId, opt => opt.MapFrom(src => src.AssetId));

            // Tracking point Mappings
            CreateMap <TrackingPointData, TrackingPoint>()
            .ForMember(dest => dest.CreatedAtUtc, opt => opt.MapFrom(src => src.CreatedAtTimeUtc))
            .ForMember(dest => dest.Latitude, opt => opt.MapFrom(src => src.Location.Latitude))
            .ForMember(dest => dest.Longitude, opt => opt.MapFrom(src => src.Location.Longitude));

            CreateMap <TrackingPoint, TrackingPointData>()
            .ForMember(dest => dest.CreatedAtTimeUtc, opt => opt.MapFrom(src => src.CreatedAtUtc))
            .ForMember(dest => dest.Location, opt => opt.MapFrom(src => GeographyHelper.CreateDbPoint(src)));

            //AssetProperties Mappings
            CreateMap <AssetPropertiesData, AssetProperties>();
            CreateMap <AssetProperties, AssetPropertiesData>();

            // Asset Mappings
            CreateMap <AssetData, Asset>()
            .ForMember(dest => dest.AssetType, opt => opt.MapFrom(src => (AssetType)src.AssetType))
            .ForMember(dest => dest.Tags, opt => opt.MapFrom(src => src.Tags.Select(t => t.TagName)))
            .ForMember(dest => dest.TrackingDeviceId,
                       opt => opt.MapFrom(src => (src.TrackingDevice != null && !src.TrackingDevice.Deleted) ? src.TrackingDevice.Id : null))
            .ForMember(dest => dest.TrackingDevice, opt => opt.MapFrom(src => (src.TrackingDevice != null && !src.TrackingDevice.Deleted) ? src.TrackingDevice : null))
            .AfterMap((src, dst) =>
            {
                // Avoid circular serialization
                if (dst.TrackingDevice != null)
                {
                    dst.TrackingDevice.Asset = null;
                }
            });

            CreateMap <Asset, AssetData>()
            .ForMember(dest => dest.TrackingDevice, opt => opt.ResolveUsing <AssetTrackingDeviceResolver>())
            .ForMember(dest => dest.Tags, opt => opt.MapFrom(src => src.Tags.Select(t => new TagData
            {
                TagName = t
            })))
            .ForMember(dest => dest.AssetType, opt => opt.MapFrom(src => (int)src.AssetType));

            // Trip leg mapping
            CreateMap <TripLegData, TripLeg>()
            .ForMember(dest => dest.TripId, opt => opt.MapFrom(src => src.TripDataId))
            .ForMember(dest => dest.Route, opt => opt.MapFrom(src => GeographyHelper.FromDbLine(src.Route)));

            CreateMap <TripLeg, TripLegData>()
            .ForMember(dest => dest.Route, opt => opt.MapFrom(src => GeographyHelper.CreateDbLine(src.Route)));

            // Trip mapping
            CreateMap <TripData, Trip>()
            .ForMember(dest => dest.TripLegs, opt => opt.MapFrom(src => src.TripLegDatas));

            CreateMap <Trip, TripData>()
            .ForMember(dest => dest.TripLegDatas, opt => opt.MapFrom(src => src.TripLegs));

            // User Mapping
            CreateMap <UserData, User>();
            CreateMap <User, UserData>();

            // Deployment Id Mapping
            CreateMap <DeploymentIdData, DeploymentId>();
            CreateMap <DeploymentId, DeploymentIdData>();

            // Jwt Tokens
            CreateMap <TokenData, JwtToken>()
            .ForMember(dest => dest.UserId, opt => opt.MapFrom(src => src.User == null ? default(string) : src.User.Id))
            .ForMember(dest => dest.TrackingDeviceId, opt => opt.MapFrom(src => src.TrackingDevice == null ? null : src.TrackingDevice.Id))
            .ForMember(dest => dest.Claims, opt => opt.MapFrom(src => JsonConvert.DeserializeObject <Dictionary <string, string> >(src.Value).Select(d => new Claim(d.Key, d.Value))));
            CreateMap <JwtToken, TokenData>()
            .ForMember(dest => dest.User, opt => opt.ResolveUsing <TokenUserResolver>())
            .ForMember(dest => dest.TrackingDevice, opt => opt.ResolveUsing <TokenTrackingDeviceResolver>())
            .ForMember(dest => dest.Value, opt => opt.MapFrom(src => JsonConvert.SerializeObject(src.Claims.ToDictionary(c => c.Type, c => c.Value))));
        }
Пример #18
0
 /// <summary>
 /// Initializes a new instance of the <see cref="LocationFactory"/> class.
 /// </summary>
 public LocationFactory()
 {
     _geography = new GeographyHelper();
 }
Пример #19
0
        public ActionResult Create(DealCreateModel model)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    var returnModel = CreateDealViewModel <DealCreateModel>();
                    returnModel.DealModel     = model.DealModel;
                    returnModel.Image         = model.Image;
                    returnModel.TagString     = model.TagString;
                    returnModel.AgesAvailable = DataContext.Ages.Select(x => new AgeModel {
                        Id = x.Id, Name = x.Name
                    }).ToList();

                    return(View(returnModel));
                }

                var deal = new Deal
                {
                    Title            = model.DealModel.Title,
                    Phone            = model.DealModel.Phone,
                    Description      = model.DealModel.Description,
                    IntroDescription = model.DealModel.IntroDescription,
                    Url             = model.DealModel.Url,
                    AlwaysAvailable = model.DealModel.AlwaysAvailable,
                    ExpiryDate      = model.DealModel.AlwaysAvailable == true ? DateTime.Now : DateTime.Parse(model.DealModel.ExpiryDate),
                    Likes           = model.DealModel.Likes,
                    Archived        = model.DealModel.Archived,
                    Expired         = model.DealModel.Expired,
                    Location        = new Location
                    {
                        Name      = model.DealModel.Location.Name,
                        Geography = GeographyHelper.ConvertLatLonToDbGeography(model.DealModel.Location.Longitude.Value, model.DealModel.Location.Latitude.Value)
                    },
                    Priority = model.DealModel.Priority,
                    CityId   = model.DealModel.City.Id,
                    Address  = new Address
                    {
                        AddressLine1 = model.DealModel.Address.AddressLine1,
                        AddressLine2 = model.DealModel.Address.AddressLine2,
                        PostCode     = model.DealModel.Location.Name
                    },
                    Season_Id = model.DealModel.Season.Id,
                    Gender_Id = model.DealModel.Gender.Id
                };

                //var deal = Mapper.Map<Deal>(model.DealModel);

                //deal.Address.PostCode = model.DealModel.Location.Name;
                //if (model.DealModel.AlwaysAvailable) deal.ExpiryDate = DateTime.Now;

                var tagList = model.TagString.Split(',').ToList();
                foreach (var tag in tagList)
                {
                    int tagId;
                    deal.Tags.Add(int.TryParse(tag, out tagId) ? DataContext.Tags.Find(tagId) : new Tag {
                        Name = tag
                    });
                }

                deal.Ages.Clear();
                foreach (var age in model.AgeString)
                {
                    int ageId;
                    deal.Ages.Add(int.TryParse(age, out ageId)
                        ? DataContext.Ages.First(t => t.Id == ageId)
                        : new Age {
                        Name = age
                    });
                }

                deal.Category = DataContext.Categories.Find(model.DealModel.Category.Id);
                deal.Company  = DataContext.Companies.Find(model.DealModel.Company.Id);
                deal.Cost     = DataContext.Costs.Find(model.DealModel.Cost.Id);

                var image = CreateImage(model.Image);
                deal.Images.Add(image);

                deal.Creator_User_Id = User.Identity.GetUserId();;

                DataContext.Deals.Add(deal);
                DataContext.Commit();

                return(RedirectToAction("Index"));
                //return RedirectToAction("Edit/", new { id = deal.Id, edit = "true" });
            }
            catch (Exception e)
            {
                Debug.Print(e.Message);
                return(View(model));
            }
        }
Пример #20
0
        /// <summary>
        /// HTTP POST to return wonder deals. Send the following in body:
        /// Current position in latitude and longitude, cityId and userId.
        /// If there are unseen priority wonders for city then it returns all of them.
        /// If there are no priority wonders then it returns useen wonders from the following:
        /// Proximity of 1 mile, 3 miles, popularity and random.
        /// There will be no duplicates in the list.
        /// If no location just returns random and popular.
        /// Returns HTTP StatusCode 200 with JSON list of wonder deals.
        /// If error, return Http Status Code 500 with error message.
        /// </summary>
        /// <returns></returns>
        public async Task <HttpResponseMessage> PostWonders([FromBody] WonderModel model)
        {
            try
            {
                if (model.UserId != null && DataContext.AspNetUsers.All(x => x.Id != model.UserId))
                {
                    return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "This user is not recognised"));
                }

                var wonders = new List <DealModel>();

                wonders = await Task.Run(() => GetWonders(model.UserId, model.CityId, priority : true));

                if (wonders.Count > 0)
                {
                    var priorityWonders = wonders.OrderBy(x => Guid.NewGuid()).ToList();
                    if (priorityWonders.Any(w => w.Broadcast == true))
                    {
                        var broadcastWonder = priorityWonders.First(w => w.Broadcast == true);
                        priorityWonders.Remove(broadcastWonder);
                        priorityWonders.Insert(0, broadcastWonder);
                    }

                    return(Request.CreateResponse(HttpStatusCode.OK, priorityWonders));
                }

                _wonders = await Task.Run(() => GetWonders(model.UserId, model.CityId, priority : false));

                if (model.Latitude != null && model.Longitude != null)
                {
                    wonders = await Task.Run(() =>
                    {
                        if (_wonders.Count <= WonderAppConstants.DefaultMaxNumberOfWonders)
                        {
                            return(_wonders.ToList());
                        }

                        var usersPosition = GeographyHelper.ConvertLatLonToDbGeography(model.Longitude.Value, model.Latitude.Value);

                        var popularWonders   = GetPopularWonders(WonderAppConstants.DefaultNumberOfWondersToTake);
                        var randomWonders    = GetRandomWonders(WonderAppConstants.DefaultNumberOfWondersToTake);
                        var oneMileWonders   = GetNearestWonders(usersPosition, from: 0, to: 1);
                        var threeMileWonders = GetNearestWonders(usersPosition, from: 1, to: 3);

                        var results = oneMileWonders.Union(threeMileWonders).Union(popularWonders).Union(randomWonders);
                        results     = results.OrderBy(x => Guid.NewGuid());

                        return(results.ToList());
                    });
                }
                else
                {
                    wonders = await Task.Run(() =>
                    {
                        var popularWonders = GetPopularWonders(WonderAppConstants.DefaultNumberOfWondersToTake * 2);
                        var randomWonders  = GetRandomWonders(WonderAppConstants.DefaultNumberOfWondersToTake * 2);

                        var results = popularWonders.Union(randomWonders);
                        results     = results.OrderBy(x => Guid.NewGuid());

                        return(Mapper.Map <List <DealModel> >(results));
                    });
                }

                return(Request.CreateResponse(HttpStatusCode.OK, wonders));
            }
            catch (Exception ex)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
            }
        }