public RedirectionController(IRepository repository, IIdGenerator idGenerator, IBase58Converter base58Converter, IAdminCodeGenerator adminCodeGenerator)
 {
     _repository = repository;
     _idGenerator = idGenerator;
     _base58Converter = base58Converter;
     _adminCodeGenerator = adminCodeGenerator;
 }

 public RepoTimelineProvider(IIdGenerator generator, ITransactionManager trans, IRepository<TimelineItem> repoTi, IRepository<TimelineItemHistory> repoTih)
 {
     this.generator = generator;
     this.trans = trans;
     this.repoTi = repoTi;
     this.repoTih = repoTih;
 }

 /// <summary>
 /// GetDocumentId is an invalid operation for wrapper classes.
 /// </summary>
 /// <param name="id">Not applicable.</param>
 /// <param name="idGenerator">Not applicable.</param>
 /// <returns>Not applicable.</returns>
 public bool GetDocumentId(
     out object id,
     out IIdGenerator idGenerator
 ) {
     var message = string.Format("GetDocumentId method cannot be called on a {0}", this.GetType().Name);
     throw new InvalidOperationException(message);
 }

 bool IBsonSerializable.GetDocumentId(
     out object id,
     out IIdGenerator idGenerator
 )
 {
     throw new InvalidOperationException();
 }

        public StatsModule(ITemplate tmpl, IIdGenerator idgen, SavegameStorage storage)
        {
            Post["/games"] = _ =>
            {
                // Get the temporary location of the file on the server
                var file = Request.Headers["X-FILE"].FirstOrDefault();

                // Get the extension of the file when it was uploaded as the
                // temporary file doesn't have an extension
                var extension = Request.Headers["X-FILE-EXTENSION"].FirstOrDefault();
                if (file == null)
                    throw new ArgumentException("File can't be null");
                if (extension == null)
                    throw new ArgumentException("File extension can't be null");

                Save savegame;
                using (var stream = getStream(file, extension))
                using (parsingTimer.NewContext())
                    savegame = new Save(stream);

                // Turn the savegame into html and return the url for it
                var stats = statsTimer.Time(() => Aggregate(savegame));
                string contents = templateTimer.Time(() => tmpl.Render(stats));
                string id = idgen.NextId();
                return storage.Store(contents, id);
            };
        }

        public SetupModule(IAggregateRootRepository repository,
                           IAccountRepository accountRepository,
                           IIdGenerator idGenerator)
            :base("/setup")
        {
            Get["/"] = _ =>
            {
                if (accountRepository.Count() > 0)
                    return HttpStatusCode.NotFound;

                return View["Index"];
            };

            Post["/"] = _ =>
            {
                var model = this.Bind<CreateModel>();

                if (accountRepository.Count() > 0)
                    return HttpStatusCode.NotFound;

                var account = new Domain.Account(idGenerator.NextGuid(),
                    model.Name, model.FirstName, model.LastName, model.Email);

                account.ChangePassword(model.Password);
                account.MakeAdmin();

                repository.Save(account);

                return Response.AsRedirect("/");
            };
        }

 public bool GetDocumentId(object document, out object id, out Type idNominalType, out IIdGenerator idGenerator)
 {
     id = null;
     idGenerator = null;
     idNominalType = null;
     return false;
 }

        private Func<RogerEndpoint, IBasicProperties> CreatePropertiesFactory(IModel model,
            IIdGenerator idGenerator,
            IMessageTypeResolver messageTypeResolver,
            IMessageSerializer serializer,
            ISequenceGenerator sequenceGenerator)
        {
            var properties = model.CreateBasicProperties();

            properties.MessageId = idGenerator.Next();
            properties.Type = messageTypeResolver.Unresolve(messageType);
            properties.ContentType = serializer.ContentType;

            properties.Headers = new Hashtable
            {
                {Headers.Sequence, BitConverter.GetBytes(sequenceGenerator.Next(messageType))}
            };

            if (persistent)
                properties.DeliveryMode = 2;

            FillAdditionalProperties(properties, idGenerator);

            return endpoint =>
            {
                properties.ReplyTo = endpoint;
                return properties;
            };
        }

 /// <summary>
 /// Gets the document Id.
 /// </summary>
 /// <param name="document">The document.</param>
 /// <param name="id">The Id.</param>
 /// <param name="idGenerator">The IdGenerator for the Id type.</param>
 /// <returns>True if the document has an Id.</returns>
 public virtual bool GetDocumentId(
     object document,
     out object id,
     out IIdGenerator idGenerator
 ) {
     throw new InvalidOperationException("Subclass must implement GetDocumentId");
 }

        public bool GetDocumentId(out object id, out Type idNominalType, out IIdGenerator idGenerator)
        {
            id = this.Name;
            idNominalType = typeof(string);
            idGenerator = null;

            return true;
        }

 public MyListWishController(DTOMapper dtoMapper, IUserIdProvider userIdProvider, 
     IRepository<WishList> repository, IIdGenerator<Wish> idGenerator )
 {
     _dtoMapper = dtoMapper;
     _userIdProvider = userIdProvider;
     _repository = repository;
     _idGenerator = idGenerator;
 }

 public IDelivery Create(IModel model,
                         IIdGenerator idGenerator,
                         IMessageTypeResolver messageTypeResolver,
                         IMessageSerializer serializer,
                         ISequenceGenerator sequenceGenerator)
 {
     return inner;
 }

 /// <summary>
 /// Gets the document Id.
 /// </summary>
 /// <param name="document">The document.</param>
 /// <param name="id">The Id.</param>
 /// <param name="idNominalType">The nominal type of the Id.</param>
 /// <param name="idGenerator">The IdGenerator for the Id type.</param>
 /// <returns>True if the document has an Id.</returns>
 public virtual bool GetDocumentId(
     object document,
     out object id,
     out Type idNominalType,
     out IIdGenerator idGenerator)
 {
     throw new NotSupportedException("Subclass must implement GetDocumentId.");
 }

        public AdminModule(IAggregateRootRepository repository,
                           IIdGenerator idGenerator)
            : base("/write/admin")
        {
            this.RequiresAuthentication();
            this.RequiresClaims(new[] { "Admin" });

            Post["/account/create"] = parameters =>
            {
                var model = this.Bind<EditableAccount>();
                var account = new Domain.Account(idGenerator.NextGuid(),
                    model.Name, model.FirstName, model.LastName, model.Email);

                var password = account.GeneratePassword();

                repository.Save(account);

                return Json(new
                {
                    Account = new Account(account),
                    Password = password
                });
            };

            Post["/account/update/{id:guid}"] = parameters =>
            {
                var model = this.Bind<EditableAccount>();
                var account = repository.GetById<Domain.Account>((Guid)parameters.id);

                if (account != null)
                {
                    account.ChangeDetails(model.Name, model.FirstName, model.LastName, model.Email);

                    repository.Save(account);

                    return Json(new
                    {
                        Account = new Account(account)
                    });
                }

                return null;
            };

            Post["/account/{id:guid}/newpassword"] = parameters =>
            {
                var model = this.Bind<AccountNewPassword>();
                var account = repository.GetById<Domain.Account>((Guid)parameters.id);

                if (account != null)
                {
                    account.ChangePassword(model.Password);
                    repository.Save(account);
                }

                return null;
            };
        }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="idGenerator">A generator to create ids to sorting lines</param>
 /// <param name="configuration">A configuration object</param>
 /// <param name="lines">The character representation of all sorting lines</param>
 public Yard(IIdGenerator idGenerator, IConfiguration configuration, IEnumerable<IEnumerable<char>> lines)
 {
     IdGenerator = idGenerator;
     Configuration = configuration;
     SortingLines = CreateSortingLines(lines);
     YardLocomotive = new YardLocomotive(Configuration);
     Yardmaster = new Yardmaster(YardLocomotive);
     TrainLine = new TrainLine();
 }

 /// <summary>
 /// Gets the document Id.
 /// </summary>
 /// <param name="document">The document.</param>
 /// <param name="id">The Id.</param>
 /// <param name="idNominalType">The nominal type of the Id.</param>
 /// <param name="idGenerator">The IdGenerator for the Id type.</param>
 /// <returns>True if the document has an Id.</returns>
 public bool GetDocumentId(
     object document,
     out object id,
     out Type idNominalType,
     out IIdGenerator idGenerator)
 {
     var bsonDocument = (BsonDocument)document;
     return ((IBsonSerializable)bsonDocument).GetDocumentId(out id, out idNominalType, out idGenerator);
 }

        public Cache(IIdGenerator idGenerator, IObjectGraph objectGraph, IEnumerable<IMaterializationHook> materializationHooks)
        {
            if (idGenerator == null) throw new ArgumentNullException("idGenerator");
            if (objectGraph == null) throw new ArgumentNullException("objectGraph");
            if (materializationHooks == null) throw new ArgumentNullException("materializationHooks");

            _idGenerator = idGenerator;
            _objectGraph = objectGraph;
            _materializationHooks = materializationHooks;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="IdMap"/> class.
        /// </summary>
        /// <param name="memberName">Name of the member.</param>
        /// <param name="memberGetter">The member getter.</param>
        /// <param name="memberSetter">The member setter.</param>
        /// <param name="valueType">Type of the value.</param>
        /// <param name="idGenerator">The id generator.</param>
        public IdMap(string memberName, Func<object, object> memberGetter, Action<object, object> memberSetter, IIdGenerator idGenerator, IValueConverter valueConverter, object unsavedValue)
            : base("_id", memberName, memberGetter, memberSetter, true)
        {
            if (idGenerator == null)
                throw new ArgumentNullException("idGenerator");

            this.IdGenerator = idGenerator;
            this.UnsavedValue = unsavedValue;
            this.ValueConverter = valueConverter;
        }

        public void CreateContext()
        {
            _typeMapper = new Moq.Mock<ITypeMapper>().Object;
            _random = new Moq.Mock<IRandom>().Object;
            _idGenerator = new Moq.Mock<IIdGenerator>().Object;

            var context = Create();

            Assert.That(context.TypeMapper, Is.Not.Null);
            Assert.That(context.Random, Is.Not.Null);
            Assert.That(context.IdGenerator, Is.Not.Null);
        }

 public ContentProvider(IIdGenerator idGenerator, ITransactionManager trans,
     IRepository<Category> repoCategory,
     IRepository<Content> repoContent,
     IRepository<CategoryContent> repoContentCategory,
     IRepository<ContentRelation> repoContentRelation)
 {
     this.idGenerator = idGenerator;
     this.trans = trans;
     this.repoCategory = repoCategory;
     this.repoContent = repoContent;
     this.repoContentCategory = repoContentCategory;
     this.repoContentRelation = repoContentRelation;
 }