/// <summary>Initializes a new instance of the <see cref="CountryRegion"/> class.</summary>
		public CountryRegion()
		{
			_countryRegionCurrencies = new EntitySet<CountryRegionCurrency>(new Action<CountryRegionCurrency>(this.Attach_CountryRegionCurrencies), new Action<CountryRegionCurrency>(this.Detach_CountryRegionCurrencies) );
			_salesTerritories = new EntitySet<SalesTerritory>(new Action<SalesTerritory>(this.Attach_SalesTerritories), new Action<SalesTerritory>(this.Detach_SalesTerritories) );
			_stateProvinces = new EntitySet<StateProvince>(new Action<StateProvince>(this.Attach_StateProvinces), new Action<StateProvince>(this.Detach_StateProvinces) );
			OnCreated();
		}

		/// <summary>Initializes a new instance of the <see cref="ProductModel"/> class.</summary>
		public ProductModel()
		{
			_products = new EntitySet<Product>(new Action<Product>(this.Attach_Products), new Action<Product>(this.Detach_Products) );
			_productModelIllustrations = new EntitySet<ProductModelIllustration>(new Action<ProductModelIllustration>(this.Attach_ProductModelIllustrations), new Action<ProductModelIllustration>(this.Detach_ProductModelIllustrations) );
			_productModelProductDescriptionCultures = new EntitySet<ProductModelProductDescriptionCulture>(new Action<ProductModelProductDescriptionCulture>(this.Attach_ProductModelProductDescriptionCultures), new Action<ProductModelProductDescriptionCulture>(this.Detach_ProductModelProductDescriptionCultures) );
			OnCreated();
		}

 public RbEmergencyPlaceReceptionCall()
 {
     this._EmergencyCalls = new EntitySet<EmergencyCall>(new Action<EmergencyCall>(this.attach_EmergencyCalls), new Action<EmergencyCall>(this.detach_EmergencyCalls));
     this._Person_CreatePersonId  = default(EntityRef<Person>);
     this._Person_ModifyPersonId  = default(EntityRef<Person>);
     OnCreated();
 }

 public RbHospitalBedType()
 {
     this._OrgStructureHospitalBeds = new EntitySet<OrgStructureHospitalBed>(new Action<OrgStructureHospitalBed>(this.attach_OrgStructureHospitalBeds), new Action<OrgStructureHospitalBed>(this.detach_OrgStructureHospitalBeds));
     this._Person_CreatePersonId  = default(EntityRef<Person>);
     this._Person_ModifyPersonId  = default(EntityRef<Person>);
     OnCreated();
 }

		/// <summary>Initializes a new instance of the <see cref="CurrencyRate"/> class.</summary>
		public CurrencyRate()
		{
			_currency = default(EntityRef<Currency>);
			_currency1 = default(EntityRef<Currency>);
			_salesOrderHeaders = new EntitySet<SalesOrderHeader>(new Action<SalesOrderHeader>(this.Attach_SalesOrderHeaders), new Action<SalesOrderHeader>(this.Detach_SalesOrderHeaders) );
			OnCreated();
		}

		/// <summary>Initializes a new instance of the <see cref="WorkOrder"/> class.</summary>
		public WorkOrder()
		{
			_product = default(EntityRef<Product>);
			_scrapReason = default(EntityRef<ScrapReason>);
			_workOrderRoutings = new EntitySet<WorkOrderRouting>(new Action<WorkOrderRouting>(this.Attach_WorkOrderRoutings), new Action<WorkOrderRouting>(this.Detach_WorkOrderRoutings) );
			OnCreated();
		}

 public Nests()
 {
     _words = new EntitySet<Words>(
         new Action<Words>(this.attach_Words),
         new Action<Words>(this.detach_Words)
         );
 }

        public override EntitySet LoadWithId(string type, string[] id, string[] attributes)
        {
            EntitySet result = new EntitySet();

            foreach (string itemId in id)
            {
                string strQuote = itemId.IndexOf("'") > 0 ? "\"" : "'"; // if id contains ' limiter is " else '

                ArrayList subQueries = new ArrayList();

                // Creates a query for each sub-type, and concatenates them using and OR expression
                foreach (string subtype in Factory.Model.GetTreeAsArray(type))
                    subQueries.Add(String.Concat("id(", strQuote, _CommandProcessor.GetKey(subtype, itemId), strQuote, ")"));

                if (subQueries.Count == 0)
                    throw new ModelElementNotFoundException("No such types in metadata: " + type);

                EntitySet es = LoadWithXPath(String.Join(" | ", (string[])subQueries.ToArray(typeof(string))));

                if (es.Count > 0)
                    result.Add(es[0]);
            }

            if (result.Count > 0)
                LoadAttribute(result, attributes);

            return result;
        }

        public void Handler_ReturnsTrue_WhenFound_ByUserId()
        {
            var userId = FakeData.Id();
            var otherUserId1 = FakeData.Id(userId);
            var otherUserId2 = FakeData.Id(userId, otherUserId1);
            var user = new ProxiedUser(userId);
            var otherUser1 = new ProxiedUser(otherUserId1);
            var otherUser2 = new ProxiedUser(otherUserId2);
            var localMemberships = new[]
            {
                new LocalMembership { User = otherUser1, },
                new LocalMembership { User = user, },
                new LocalMembership { User = otherUser2, },
            };
            var data = localMemberships.AsQueryable();
            var query = new UserHasLocalMembership(user.Id);
            var dbSet = new Mock<DbSet<LocalMembership>>(MockBehavior.Strict).SetupDataAsync(data);
            var entities = new Mock<IReadEntities>(MockBehavior.Strict);
            var entitySet = new EntitySet<LocalMembership>(dbSet.Object, entities.Object);
            entities.Setup(x => x.Query<LocalMembership>()).Returns(entitySet);
            var handler = new HandleUserHasLocalMembershipQuery(entities.Object);

            bool result = handler.Handle(query).Result;

            result.ShouldBeTrue();
            entities.Verify(x => x.Query<LocalMembership>(), Times.Once);
        }

 public RbReasonOfAbsence()
 {
     this._ActionPropertyRbReasonOfAbsences = new EntitySet<ActionPropertyRbReasonOfAbsence>(new Action<ActionPropertyRbReasonOfAbsence>(this.attach_ActionPropertyRbReasonOfAbsences), new Action<ActionPropertyRbReasonOfAbsence>(this.detach_ActionPropertyRbReasonOfAbsences));
     this._Person_CreatePersonId  = default(EntityRef<Person>);
     this._Person_ModifyPersonId  = default(EntityRef<Person>);
     OnCreated();
 }

 public Group()
 {
     _activitiesGroupsRef = new EntitySet<ActivityGroup>(
         new Action<ActivityGroup>(this.addActivitiesGroupsRef),
         new Action<ActivityGroup>(this.removeActivitiesGroupsRef)
         );
 }

 // Assign handlers for the add and remove operations, respectively.
 public ToDoCategory()
 {
     _todos = new EntitySet<ToDoItem>(
         new Action<ToDoItem>(this.attach_ToDo),
         new Action<ToDoItem>(this.detach_ToDo)
         );
 }

        public void Handler_ReturnsNullLocalMembership_WhenNotFound_ByVerifiedEmail()
        {
            var emailAddress = FakeData.Email();
            var user = new User();
            user.EmailAddresses.Add(new EmailAddress
            {
                IsVerified = false,
                Value = emailAddress,
            });
            var data = new[]
            {
                new LocalMembership { User = user, },
            }.AsQueryable();
            var query = new LocalMembershipByVerifiedEmail(emailAddress);
            var dbSet = new Mock<DbSet<LocalMembership>>(MockBehavior.Strict).SetupDataAsync(data);
            var entities = new Mock<IReadEntities>(MockBehavior.Strict);
            var entitySet = new EntitySet<LocalMembership>(dbSet.Object, entities.Object);
            entities.Setup(x => x.Query<LocalMembership>()).Returns(entitySet);
            var handler = new HandleLocalMembershipByVerifiedEmailQuery(entities.Object);

            LocalMembership result = handler.Handle(query).Result;

            result.ShouldBeNull();
            entities.Verify(x => x.Query<LocalMembership>(), Times.Once);
        }

 public ECROperation()
 {
     this._ECRCheckItems = new EntitySet<ECRCheckItem>(new Action<ECRCheckItem>(this.attach_ECRCheckItems), new Action<ECRCheckItem>(this.detach_ECRCheckItems));
     this._Person  = default(EntityRef<Person>);
     this._RbECROperationType  = default(EntityRef<RbECROperationType>);
     OnCreated();
 }

 public RbTempInvalidExtraReason()
 {
     this._TempInvalids = new EntitySet<TempInvalid>(new Action<TempInvalid>(this.attach_TempInvalids), new Action<TempInvalid>(this.detach_TempInvalids));
     this._Person_CreatePersonId  = default(EntityRef<Person>);
     this._Person_ModifyPersonId  = default(EntityRef<Person>);
     OnCreated();
 }

 public Department()
 {
     _employees = new EntitySet<Employee>(
         new Action<Employee>(this.attach_Employee),
         new Action<Employee>(this.detach_Employee)
         );
 }

 public OrganisationAccount()
 {
     this._Contracts_RecipientAccountId = new EntitySet<Contract>(new Action<Contract>(this.attach_Contracts_RecipientAccountId), new Action<Contract>(this.detach_Contracts_RecipientAccountId));
     this._Contracts_PayerAccountId = new EntitySet<Contract>(new Action<Contract>(this.attach_Contracts_PayerAccountId), new Action<Contract>(this.detach_Contracts_PayerAccountId));
     this._Bank  = default(EntityRef<Bank>);
     OnCreated();
 }

		/// <summary>Initializes a new instance of the <see cref="SpecialOfferProduct"/> class.</summary>
		public SpecialOfferProduct()
		{
			_product = default(EntityRef<Product>);
			_salesOrderDetails = new EntitySet<SalesOrderDetail>(new Action<SalesOrderDetail>(this.Attach_SalesOrderDetails), new Action<SalesOrderDetail>(this.Detach_SalesOrderDetails) );
			_specialOffer = default(EntityRef<SpecialOffer>);
			OnCreated();
		}

 public LocationAddress()
 {
     _location = new EntitySet<Location>(
         attach_Location,
         detach_Location
         );
 }

        public void Handler_ReturnsRemoteMembershipViews_WhenFound_ByUserId()
        {
            var userId = FakeData.Id();
            var otherUserId1 = FakeData.Id(userId);
            var otherUserId2 = FakeData.Id(userId, otherUserId1);
            var remoteMemberships = new[]
            {
                new ProxiedRemoteMembership(FakeData.String(), FakeData.String())
                    { UserId = otherUserId1, },
                new ProxiedRemoteMembership(FakeData.String(), FakeData.String())
                    { UserId = otherUserId2, },
                new ProxiedRemoteMembership(FakeData.String(), FakeData.String())
                    { UserId = userId, },
            };
            var data = remoteMemberships.AsQueryable();
            var query = new RemoteMembershipViewsBy(userId);
            var dbSet = new Mock<DbSet<RemoteMembership>>(MockBehavior.Strict).SetupDataAsync(data);
            var entities = new Mock<IReadEntities>(MockBehavior.Strict);
            var entitySet = new EntitySet<RemoteMembership>(dbSet.Object, entities.Object);
            entities.Setup(x => x.Query<RemoteMembership>()).Returns(entitySet);
            var handler = new HandleRemoteMembershipViewsByQuery(entities.Object);

            RemoteMembershipView[] results = handler.Handle(query).Result.ToArray();

            results.ShouldNotBeNull();
            results.Length.ShouldEqual(1);
            RemoteMembershipView result = results.Single();
            var expectedEntity = data.Single(x => x.UserId == userId);
            result.UserId.ShouldEqual(expectedEntity.UserId);
            result.Provider.ShouldEqual(expectedEntity.LoginProvider);
            result.Key.ShouldEqual(expectedEntity.ProviderKey);
            entities.Verify(x => x.Query<RemoteMembership>(), Times.Once);
        }