Example #1
0
        /// <summary>
        /// Selects the entity whose key member value is equal to the request's key member value:
        ///     ie: Single(entity => request.key == entity.key)
        /// </summary>
        public static RequestEntityConfigBuilder <TRequest, TEntity> SelectBy <TRequest, TEntity>(
            this RequestEntityConfigBuilder <TRequest, TEntity> config,
            string key)
            where TEntity : class
        {
            var kRequest = Key.MakeKey <TRequest>(key);
            var kEntity  = Key.MakeKey <TEntity>(key);

            var selector = SelectorHelpers.BuildSingle <TRequest, TEntity>(kRequest, kEntity);

            return(config.SetSelector(selector));
        }
Example #2
0
        /// <summary>
        /// Selects the entity whose entityKey member value is equal to the request's requestKey member value:
        ///     ie: Single(entity => request.requestKey == entity.entityKey)
        /// </summary>
        public static RequestEntityConfigBuilder <TRequest, TEntity> SelectBy <TRequest, TEntity, TRequestKey>(
            this RequestEntityConfigBuilder <TRequest, TEntity> config,
            Expression <Func <TRequest, TRequestKey> > requestKey,
            string entityKey)
            where TEntity : class
        {
            var kRequest = Key.MakeKeys(requestKey);
            var kEntity  = Key.MakeKey <TEntity>(entityKey);

            if (kRequest == null || kRequest.Length == 0 || kEntity == null)
            {
                return(config);
            }

            if (kRequest.Length != 1)
            {
                throw new IncompatibleKeysException(typeof(TRequest), typeof(TEntity));
            }

            var selector = SelectorHelpers.BuildSingle <TRequest, TEntity>(kRequest[0], kEntity);

            return(config.SetSelector(selector));
        }
Example #3
0
        public async Task Handle_DefaultWithResponse_CreatesUserAndReturnsDto()
        {
            var request = new CreateRequest <User, UserDto, UserGetDto>(new UserDto {
                Name = "TestUser"
            });
            var response = await Mediator.HandleAsync(request);

            Assert.IsFalse(response.HasErrors);
            Assert.AreEqual(1, Context.Set <User>().Count());
            Assert.IsNotNull(response.Result);
            Assert.AreEqual("TestUser", response.Result.Name);
            Assert.AreEqual(response.Result.Id, Context.Set <User>().First().Id);


            var requestTest = new CreateUserWithoutResponseRequest();

            var kRequest = Key.MakeKeys <CreateUserWithoutResponseRequest, string>(x => x.User.Name);
            var kEntity  = Key.MakeKeys <User, string>(x => x.Name);
            var selector = SelectorHelpers.BuildSingle <CreateUserWithoutResponseRequest, User>(kRequest[0], kEntity[0]);
            var test1    = selector.Get <User>()(new CreateUserWithoutResponseRequest());
            var test2    = Test(request => user => request.User.Name == user.Name, requestTest);

            int n = 0;
        }