private static void Go(long userId)
        {
            var settings = new MongoServerSettings
            {
                Server = new MongoServerAddress("127.0.0.1", 27017),
                SafeMode = SafeMode.False
            };
            var mongoServer = new MongoServer(settings);

            var database = mongoServer.GetDatabase("Test");

            var map = new NoteMap();
            var collection = new EntityCollection<Note>(database, map.GetDescriptor(), true);

            var note = new Note
            {
                NoteID = "1",
                Title = "This is a book.",
                Content = "Oh yeah",
                UserID = 123321L
            };
            // collection.InsertOnSubmit(note);
            // collection.SubmitChanges();
            // var data = collection.SelectTo(n => new { n.NoteID, n.UserID });
            collection.Log = Console.Out;
            var a = 4;
            collection.Update(
                n => new Note { },
                n => true);
        }

        public JArray getValuesFromLists(EntityCollection lists, bool translate, bool allAttributes)
        {
            var jsonLists = new JArray();

            foreach (var list in lists.Entities)
            {
                var jsonList = new JObject();

                foreach (var prop in list.GetType().GetProperties())
                {
                    if (prop.Name != "Item")
                    {
                        var val = prop.GetValue(list, null);

                        if (allAttributes | val != null)
                            jsonList[prop.Name] = val == null ? null : val.ToString();
                    }
                }

                jsonLists.Add(jsonList);
            }

            if (translate)
            {
                jsonLists = translateToDisplayName(jsonLists, "list");
            }

            return jsonLists;
        }

        public static EntityCollection GetCollection()
        {
            EntityCollection tempList = null;

            using (SqlConnection myConnection = new SqlConnection(AppConfiguration.ConnectionString))
            {
                using (SqlCommand myCommand = new SqlCommand("usp_GetEntity", myConnection))
                {
                    myCommand.CommandType = CommandType.StoredProcedure;
                    myCommand.Parameters.AddWithValue("@QueryId", SelectTypeEnum.GetCollection);
                    myConnection.Open();
                    using (SqlDataReader myReader = myCommand.ExecuteReader())
                    {
                        if (myReader.HasRows)
                        {
                            tempList = new EntityCollection();
                            while (myReader.Read())
                            {
                                tempList.Add(FillDataRecord(myReader));
                            }

                        }
                        myReader.Close();
                    }
                }
            }

            return tempList;
        }

        public Guid Create( Entity entity )
        {
            // TODO: can the ID be assigned manually? I can't remember
            Guid id = Guid.NewGuid();
            entity.Id = id;

            string name = entity.GetType().Name;
            if( data.ContainsKey( name ) == false ) {
                data.Add( name, new EntityCollection() );
            }

            if( name == "Entity" ) {
                Entity de = ( Entity )entity;
                // We set name here to support DynamicEntity
                name = de.LogicalName;
                de[name + "id"] = id;
            }
            else {
                entity.GetType().GetProperty( name + "id" ).SetValue( entity, id, null );
            }

            if( !data.ContainsKey( name ) ) {
                data[ name ] = new EntityCollection();
            }
            data[ name ].Entities.Add( entity );

            if( m_persist ) {
                PersistToDisk( m_filename );
            }

            return id;
        }

 public ExpressionContext(ISession session, EntityCollection entityCollection, string scopeQualifier, string dynamicPropertiesContainerName)
 {
     this.Session = session;
     this.EntityCollection = entityCollection;
     this.ScopeQualifier = scopeQualifier;
     this.DynamicPropertiesContainerName = dynamicPropertiesContainerName;
 }

 internal void InitPos(EntityCollection collection)
 {
     sw.WriteLine("Init position");
     saveCollection(collection);
     sw.WriteLine("End init position");
     sw.Flush();
 }

 public List<decimal> GetjournalSum(int periodId, int typeid, int entityid)
 {
     using (RecordAccessClient _Client = new RecordAccessClient(EndpointName.RecordAccess))
     {
         if (typeid.Equals(2))
         {
            // Entity _entity =
             EntityAccessClient _enClient = new EntityAccessClient(EndpointName.EntityAccess);
             EntityCollection _accountcollection = new EntityCollection(_enClient.QueryAllSubEntity(entityid));
             List<decimal> _allandsub = new List<decimal>();
             decimal _base = 0;
             decimal _sgd = 0;
             _accountcollection.Add(_enClient.Query2(entityid)[0]);
             foreach (Entity _entity in _accountcollection)
             {
                 if (_Client.GetjournalSum(periodId, typeid, _entity.EntityID).ToList().Count > 0)
                 {
                     _base += _Client.GetjournalSum(periodId, typeid, _entity.EntityID).ToList()[0];
                     _sgd += _Client.GetjournalSum(periodId, typeid, _entity.EntityID).ToList()[1];
                 }
             }
             _allandsub.Add(_base);
             _allandsub.Add(_sgd);
             return _allandsub.ToList();
         }
         else
         {
             return _Client.GetjournalSum(periodId, typeid, entityid).ToList();
         }
     }
 }

        public static EntityCollection LoadFromDatabase(string connectionString)
        {
            var entities = new EntityCollection();

            var schemaInfo = DatabaseSchemaInfo.LoadFromDatabase(connectionString);
            foreach (var table in schemaInfo.Tables)
            {
                var entity = new Entity
                {
                    Name = table.Name,
                    Schema = table.Schema,
                    Database = table.Database
                };
                entities.Add(entity);

                foreach (var column in table.Columns)
                {
                    var member = new EntityMember
                    {
                        Name = column.Name,
                        DataType = DataTypeInfo.FromSqlDataTypeName(column.DataType, column.IsNullable),
                        MaxLength = column.MaxLength,
                        DecimalPlaces = column.DecimalPlaces,
                        IsNullable = column.IsNullable,
                        IsPrimaryKey = column.IsPrimaryKey,
                        IsIdentity = column.IsIdentity,
                        IsComputed = column.IsComputed,
                        OrdinalPosition = column.OrdinalPosition
                    };
                    entity.Members.Add(member);
                }
            }

            return entities;
        }

 public override void Reset()
 {
     this.Trucks = new EntityCollection<TruckType>();
     this.VehicleGPSSet = new EntityCollection<VehicleGPSType>();
     this.DerivedVehicleGPSSet = new EntityCollection<DerivedVehicleGPSType>();
     this.VehicleGPSSetInGPS = new EntityCollection<VehicleGPSType>();
 }

        /// <summary>
        /// Получаем набор неуправляемых решений для организации
        /// </summary>
        /// <param name="service">сервис</param>
        /// <returns></returns>
        public static EntityCollection GetSolutions(IOrganizationService service)
        {
            var solutions = new EntityCollection();

            QueryExpression q = new QueryExpression("solution");
            //Берем только неуправляемые решения
            q.Criteria.AddCondition(new ConditionExpression("ismanaged", ConditionOperator.Equal, false));
            //не берем специальные CRMные солюшены
            q.Criteria.AddCondition(new ConditionExpression("friendlyname", ConditionOperator.NotEqual, "Active Solution"));
            q.Criteria.AddCondition(new ConditionExpression("friendlyname", ConditionOperator.NotEqual, "Default Solution"));
            q.Criteria.AddCondition(new ConditionExpression("friendlyname", ConditionOperator.NotEqual, "Basic Solution"));
            q.Orders.Add(new OrderExpression("createdon", OrderType.Descending));
            q.ColumnSet = new ColumnSet("friendlyname", "uniquename", "version", "installedon");
            q.PageInfo = new PagingInfo()
            {
                Count = 200,
                PageNumber = 1
            };

            EntityCollection ec;
            do
            {
                ec = service.RetrieveMultiple(q);
                solutions.Entities.AddRange(ec.Entities);
                q.PageInfo.PageNumber++;
                q.PageInfo.PagingCookie = ec.PagingCookie;
            } while (ec.MoreRecords);

            return solutions;
        }

 public Int64? InsertArea1(ForestArea forestArea, CadastralPoint[] cadastralPoints)
 {
     using (var db = new DefaultCS())
     {
         try
         {
             if (cadastralPoints != null)
             {
                 EntityCollection<CadastralPoint> cp = new EntityCollection<CadastralPoint>();
                 foreach (var cpp in cadastralPoints)
                 {
                     cp.Add(cpp);
                 }
                 forestArea.CadastralPoints1 = cp;
             }
             forestArea.CreatedDate = DateTime.Now;
             db.ForestAreas.AddObject(forestArea);
             db.SaveChanges();
             return forestArea.Id;
         }
         catch (Exception ex)
         {
             return null;
         }
     }
 }

 public ActionsQueue(EntityCollection gameCollection, GameField field)
 {
     _field = field;
     _queue = new List<Action>();
     _size = _queue.Count;
     _gameCollection = gameCollection;
 }

        internal static IQueryable<BL.DomainModel.Supplier> AdaptSupplier(EntityCollection<Supplier> supplierCollection)
        {
            if (supplierCollection.IsLoaded == false) return null;

            var suppliers = from s in supplierCollection.AsEnumerable()
                            select AdaptSupplier(s);
            return suppliers.AsQueryable();
        }

 public Boom(Cell cell, GameTime gameTime, EntityCollection parent)
 {
     Texture = LogicService.boom;
     this.Cell = cell;
     startedTime = gameTime.Total.TotalSeconds;
     this.parent = parent;
     Order = 6;
 }

 public Person()
 {
     Trips = new EntityCollection<Trip>();
     friends = new EntityCollection<Person>((DataSourceManager.GetCurrentDataSource<TripPinServiceDataSource>()).People);
     Emails = new Collection<string>();
     AddressInfo = new Collection<Location>();
     this.Concurrency = DateTime.UtcNow.Ticks;
 }

        public void Execute(EntityCollection entities)
        {
            if (!this.contentLoaded) {
                throw new InvalidOperationException("Content not loaded");
            }

            this.ExecuteImpl(entities);
        }

 public ChartRenderingInfo(EntityCollection entities)
 {
   base.\u002Ector();
   ChartRenderingInfo chartRenderingInfo = this;
   this.chartArea = (Rectangle2D) new Rectangle2D.Double();
   this.plotInfo = new PlotRenderingInfo(this);
   this.entities = entities;
 }

        protected override void ExecuteImpl(EntityCollection entities)
        {
            var bulletP = new Entity("bullet") {
                Textured.Instance,
                Order2Update.Instance,

                new CustomOnEscape(new BoundingBox2(
                    new Vector2(0, 0),
                    new Vector2(640, 480)
                ), (e) => {
                    entities.EnqueueDestroy(e);
                }),

                { Textured.Texture, this.bulletTexture },
                { Properties.DestroysEnemies, true },
                { Properties.Damage, 10.0f },

                {
                    Collidable.Body,
                    new Body(new ShapePrimitive[] {
                        new CircleShape(Vector2.Zero, 8)
                    })
                },
            };

            var basicWeapon = new Entity {
                new CustomBulletEmitter((e, weaponOwner) => {
                    var bullet = bulletP.Create();
                    bullet.Set(Located.Position, e.Get(Located.Position) + weaponOwner.Get(Located.Position));
                    bullet.Set(Located.Velocity, e.Get(Located.Velocity));
                    bullet.Set(Properties.Owner, weaponOwner);
                    entities.EnqueueSpawn(bullet);
                })
            };

            var weapons = new[] {
                basicWeapon.Create("top").Configure((e) => {
                    e.Set(Located.Position, new Vector2(0, 0));
                    e.Set(Located.Velocity, new Vector2(7, 0));
                }),

                basicWeapon.Create("bottom").Configure((e) => {
                    e.Set(Located.Position, new Vector2(0, 30));
                    e.Set(Located.Velocity, new Vector2(7, 0));
                }),

                basicWeapon.Create("center").Configure((e) => {
                    e.Set(Located.Position, new Vector2(0, 15));
                    e.Set(Located.Velocity, new Vector2(7, 0));
                }),
            };

            this.weaponConfigs = new[] {
                new[] { weapons[2], },
                new[] { weapons[0], weapons[1], },
                new[] { weapons[0], weapons[1], weapons[2], },
            };
        }

 public void GetProductsTest()
 {
     var _products = new EntityCollection<Product>().AsQueryable();
     mockProductRepository.Setup(x => x.GetAll()).Returns(_products);
     var products = purcService.GetProducts();
     Assert.IsNotNull(products);
     Assert.IsInstanceOfType(products, typeof(IQueryable<IMaster>));
     mockProductRepository.Verify(x => x.GetAll());
 }

        internal static IQueryable<BL.DomainModel.Address> AdaptAddresses(EntityCollection<Address> addressCollection)
        {
            if (addressCollection.IsLoaded == false)
                return null;

            var addresses = from a in addressCollection.AsEnumerable()
                            select AdaptAddress(a);
            return addresses.AsQueryable();
        }