Пример #1
0
        internal World(ModData modData, Map map, OrderManager orderManager, WorldType type)
        {
            Type           = type;
            OrderManager   = orderManager;
            orderGenerator = new UnitOrderGenerator();
            Map            = map;
            Timestep       = orderManager.LobbyInfo.GlobalSettings.Timestep;
            SharedRandom   = new MersenneTwister(orderManager.LobbyInfo.GlobalSettings.RandomSeed);
            LocalRandom    = new MersenneTwister();

            ModelCache = modData.ModelSequenceLoader.CacheModels(map, modData, map.Rules.ModelSequences);

            var worldActorType = type == WorldType.Editor ? "EditorWorld" : "World";

            WorldActor = CreateActor(worldActorType, new TypeDictionary());
            ActorMap   = WorldActor.Trait <IActorMap>();
            ScreenMap  = WorldActor.Trait <ScreenMap>();
            Selection  = WorldActor.Trait <ISelection>();

            // Reset mask
            LongBitSet <PlayerBitMask> .Reset();

            // Add players
            foreach (var cmp in WorldActor.TraitsImplementing <ICreatePlayers>())
            {
                cmp.CreatePlayers(this);
            }

            // Set defaults for any unset stances
            foreach (var p in Players)
            {
                if (!p.Spectating)
                {
                    AllPlayersMask = AllPlayersMask.Union(p.PlayerMask);
                }

                foreach (var q in Players)
                {
                    SetUpPlayerMask(p, q);

                    if (!p.Stances.ContainsKey(q))
                    {
                        p.Stances[q] = Stance.Neutral;
                    }
                }
            }

            Game.Sound.SoundVolumeModifier = 1.0f;

            gameInfo = new GameInformation
            {
                Mod     = Game.ModData.Manifest.Id,
                Version = Game.ModData.Manifest.Metadata.Version,

                MapUid   = Map.Uid,
                MapTitle = Map.Title
            };

            RulesContainTemporaryBlocker = map.Rules.Actors.Any(a => a.Value.HasTraitInfo <ITemporaryBlockerInfo>());
        }
Пример #2
0
        internal World(ModData modData, Map map, OrderManager orderManager, WorldT type)
        {
            Type           = type;
            OrderManager   = orderManager;
            orderGenerator = new UnitOrderGenerator();
            Map            = map;
            Timestep       = orderManager.LobbyInfo.GlobalSettings.Timestep;
            SharedRandom   = new MersenneTwister(orderManager.LobbyInfo.GlobalSettings.RandomSeed);

            ModelCache = modData.ModelSequenceLoader.CachModels(map, modData, map.Rules.ModelSequences);

            var worldActorT = type == WorldT.Editor ? "EditorWorld" : "World";

            WorldActor = CreateActor(worldActorT, new TypeDictionary());
            ActorMap   = WorldActor.Trait <IActorMap>();
            ScreenMap  = WorldActor.Trait <ScreenMap>();

            //Add players
            foreach (var cmp in WorldActor.TraitsImplementing <ICreatePlayers>())
            {
                cmp.CreatePlayers(this);
            }

            //Set defaults for any unset stances
            foreach (var p in Players)
            {
                foreach (var q in Players)
                {
                    if (!p.Stances.ContainsKey(q))
                    {
                        p.Stances[q] = Stance.Neutral;
                    }
                }
            }
        }
Пример #3
0
 public UsersController(IUserServices userServices,
                        IAccountServices accountServices,
                        ICategoryServices categoryServices,
                        ITransactionServices transactionServices,
                        IBudgetServices budgetServices,
                        IHttpContextProvider context,
                        ISiteConfiguration config,
                        ICryptoProvider crypto,
                        IUrlHelper urlHelper,
                        IModelCache cache,
                        ICachingHelpers cachingHelpers,
                        ISessionServices sessionServices)
     : base(userServices,
                                                                 accountServices,
                                                                 categoryServices,
                                                                 transactionServices, 
                                                                 budgetServices,
                                                                 context,
                                                                 config,
                                                                 urlHelper,
                                                                 cache,
                                                                 cachingHelpers)
 {
     _crypto = crypto;
     _sessionServices = sessionServices;
 }
Пример #4
0
        public bool TryGetModelCache <TModel>(out IModelCache model)
        {
            var result = typeModelMap.TryGetValue(typeof(TModel).GetTypeData(), out ModelCache modelCache);

            model = modelCache;

            return(result);
        }
        public RabbitMqSendTransport(IModelCache modelCache, SendSettings sendSettings, params ExchangeBindingSettings[] exchangeBindings)
        {
            _observers    = new SendObservable();
            _sendSettings = sendSettings;
            _modelCache   = modelCache;

            _filter = new PrepareSendExchangeFilter(_sendSettings, exchangeBindings);
        }
        public RabbitMqSendTransport(IModelCache modelCache, IFilter <ModelContext> preSendFilter, string exchange)
        {
            _observers  = new SendObservable();
            _modelCache = modelCache;

            _filter   = preSendFilter;
            _exchange = exchange;
        }
Пример #7
0
 public MetaService(
     IMetaRepository metaRepository,
     IModelLoader modelLoader,
     IModelCache cache)
 {
     _metaRepository = metaRepository.NotNull(nameof(metaRepository));
     _modelLoader    = modelLoader.NotNull(nameof(modelLoader));
     _cache          = cache.NotNull(nameof(cache));
 }
Пример #8
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="renderData"></param>
 /// <param name="cache"></param>
 /// <param name="t"></param>
 /// <param name="lightDirection"></param>
 /// <param name="ambientLight"></param>
 /// <param name="diffuseLight"></param>
 /// <param name="colorPaletteTextureMidIndex"></param>
 /// <param name="normalsPaletteTextureMidIndex"></param>
 void Render(ModelRenderData renderData, IModelCache cache, float[] t, float[] lightDirection,
             float[] ambientLight, float[] diffuseLight, float colorPaletteTextureMidIndex, float normalsPaletteTextureMidIndex)
 {
     shader.SetTexture("DiffuseTexture", renderData.Sheet.GetTexture());
     shader.SetVec("PaletteRows", colorPaletteTextureMidIndex, normalsPaletteTextureMidIndex);
     shader.SetMatrix("TransformMatrix", t);
     shader.SetVec("LightDirection", lightDirection, 4);
     shader.SetVec("AmbientLight", ambientLight, 3);
     shader.SetVec("DiffuseLight", diffuseLight, 3);
     shader.Render(() => renderer.DrawBatch(cache.VertexBuffer, renderData.Start, renderData.Count, PrimitiveType.TriangleList));
 }
Пример #9
0
 public GenericSearchModelBinder(IListConfiguration configuration,
                                 IModelActivator modelActivator,
                                 IModelPropertyActivator modelPropertyActivator,
                                 IModelCache modelCache,
                                 IModelBinder fallbackModelBinder)
 {
     this.configuration          = configuration;
     this.modelActivator         = modelActivator;
     this.modelPropertyActivator = modelPropertyActivator;
     this.modelCache             = modelCache;
     this.fallbackModelBinder    = fallbackModelBinder;
 }
Пример #10
0
        internal World(ModData modData, Map map, OrderManager orderManager, WorldType type)
        {
            Type           = type;
            OrderManager   = orderManager;
            orderGenerator = new UnitOrderGenerator();
            Map            = map;
            Timestep       = orderManager.LobbyInfo.GlobalSettings.Timestep;
            SharedRandom   = new MersenneTwister(orderManager.LobbyInfo.GlobalSettings.RandomSeed);

            ModelCache = modData.ModelSequenceLoader.CacheModels(map, modData, map.Rules.ModelSequences);

            var worldActorType = type == WorldType.Editor ? "EditorWorld" : "World";

            WorldActor = CreateActor(worldActorType, new TypeDictionary());
            ActorMap   = WorldActor.Trait <IActorMap>();
            ScreenMap  = WorldActor.Trait <ScreenMap>();

            // Add players
            foreach (var cmp in WorldActor.TraitsImplementing <ICreatePlayers>())
            {
                cmp.CreatePlayers(this);
            }

            // Set defaults for any unset stances
            foreach (var p in Players)
            {
                foreach (var q in Players)
                {
                    if (!p.Stances.ContainsKey(q))
                    {
                        p.Stances[q] = Stance.Neutral;
                    }
                }
            }

            Game.Sound.SoundVolumeModifier = 1.0f;

            gameInfo = new GameInformation
            {
                Mod     = Game.ModData.Manifest.Id,
                Version = Game.ModData.Manifest.Metadata.Version,

                MapUid   = Map.Uid,
                MapTitle = Map.Title
            };
        }
Пример #11
0
        internal World(ModData modData, Map map, OrderManager orderManager, WorldType type)
        {
            Type           = type;
            OrderManager   = orderManager;
            orderGenerator = new UnitOrderGenerator();
            Map            = map;
            Timestep       = orderManager.LobbyInfo.GlobalSettings.Timestep;
            SharedRandom   = new MersenneTwister(orderManager.LobbyInfo.GlobalSettings.RandomSeed);
            LocalRandom    = new MersenneTwister();

            ModelCache = modData.ModelSequenceLoader.CacheModels(map, modData, map.Rules.ModelSequences);

            var worldActorType = type == WorldType.Editor ? "EditorWorld" : "World";

            WorldActor      = CreateActor(worldActorType, new TypeDictionary());
            ActorMap        = WorldActor.Trait <IActorMap>();
            ScreenMap       = WorldActor.Trait <ScreenMap>();
            Selection       = WorldActor.Trait <ISelection>();
            OrderValidators = WorldActor.TraitsImplementing <IValidateOrder>().ToArray();

            LongBitSet <PlayerBitMask> .Reset();

            // Create an isolated RNG to simplify synchronization between client and server player faction/spawn assignments
            var playerRandom = new MersenneTwister(orderManager.LobbyInfo.GlobalSettings.RandomSeed);

            foreach (var cmp in WorldActor.TraitsImplementing <ICreatePlayers>())
            {
                cmp.CreatePlayers(this, playerRandom);
            }

            Game.Sound.SoundVolumeModifier = 1.0f;

            gameInfo = new GameInformation
            {
                Mod     = Game.ModData.Manifest.Id,
                Version = Game.ModData.Manifest.Metadata.Version,

                MapUid   = Map.Uid,
                MapTitle = Map.Title
            };

            RulesContainTemporaryBlocker = map.Rules.Actors.Any(a => a.Value.HasTraitInfo <ITemporaryBlockerInfo>());
            gameSettings = Game.Settings.Game;
        }
Пример #12
0
 public BaseController(IUserServices userServices,
                       IAccountServices accountServices,
                       ICategoryServices categoryServices,
                       ITransactionServices transactionServices,
                       IBudgetServices budgetServices,
                       IHttpContextProvider context,
                       ISiteConfiguration config,
                       IUrlHelper urlHelper,
                       IModelCache cache,
                       ICachingHelpers cachingHelpers)
 {
     _userServices = userServices;
     _accountServices = accountServices;
     _categoryServices = categoryServices;
     _transactionServices = transactionServices;
     _budgetServices = budgetServices;
     _context = context;
     _config = config;
     _url = urlHelper;
     _cache = cache;
     _cachingHelpers = cachingHelpers;
 }
 public CachingTransactionServices(ITransactionServices nonCachingTransactionServices, IModelCache cache, ICachingHelpers helpers)
     : base(cache, helpers)
 {
     _transactionServices = nonCachingTransactionServices;
 }
Пример #14
0
        public ModelMapperProfile(IModelCache modelCache)
        {
            ModelCache = modelCache;
            CreateMap <MappableDTO, MappableModel>()
            .BeforeMap((src, dest) => dest?.InitReset())
            .ForMember(dest => dest.LastUpdate, opt => opt.MapFrom((src, trg) => DateTime.Now))
            .ForMember(dest => dest.IsExpired, opt => opt.MapFrom((src, trg) => false))
            .AfterMap((src, dest) => dest?.ResetChangedState())
            .IncludeAllDerived();

            // Mapping Season data
            CreateMap <SeasonDataDTO, SeasonModel>()
            .EqualityComparison((src, dest) => src.SeasonId == dest.SeasonId)
            .ConstructUsing(source => ModelCache.PutOrGetModel(new SeasonModel(source.SeasonId)))
            .AfterMap((src, dest) =>
            {
                CurrentSchedules = null;
                dest.InitReset();
            })
            .ReverseMap();
            CreateMap <SeasonInfoDTO, SeasonModel>()
            .EqualityComparison((src, dest) => src.SeasonId == dest.SeasonId)
            .ConstructUsing(source => ModelCache.PutOrGetModel(new SeasonModel(source.SeasonId)))
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .ReverseMap();

            // Mapping League member data
            CreateMap <LeagueMemberDataDTO, LeagueMember>()
            .ConstructUsing(source => (source != null) ? ModelCache.PutOrGetModel(new LeagueMember(source.MemberId.GetValueOrDefault())) : null)
            .ReverseMap();
            CreateMap <LeagueMemberInfoDTO, LeagueMember>()
            .ConvertUsing(source => (source != null) ? ModelCache.PutOrGetModel(new LeagueMember(source.MemberId.GetValueOrDefault())) : null);
            //.ConstructUsing(source => new LeagueMember(source.MemberId));
            CreateMap <LeagueMember, LeagueMemberInfoDTO>();

            CreateMap <TeamDataDTO, TeamModel>()
            .ConstructUsing(source => (source != null) ? ModelCache.PutOrGetModel(new TeamModel()
            {
                TeamId = source.TeamId
            }) : null)
            .ForMember(dest => dest.Members, opt => opt.MapFrom((src, dest, members) =>
            {
                return(new ObservableCollection <LeagueMember>(src.MemberIds.Select(x => ModelCache.PutOrGetModel(new LeagueMember(x)))));
            }))
            .ReverseMap()
            .ForMember(dest => dest.MemberIds, opt => opt.MapFrom((src, dest, members) =>
            {
                return(src.Members.Select(x => x.MemberId.GetValueOrDefault()).ToArray());
            }));

            // Mapping incident data
            CreateMap <IncidentReviewDataDTO, IncidentReviewModel>()
            .ConstructUsing(source => ModelCache.PutOrGetModel(new IncidentReviewModel(source.ReviewId)))
            .EqualityComparison((src, dest) => src.ReviewId == dest.ReviewId)
            .IncludeBase <IncidentReviewInfoDTO, IncidentReviewInfo>()
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .ReverseMap()
            .IncludeBase <IncidentReviewInfo, IncidentReviewInfoDTO>();
            CreateMap <IncidentReviewInfoDTO, IncidentReviewInfo>()
            //.ConstructUsing(source => new IncidentReviewInfo() { ReviewId = source.ReviewId })
            .ConstructUsing(source => Test(source))
            .EqualityComparison((src, dest) => src.ReviewId == dest.ReviewId)
            .ForMember(dest => dest.Author, opt => opt.MapFrom((src, dest, author) =>
            {
                if (dest.Author != null && dest.Author.UserId == src.AuthorUserId)
                {
                    return(dest.Author);
                }

                return(LeagueContext.UserManager.GetUserModel(src.AuthorUserId));
            }))
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .ReverseMap()
            .ForMember(dest => dest.AuthorUserId, opt => opt.MapFrom(src => src.Author != null ? src.Author.UserId : null));

            // Mapping comment data
            CreateMap <ReviewCommentDataDTO, ReviewCommentModel>()
            .ConstructUsing(source => ModelCache.PutOrGetModel(new ReviewCommentModel(source.CommentId.GetValueOrDefault(), source.AuthorName)))
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .IncludeAllDerived()
            .ReverseMap();
            CreateMap <CommentDataDTO, CommentModel>()
            .ConstructUsing(source => ModelCache.PutOrGetModel(new CommentModel(source.CommentId.GetValueOrDefault(), source.AuthorName)))
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .IncludeAllDerived()
            .ReverseMap();
            CreateMap <CommentInfoDTO, CommentInfo>()
            //.ConstructUsing(source => ModelCache.PutOrGetModel(new CommentBase(source.CommentId.GetValueOrDefault(), source.AuthorName)))
            .ConstructUsing(source => new CommentInfo(source.CommentId, source.AuthorName))
            .ForMember(dest => dest.Author, opt => opt.MapFrom((src, dest, author) =>
            {
                if (dest.Author != null && dest.Author.UserId == src.AuthorUserId)
                {
                    return(dest.Author);
                }

                return(LeagueContext.UserManager.GetUserModel(src.AuthorUserId));
            }))
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .IncludeAllDerived()
            .ReverseMap()
            .ForMember(dest => dest.AuthorUserId, opt => opt.MapFrom(src => src.Author != null ? src.Author.UserId : null))
            .ForMember(dest => dest.AuthorName, opt => opt.MapFrom(src => src.Author != null ? src.Author.UserName : src.AuthorName));
            //.IncludeAllDerived();

            // Mapping schedule data
            CreateMap <ScheduleDataDTO, ScheduleModel>()
            .BeforeMap((src, dest) =>
            {
                if (CurrentSchedules == null)
                {
                    CurrentSchedules = new ScheduleModel[0];
                }
                //CurrentSessions = dest?.Sessions;
            })
            //.ForMember(dest => dest.Season, opt => opt.Ignore())
            .EqualityComparison((src, dest) => src.ScheduleId == dest.ScheduleId)
            .ConstructUsing(source => ModelCache.PutOrGetModel(new ScheduleModel(source.ScheduleId)))
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
                CurrentSessions = null;
                SortObservableCollection(dest.Sessions, x => x.Date);
                int i = 1;
                foreach (var race in dest.Sessions.Where(x => x.SessionType == SessionType.Race).Cast <RaceSessionModel>())
                {
                    race.RaceId = i;
                    i++;
                }
            })
            .ReverseMap();
            //CreateMap<ScheduleInfoDTO, ScheduleModel>()
            //    .EqualityComparison((src, dest) => src.ScheduleId == dest.ScheduleId)
            //    .ConstructUsing(source => new ScheduleModel(source.ScheduleId))
            //    .AfterMap((src, dest) =>
            //    {
            //        dest.InitReset();
            //    })
            //    .ReverseMap()
            //    .As<ScheduleDataDTO>();
            CreateMap <ScheduleInfoDTO, ScheduleInfo>()
            .EqualityComparison((src, dest) => src.ScheduleId == dest.ScheduleId)
            .ReverseMap()
            .IncludeAllDerived();

            // Mapping session data
            CreateMap <SessionDataDTO, SessionModel>()
            .BeforeMap((src, dest) =>
            {
                if (CurrentSessions == null)
                {
                    CurrentSessions = new SessionModel[0];
                }
            })
            //.ForMember(dest => dest.Season, opt => opt.Ignore())
            //.ForMember(dest => dest.Schedule, opt => opt.Ignore())
            //.ForMember(dest => dest.Location, opt => opt.MapFrom(src => src.LocationId))
            .EqualityComparison((src, dest) => src.SessionId == dest.SessionId)
            //.ConstructUsing(source => (source.SessionType == SessionType.Race) ? new RaceSessionModel(source.SessionId) : new SessionModel(source.SessionId, source.SessionType))
            .ConstructUsing(source => ModelCache.PutOrGetModel(new SessionModel(source.SessionId, source.SessionType)))
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .Include <RaceSessionDataDTO, RaceSessionModel>();
            CreateMap <RaceSessionDataDTO, RaceSessionModel>()
            .BeforeMap((src, dest) =>
            {
                if (CurrentSessions == null)
                {
                    CurrentSessions = new SessionModel[0];
                }
            })
            //.ForMember(dest => dest.Season, opt => opt.Ignore())
            //.ForMember(dest => dest.Schedule, opt => opt.Ignore())
            //.ForMember(dest => dest.Location, opt => opt.MapFrom(src => src.LocationId))
            .EqualityComparison((src, dest) => src.SessionId == dest.SessionId)
            .ConstructUsing(source => ModelCache.PutOrGetModel(new RaceSessionModel(source.SessionId, source.RaceId)))
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            });
            CreateMap <SessionModel, SessionDataDTO>()
            //.ForMember(dest => dest.LocationId, opt => opt.MapFrom(source => source.Location))
            .Include <RaceSessionModel, RaceSessionDataDTO>();
            CreateMap <RaceSessionModel, RaceSessionDataDTO>();
            //.ForMember(dest => dest.LocationId, opt => opt.MapFrom(source => source.Location));
            CreateMap <SessionInfoDTO, SessionInfo>()
            //.BeforeMap((src, dest) =>
            //{
            //    if (CurrentSessions == null)
            //    {
            //        CurrentSessions = new SessionInfo[0];
            //    }
            //})
            .ConstructUsing(source => new SessionInfo(source.SessionId, source.SessionType))
            .ReverseMap();

            // Mapping result data
            CreateMap <ResultDataDTO, ResultModel>()
            .ConstructUsing(source => ModelCache.PutOrGetModel(new ResultModel(source.ResultId.GetValueOrDefault())))
            .EqualityComparison((src, dest) => src.ResultId == dest.ResultId)
            .ReverseMap();
            CreateMap <ResultInfoDTO, ResultInfo>()
            .ConstructUsing(source => new ResultInfo(source.ResultId.GetValueOrDefault()))
            .ReverseMap()
            .Include <ResultModel, ResultDataDTO>();

            CreateMap <ResultRowDataDTO, ResultRowModel>()
            .ConstructUsing(source => ModelCache.PutOrGetModel(new ResultRowModel(source.ResultRowId)))
            .ForMember(dest => dest.Location, opt => opt.MapFrom((src, trg) => LeagueContext.Locations.FirstOrDefault(x => x.LocationId == src.LocationId)))
            .EqualityComparison((src, dest) => src.ResultRowId == dest.ResultRowId)
            .ReverseMap();

            CreateMap <ScoringDataDTO, ScoringModel>()
            .ConstructUsing(source => ModelCache.PutOrGetModel(new ScoringModel(source.ScoringId)))
            .EqualityComparison((src, dest) => src.ScoringId == dest.ScoringId)
            .ForMember(dest => dest.BasePoints, opt => opt.MapFrom((src, dest, result) =>
            {
                if (src.BasePoints == null || src.BasePoints == "" || src.BasePoints == " ")
                {
                    return(new ObservableCollection <ScoringModel.BasePointsValue>());
                }
                string[] pointString = src.BasePoints.Split(' ');
                ObservableCollection <ScoringModel.BasePointsValue> pairs = new ObservableCollection <ScoringModel.BasePointsValue>();
                for (int i = 0; i < pointString.Count(); i++)
                {
                    pairs.Add(new ScoringModel.BasePointsValue(i + 1, int.Parse(pointString[i])));
                }
                return(pairs);
            }))
            .ForMember(dest => dest.BonusPoints, opt => opt.MapFrom((src, dest, result) =>
            {
                if (src.BonusPoints == null || src.BonusPoints == "" || src.BonusPoints == " ")
                {
                    return(new ObservableCollection <ScoringModel.BonusPointsValue>());
                }
                string[] pointString = src.BonusPoints.Split(' ');
                ObservableCollection <ScoringModel.BonusPointsValue> pairs = new ObservableCollection <ScoringModel.BonusPointsValue>();
                for (int i = 0; i < pointString.Count(); i++)
                {
                    var stringPair = pointString[i].Split(':');
                    pairs.Add(new ScoringModel.BonusPointsValue(stringPair.First(), int.Parse(stringPair.Last())));
                }
                return(pairs);
            }))
            .ForMember(dest => dest.IncPenaltyPoints, opt => opt.Ignore())
            .ReverseMap()
            .ForMember(dest => dest.BasePoints, opt => opt.MapFrom(src => (src.BasePoints.Count > 0) ? src.BasePoints.Select(x => x.Value.ToString()).Aggregate((x, y) => x + " " + y) : ""))
            .ForMember(dest => dest.BonusPoints, opt => opt.MapFrom(src => (src.BonusPoints.Count > 0) ? src.BonusPoints.Select(x => x.Key + ":" + x.Value.ToString()).Aggregate((x, y) => x + " " + y) : ""))
            .ForMember(dest => dest.IncPenaltyPoints, opt => opt.Ignore());
            CreateMap <ScoringInfoDTO, ScoringModel>()
            .ConstructUsing(source => ModelCache.PutOrGetModel(new ScoringModel(source.ScoringId)))
            .EqualityComparison((src, dest) => src.ScoringId == dest.ScoringId)
            .ForAllMembers(opt => opt.Ignore());
            CreateMap <ScoringModel, ScoringInfoDTO>();
            CreateMap <ScoringInfoDTO, ScoringInfo>()
            .ConstructUsing(source => new ScoringInfo(source.ScoringId))
            .EqualityComparison((src, dest) => src.ScoringId == dest.ScoringId)
            .ReverseMap();
            CreateMap <ScoringTableDataDTO, ScoringTableModel>()
            .ConstructUsing(source => ModelCache.PutOrGetModel(new ScoringTableModel()
            {
                ScoringTableId = source.ScoringTableId
            }))
            .EqualityComparison((src, dest) => src.ScoringTableId == dest.ScoringTableId)
            .ForMember(dest => dest.Scorings, opt => opt.MapFrom((src, dest, result, context) =>
            {
                List <double> factors = new List <double>();
                bool success          = true;
                if (src.ScoringFactors != null)
                {
                    var factorStrings = src.ScoringFactors.Replace(',', '.').Split(';');
                    foreach (var factorString in factorStrings)
                    {
                        if (double.TryParse(factorString, System.Globalization.NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out double factor))
                        {
                            factors.Add(factor);
                        }
                        else
                        {
                            success = false;
                            break;
                        }
                    }
                }

                if (factors.Count() == 0 || success == false)
                {
                    factors = src.Scorings.Select(x => (double)1).ToList();
                }

                var mapper            = context.Mapper;
                var destMultiScorings = src.Scorings.Select((x, i) => new MyKeyValuePair <ScoringInfo, double>(mapper.Map <ScoringModel>(x), factors.ElementAt(i)));
                return(new ObservableCollection <MyKeyValuePair <ScoringInfo, double> >(destMultiScorings));
            }))
            .ReverseMap()
            .ForMember(dest => dest.ScoringFactors, opt => opt.MapFrom((src, dest, factors) =>
            {
                if (src.Scorings?.Count > 0)
                {
                    return(src.Scorings.Select(x => x.Value.ToString()).Aggregate((x, y) => x + ";" + y));
                }
                return(null);
            }))
            .ForMember(dest => dest.Scorings, opt => opt.MapFrom((src, dest, scorings) =>
            {
                if (src.Scorings?.Count > 0)
                {
                    return(src.Scorings.Select(x => x.Key).ToArray());
                }
                return(new ScoringInfo[0]);
            }));
            CreateMap <ScoredResultRowDataDTO, ScoredResultRowModel>()
            //.ConstructUsing(source => ModelCache.PutOrGetModel(new ScoredResultRowModel() { ScoredResultRowId = source.ScoredResultRowId}))
            .ConstructUsing(source => new ScoredResultRowModel()
            {
                ScoredResultRowId = source.ScoredResultRowId
            })
            .ForMember(dest => dest.Location, opt => opt.MapFrom((src, trg) => LeagueContext.Locations.FirstOrDefault(x => x.LocationId == src.LocationId)))
            .EqualityComparison((src, dest) => src.ScoredResultRowId == dest.ScoredResultRowId)
            .IncludeBase <ResultRowDataDTO, ResultRowModel>();
            //.EqualityComparison((src, dest) => src.ScoredResultRowId == dest.ScoredResultRowId)

            CreateMap <ScoredResultDataDTO, ScoredResultModel>()
            .ConstructUsing(source => ModelCache.PutOrGetModel(new ScoredResultModel()
            {
                Scoring = new ScoringInfo(source.Scoring.ScoringId), ResultId = source.ResultId
            }))
            .EqualityComparison((src, dest) => src.Session.SessionId == dest.Session.SessionId && src.Scoring.ScoringId == dest.Scoring.ScoringId)
            .Include <ScoredTeamResultDataDTO, ScoredTeamResultModel>()
            //.AfterMap((src, dest) => dest.FinalResults = new ObservableCollection<ScoredResultRowModel>(dest.FinalResults.OrderBy(x => x.FinalPosition)))
            //.ForMember(dest => dest.FinalResults, opt => opt.MapFrom(src => src.ScoredResults))
            ;

            CreateMap <ScoredTeamResultDataDTO, ScoredTeamResultModel>()
            .ConstructUsing(source => ModelCache.PutOrGetModel(new ScoredTeamResultModel()
            {
                Scoring = new ScoringInfo(source.Scoring.ScoringId), ResultId = source.ResultId
            }))
            .EqualityComparison((src, dest) => src.Session.SessionId == dest.Session.SessionId && src.Scoring.ScoringId == dest.Scoring.ScoringId)
            .ForMember(dest => dest.TeamResults, opt => opt.MapFrom((src, trg) => src.TeamResults.OrderBy(x => x.FinalPosition)));

            CreateMap <ScoredTeamResultRowDataDTO, ScoredTeamResultRowModel>()
            .ConstructUsing(source => new ScoredTeamResultRowModel()
            {
                ScoredResultRowId = source.ScoredResultRowId
            })
            .EqualityComparison((src, dest) => src.ScoredResultRowId == dest.ScoredResultRowId)
            .ForMember(dest => dest.Team, opt => opt.MapFrom((src, dst) =>
            {
                return(modelCache.PutOrGetModel(new TeamModel()
                {
                    TeamId = src.TeamId
                }));
            }));

            CreateMap <StandingsDataDTO, StandingsModel>()
            .ConstructUsing(source => ModelCache.PutOrGetModel(new StandingsModel()
            {
                ScoringTableId = source.ScoringTableId, SessionId = source.SessionId
            }))
            .EqualityComparison((src, dest) => src.ScoringTableId == dest.ScoringTableId)
            .Include <TeamStandingsDataDTO, TeamStandingsModel>();
            CreateMap <StandingsRowDataDTO, StandingsRowModel>()
            //.ConstructUsing(source => ModelCache.PutOrGetModel(new StandingsRowModel() { Scoring = new ScoringInfo(source.Scoring.ScoringId), Member = new LeagueMember(source.Member.MemberId) }))
            .ConstructUsing(source => new StandingsRowModel())
            .EqualityComparison((src, dest) => src.Member.MemberId == dest.Member.MemberId)
            .Include <TeamStandingsRowDataDTO, TeamStandingsRowModel>();

            CreateMap <TeamStandingsDataDTO, TeamStandingsModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new TeamStandingsModel()
            {
                ScoringTableId = source.ScoringTableId, SessionId = source.SessionId
            }))
            .EqualityComparison((src, dest) => src.ScoringTableId == dest.ScoringTableId);
            CreateMap <TeamStandingsRowDataDTO, TeamStandingsRowModel>()
            .ConstructUsing(source => new TeamStandingsRowModel())
            .ForMember(dest => dest.Team, opt => opt.MapFrom((src, dst) =>
            {
                return(modelCache.PutOrGetModel(new TeamModel()
                {
                    TeamId = src.TeamId
                }));
            }))
            .EqualityComparison((src, dest) => src.TeamId == dest.Team.TeamId);

            CreateMap <AddPenaltyDTO, AddPenaltyModel>()
            .ConstructUsing(source => ModelCache.PutOrGetModel(new AddPenaltyModel(source.ScoredResultRowId)))
            .EqualityComparison((src, dest) => src.ScoredResultRowId == dest.ScoredResultRowId)
            .ReverseMap();

            //CreateMap<LeagueUserDTO, UserModel>()
            //    .ConstructUsing(source => ModelCache.PutOrGetModel(new UserModel(source.AdminId)))
            //    .EqualityComparison((src, dest) => src.AdminId == dest.UserId);

            CreateMap <UserDTO, UserModel>()
            .ConstructUsing(src => ModelCache.PutOrGetModel(new UserModel(src.UserId)));
            //.ForMember(dest => dest.Admin, opt => opt.MapFrom(src => src));
            CreateMap <UserModel, UserDTO>();

            CreateMap <ReviewVoteDataDTO, ReviewVoteModel>()
            .ConstructUsing(src => new ReviewVoteModel()
            {
                ReviewVoteId = src.ReviewVoteId
            })
            .EqualityComparison((src, dest) => src.ReviewVoteId == dest.ReviewVoteId)
            .ForMember(dest => dest.VoteCategory, opt => opt
                       .MapFrom(src => src.VoteCategoryId != null ? ModelCache.PutOrGetModel(new VoteCategoryModel()
            {
                CatId = src.VoteCategoryId.Value
            }) : null))
            .ReverseMap()
            .ForMember(dest => dest.VoteCategoryId, opt => opt.MapFrom(src => src.VoteCategory != null ? src.VoteCategory.CatId : (long?)null));

            //.ForMember(dest => dest.AdminId, opt => opt.MapFrom(src => (src.Admin != null) ? (int?)src.Admin.AdminId : null))
            //.ForMember(dest => dest.IsOwner, opt => opt.MapFrom(src => (src.Admin != null) ? (bool?)src.Admin.IsOwner : null))
            //.ForMember(dest => dest.LeagueName, opt => opt.MapFrom(src => (src.Admin != null) ? src.Admin.LeagueName : null))
            //.ForMember(dest => dest.Rights, opt => opt.MapFrom(src => (src.Admin != null) ? src.Admin.Rights : 0));

            //CreateMap<UserDTO, AdminModel>()
            //    .ConstructUsing(src => (LeagueContext.CurrentUser.Admin.AdminId == src.AdminId) ? LeagueContext.CurrentUser.Admin : new AdminModel((src.AdminId == null) ? 0 : (int)src.AdminId));
            CreateMap <TimeSpan, LapTime>()
            .ConvertUsing <LapTimeConverter>();
            CreateMap <TimeSpan, LapInterval>()
            .ConvertUsing <LapIntervalConverter>();

            CreateMap <LapTime, TimeSpan>()
            .ConvertUsing <LapTimeConverter>();
            CreateMap <LapInterval, TimeSpan>()
            .ConvertUsing <LapIntervalConverter>();

            CreateMap <VoteCategoryDTO, VoteCategoryModel>()
            .ConstructUsing(src => ModelCache.PutOrGetModel(new VoteCategoryModel()
            {
                CatId = src.CatId
            }))
            .EqualityComparison((src, dest) => src.CatId == dest.CatId)
            .ReverseMap();

            CreateMap <CustomIncidentDTO, CustomIncidentModel>()
            .ConstructUsing(src => ModelCache.PutOrGetModel(new CustomIncidentModel()
            {
                IncidentId = src.IncidentId
            }))
            .EqualityComparison((src, dest) => src.IncidentId == dest.IncidentId)
            .ReverseMap();

            CreateMap <ReviewPenaltyDTO, ReviewPenaltyModel>()
            .ConstructUsing(src => ModelCache.PutOrGetModel(new ReviewPenaltyModel()
            {
                ResultRowId = src.ResultRowId, ReviewId = src.ReviewId
            }))
            .EqualityComparison((src, dest) => src.ResultRowId == dest.ResultRowId && src.ReviewId == dest.ReviewId)
            .ReverseMap();

            CreateMap <ResultsFilterOptionDTO, ResultsFilterOptionModel>()
            .ConstructUsing(src => ModelCache.PutOrGetModel(new ResultsFilterOptionModel(src.ResultsFilterId, src.ScoringId)))
            .EqualityComparison((src, dest) => src.ResultsFilterId == dest.ResultsFilterId)
            .ForMember(dest => dest.FilterValues, opt => opt.MapFrom((src, dest, destMember, context) =>
            {
                var targetColumnProperty = typeof(ResultRowModel).GetNestedPropertyInfo(dest.ColumnPropertyName);
                var sourceColumnProperty = typeof(ResultRowDataDTO).GetNestedPropertyInfo(src.ColumnPropertyName);
                var targetPropertyType   = targetColumnProperty.PropertyType;
                var sourcePropertyType   = sourceColumnProperty.PropertyType;
                return(new ObservableCollection <FilterValueModel>(src.FilterValues?
                                                                   .Select(x => new FilterValueModel(targetPropertyType, targetPropertyType.Equals(sourcePropertyType) == false ? context.Mapper.Map(x, sourcePropertyType, targetPropertyType) : x))
                                                                   ?? new FilterValueModel[0]));
            }))
            .ReverseMap()
            .ForMember(dest => dest.FilterValues, opt => opt.MapFrom((src, dest, destMember, context) =>
            {
                var targetColumnProperty = typeof(ResultRowDataDTO).GetNestedPropertyInfo(dest.ColumnPropertyName);
                var sourceColumnProperty = typeof(ResultRowModel).GetNestedPropertyInfo(src.ColumnPropertyName);
                var targetPropertyType   = targetColumnProperty.PropertyType;
                var sourcePropertyType   = sourceColumnProperty.PropertyType;
                return(src.FilterValues?
                       .Select(x => targetPropertyType.Equals(sourcePropertyType) == false ? context.Mapper.Map(x.Value, sourcePropertyType, targetPropertyType) : x.Value)
                       .ToArray()
                       ?? new object[0]);
            }));
        }
Пример #15
0
 public ModelManager(IModelCache modelCache, IModelDataProvider modelDataProvider, IConfigurationProvider mapperConfiguration)
 {
     ModelCache = modelCache;
     ModelDataProvider = modelDataProvider;
     MapperConfiguration = mapperConfiguration as MapperConfiguration;
 }
Пример #16
0
 public LeagueMember GetLeagueMember(long?memberId, IModelCache modelCache)
 {
     return(memberId != null?modelCache.PutOrGetModel(new LeagueMember(memberId)) : null);
 }
 public CachingBudgetServices(IBudgetServices nonCachingBudgetServices, IModelCache cache, ICachingHelpers helpers)
     : base(cache, helpers)
 {
     _budgetServices = nonCachingBudgetServices;
 }
 public CachingTagServices(ITagServices nonCachingTagServices, IModelCache cache, ICacheConfigurationInfo config)
 {
     _tagServices = nonCachingTagServices;
     _cache = cache;
     _config = config;
 }
Пример #19
0
        public ModelMapperProfile(IModelCache modelCache)
        {
            CreateMap <MappableDTO, MappableModel>()
            .BeforeMap((src, dest) => dest?.InitReset())
            .ForMember(dest => dest.LastUpdate, opt => opt.MapFrom((src, trg) => DateTime.Now))
            .ForMember(dest => dest.IsExpired, opt => opt.MapFrom((src, trg) => false))
            .AfterMap((src, dest) => dest?.ResetChangedState())
            .IncludeAllDerived();

            // Mapping Season data
            CreateMap <SeasonDataDTO, SeasonModel>()
            .EqualityComparison((src, dest) => src.SeasonId == dest.SeasonId)
            .ConstructUsing(source => modelCache.PutOrGetModel(new SeasonModel(source.SeasonId)))
            .ForMember(dest => dest.Schedules, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.Scorings, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.ScoringTables, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.SeasonStatisticSets, opt => opt.MapFrom(src => src.SeasonStatisticSetIds.Select(x => new StatisticSetInfo()
            {
                Id = x
            })))
            .AfterMap((src, dest) =>
            {
                CurrentSchedules = null;
                dest.InitReset();
            })
            .ReverseMap();
            CreateMap <SeasonInfoDTO, SeasonModel>()
            .EqualityComparison((src, dest) => src.SeasonId == dest.SeasonId)
            .ConstructUsing(source => modelCache.PutOrGetModel(new SeasonModel(source.SeasonId)))
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .ReverseMap();

            // Mapping League member data
            CreateMap <LeagueMemberDataDTO, LeagueMember>()
            .ConstructUsing(source => (source != null) ? modelCache.PutOrGetModel(new LeagueMember(source.MemberId.GetValueOrDefault())) : null)
            .ReverseMap();
            CreateMap <LeagueMemberInfoDTO, LeagueMember>()
            .ConvertUsing(source => (source != null) ? modelCache.PutOrGetModel(new LeagueMember(source.MemberId.GetValueOrDefault())) : null);
            //.ConstructUsing(source => new LeagueMember(source.MemberId));
            CreateMap <LeagueMember, LeagueMemberInfoDTO>();

            CreateMap <TeamDataDTO, TeamModel>()
            .ConstructUsing(source => (source != null) ? modelCache.PutOrGetModel(new TeamModel()
            {
                TeamId = source.TeamId
            }) : null)
            //.ForMember(dest => dest.Members, opt => opt.MapFrom((src, dest, members) =>
            //{
            //    return new ObservableCollection<LeagueMember>(src.MemberIds.Select(x => ModelCache.PutOrGetModel(new LeagueMember(x))));
            //}))
            .ForMember(dest => dest.Members, opt => opt.MapFrom(src => src.MemberIds))
            .ForMember(dest => dest.Members, opt => opt.UseDestinationValue())
            .ReverseMap()
            .ForMember(dest => dest.MemberIds, opt => opt.MapFrom((TeamModel src, TeamDataDTO dest, long[] members) =>
            {
                return(src.Members.Select(x => x.MemberId.GetValueOrDefault()).ToArray());
            }));

            CreateMap <long, LeagueMember>()
            .ConvertUsing((src, dest) => GetLeagueMember(src, modelCache));

            // Mapping incident data
            CreateMap <IncidentReviewDataDTO, IncidentReviewModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new IncidentReviewModel(source.ReviewId)))
            .ForMember(dest => dest.InvolvedMembers, opt => opt.MapFrom(src => src.InvolvedMemberIds.Select(x => GetLeagueMember(x, modelCache))))
            .ForMember(dest => dest.InvolvedMembers, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.Comments, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.AcceptedReviewVotes, opt => opt.UseDestinationValue())
            .EqualityComparison((src, dest) => src.ReviewId == dest.ReviewId)
            .IncludeBase <IncidentReviewInfoDTO, IncidentReviewInfo>()
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .ReverseMap()
            .ForMember(dest => dest.InvolvedMemberIds, opt => opt.MapFrom(src => src.InvolvedMembers.Select(x => x.MemberId)))
            .IncludeBase <IncidentReviewInfo, IncidentReviewInfoDTO>();
            CreateMap <IncidentReviewInfoDTO, IncidentReviewInfo>()
            //.ConstructUsing(source => new IncidentReviewInfo() { ReviewId = source.ReviewId })
            .ConstructUsing(source => Test(source))
            .EqualityComparison((src, dest) => src.ReviewId == dest.ReviewId)
            .ForMember(dest => dest.Author, opt => opt.MapFrom((src, dest, author) =>
            {
                if (dest.Author != null && dest.Author.UserId == src.AuthorUserId)
                {
                    return(dest.Author);
                }

                return(LeagueContext.UserManager.GetUserModel(src.AuthorUserId));
            }))
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .ReverseMap()
            .ForMember(dest => dest.AuthorUserId, opt => opt.MapFrom(src => src.Author != null ? src.Author.UserId : null));

            // Mapping comment data
            CreateMap <ReviewCommentDataDTO, ReviewCommentModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new ReviewCommentModel(source.CommentId.GetValueOrDefault(), source.AuthorName)))
            .EqualityComparison((src, dest) => src.CommentId == dest.CommentId)
            .ForMember(dest => dest.CommentReviewVotes, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.Replies, opt => opt.UseDestinationValue())
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .IncludeAllDerived()
            .ReverseMap();
            CreateMap <CommentDataDTO, CommentModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new CommentModel(source.CommentId.GetValueOrDefault(), source.AuthorName)))
            .EqualityComparison((src, dest) => src.CommentId == dest.CommentId)
            .ForMember(dest => dest.Replies, opt => opt.UseDestinationValue())
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .IncludeAllDerived()
            .ReverseMap();
            CreateMap <CommentInfoDTO, CommentInfo>()
            //.ConstructUsing(source => ModelCache.PutOrGetModel(new CommentBase(source.CommentId.GetValueOrDefault(), source.AuthorName)))
            .ConstructUsing(source => new CommentInfo(source.CommentId, source.AuthorName))
            .EqualityComparison((src, dest) => src.CommentId == dest.CommentId)
            .ForMember(dest => dest.Author, opt => opt.MapFrom((src, dest, author) =>
            {
                if (dest.Author != null && dest.Author.UserId == src.AuthorUserId)
                {
                    return(dest.Author);
                }

                return(LeagueContext.UserManager.GetUserModel(src.AuthorUserId));
            }))
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .IncludeAllDerived()
            .ReverseMap()
            .ForMember(dest => dest.AuthorUserId, opt => opt.MapFrom(src => src.Author != null ? src.Author.UserId : null))
            .ForMember(dest => dest.AuthorName, opt => opt.MapFrom(src => src.Author != null ? src.Author.UserName : src.AuthorName));
            //.IncludeAllDerived();

            // Mapping schedule data
            CreateMap <ScheduleDataDTO, ScheduleModel>()
            .BeforeMap((src, dest) =>
            {
                if (CurrentSchedules == null)
                {
                    CurrentSchedules = new ScheduleModel[0];
                }
                //CurrentSessions = dest?.Sessions;
            })
            //.ForMember(dest => dest.Season, opt => opt.Ignore())
            .EqualityComparison((src, dest) => src.ScheduleId == dest.ScheduleId)
            .ForMember(dest => dest.Sessions, opt => opt.UseDestinationValue())
            .ConstructUsing(source => modelCache.PutOrGetModel(new ScheduleModel(source.ScheduleId)))
            //.ForMember(dest => dest.Sessions, opt => opt.MapFrom((src, dest, target, context) => context.Mapper.Map(src.Sessions, dest.Sessions)))
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
                CurrentSessions = null;
                SortObservableCollection(dest.Sessions, x => x.Date);
                int i = 1;
                foreach (var race in dest.Sessions.Where(x => x.SessionType == SessionType.Race || x.SessionType == SessionType.HeatEvent).OfType <RaceSessionModel>())
                {
                    race.RaceId = i;
                    i++;
                }
            })
            .ReverseMap();

            CreateMap <ScheduleInfoDTO, ScheduleInfo>()
            .EqualityComparison((src, dest) => src.ScheduleId == dest.ScheduleId)
            .ReverseMap()
            .IncludeAllDerived();

            // Mapping session data
            CreateMap <SessionDataDTO, SessionModel>()
            .BeforeMap((src, dest) =>
            {
                if (CurrentSessions == null)
                {
                    CurrentSessions = new SessionModel[0];
                }
            })
            .EqualityComparison((src, dest) => src.SessionId == dest.SessionId)
            //.ConstructUsing(source => (source.SessionType == SessionType.Race) ? new RaceSessionModel(source.SessionId) : new SessionModel(source.SessionId, source.SessionType))
            .ConstructUsing(source => modelCache.PutOrGetModel(new SessionModel(source.SessionId, source.SessionType)))
            .ForMember(dest => dest.ParentSession, opt => opt.MapFrom(src => src.ParentSessionId != null ? modelCache.GetModel <SessionModel>(src.ParentSessionId.Value) : null))
            .ForMember(dest => dest.SessionResult, opt => opt.MapFrom(src => src.SessionResultId != null ? new ResultInfo(src.SessionResultId) : null))
            .ForMember(dest => dest.Reviews, opt => opt.MapFrom(src => src.ReviewIds.Select(x => new IncidentReviewInfo()
            {
                ReviewId = x
            })))
            .ForMember(dest => dest.Reviews, opt => opt.UseDestinationValue())
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            })
            .Include <RaceSessionDataDTO, RaceSessionModel>();
            CreateMap <RaceSessionDataDTO, RaceSessionModel>()
            .BeforeMap((src, dest) =>
            {
                if (CurrentSessions == null)
                {
                    CurrentSessions = new SessionModel[0];
                }
            })
            .EqualityComparison((src, dest) => src.SessionId == dest.SessionId)
            .ForMember(dest => dest.Reviews, opt => opt.UseDestinationValue())
            .ConstructUsing(source => modelCache.PutOrGetModel(new RaceSessionModel(source.SessionId, source.RaceId)))
            //.ForMember(dest => dest.Reviews, opt => opt.UseDestinationValue())
            .AfterMap((src, dest) =>
            {
                dest.InitReset();
            });
            CreateMap <SessionModel, SessionDataDTO>()
            //.ForMember(dest => dest.LocationId, opt => opt.MapFrom(source => source.Location))
            .ForMember(dest => dest.SessionResultId, opt => opt.MapFrom(src => src.SessionResult != null ? src.SessionResult.ResultId : null))
            .ForMember(dest => dest.ReviewIds, opt => opt.MapFrom(src => src.Reviews.Select(x => x.ReviewId.GetValueOrDefault())))
            .Include <RaceSessionModel, RaceSessionDataDTO>();
            CreateMap <RaceSessionModel, RaceSessionDataDTO>();
            //.ForMember(dest => dest.LocationId, opt => opt.MapFrom(source => source.Location));
            CreateMap <SessionInfoDTO, SessionInfo>()
            .ConstructUsing(source => new SessionInfo(source.SessionId, source.SessionType))
            .ReverseMap();

            //Mapping result data
            CreateMap <ResultDataDTO, ResultModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new ResultModel(source.ResultId.GetValueOrDefault())))
            .EqualityComparison((src, dest) => src.ResultId == dest.ResultId)
            .ForMember(dest => dest.Session, opt => opt.MapFrom(src => new SessionInfo(src.SessionId, SessionType.Undefined)))
            .ForMember(dest => dest.RawResults, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.Reviews, opt => opt.MapFrom(src => src.ReviewIds.Select(x => new IncidentReviewInfo()
            {
                ReviewId = x
            })))
            .ForMember(dest => dest.Reviews, opt => opt.UseDestinationValue())
            .ReverseMap()
            .ForMember(dest => dest.SessionId, opt => opt.MapFrom(src => src.Session.SessionId))
            .ForMember(dest => dest.ReviewIds, opt => opt.MapFrom(src => src.Reviews.Select(x => x.ReviewId.GetValueOrDefault())));

            CreateMap <SimSessionDetailsDTO, SimSessionDetails>()
            .ReverseMap();

            CreateMap <ResultInfoDTO, ResultInfo>()
            .ConstructUsing(source => new ResultInfo(source.ResultId.GetValueOrDefault()))
            .ReverseMap()
            .Include <ResultModel, ResultDataDTO>();

            CreateMap <ResultRowDataDTO, ResultRowModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new ResultRowModel(source.ResultRowId)))
            .ForMember(dest => dest.Member, opt => opt.MapFrom(src => GetLeagueMember(src.MemberId, modelCache)))
            .ForMember(dest => dest.Team, opt => opt.MapFrom(src => src.TeamId != null ? modelCache.PutOrGetModel(new TeamModel()
            {
                TeamId = src.TeamId.GetValueOrDefault()
            }) : null))
            .ForMember(dest => dest.Location, opt => opt.MapFrom((src, trg) => LeagueContext.Locations.FirstOrDefault(x => x.LocationId == src.LocationId)))
            .EqualityComparison((src, dest) => src.ResultRowId == dest.ResultRowId)
            .ReverseMap()
            .ForMember(dest => dest.MemberId, opt => opt.MapFrom(src => src.Member.MemberId))
            .ForMember(dest => dest.LocationId, opt => opt.MapFrom(src => src.Location != null ? src.Location.LocationId : null))
            .ForMember(dest => dest.TeamId, opt => opt.MapFrom(src => src.Team != null ? src.Team.TeamId : (long?)null));

            CreateMap <ScoringDataDTO, ScoringModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new ScoringModel(source.ScoringId)))
            .EqualityComparison((src, dest) => src.ScoringId == dest.ScoringId)
            .ForMember(dest => dest.ConnectedSchedule, opt => opt.MapFrom(src => src.ConnectedScheduleId != null ? new ScheduleInfo(src.ConnectedScheduleId) : null))
            .ForMember(dest => dest.Sessions, opt => opt.MapFrom(src => src.SessionIds.Select(x => modelCache.PutOrGetModel(new SessionModel(x, SessionType.Undefined)))))
            .ForMember(dest => dest.ExtScoringSource, opt => opt.MapFrom(src => src.ExtScoringSourceId != null ? new ScoringInfo(src.ExtScoringSourceId) : null))
            .ForMember(dest => dest.AccumulateScoring, opt => opt.MapFrom(src => src.AccumulateResults != AccumulateResultsOption.None ? true : false))
            .ForMember(dest => dest.BasePoints, opt => opt.MapFrom((src, dest, result) =>
            {
                ObservableCollection <ScoringModel.BasePointsValue> pairs = new ObservableCollection <ScoringModel.BasePointsValue>();
                pairs.Clear();
                if (src.BasePoints == null || src.BasePoints == "" || src.BasePoints == " ")
                {
                    return(pairs);
                }
                string[] pointString = src.BasePoints.Split(' ');
                for (int i = 0; i < pointString.Count(); i++)
                {
                    pairs.Add(new ScoringModel.BasePointsValue(i + 1, int.Parse(pointString[i])));
                }
                return(pairs);
            }))
            .ForMember(dest => dest.BasePoints, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.BonusPoints, opt => opt.MapFrom((src, dest, result) =>
            {
                ObservableCollection <ScoringModel.BonusPointsValue> pairs = new ObservableCollection <ScoringModel.BonusPointsValue>();
                pairs.Clear();
                if (src.BonusPoints == null || src.BonusPoints == "" || src.BonusPoints == " ")
                {
                    return(pairs);
                }
                string[] pointString = src.BonusPoints.Split(' ');
                for (int i = 0; i < pointString.Count(); i++)
                {
                    var stringPair = pointString[i].Split(':');
                    pairs.Add(new ScoringModel.BonusPointsValue(stringPair.First(), int.Parse(stringPair.Last())));
                }
                return(pairs);
            }))
            .ForMember(dest => dest.ScoringWeights, opt => opt.MapFrom(src => src.SubSessionScoringIds
                                                                       .Select(x => modelCache.PutOrGetModel(new ScoringModel()
            {
                ScoringId = x
            }))
                                                                       .Zip(src.ScoringWeights, (scoring, weight) => new MyKeyValuePair <ScoringModel, double>(scoring, weight))))
            .ForMember(dest => dest.BonusPoints, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.Sessions, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.Standings, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.ResultsFilterOptionIds, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.ScoringWeights, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.IncPenaltyPoints, opt => opt.Ignore())
            .ForMember(dest => dest.SubSessionScorings, opt => opt
                       .MapFrom((src => src.SubSessionScoringIds
                                 .Select(x => modelCache.PutOrGetModel(new ScoringModel()
            {
                ScoringId = x
            }))
                                 ))
                       )
            .ForMember(dest => dest.SubSessionScorings, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.ParentScoring, opt => opt.MapFrom(src => src.ParentScoringId != null ? modelCache.PutOrGetModel(new ScoringModel()
            {
                ScoringId = src.ParentScoringId
            }) : null))
            .ReverseMap()
            .ForMember(dest => dest.ConnectedScheduleId, opt => opt.MapFrom(src => src.ConnectedSchedule != null ? src.ConnectedSchedule.ScheduleId : null))
            .ForMember(dest => dest.SessionIds, opt => opt.MapFrom(src => src.Sessions.Select(x => x.SessionId)))
            .ForMember(dest => dest.ExtScoringSourceId, opt => opt.MapFrom(src => src.ExtScoringSource != null ? src.ExtScoringSource.ScoringId : null))
            .ForMember(dest => dest.BasePoints, opt => opt.MapFrom(src => (src.BasePoints.Count > 0) ? src.BasePoints.Select(x => x.Value.ToString()).Aggregate((x, y) => x + " " + y) : ""))
            .ForMember(dest => dest.BonusPoints, opt => opt.MapFrom(src => (src.BonusPoints.Count > 0) ? src.BonusPoints.Select(x => x.Key + ":" + x.Value.ToString()).Aggregate((x, y) => x + " " + y) : ""))
            .ForMember(dest => dest.AccumulateResults, opt => opt.MapFrom(src => src.AccumulateScoring == true ? src.AccumulateResults : AccumulateResultsOption.None))
            .ForMember(dest => dest.SubSessionScoringIds, opt => opt.MapFrom(src => src.SubSessionScorings.Select(x => x.ScoringId)))
            .ForMember(dest => dest.ScoringWeights, opt => opt.MapFrom(src => src.SubSessionScorings
                                                                       .Select(x => src.ScoringWeights.Any(y => y.Key == x) ? src.ScoringWeights.SingleOrDefault(y => y.Key == x).Value : 0)))
            .ForMember(dest => dest.IncPenaltyPoints, opt => opt.Ignore());
            CreateMap <ScoringInfoDTO, ScoringModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new ScoringModel(source.ScoringId)))
            .EqualityComparison((src, dest) => src.ScoringId == dest.ScoringId)
            .ForAllMembers(opt => opt.Ignore());
            CreateMap <ScoringModel, ScoringInfoDTO>();
            CreateMap <ScoringInfoDTO, ScoringInfo>()
            .ConstructUsing(source => new ScoringInfo(source.ScoringId))
            .EqualityComparison((src, dest) => src.ScoringId == dest.ScoringId)
            .ReverseMap();
            CreateMap <ScoringTableDataDTO, ScoringTableModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new ScoringTableModel()
            {
                ScoringTableId = source.ScoringTableId
            }))
            .EqualityComparison((src, dest) => src.ScoringTableId == dest.ScoringTableId)
            .ForMember(dest => dest.Sessions, opt => opt.MapFrom(src => src.SessionIds.Select(x => new SessionInfo(x, SessionType.Undefined))))
            .ForMember(dest => dest.Scorings, opt => opt.MapFrom((src, dest, result, context) =>
            {
                List <double> factors = new List <double>();
                bool success          = true;
                if (src.ScoringFactors != null)
                {
                    var factorStrings = src.ScoringFactors.Replace(',', '.').Split(';');
                    foreach (var factorString in factorStrings)
                    {
                        if (double.TryParse(factorString, System.Globalization.NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out double factor))
                        {
                            factors.Add(factor);
                        }
                        else
                        {
                            success = false;
                            break;
                        }
                    }
                }

                if (factors.Count() == 0 || success == false)
                {
                    factors = src.ScoringIds.Select(x => (double)1).ToList();
                }

                var mapper = context.Mapper;
                //var destMultiScorings = src.Scorings.Select((x, i) => new MyKeyValuePair<ScoringInfo, double>(mapper.Map<ScoringModel>(x), factors.ElementAt(i)));
                var destMultiScorings = src.ScoringIds.Select((x, i) => new MyKeyValuePair <ScoringInfo, double>(mapper.Map <ScoringInfo>(modelCache.PutOrGetModel(new ScoringInfo(x))), factors.ElementAt(i)));
                return(new ObservableCollection <MyKeyValuePair <ScoringInfo, double> >(destMultiScorings));
            }))
            .ForMember(dest => dest.Scorings, opt => opt.UseDestinationValue())
            .ReverseMap()
            .ForMember(dest => dest.SessionIds, opt => opt.MapFrom(src => src.Sessions.Select(x => x.SessionId)))
            .ForMember(dest => dest.ScoringFactors, opt => opt.MapFrom((src, dest, factors) =>
            {
                if (src.Scorings?.Count > 0)
                {
                    return(src.Scorings.Select(x => x.Value.ToString()).Aggregate((x, y) => x + ";" + y));
                }
                return(null);
            }))
            .ForMember(dest => dest.ScoringIds, opt => opt.MapFrom((src, dest, scoringIds) =>
            {
                if (src.Scorings?.Count > 0)
                {
                    return(src.Scorings.Select(x => x.Key.ScoringId.GetValueOrDefault()).Where(x => x != default).ToArray());
                }
                return(new long[0]);
            }));
            CreateMap <ScoredResultRowDataDTO, ScoredResultRowModel>()
            //.ConstructUsing(source => ModelCache.PutOrGetModel(new ScoredResultRowModel() { ScoredResultRowId = source.ScoredResultRowId}))
            .ConstructUsing(source => new ScoredResultRowModel()
            {
                ScoredResultRowId = source.ScoredResultRowId
            })
            .ForMember(dest => dest.Location, opt => opt.MapFrom((src, trg) => LeagueContext.Locations.FirstOrDefault(x => x.LocationId == src.LocationId)))
            .EqualityComparison((src, dest) => src.ScoredResultRowId == dest.ScoredResultRowId)
            .IncludeBase <ResultRowDataDTO, ResultRowModel>();
            //.EqualityComparison((src, dest) => src.ScoredResultRowId == dest.ScoredResultRowId)

            CreateMap <ScoredResultDataDTO, ScoredResultModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new ScoredResultModel()
            {
                Scoring = new ScoringInfo(source.ScoringId), ResultId = source.ResultId
            }))
            .EqualityComparison((src, dest) => src.SessionId == dest.Session.SessionId && src.ScoringId == dest.Scoring.ScoringId)
            .ForMember(dest => dest.Scoring, opt => opt.MapFrom(src => new ScoringInfo(src.ScoringId)))
            .ForMember(dest => dest.FinalResults, opt => opt.MapFrom(src => src.FinalResults.OrderBy(x => x.FinalPosition)))
            .ForMember(dest => dest.FinalResults, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.HardChargers, opt => opt.MapFrom(src => src.HardChargerMemberIds.Select(x => GetLeagueMember(x, modelCache))))
            .ForMember(dest => dest.CleanestDrivers, opt => opt.MapFrom(src => src.CleanesDriverMemberIds.Select(x => GetLeagueMember(x, modelCache))))
            .ForMember(dest => dest.HardChargers, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.CleanestDrivers, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.FastestLapDriver, opt => opt.MapFrom(src => src.FastestLapDriverId))
            .Include <ScoredTeamResultDataDTO, ScoredTeamResultModel>();

            CreateMap <ScoredTeamResultDataDTO, ScoredTeamResultModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new ScoredTeamResultModel()
            {
                Scoring = new ScoringInfo(source.ScoringId), ResultId = source.ResultId
            }))
            .EqualityComparison((src, dest) => src.SessionId == dest.Session.SessionId && src.ScoringId == dest.Scoring.ScoringId)
            .ForMember(dest => dest.FinalResults, opt => opt.MapFrom(src => src.FinalResults.OrderBy(x => x.FinalPosition)))
            .ForMember(dest => dest.FinalResults, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.TeamResults, opt => opt.MapFrom((src, trg) => src.TeamResults.OrderBy(x => x.FinalPosition)))
            .ForMember(dest => dest.TeamResults, opt => opt.UseDestinationValue())
            .IncludeBase <ScoredResultDataDTO, ScoredResultModel>();

            CreateMap <ScoredTeamResultRowDataDTO, ScoredTeamResultRowModel>()
            .ConstructUsing(source => new ScoredTeamResultRowModel()
            {
                ScoredResultRowId = source.ScoredResultRowId
            })
            .EqualityComparison((src, dest) => src.ScoredResultRowId == dest.ScoredResultRowId)
            .ForMember(dest => dest.ScoredResultRows, opt => opt.UseDestinationValue())
            .ForMember(dest => dest.Team, opt => opt.MapFrom((src, dst) =>
            {
                return(modelCache.PutOrGetModel(new TeamModel()
                {
                    TeamId = src.TeamId
                }));
            }));

            CreateMap <StandingsDataDTO, StandingsModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new StandingsModel()
            {
                ScoringTableId = source.ScoringTableId, SessionId = source.SessionId
            }))
            .EqualityComparison((src, dest) => src.ScoringTableId == dest.ScoringTableId)
            .ForMember(dest => dest.MostWinsDriver, opt => opt.MapFrom(src => GetLeagueMember(src.MostWinsDriverId, modelCache)))
            .ForMember(dest => dest.MostPolesDriver, opt => opt.MapFrom(src => GetLeagueMember(src.MostPolesDriverId, modelCache)))
            .ForMember(dest => dest.CleanestDriver, opt => opt.MapFrom(src => GetLeagueMember(src.CleanestDriverId, modelCache)))
            .ForMember(dest => dest.MostPenaltiesDriver, opt => opt.MapFrom(src => GetLeagueMember(src.MostPenaltiesDriverId, modelCache)))
            .ForMember(dest => dest.StandingsRows, opt => opt.UseDestinationValue())
            .Include <TeamStandingsDataDTO, TeamStandingsModel>();

            CreateMap <StandingsRowDataDTO, StandingsRowModel>()
            //.ConstructUsing(source => ModelCache.PutOrGetModel(new StandingsRowModel() { Scoring = new ScoringInfo(source.Scoring.ScoringId), Member = new LeagueMember(source.Member.MemberId) }))
            .ConstructUsing(source => new StandingsRowModel())
            .ForMember(dest => dest.Member, opt => opt.MapFrom(src => GetLeagueMember(src.MemberId, modelCache)))
            .ForMember(dest => dest.DriverResults, opt => opt.MapFrom(src => src.DriverResults.OrderBy(x => x.Date)))
            .ForMember(dest => dest.Team, opt => opt.MapFrom(src => src.TeamId != null ? modelCache.PutOrGetModel(new TeamModel()
            {
                TeamId = src.TeamId.Value
            }) : null))
            .EqualityComparison((src, dest) => src.MemberId == dest.Member.MemberId)
            .Include <TeamStandingsRowDataDTO, TeamStandingsRowModel>();

            CreateMap <TeamStandingsDataDTO, TeamStandingsModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new TeamStandingsModel()
            {
                ScoringTableId = source.ScoringTableId, SessionId = source.SessionId
            }))
            .EqualityComparison((src, dest) => src.ScoringTableId == dest.ScoringTableId)
            .ForMember(dest => dest.StandingsRows, opt => opt.UseDestinationValue());
            CreateMap <TeamStandingsRowDataDTO, TeamStandingsRowModel>()
            .ConstructUsing(source => new TeamStandingsRowModel())
            .ForMember(dest => dest.Team, opt => opt.MapFrom((src, dst) =>
            {
                return(modelCache.PutOrGetModel(new TeamModel()
                {
                    TeamId = src.TeamId
                }));
            }))
            .ForMember(dest => dest.DriverStandingsRows, opt => opt.MapFrom(src => src.DriverStandingsRows.OrderBy(x => - x.TotalPoints).ThenBy(x => - x.PenaltyPoints)))
            .ForMember(dest => dest.DriverStandingsRows, opt => opt.UseDestinationValue())
            .EqualityComparison((src, dest) => src.TeamId == dest.Team.TeamId);

            CreateMap <AddPenaltyDTO, AddPenaltyModel>()
            .ConstructUsing(source => modelCache.PutOrGetModel(new AddPenaltyModel(source.ScoredResultRowId)))
            .EqualityComparison((src, dest) => src.ScoredResultRowId == dest.ScoredResultRowId)
            .ReverseMap();

            //CreateMap<LeagueUserDTO, UserModel>()
            //    .ConstructUsing(source => ModelCache.PutOrGetModel(new UserModel(source.AdminId)))
            //    .EqualityComparison((src, dest) => src.AdminId == dest.UserId);

            CreateMap <UserDTO, UserModel>()
            .ConstructUsing(src => modelCache.PutOrGetModel(new UserModel(src.UserId)));
            //.ForMember(dest => dest.Admin, opt => opt.MapFrom(src => src));
            CreateMap <UserModel, UserDTO>();

            CreateMap <ReviewVoteDataDTO, ReviewVoteModel>()
            .ConstructUsing(src => new ReviewVoteModel()
            {
                ReviewVoteId = src.ReviewVoteId
            })
            .EqualityComparison((src, dest) => src.ReviewVoteId == dest.ReviewVoteId)
            .ForMember(dest => dest.MemberAtFault, opt => opt.MapFrom(src => GetLeagueMember(src.MemberAtFaultId, modelCache)))
            .ForMember(dest => dest.VoteCategory, opt => opt
                       .MapFrom(src => src.VoteCategoryId != null ? modelCache.PutOrGetModel(new VoteCategoryModel()
            {
                CatId = src.VoteCategoryId.Value
            }) : null))
            .ReverseMap()
            .ForMember(dest => dest.MemberAtFaultId, opt => opt.MapFrom(src => src.MemberAtFault != null ? src.MemberAtFault.MemberId : null))
            .ForMember(dest => dest.VoteCategoryId, opt => opt.MapFrom(src => src.VoteCategory != null ? src.VoteCategory.CatId : (long?)null));

            CreateMap <TimeSpan, LapTime>()
            .ConvertUsing <LapTimeConverter>();
            CreateMap <TimeSpan, LapInterval>()
            .ConvertUsing <LapIntervalConverter>();

            CreateMap <LapTime, TimeSpan>()
            .ConvertUsing <LapTimeConverter>();
            CreateMap <LapInterval, TimeSpan>()
            .ConvertUsing <LapIntervalConverter>();

            CreateMap <VoteCategoryDTO, VoteCategoryModel>()
            .ConstructUsing(src => modelCache.PutOrGetModel(new VoteCategoryModel()
            {
                CatId = src.CatId
            }))
            .EqualityComparison((src, dest) => src.CatId == dest.CatId)
            .ReverseMap();

            CreateMap <CustomIncidentDTO, CustomIncidentModel>()
            .ConstructUsing(src => modelCache.PutOrGetModel(new CustomIncidentModel()
            {
                IncidentId = src.IncidentId
            }))
            .EqualityComparison((src, dest) => src.IncidentId == dest.IncidentId)
            .ReverseMap();

            CreateMap <ReviewPenaltyDTO, ReviewPenaltyModel>()
            .ConstructUsing(src => modelCache.PutOrGetModel(new ReviewPenaltyModel()
            {
                ResultRowId = src.ResultRowId, ReviewId = src.ReviewId
            }))
            .EqualityComparison((src, dest) => src.ResultRowId == dest.ResultRowId && src.ReviewId == dest.ReviewId)
            .ReverseMap();

            CreateMap <ResultsFilterOptionDTO, ResultsFilterOptionModel>()
            .ConstructUsing(src => modelCache.PutOrGetModel(new ResultsFilterOptionModel(src.ResultsFilterId, src.ScoringId)))
            .EqualityComparison((src, dest) => src.ResultsFilterId == dest.ResultsFilterId)
            .ForMember(dest => dest.FilterValues, opt => opt.MapFrom((src, dest, destMember, context) =>
            {
                var targetColumnProperty = typeof(ResultRowModel).GetNestedPropertyInfo(dest.ColumnPropertyName);
                var sourceColumnProperty = typeof(ResultRowDataDTO).GetNestedPropertyInfo(src.ColumnPropertyName);
                var targetPropertyType   = targetColumnProperty.PropertyType;
                var sourcePropertyType   = sourceColumnProperty.PropertyType;
                return(new ObservableCollection <FilterValueModel>(src.FilterValues?
                                                                   .Select(x => new FilterValueModel(targetPropertyType, Convert.ChangeType(x, targetPropertyType)))
                                                                   ?? new FilterValueModel[0]));
            }))
            .ForMember(dest => dest.FilterValues, opt => opt.UseDestinationValue())
            .ReverseMap()
            .ForMember(dest => dest.FilterValues, opt => opt.MapFrom((src, dest, destMember, context) =>
            {
                var targetColumnProperty = typeof(ResultRowDataDTO).GetNestedPropertyInfo(dest.ColumnPropertyName);
                var sourceColumnProperty = typeof(ResultRowModel).GetNestedPropertyInfo(src.ColumnPropertyName);
                var targetPropertyType   = targetColumnProperty.PropertyType;
                var sourcePropertyType   = sourceColumnProperty.PropertyType;
                return(src.FilterValues?
                       .Select(x => Convert.ChangeType(x.Value, targetPropertyType))
                       .ToArray()
                       ?? new object[0]);
            }));

            CreateMap <LeagueDTO, LeagueModel>();

            #region statistic mapping
            CreateMap <StatisticSetDTO, StatisticSetInfo>();

            CreateMap <StatisticSetDTO, StatisticSetModel>()
            .ConstructUsing(src => modelCache.PutOrGetModel(new StatisticSetModel()
            {
                Id = src.Id
            }))
            .EqualityComparison((src, dest) => src.Id == dest.Id)
            .Include <SeasonStatisticSetDTO, SeasonStatisticSetModel>()
            .Include <LeagueStatisticSetDTO, LeagueStatisticSetModel>()
            .Include <ImportedStatisticSetDTO, ImportedStatisticSetModel>()
            .ReverseMap()
            .IncludeAllDerived();

            CreateMap <SeasonStatisticSetDTO, SeasonStatisticSetModel>()
            .ConstructUsing(src => modelCache.PutOrGetModel(new SeasonStatisticSetModel()
            {
                Id = src.Id
            }))
            .ForMember(dest => dest.Season, opt => opt.MapFrom(src => modelCache.PutOrGetModel(new SeasonModel()
            {
                SeasonId = src.SeasonId
            })))
            .ForMember(dest => dest.ScoringTable, opt => opt.MapFrom(src => src.ScoringTableId.HasValue && src.ScoringTableId != 0 ? modelCache.PutOrGetModel(new ScoringTableModel()
            {
                ScoringTableId = src.ScoringTableId.Value
            }) : null))
            .EqualityComparison((src, dest) => src.Id == dest.Id)
            .ReverseMap()
            .ForMember(dest => dest.ScoringTableId, opt => opt.MapFrom(src => src != null ? src.ScoringTable.ScoringTableId : (long?)null))
            .ForMember(dest => dest.SeasonId, opt => opt.MapFrom(src => src.Season.SeasonId));

            CreateMap <LeagueStatisticSetDTO, LeagueStatisticSetModel>()
            .ConstructUsing(src => modelCache.PutOrGetModel(new LeagueStatisticSetModel()
            {
                Id = src.Id
            }))
            .ForMember(dest => dest.StatisticSets, opt => opt.MapFrom(src => src.SeasonStatisticSetIds.Select(x => modelCache.GetModel <StatisticSetModel>(x) ?? new StatisticSetModel()
            {
                Id = x
            })))
            .EqualityComparison((src, dest) => src.Id == dest.Id)
            .ReverseMap()
            .ForMember(dest => dest.SeasonStatisticSetIds, opt => opt.MapFrom(src => src.StatisticSets.Select(x => x.Id)));

            CreateMap <ImportedStatisticSetDTO, ImportedStatisticSetModel>()
            .ConstructUsing(src => modelCache.PutOrGetModel(new ImportedStatisticSetModel()
            {
                Id = src.Id
            }))
            .EqualityComparison((src, dest) => src.Id == dest.Id)
            .ReverseMap();

            CreateMap <DriverStatisticDTO, DriverStatisticModel>()
            .ConstructUsing(src => modelCache.PutOrGetModel(new DriverStatisticModel()
            {
                StatisticSetId = src.StatisticSetId
            }))
            .EqualityComparison((src, dest) => src.StatisticSetId == dest.StatisticSetId)
            .ReverseMap();

            CreateMap <DriverStatisticRowDTO, DriverStatisticRowModel>()
            .EqualityComparison((src, dest) => src.StatisticSetId == dest.StatisticSetId && src.MemberId == dest.MemberId)
            .ForMember(dest => dest.LeagueMember, opt => opt.MapFrom(src => GetLeagueMember(src.MemberId, modelCache)))
            .ReverseMap();
            #endregion
        }
 public EntryController(IEntryServices entryServices, ICommentServices commentServices, ITagServices tagServices, IConfigurationInfo config, IModelCache cache) : base(entryServices, commentServices, config) 
 {
     _tagServices = tagServices;
     _cache = cache;
 }
Пример #21
0
 public RequestModelProvider(IModelCache modelCache) => this.modelCache = modelCache;
Пример #22
0
        public void RegisterDataModel( )
        {
            IModelCache model = reflector.Register <Customer>();

            Assert.IsNotNull(model);
        }
Пример #23
0
 public CachingUserServices(IUserServices nonCachingUserServices, IModelCache cache, ICachingHelpers helpers)
     : base(cache, helpers)
 {
     _userServices = nonCachingUserServices;
 }
 public CachingAccountServices(IAccountServices nonCachingAccountServices, IModelCache cache, ICachingHelpers helpers)
     : base(cache, helpers)
 {
     _accountServices = nonCachingAccountServices;
 }