public RbECROperationType()
 {
     this._ECROperations = new EntitySet<ECROperation>(new Action<ECROperation>(this.attach_ECROperations), new Action<ECROperation>(this.detach_ECROperations));
     this._Person_CreatePersonId  = default(EntityRef<Person>);
     this._Person_ModifyPersonId  = default(EntityRef<Person>);
     OnCreated();
 }
 public ClientQuoting()
 {
     this._ActionPropertyClientQuotings = new EntitySet<ActionPropertyClientQuoting>(new Action<ActionPropertyClientQuoting>(this.attach_ActionPropertyClientQuotings), new Action<ActionPropertyClientQuoting>(this.detach_ActionPropertyClientQuotings));
     this._Person_CreatePersonId  = default(EntityRef<Person>);
     this._Person_ModifyPersonId  = default(EntityRef<Person>);
     OnCreated();
 }
Example #3
0
 // Assign handlers for the add and remove operations, respectively.
 public TaskSeries()
 {
     _tasks = new EntitySet<Task>(
         new Action<Task>(this.attach_Task),
         new Action<Task>(this.detach_Task)
         );
 }
		/// <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();
		}
 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 RbStatusObservationClientType()
 {
     this._ClientStatusObservations = new EntitySet<ClientStatusObservation>(new Action<ClientStatusObservation>(this.attach_ClientStatusObservations), new Action<ClientStatusObservation>(this.detach_ClientStatusObservations));
     this._Person_CreatePersonId  = default(EntityRef<Person>);
     this._Person_ModifyPersonId  = default(EntityRef<Person>);
     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();
		}
Example #8
0
        private static void SetupEntities(EntitySet set)
        {
            var entity1 = CreateEntity(set, "Entity1");
            var entity2 = CreateEntity(set, "Entity2");

            entity1.CreateReferenceTo(entity2);
        }
Example #9
0
		/// <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();
		}
Example #10
0
		/// <summary>Initializes a new instance of the <see cref="Order"/> class.</summary>
		public Order()
		{
			_customer = default(EntityRef<Customer>);
			_employee = default(EntityRef<Employee>);
			_orderRows = new EntitySet<OrderRow>(new Action<OrderRow>(this.Attach_OrderRows), new Action<OrderRow>(this.Detach_OrderRows) );
			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();
 }
Example #12
0
 public LocationAddress()
 {
     _location = new EntitySet<Location>(
         attach_Location,
         detach_Location
         );
 }
Example #13
0
 public Nests()
 {
     _words = new EntitySet<Words>(
         new Action<Words>(this.attach_Words),
         new Action<Words>(this.detach_Words)
         );
 }
 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="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 RbBloodType()
 {
     this._Clients = new EntitySet<Client>(new Action<Client>(this.attach_Clients), new Action<Client>(this.detach_Clients));
     this._Person_CreatePersonId  = default(EntityRef<Person>);
     this._Person_ModifyPersonId  = default(EntityRef<Person>);
     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 Account()
 {
     _accountRoles = new EntitySet<AccountRole>(new Action<AccountRole>(this.AccountRoles_Attach), new Action<AccountRole>(this.AccountRoles_Detach));
     _avatar = new EntitySet<Avatar>(new Action<Avatar>(this.Avatar_Attach), new Action<Avatar>(this.Avatar_Detach));
     _accountSessions = new EntitySet<AccountSession>(new Action<AccountSession>(this.AccountSessions_Attach), new Action<AccountSession>(this.AccountSessions_Detach));
     this.OnCreated();
 }
 public JobTicket()
 {
     this._ActionPropertyJobTickets = new EntitySet<ActionPropertyJobTicket>(new Action<ActionPropertyJobTicket>(this.attach_ActionPropertyJobTickets), new Action<ActionPropertyJobTicket>(this.detach_ActionPropertyJobTickets));
     this._EQueueTicket  = default(EntityRef<EQueueTicket>);
     this._Job  = default(EntityRef<Job>);
     OnCreated();
 }
        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);
        }
 public RbNomenclatureAnalog()
 {
     this._RbNomenclatures = new EntitySet<RbNomenclature>(new Action<RbNomenclature>(this.attach_RbNomenclatures), new Action<RbNomenclature>(this.detach_RbNomenclatures));
     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)
         );
 }
Example #23
0
        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 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();
 }
Example #25
0
 public Group()
 {
     _activitiesGroupsRef = new EntitySet<ActivityGroup>(
         new Action<ActivityGroup>(this.addActivitiesGroupsRef),
         new Action<ActivityGroup>(this.removeActivitiesGroupsRef)
         );
 }
        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);
        }
Example #27
0
 // 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_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 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();
 }
		/// <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();
		}
 internal AssociationSetMapping(AssociationSet associationSet, EntitySet storeEntitySet)
     : this(associationSet, storeEntitySet, (EntityContainerMapping)null)
 {
 }
 public Orders()
 {
     this._Order_Details = new EntitySet <Order_Details>(new Action <Order_Details>(this.attach_Order_Details), new Action <Order_Details>(this.detach_Order_Details));
     this._Customers     = default(EntityRef <Customers>);
     OnCreated();
 }
 public Customers()
 {
     this._Orders = new EntitySet <Orders>(new Action <Orders>(this.attach_Orders), new Action <Orders>(this.detach_Orders));
     OnCreated();
 }
Example #34
0
 public Customer()
 {
     this._Orders = new EntitySet <Order>();
 }
Example #35
0
 public Lecture()
 {
     this._StudentLectures = new EntitySet <StudentLecture>(new Action <StudentLecture>(this.attach_StudentLectures), new Action <StudentLecture>(this.detach_StudentLectures));
     OnCreated();
 }
Example #36
0
 public Student()
 {
     this._StudentLectures = new EntitySet <StudentLecture>(new Action <StudentLecture>(this.attach_StudentLectures), new Action <StudentLecture>(this.detach_StudentLectures));
     this._University      = default(EntityRef <University>);
     OnCreated();
 }
Example #37
0
 public University()
 {
     this._Students = new EntitySet <Student>(new Action <Student>(this.attach_Students), new Action <Student>(this.detach_Students));
     OnCreated();
 }
Example #38
0
 public Answer()
 {
     this._DetailSurveys = new EntitySet <DetailSurvey>(new Action <DetailSurvey>(this.attach_DetailSurveys), new Action <DetailSurvey>(this.detach_DetailSurveys));
     OnCreated();
 }
 public System(EntitySet set, IParallelRunner runner, int minEntityCountByRunnerIndex)
     : base(set, runner, minEntityCountByRunnerIndex)
 {
 }
Example #40
0
 public CabinType()
 {
     this._Surveys = new EntitySet <Survey>(new Action <Survey>(this.attach_Surveys), new Action <Survey>(this.detach_Surveys));
     OnCreated();
 }
 public System(EntitySet set)
     : base(set)
 {
 }
Example #42
0
 public Airport()
 {
     this._Surveys  = new EntitySet <Survey>(new Action <Survey>(this.attach_Surveys), new Action <Survey>(this.detach_Surveys));
     this._Surveys1 = new EntitySet <Survey>(new Action <Survey>(this.attach_Surveys1), new Action <Survey>(this.detach_Surveys1));
     OnCreated();
 }
Example #43
0
 public Subject()
 {
     this._Marks         = new EntitySet <Mark>(new Action <Mark>(this.attach_Marks), new Action <Mark>(this.detach_Marks));
     this._Registrations = new EntitySet <Registration>(new Action <Registration>(this.attach_Registrations), new Action <Registration>(this.detach_Registrations));
     OnCreated();
 }
 public System(EntitySet set, IParallelRunner runner)
     : base(set, runner)
 {
 }
        /// <summary>
        /// don't let this be constructed publicly;
        /// </summary>
        /// <exception cref="EntityCommandCompilationException">Cannot prepare the command definition for execution; consult the InnerException for more information.</exception>
        /// <exception cref="NotSupportedException">The ADO.NET Data Provider you are using does not support CommandTrees.</exception>
        internal EntityCommandDefinition(DbProviderFactory storeProviderFactory, DbCommandTree commandTree)
        {
            EntityUtil.CheckArgumentNull(storeProviderFactory, "storeProviderFactory");
            EntityUtil.CheckArgumentNull(commandTree, "commandTree");

            DbProviderServices storeProviderServices = DbProviderServices.GetProviderServices(storeProviderFactory);

            try {
                if (DbCommandTreeKind.Query == commandTree.CommandTreeKind)
                {
                    // Next compile the plan for the command tree
                    List <ProviderCommandInfo> mappedCommandList = new List <ProviderCommandInfo>();
                    ColumnMap columnMap;
                    int       columnCount;
                    PlanCompiler.Compile(commandTree, out mappedCommandList, out columnMap, out columnCount, out _entitySets);
                    _columnMapGenerators = new IColumnMapGenerator[] { new ConstantColumnMapGenerator(columnMap, columnCount) };
                    // Note: we presume that the first item in the ProviderCommandInfo is the root node;
                    Debug.Assert(mappedCommandList.Count > 0, "empty providerCommandInfo collection and no exception?"); // this shouldn't ever happen.

                    // Then, generate the store commands from the resulting command tree(s)
                    _mappedCommandDefinitions = new List <DbCommandDefinition>(mappedCommandList.Count);

                    foreach (ProviderCommandInfo providerCommandInfo in mappedCommandList)
                    {
                        DbCommandDefinition providerCommandDefinition = storeProviderServices.CreateCommandDefinition(providerCommandInfo.CommandTree);

                        if (null == providerCommandDefinition)
                        {
                            throw EntityUtil.ProviderIncompatible(System.Data.Entity.Strings.ProviderReturnedNullForCreateCommandDefinition);
                        }
                        _mappedCommandDefinitions.Add(providerCommandDefinition);
                    }
                }
                else
                {
                    Debug.Assert(DbCommandTreeKind.Function == commandTree.CommandTreeKind, "only query and function command trees are supported");
                    DbFunctionCommandTree entityCommandTree = (DbFunctionCommandTree)commandTree;

                    // Retrieve mapping and metadata information for the function import.
                    FunctionImportMappingNonComposable mapping          = GetTargetFunctionMapping(entityCommandTree);
                    IList <FunctionParameter>          returnParameters = entityCommandTree.EdmFunction.ReturnParameters;
                    int resultSetCount = returnParameters.Count > 1 ? returnParameters.Count : 1;
                    _columnMapGenerators = new IColumnMapGenerator[resultSetCount];
                    TypeUsage storeResultType = DetermineStoreResultType(entityCommandTree.MetadataWorkspace, mapping, 0, out _columnMapGenerators[0]);
                    for (int i = 1; i < resultSetCount; i++)
                    {
                        DetermineStoreResultType(entityCommandTree.MetadataWorkspace, mapping, i, out _columnMapGenerators[i]);
                    }
                    // Copy over parameters (this happens through a more indirect route in the plan compiler, but
                    // it happens nonetheless)
                    List <KeyValuePair <string, TypeUsage> > providerParameters = new List <KeyValuePair <string, TypeUsage> >();
                    foreach (KeyValuePair <string, TypeUsage> parameter in entityCommandTree.Parameters)
                    {
                        providerParameters.Add(parameter);
                    }

                    // Construct store command tree usage.
                    DbFunctionCommandTree providerCommandTree = new DbFunctionCommandTree(entityCommandTree.MetadataWorkspace, DataSpace.SSpace,
                                                                                          mapping.TargetFunction, storeResultType, providerParameters);

                    DbCommandDefinition storeCommandDefinition = storeProviderServices.CreateCommandDefinition(providerCommandTree);
                    _mappedCommandDefinitions = new List <DbCommandDefinition>(1)
                    {
                        storeCommandDefinition
                    };

                    EntitySet firstResultEntitySet = mapping.FunctionImport.EntitySets.FirstOrDefault();
                    if (firstResultEntitySet != null)
                    {
                        _entitySets = new Set <EntitySet>();
                        _entitySets.Add(mapping.FunctionImport.EntitySets.FirstOrDefault());
                        _entitySets.MakeReadOnly();
                    }
                }

                // Finally, build a list of the parameters that the resulting command should have;
                List <EntityParameter> parameterList = new List <EntityParameter>();

                foreach (KeyValuePair <string, TypeUsage> queryParameter in commandTree.Parameters)
                {
                    EntityParameter parameter = CreateEntityParameterFromQueryParameter(queryParameter);
                    parameterList.Add(parameter);
                }

                _parameters = new System.Collections.ObjectModel.ReadOnlyCollection <EntityParameter>(parameterList);
            }
            catch (EntityCommandCompilationException) {
                // No need to re-wrap EntityCommandCompilationException
                throw;
            }
            catch (Exception e) {
                // we should not be wrapping all exceptions
                if (EntityUtil.IsCatchableExceptionType(e))
                {
                    // we don't wan't folks to have to know all the various types of exceptions that can
                    // occur, so we just rethrow a CommandDefinitionException and make whatever we caught
                    // the inner exception of it.
                    throw EntityUtil.CommandCompilation(System.Data.Entity.Strings.EntityClient_CommandDefinitionPreparationFailed, e);
                }
                throw;
            }
        }
 public System(EntitySet set, bool useBuffer)
     : base(set, useBuffer)
 {
 }
Example #47
0
		public DictionaryHeader()
		{
			this._Dictionaries = new EntitySet<Dictionary>(new Action<Dictionary>(this.attach_Dictionaries), new Action<Dictionary>(this.detach_Dictionaries));
			OnCreated();
		}
 internal FunctionColumnMapGenerator(FunctionImportMappingNonComposable mapping, int resultSetIndex, EntitySet entitySet, StructuralType baseStructuralType)
 {
     _mapping            = mapping;
     _entitySet          = entitySet;
     _baseStructuralType = baseStructuralType;
     _resultSetIndex     = resultSetIndex;
 }
Example #49
0
 public NHANVIEN()
 {
     this._LOPs = new EntitySet <LOP>(new Action <LOP>(this.attach_LOPs), new Action <LOP>(this.detach_LOPs));
     OnCreated();
 }
Example #50
0
 public Territory()
 {
     this._EmployeeTerritories = new EntitySet <EmployeeTerritory>();
 }
Example #51
0
 public HOCPHAN()
 {
     this._BANGDIEMs = new EntitySet <BANGDIEM>(new Action <BANGDIEM>(this.attach_BANGDIEMs), new Action <BANGDIEM>(this.detach_BANGDIEMs));
     OnCreated();
 }
Example #52
0
 public Bird()
 {
     this._BirdCounts = new EntitySet <BirdCount>(new Action <BirdCount>(this.attach_BirdCounts), new Action <BirdCount>(this.detach_BirdCounts));
     OnCreated();
 }
Example #53
0
 public TabSystemUser()
 {
     _tabCredentialInFoS = new EntitySet <TabCredentialInfos>(new Action <TabCredentialInfos>(this.TabCredentialInFOs_Attach), new Action <TabCredentialInfos>(this.TabCredentialInFOs_Detach));
     this.OnCreated();
 }
Example #54
0
 public LOP()
 {
     this._SINHVIENs = new EntitySet <SINHVIEN>(new Action <SINHVIEN>(this.attach_SINHVIENs), new Action <SINHVIEN>(this.detach_SINHVIENs));
     this._NHANVIEN  = default(EntityRef <NHANVIEN>);
     OnCreated();
 }
Example #55
0
 public User()
 {
     this._Videos = new EntitySet <Video>(new Action <Video>(this.attach_Videos), new Action <Video>(this.detach_Videos));
     OnCreated();
 }
Example #56
0
 public SINHVIEN()
 {
     this._BANGDIEMs = new EntitySet <BANGDIEM>(new Action <BANGDIEM>(this.attach_BANGDIEMs), new Action <BANGDIEM>(this.detach_BANGDIEMs));
     this._LOP       = default(EntityRef <LOP>);
     OnCreated();
 }
Example #57
0
 public virtual T GetModel(Expression <Func <T, bool> > exp)
 => EntitySet.SingleOrDefault(exp);
Example #58
0
 public Product()
 {
     this._Order_Details = new EntitySet <Order_Detail>(new Action <Order_Detail>(this.attach_Order_Details), new Action <Order_Detail>(this.detach_Order_Details));
     OnCreated();
 }
Example #59
0
 public virtual IQueryable <T> GetModels(Expression <Func <T, bool> > exp)
 => EntitySet.Where(exp);
Example #60
0
 public virtual int GetCount(Expression <Func <T, bool> > exp)
 => exp == null?EntitySet.Count() : EntitySet.Where(exp).Count();