public ProjectService(IStore<Project> ps, IStore<Platform> tps, IMappingEngine mapper, ILoggerService log)
 {
     TestProjectStore = ps;
     TestPlatformStore = tps;
     Mapper = mapper;
     Log = log;
 }

 public InitializationModel(IStore<Player> playerCollection, IStore<RankingDetail> rankingCollection, IStore<Owner> ownerCollection, IStore<BidDetail> bidCollection)
 {
     _playerCollection = playerCollection.FindAll().ToList();
     _rankingCollection = rankingCollection.FindAll().ToList();
     _ownerCollection = ownerCollection.FindAll().ToList();
     _bidCollection = bidCollection;
 }

        public void Add(IStore store, StoreData data)
        {
            var datalist = this.datalist;//GetCacheData();

            if (datalist == null)
            {
                return;
            }

            StoreDataEntity entity = new StoreDataEntity
            {
                Store = store
                ,
                Data = data
            };

            string dk = GetDataKey(data.Type, data.Key);

            datalist.AddOrUpdate(dk, entity, (string k, StoreDataEntity oldData) =>
            {
                return entity;
            });

            if (datalist.Count >= this.capacity)
            {
                ThreadPool.QueueUserWorkItem(SaveAsync, null);
            }
        }

 public ReducedContentHandler(IRRConfiguration config, IHostingEnvironmentWrapper hostingEnvironment, IUriBuilder uriBuilder, IStore store)
 {
     this.config = config;
     this.hostingEnvironment = hostingEnvironment;
     this.uriBuilder = uriBuilder;
     this.store = store;
 }

        public bool Render(IStore store, TextWriter output, out Value result)
        {
            bool	halt;

            foreach (KeyValuePair<IEvaluator, INode> branch in this.branches)
            {
                if (branch.Key.Evaluate (store, output).AsBoolean)
                {
                    store.Enter ();

                    halt = branch.Value.Render (store, output, out result);

                    store.Leave ();

                    return halt;
                }
            }

            if (this.fallback != null)
            {
                store.Enter ();

                halt = this.fallback.Render (store, output, out result);

                store.Leave ();

                return halt;
            }

            result = VoidValue.Instance;

            return false;
        }

        public TableStateStore(IStore store)
        {
            if (store == null)
                throw new ArgumentNullException("store");

            Store = store;
        }

        /// <summary>
        /// ctor.  requires IStore to wrap
        /// </summary>
        /// <param name="decorated"></param>
        public InterceptingStoreDecoration(IStore decorated, ILogger logger)
            : base(decorated)
        {
            this.Logger = logger;

            //init the intercept chains, wrapping them around the core operations
            this.CommitOperationIntercept = new InterceptChain<ICommitBag, Nothing>((bag) =>
            {
                this.Decorated.Commit(bag);
                return Nothing.VOID;
            });
            this.CommitOperationIntercept.Completed += CommitOperationIntercept_Completed;

            this.GetOperationIntercept = new InterceptChain<IStoredObjectId, IHasId>((x) =>
            {
                return this.Decorated.Get(x);
            });
            this.GetOperationIntercept.Completed += GetOperationIntercept_Completed;

            this.GetAllOperationIntercept = new InterceptChain<Nothing, List<IHasId>>((x) =>
            {
                return this.Decorated.GetAll();
            });
            this.GetAllOperationIntercept.Completed += GetAllOperationIntercept_Completed;
            
            this.SearchOperationIntercept = new InterceptChain<LogicOfTo<IHasId,bool>, List<IHasId>>((x) =>
            {
                return this.Decorated.Search(x);
            });
            this.SearchOperationIntercept.Completed += SearchOperationIntercept_Completed;
        }

 public UssdContext(IStore store, UssdRequest request, Dictionary<string, string> data)
 {
     Store = store;
     Request = request;
     Data = data;
     DataBag = new UssdDataBag(Store, DataBagKey);
 }

		public StoreInfoPage(IStore store, ContentMode mode = ContentMode.View)
		{
			//Setup view model
			this.ViewModel = MvxToolbox.LoadViewModel<StoreInfoViewModel>();
			this.ViewModel.Store = store;
			this.ViewModel.Mode = mode;

			InitializeComponent();

			//Setup Header
			this.HeaderView.BindingContext = this.ViewModel;

			//Setup events
			this.listView.ItemSelected += itemSelected;
			this.ViewModel.Products.ReloadFinished += (sender, e) =>
			{
				this.listView.EndRefresh();
			};

			//Setup view model actions
			this.ViewModel.ShowStoreDetailsAction = async (s) =>
			{
				await this.Navigation.PushAsync(new StoreDetailsPage(s, mode));
			};

			this.ViewModel.AddProductAction = async (p, s) =>
			{
				await this.Navigation.PushModalAsync(new NavigationPage(new SaveProductPage(p, s)));
			};
		}

 public ProjectVersionService(IStore<Project> projectStore, IStore<ProjectVersion> projectVersionStore, IMappingEngine mapper, ILoggerService log)
 {
     ProjectStore = projectStore;
     ProjectVersionStore = projectVersionStore;
     Mapper = mapper;
     Log = log;
 }

        /// <summary>
        /// Initializes a new instance of the MainViewModel class.
        /// </summary>
        public MainViewModel(IStore store, INavigationService nav)
        {
            this.store = store;
            this.nav = nav;

            this.Groups = new ObservableCollection<Group>();
        }

        // If you care for what's inside your TInitializer model,
        // add the parameter to the ctor of the view.
        // Compare to ListViewModel - where we're not interested in the model.
        public DetailViewModel(IStore store, ShowCustomerDetails args)
        {
            _store = store;

            var c = _store.LoadCustomer(args.CustomerId);
            Console.WriteLine("Customer details: {0}, {1}", c.Name, c.Birthday);
        }

    public override void OnHandle(IStore store,
                                  string collection,
                                  JObject command,
                                  JObject document)
    {
      IObjectStore st = store.GetCollection(collection);

      if (document.Type == JTokenType.Array)
      {
        var documents = document.Values();
        if (documents != null)
          foreach (JObject d in documents)
          {
            var k = d.Property(DocumentMetadata.IdPropertyName);
            if (k != null)
              st.Set((string)k, d);
          }

      }
      else
      {
        var k = document.Property(DocumentMetadata.IdPropertyName);
        if (k != null)
          st.Set((string)k, document);
      }
    }

        // A method that handles densodb events MUST have this delegate.
        public static void Set(IStore dbstore, BSonDoc command)
        {
            // IStore interface gives you a lowlevel access to DB Structure,
              // Every action you take now will jump directly into DB without any event dispatching

              // The Istore is preloaded from densodb, and you should not have access to densodb internals.

              // Now deserialize message from Bson object.
              // should be faster using BsonObject directly but this way is more clear.
              var message = command.FromBSon<Message>();

              // Get the sender UserProfile
              var userprofile = dbstore.GetCollection("users").Where(d => d["UserName"].ToString() == message.From).FirstOrDefault().FromBSon<UserProfile>();

              if (userprofile != null)
              {
            // add message to user's messages
            var profilemessages = dbstore.GetCollection(string.Format("messages_{0}", userprofile.UserName));
            profilemessages.Set(command);

            // add message to user's wall
            var profilewall = dbstore.GetCollection(string.Format("wall_{0}", userprofile.UserName));
            profilewall.Set(command);

            // Now i have user's follower.
            foreach (var follower in userprofile.FollowedBy)
            {
              // Get followers's wall
              var followerwall = dbstore.GetCollection(string.Format("wall_{0}", follower));

              // store the messages in follower's wall.
              followerwall.Set(command);
            }
              }
        }

        public MessagingModule(Config cfg, IStore store)
            : base("/Admin/Messaging")
        {
            Get["/"] = _ => View["Admin/Messaging/Index"];
            Get["/Messages"] = _ => Response.AsJson(new { store.Messages });
            Get["/Message/{message}/"] = _ =>
            {
                Type t = store.ResolveMessageType(_.message);
                string kind = "other";
                if (typeof(Neva.Messaging.IQuery).IsAssignableFrom(t)) kind = "Query";
                if (typeof(Neva.Messaging.ICommand).IsAssignableFrom(t)) kind = "Command";
                if (typeof(Neva.Messaging.IEvent).IsAssignableFrom(t)) kind = "Event";

                return Response.AsJson(new
                {
                    Name = _.message,
                    Kind = kind,
                    Properties = t.GetProperties().Select(p => new
                    {
                        p.Name,
                        p.PropertyType,
                        IsXml = p.GetCustomAttributes(typeof(XmlAttribute), false).Length > 0
                    })
                });
            };
        }

        /// <summary>
        /// Creates a new store management window.
        /// </summary>
        /// <param name="store">The <see cref="IStore"/> to manage.</param>
        /// <param name="feedCache">Information about implementations found in the <paramref name="store"/> are extracted from here.</param>
        public StoreManageForm([NotNull] IStore store, [NotNull] IFeedCache feedCache)
        {
            #region Sanity checks
            if (store == null) throw new ArgumentNullException("store");
            if (feedCache == null) throw new ArgumentNullException("feedCache");
            #endregion

            _store = store;
            _feedCache = feedCache;

            InitializeComponent();
            buttonRunAsAdmin.AddShieldIcon();

            HandleCreated += delegate
            {
                Program.ConfigureTaskbar(this, Text, subCommand: ".Store.Manage", arguments: StoreMan.Name + " manage");
                if (Locations.IsPortable) Text += @" - " + Resources.PortableMode;
                if (WindowsUtils.IsAdministrator) Text += @" (Administrator)";
                else if (WindowsUtils.IsWindowsNT) buttonRunAsAdmin.Visible = true;
            };

            Shown += delegate { RefreshList(); };

            _treeView.SelectedEntryChanged += OnSelectedEntryChanged;
            _treeView.CheckedEntriesChanged += OnCheckedEntriesChanged;
            splitContainer.Panel1.Controls.Add(_treeView);
        }

 /// <summary>
 /// Process USSD requests. Automatically routes to nested routes.
 /// </summary>
 /// <param name="store">Session store</param>
 /// <param name="request"></param>
 /// <param name="initiationController">Initiation controller</param>
 /// <param name="initiationAction">Initiation action</param>
 /// <param name="data">Data available to controllers</param>
 /// <param name="loggingStore">Logging store</param>
 /// <param name="arbitraryLogData">Arbitrary data to add to session log</param>
 /// <returns></returns>
 public static async Task<UssdResponse> Process(IStore store, UssdRequest request,
     string initiationController, string initiationAction,
     Dictionary<string, string> data = null, ILoggingStore loggingStore = null, string arbitraryLogData = null)
 {
     return
             await
                 ProcessRequest(store, request, initiationController, initiationAction, data, loggingStore,
                     arbitraryLogData);
     // TODO: auto process sub dial
     //var messages = GetInitiationMessages(request);
     //if (messages == null)
     //{
     //    return
     //        await
     //            ProcessRequest(store, request, initiationController, initiationAction, data, loggingStore,
     //                arbitraryLogData);
     //}
     //UssdResponse response = null;
     //for (int i = 0; i < messages.Count; i++)
     //{
     //    request.Message = messages[i];
     //    if (i != 0) request.Type = UssdRequestTypes.Response.ToString();
     //    bool dispose = (i == messages.Count-1);
     //    response =
     //        await
     //            ProcessRequest(store, request, initiationController, initiationAction, data, loggingStore,
     //                arbitraryLogData, dispose);
     //}
     //return response;
 }

 public StreamJournalWriter(IStore storage, EngineConfiguration config)
 {
     _config = config;
     _storage = storage;
     _journalFormatter = config.CreateFormatter(FormatterUsage.Journal);
     _rolloverStrategy = _config.CreateRolloverStrategy();
 }

 /// <summary>
 /// copies items between stores
 /// </summary>
 /// <param name="store"></param>
 /// <param name="storeToMoveTo"></param>
 /// <param name="itemsToMove"></param>
 public static void CopyItems(this IStore store, IStore storeToMoveTo, List<StoredObjectId> itemsToMove)
 {
     itemsToMove.WithEach(x =>
     {
         CopyItem(store, storeToMoveTo, x);
     });
 }

 public StoreDetail(IStore s)
 {
     Id = s.Id;
     SizeLimit = s.SizeLimit;
     CurrentSize = s.CurrentSize;
     Label = s.Label;
 }