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());
        }
        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));
        }
        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);
        }
        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));
            }
        }
        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();
        }
        /// <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));
            }
        }
Beispiel #7
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));
            }
        }