상속: IContextFactory
예제 #1
0
		private Bug421071Test.TopLevelScope CreateGlobalScope()
		{
			factory = new Bug421071Test.DynamicScopeContextFactory();
			Context context = factory.EnterContext();
			// noinspection deprecation
			Bug421071Test.TopLevelScope globalScope = new Bug421071Test.TopLevelScope(this, context);
			Context.Exit();
			return globalScope;
		}
예제 #2
0
파일: Utils.cs 프로젝트: hazzik/Rhino.Net
		/// <summary>Runs the provided action at the given optimization level</summary>
		public static void RunWithOptimizationLevel(ContextFactory contextFactory, ContextAction action, int optimizationLevel)
		{
			Context cx = contextFactory.EnterContext();
			try
			{
				cx.SetOptimizationLevel(optimizationLevel);
				action.Run(cx);
			}
			finally
			{
				Context.Exit();
			}
		}
예제 #3
0
        // Context currently instanciated and initializes the context.
        // therefore the test will fail due to insufficient setup.
        // TODO: Make ContextFactory testable.
        public void Create_OsIsWindows_ReturnsWindowsContext()
        {
            // Arrange
            var loader = Substitute.For<ILibraryLoader>();
            var libmapper = Substitute.For<ILibraryInterfaceMapper>();
            var factory = new ContextFactory(loader, libmapper, PlatformID.Win32NT);
        
            // Act
            var context = factory.Create(new ContextCreationParameters{ Device = 1, Window = 1});

            // Assert
            Assert.That(context, Is.InstanceOf<WindowsContext>());
            loader.Received(1).Load("GDI32");
            loader.Received(1).Load("OpenGL32");
        }
예제 #4
0
		protected internal override object GetInterfaceProxyHelper(ContextFactory cf, Type[] interfaces)
		{
			// XXX: How to handle interfaces array withclasses from different
			// class loaders? Using cf.getApplicationClassLoader() ?
			ClassLoader loader = interfaces[0].GetClassLoader();
			Type cl = Proxy.GetProxyClass(loader, interfaces);
			ConstructorInfo<object> c;
			try
			{
				c = cl.GetConstructor(new Type[] { typeof(InvocationHandler) });
			}
			catch (MissingMethodException ex)
			{
				// Should not happen
				throw Kit.InitCause(new InvalidOperationException(), ex);
			}
			return c;
		}
		public virtual void TestSetNullForScriptableSetter()
		{
			string scriptCode = "foo.myProp = new Foo2();\n" + "foo.myProp = null;";
			ContextFactory factory = new ContextFactory();
			Context cx = factory.EnterContext();
			try
			{
				ScriptableObject topScope = cx.InitStandardObjects();
				CustomSetterAcceptNullScriptableTest.Foo foo = new CustomSetterAcceptNullScriptableTest.Foo();
				// define custom setter method
				MethodInfo setMyPropMethod = typeof(CustomSetterAcceptNullScriptableTest.Foo).GetMethod("setMyProp", typeof(CustomSetterAcceptNullScriptableTest.Foo2));
				foo.DefineProperty("myProp", null, null, setMyPropMethod, ScriptableObject.EMPTY);
				topScope.Put("foo", topScope, foo);
				ScriptableObject.DefineClass<CustomSetterAcceptNullScriptableTest.Foo2>(topScope);
				cx.EvaluateString(topScope, scriptCode, "myScript", 1, null);
			}
			finally
			{
				Context.Exit();
			}
		}
예제 #6
0
		public virtual void TestStrictModeError()
		{
			contextFactory = new StrictModeApiTest.MyContextFactory();
			Context cx = contextFactory.EnterContext();
			try
			{
				global = cx.InitStandardObjects();
				try
				{
					RunScript("({}.nonexistent);");
					NUnit.Framework.Assert.Fail();
				}
				catch (EvaluatorException e)
				{
					NUnit.Framework.Assert.IsTrue(e.Message.StartsWith("Reference to undefined property"));
				}
			}
			finally
			{
				Context.Exit();
			}
		}
        public async void when_settling_an_overdue_payment()
        {
            var orderId      = Guid.NewGuid();
            var creditCardId = Guid.NewGuid();
            var pickUpDate   = DateTime.Now;

            var client = GetPaymentClient();

            using (var context = ContextFactory.Invoke())
            {
                context.RemoveAll <OrderDetail>();
                context.RemoveAll <OverduePaymentDetail>();
                context.SaveChanges();

                var tokenizeResponse = await client.Tokenize(TestCreditCards.Visa.Number, TestCreditCards.Visa.NameOnCard, TestCreditCards.Visa.ExpirationDate, TestCreditCards.Visa.AvcCvvCvv2.ToString(), null, TestCreditCards.Visa.ZipCode, TestAccount);

                var token = tokenizeResponse.CardOnFileToken;

                var testAccount = context.Set <AccountDetail>().First(a => a.Id == TestAccount.Id);
                testAccount.DefaultCreditCard = creditCardId;

                context.RemoveAll <CreditCardDetails>();
                context.SaveChanges();

                context.Set <CreditCardDetails>().Add(new CreditCardDetails
                {
                    CreditCardId      = creditCardId,
                    AccountId         = TestAccount.Id,
                    CreditCardCompany = "Visa",
                    Token             = token,
                    Country           = new CountryISOCode("CA"),
                    Email             = testAccount.Email,
                    Phone             = "5145552222",
                });

                context.Set <OrderDetail>().Add(new OrderDetail
                {
                    Id                 = orderId,
                    AccountId          = TestAccount.Id,
                    BookingFees        = 15m,
                    CreatedDate        = DateTime.Now,
                    PickupDate         = pickUpDate,
                    PickupAddress      = TestAddresses.GetAddress1(),
                    ClientLanguageCode = SupportedLanguages.en.ToString()
                });

                context.Set <OrderStatusDetail>().Add(new OrderStatusDetail
                {
                    OrderId       = orderId,
                    IBSOrderId    = 12345,
                    VehicleNumber = "9001",
                    Status        = OrderStatus.Canceled,
                    AccountId     = TestAccount.Id,
                    PickupDate    = pickUpDate
                });

                context.Set <OrderPairingDetail>().Add(new OrderPairingDetail
                {
                    OrderId           = orderId,
                    AutoTipPercentage = 15
                });

                context.Set <OverduePaymentDetail>().Add(new OverduePaymentDetail
                {
                    AccountId             = TestAccount.Id,
                    IBSOrderId            = 12345,
                    OrderId               = orderId,
                    TransactionDate       = DateTime.Now,
                    TransactionId         = "TransId",
                    OverdueAmount         = 52.34m,
                    ContainBookingFees    = false,
                    ContainStandaloneFees = false,
                    IsPaid = false
                });

                context.SaveChanges();
            }

            var result = await client.SettleOverduePayment(null);

            Assert.AreEqual(true, result.IsSuccessful);

            var overduePayment = await client.GetOverduePayment();

            Assert.IsNull(overduePayment);
        }
예제 #8
0
파일: Utils.cs 프로젝트: hazzik/Rhino.Net
		/// <summary>Runs the action successively with all available optimization levels</summary>
		public static void RunWithAllOptimizationLevels(ContextFactory contextFactory, ContextAction action)
		{
			RunWithOptimizationLevel(contextFactory, action, -1);
			RunWithOptimizationLevel(contextFactory, action, 0);
			RunWithOptimizationLevel(contextFactory, action, 1);
		}
예제 #9
0
파일: Program.cs 프로젝트: hazzik/Rhino.Net
		/// <summary>Entry point for embedded applications.</summary>
		/// <remarks>
		/// Entry point for embedded applications.  This method attaches
		/// to the given
		/// <see cref="Rhino.ContextFactory">Rhino.ContextFactory</see>
		/// with the given scope.  No
		/// I/O redirection is performed as with
		/// <see cref="Main(string[])">Main(string[])</see>
		/// .
		/// </remarks>
		public static Program MainEmbedded(ContextFactory factory, Scriptable scope, string title)
		{
			return MainEmbeddedImpl(factory, scope, title);
		}
        /// <summary>
        /// Construct filter expression for entity.
        /// </summary>
        /// <param name="entity">Entity to construct filter expression for.</param>
        /// <param name="typeOfFilter">Type of filter expression.</param>
        /// <returns>Filter expression according to entity.</returns>
        public Expression <Func <TEntity, bool> > ConstructFilterExpression(
            TEntity entity,
            FilterType typeOfFilter)
        {
            Expression <Func <TEntity, bool> > filterExpression = null;
            IEnumerable <string> primaryKeyNames = GetPrimaryKeys();

            if (primaryKeyNames.Count() == 0)
            {
                throw new ArgumentException(string.Format(
                                                "'{0}' has no configured primary key.",
                                                typeof(TEntity).Name));
            }

            List <Expression>        equalityExpressions = new List <Expression>();
            IEnumerable <Expression> singleExpressionList;

            ParameterExpression parameterExp = Expression.Parameter(typeof(TEntity), "m");
            Expression          pkFilter     = null;
            Expression          ukFilter     = null;

            bool primaryKeysHaveDefaultValues = entity.HasDefaultValues(primaryKeyNames);

            if (!primaryKeysHaveDefaultValues &&
                typeOfFilter != FilterType.OnlyUnique)
            {
                // If primary keys do not have their default values
                // add this check to equlity expression list
                singleExpressionList = parameterExp
                                       .ConstructEqualityExpressions(
                    entity,
                    primaryKeyNames);

                pkFilter = singleExpressionList.ConstructAndChain();
            }

            if (typeOfFilter != FilterType.OnlyId &&
                (primaryKeysHaveDefaultValues ||
                 typeOfFilter != FilterType.IdOptionalUnique))
            {
                IEnumerable <PropertiesWithSource> uniqueProperties =
                    MappingStorage.Instance.UniqueProperties.Where(
                        m => m.SourceType.Equals(entity.GetType()));

                if (uniqueProperties.Count() > 0)
                {
                    foreach (PropertiesWithSource unique in uniqueProperties)
                    {
                        /*
                         ***********************************************************
                         * If any of current set of properties
                         * marked as unique is foreign key,
                         * has default value, and appropriate navigation property is not
                         * null and also origin of this foreign
                         * key has any store generated primary key then this
                         * uniqueness must be ignored.
                         * For example if PersonId (int) and DocumentType (short) has been
                         * set as composite unique in PersonDocument and
                         * if PersonId is foreign key to Person, which in its term has
                         * Primary key which is store generated and if there is no navigation
                         * property to Person from PersonDocument or PersonDocument.Person is not null
                         * then PersonId = 0 and DocumentType = 5 should not
                         * be treated as unique, because the real value of PersonId
                         * will be computed when data will be inserted.
                         ***********************************************************
                         */

                        IGraphEntityTypeManager uniqueSourceTypeManager = ContextFactory
                                                                          .GetEntityTypeManager(unique.SourceType.Name);

                        bool uniquenessMustBeIgnored = false;

                        var uniquePropertyNames = unique.Properties.Select(m => m.Name).ToList();
                        var uniqueForeignKeys   = uniqueSourceTypeManager
                                                  .GetForeignKeyDetails()
                                                  .Select(m => new
                        {
                            TargetClass = m.FromDetails.ContainerClass,
                            Keys        = m.ToDetails.Keys.Intersect(uniquePropertyNames)
                        })
                                                  .Where(m => m.Keys != null &&
                                                         m.Keys.Any());

                        NavigationDetail navigationDetailsOfCurrent = GetNavigationDetail();

                        // If unuque property is foreign key
                        if (uniqueForeignKeys != null &&
                            uniqueForeignKeys.Any())
                        {
                            foreach (var uniqueFk in uniqueForeignKeys)
                            {
                                // If foreign key has default value
                                if (uniqueFk.Keys.Any(u => entity.HasDefaultValue(u)))
                                {
                                    // Get navigation relation according to foreign key
                                    NavigationRelation navigationRelation = navigationDetailsOfCurrent
                                                                            .Relations
                                                                            .FirstOrDefault(r => r.Direction == NavigationDirection.From &&
                                                                                            r.PropertyTypeName.Equals(uniqueFk.TargetClass) &&
                                                                                            r.ToKeyNames.Intersect(uniqueFk.Keys).Any());

                                    // If corresponding navigation property is not null
                                    // or there is no such navigation property
                                    if (navigationRelation == null ||
                                        entity.GetPropertyValue(navigationRelation.PropertyName) != null)
                                    {
                                        bool foreignKeyHasStoreGeneratedPrimaryKey =
                                            uniqueFk.Keys.Any(k =>
                                        {
                                            // Get origin of foreign key and check
                                            // if it has store generated key.
                                            string foreignKeyOrigin = uniqueSourceTypeManager
                                                                      .GetOriginOfForeignKey(k);
                                            IGraphEntityTypeManager foreignKeyOriginTypeManger = ContextFactory
                                                                                                 .GetEntityTypeManager(foreignKeyOrigin);
                                            return(foreignKeyOriginTypeManger.HasStoreGeneratedKey());
                                        });

                                        // If origin of foreign key has store generated Primary key
                                        if (foreignKeyHasStoreGeneratedPrimaryKey)
                                        {
                                            uniquenessMustBeIgnored = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }

                        // If uniqueness must be ignored then skip this iteration
                        if (uniquenessMustBeIgnored)
                        {
                            continue;
                        }

                        singleExpressionList = parameterExp
                                               .ConstructEqualityExpressions(
                            entity,
                            unique.Properties
                            .Select(m => m.Name).ToList());
                        equalityExpressions.Add(singleExpressionList.ConstructAndChain());
                    }

                    if (equalityExpressions.Count > 0)
                    {
                        ukFilter = equalityExpressions.ConstructOrChain();
                    }
                }
            }

            equalityExpressions.Clear();
            if (pkFilter != null)
            {
                equalityExpressions.Add(pkFilter);
            }

            if (ukFilter != null)
            {
                equalityExpressions.Add(ukFilter);
            }

            if (equalityExpressions.Count > 0)
            {
                Expression filterBaseExpression = typeOfFilter == FilterType.IdAndUnique
                    ? equalityExpressions.ConstructAndChain()
                    : equalityExpressions.ConstructOrChain();

                filterExpression = Expression.Lambda <Func <TEntity, bool> >(
                    filterBaseExpression, parameterExp);
            }

            return(filterExpression);
        }
예제 #11
0
			public _InvocationHandler_107(object target, InterfaceAdapter adapter, ContextFactory cf, Scriptable topScope)
			{
				this.target = target;
				this.adapter = adapter;
				this.cf = cf;
				this.topScope = topScope;
			}
예제 #12
0
 public ShipmentsBO(ContextFactory factory)
 {
     _factory = factory;
 }
        public AdditionalFieldLogic()
        {
            IMMRequestContext IMMRequestContext = ContextFactory.GetNewContext();

            this.repository = new AdditionalFieldRepository(IMMRequestContext);
        }
예제 #14
0
파일: Global.cs 프로젝트: hazzik/Rhino.Net
		public virtual void Init(ContextFactory factory)
		{
			factory.Call(new _ContextAction_77(this));
		}
예제 #15
0
        /// <summary>
        /// Obtient toutes les données du projet spécifié.
        /// </summary>
        /// <param name="projectId">L'identifiant du projet.</param>
        public virtual async Task <RestitutionData> GetFullProjectDetails(int projectId) =>
        await Task.Run(async() =>
        {
            using (var context = ContextFactory.GetNewContext(_securityContext.CurrentUser, _localizationManager))
            {
                IDictionary <ProcessReferentialIdentifier, bool> referentialsUsed = await _sharedScenarioActionsOperations.GetReferentialsUse(context, projectId);
                Referentials referentials = await Queries.LoadAllReferentialsOfProject(context, projectId, referentialsUsed);

                //await context.Videos.Where(v => v.ProjectId == projectId).ToArrayAsync();
                await context.ScenarioNatures.ToArrayAsync();
                await context.ScenarioStates.ToArrayAsync();
                await context.ActionTypes.ToArrayAsync();
                await context.ActionValues.ToArrayAsync();

                Project project = await context.Projects
                                  .Include(nameof(Project.Process))
                                  .Include($"{nameof(Project.Process)}.{nameof(Procedure.Videos)}")
                                  .Include($"{nameof(Project.Process)}.{nameof(Procedure.UserRoleProcesses)}")
                                  .Include($"{nameof(Project.Process)}.{nameof(Procedure.UserRoleProcesses)}.{nameof(UserRoleProcess.User)}")
                                  .Include($"{nameof(Project.Process)}.{nameof(Procedure.UserRoleProcesses)}.{nameof(UserRoleProcess.User)}.{nameof(User.DefaultLanguage)}")
                                  .Include(nameof(Project.Scenarios))
                                  .Include($"{nameof(Project.Scenarios)}.{nameof(Scenario.Actions)}")
                                  .Include(nameof(Project.Objective))
                                  .FirstAsync(s => s.ProjectId == projectId);

                project.ScenariosCriticalPath = PrepareService.GetSummary(project, true);

                // Scénarios
                foreach (Scenario scenario in project.Scenarios.Where(s => s.OriginalScenarioId.HasValue))
                {
                    // Remapper l'original
                    scenario.Original = project.Scenarios.Single(s => s.ScenarioId == scenario.OriginalScenarioId);

                    ScenarioCriticalPath matchingCriticalItem = project.ScenariosCriticalPath.FirstOrDefault(i => i.Id == scenario.ScenarioId);
                    if (matchingCriticalItem != null)
                    {
                        matchingCriticalItem.OriginalLabel = scenario.Original.Label;
                    }
                }

                ProjectReferential[] projectReferentials = await context.ProjectReferentials.Where(pr => pr.ProjectId == projectId).ToArrayAsync();

                User user = await context.Users.FirstAsync(u => u.UserId == project.CreatedByUserId);

                ModificationsUsers modificationsUsers = new ModificationsUsers
                {
                    CreatedByFullName      = (await context.Users.FirstAsync(u => u.UserId == project.ModifiedByUserId)).FullName,
                    LastModifiedByFullName = (await context.Users.FirstAsync(u => u.UserId == project.ModifiedByUserId)).FullName
                };

                Scenario[] scenarios = await context.Scenarios
                                       .Where(s => s.ProjectId == projectId)
                                       .ToArrayAsync();

                await Queries.LoadScenariosDetails(context, scenarios, referentialsUsed);

                ILookup <int, KAction> actionsToLoad = scenarios
                                                       .SelectMany(a => a.Actions)
                                                       .Where(a => a.IsReduced && a.OriginalActionId.HasValue)
                                                       .ToLookup(a => a.OriginalActionId.Value, a => a);

                if (actionsToLoad.Any())
                {
                    foreach (var duration in await _sharedScenarioActionsOperations.GetActionsBuildDurations(context, actionsToLoad.Select(g => g.Key)))
                    {
                        foreach (KAction action in actionsToLoad[duration.ActionId])
                        {
                            action.Reduced.Saving = duration.BuildDuration - action.BuildDuration;
                        }
                    }
                }

                ScenarioActionHierarchyHelper.MapScenariosActionsOriginals(scenarios);

                return(new RestitutionData()
                {
                    Project = project,
                    ProjectCreatedByUser = user,
                    Scenarios = scenarios,
                    ActionCategories = referentials.Categories,
                    ModificationsUsers = modificationsUsers,
                    ReferentialsUse = projectReferentials,
                });
            }
        });
예제 #16
0
 public SubthemeRepository() : base(ContextFactory.GetContext())
 {
 }
예제 #17
0
 /// <summary>
 /// 默认构造函数==  程序内赋值调用  有参参数
 /// </summary>
 public BaseManager( )
     : this(ContextFactory.CurrentContext())
 {
 }
 public ContextElementHandler(ElementFactories factories)
 {
     this._factory = factories.Contexts;
 }
예제 #19
0
 protected override ComponentTestContext CreateContext()
 {
     // NOTE: Db Context transactions are not currenty supported by the EF Core InMemory database.
     // An MSSQL instance is used for unit of work tests.
     return(ContextFactory.CreateContextWithMSSQLDb(nameof(UnitOfWork_Test)));
 }
예제 #20
0
파일: Context.cs 프로젝트: hazzik/Rhino.Net
		/// <summary>Creates a new context.</summary>
		/// <remarks>
		/// Creates a new context. Provided as a preferred super constructor for
		/// subclasses in place of the deprecated default public constructor.
		/// </remarks>
		/// <param name="factory">
		/// the context factory associated with this context (most
		/// likely, the one that created the context). Can not be null. The context
		/// features are inherited from the factory, and the context will also
		/// otherwise use its factory's services.
		/// </param>
		/// <exception cref="System.ArgumentException">if factory parameter is null.</exception>
		protected internal Context(ContextFactory factory)
		{
			// API class
			if (factory == null)
			{
				throw new ArgumentException("factory == null");
			}
			this.factory = factory;
			version = VERSION_DEFAULT;
			optimizationLevel = codegenClass != null ? 0 : -1;
			maximumInterpreterStackDepth = int.MaxValue;
		}
예제 #21
0
 static CoreObservations()
 {
     ContextFactory.ChangeAllowedNumberOfBecauseBlocksTo(2);
 }
예제 #22
0
파일: Context.cs 프로젝트: hazzik/Rhino.Net
		/// <summary>
		/// Call
		/// <see cref="Callable.Call(Context, Scriptable, Scriptable, object[])">Callable.Call(Context, Scriptable, Scriptable, object[])</see>
		/// using the Context instance associated with the current thread.
		/// If no Context is associated with the thread, then
		/// <see cref="ContextFactory.MakeContext()">ContextFactory.MakeContext()</see>
		/// will be called to construct
		/// new Context instance. The instance will be temporary associated
		/// with the thread during call to
		/// <see cref="ContextAction.Run(Context)">ContextAction.Run(Context)</see>
		/// .
		/// <p>
		/// It is allowed but not advisable to use null for <tt>factory</tt>
		/// argument in which case the global static singleton ContextFactory
		/// instance will be used to create new context instances.
		/// </summary>
		/// <seealso cref="ContextFactory.Call(ContextAction)">ContextFactory.Call(ContextAction)</seealso>
		public static object Call(ContextFactory factory, Callable callable, Scriptable scope, Scriptable thisObj, object[] args)
		{
			if (factory == null)
			{
				factory = ContextFactory.GetGlobal();
			}
			return Call(factory, new _ContextAction_476(callable, scope, thisObj, args));
		}
예제 #23
0
 public override void Init(string contextName, ContextFactory factory)
 {
     base.Init(contextName, factory);
     ParseAndSetPeriod(PeriodProperty);
 }
예제 #24
0
파일: Program.cs 프로젝트: hazzik/Rhino.Net
		/// <summary>
		/// Helper method for
		/// <see cref="MainEmbedded(string)">MainEmbedded(string)</see>
		/// , etc.
		/// </summary>
		private static Program MainEmbeddedImpl(ContextFactory factory, object scopeProvider, string title)
		{
			if (title == null)
			{
				title = "Rhino JavaScript Debugger (embedded usage)";
			}
			Program main = new Program(title);
			main.DoBreak();
			main.SetExitAction(new Main.IProxy(Main.IProxy.EXIT_ACTION));
			main.AttachTo(factory);
			if (scopeProvider is ScopeProvider)
			{
				main.SetScopeProvider((ScopeProvider)scopeProvider);
			}
			else
			{
				Scriptable scope = (Scriptable)scopeProvider;
				if (scope is Global)
				{
					Global global = (Global)scope;
					global.SetIn(main.GetIn());
					global.SetOut(main.GetOut());
					global.SetErr(main.GetErr());
				}
				main.SetScope(scope);
			}
			main.Pack();
			main.SetSize(600, 460);
			main.SetVisible(true);
			return main;
		}
예제 #25
0
 public async Task <Image> GetImage(int imageId)
 {
     await using var context = ContextFactory.CreateDbContext(ConnectionString);
     return(context.Images.FirstOrDefault(i => i.Id == imageId));
 }
예제 #26
0
		protected internal override object NewInterfaceProxy(object proxyHelper, ContextFactory cf, InterfaceAdapter adapter, object target, Scriptable topScope)
		{
			ConstructorInfo<object> c = (ConstructorInfo<object>)proxyHelper;
			InvocationHandler handler = new _InvocationHandler_107(target, adapter, cf, topScope);
			// In addition to methods declared in the interface, proxies
			// also route some java.lang.Object methods through the
			// invocation handler.
			// Note: we could compare a proxy and its wrapped function
			// as equal here but that would break symmetry of equal().
			// The reason == suffices here is that proxies are cached
			// in ScriptableObject (see NativeJavaObject.coerceType())
			object proxy;
			try
			{
				proxy = c.NewInstance(handler);
			}
			catch (TargetInvocationException ex)
			{
				throw Context.ThrowAsScriptRuntimeEx(ex);
			}
			catch (MemberAccessException ex)
			{
				// Should not happen
				throw Kit.InitCause(new InvalidOperationException(), ex);
			}
			catch (InstantiationException ex)
			{
				// Should not happen
				throw Kit.InitCause(new InvalidOperationException(), ex);
			}
			return proxy;
		}
예제 #27
0
 public async Task DeleteImage(int imageId)
 {
     await using var context = ContextFactory.CreateDbContext(ConnectionString);
     context.Images.Remove(context.Images.First(i => i.Id == imageId));
     await context.SaveChangesAsync();
 }
 public AssemblyExplorer()
 {
     _contextFactory = new ContextFactory();
 }
예제 #29
0
		public static void SetGlobalContextFactory(ContextFactory factory)
		{
			GrabContextFactoryGlobalSetter();
			globalSetter.SetContextFactoryGlobal(factory);
		}
예제 #30
0
 public Repository2(ContextFactory factory)
 {
     Factory = factory;
 }
 public void Initialize()
 {
     _context         = ContextFactory.CreateContext(true);
     _shareRepository = new ShareRepository(_context);
 }
        /// <summary>
        /// Synchronize keys of entity with matching entity.
        /// <remarks>
        /// In EntityFramework at one-to-one relationships, setting primary key
        /// of parent entity and setting state of entities to Unchanged or to Modified
        /// will also change primary key value of child entity.
        /// But vice-versa is not correct. This means that setting primary key value
        /// of child entity and setting state of entities to Unchanged or to Modified
        /// will not change primary key value of parent key, instead, it resets primary
        /// key value of child entity to its default value, (or to value of primary key
        /// of parent).
        /// This method is for synchronizing PKs of entity and PKs of matching entity and
        /// setting key of parent to key of child entities at one to relationships.
        /// </remarks>
        /// </summary>
        /// <param name="entity">Entity to set pk and parent key values.</param>
        /// <param name="matchingEntity">Found matching entity from underlying source.</param>
        public void SynchronizeKeys(
            TEntity entity,
            TEntity matchingEntity)
        {
            /*
             *
             *
             * Set keys of parent entity to value of child entity at one to one relations.
             *
             *
             */
            IEnumerable <RelationshipDetail> associatedRealtionships = GetForeignKeyDetails()
                                                                       .Where(m => m.ToDetails.ContainerClass.Equals(entity.GetType().Name) &&
                                                                              m.ToDetails.RelationshipMultiplicity == RelationshipMultiplicity.One);

            foreach (RelationshipDetail relationshipDetail in associatedRealtionships)
            {
                // Get parent property name from navigation details using information from foreign keys
                IGraphEntityTypeManager entityTypeManager = ContextFactory
                                                            .GetEntityTypeManager(relationshipDetail.ToDetails.ContainerClass);
                string parentPropertyName = entityTypeManager
                                            .GetNavigationDetail()
                                            .Relations
                                            .Where(n => n.PropertyTypeName.Equals(relationshipDetail.FromDetails.ContainerClass) &&
                                                   n.SourceMultiplicity == relationshipDetail.ToDetails.RelationshipMultiplicity &&
                                                   n.TargetMultiplicity == relationshipDetail.FromDetails.RelationshipMultiplicity)
                                            .Select(n => n.PropertyName)
                                            .FirstOrDefault();

                dynamic parent = entity.GetPropertyValue(parentPropertyName);

                if (parent != null)
                {
                    for (int i = 0; i < relationshipDetail.FromDetails.Keys.Count; i++)
                    {
                        // Get matching from and to key names
                        string fromKeyName = relationshipDetail.FromDetails.Keys[i];
                        string toKeyName   = relationshipDetail.ToDetails.Keys[i];

                        ReflectionExtensions.SetPropertyValue(parent,
                                                              fromKeyName,
                                                              matchingEntity.GetPropertyValue(toKeyName));
                    }
                }
            }

            /*
             *   Description:
             *     PK value shuold be changed by using
             *     context.Entry(entity).Property(pkName).CurrentValue = pkValue;
             *     becasue setting value by entity.pkName = pkValue will not synchronize
             *     it with dependent navigation properties automatically but prior method
             *     will do it.
             *     Primary key values of entity itself must be changed after
             *     principal parent keys has been synchronized. Because changing
             *     primary key value of entity using
             *     context.Entry(entity).Property(pkName).CurrentValue = pkValue
             *     set principal parent navigation property to null.
             */
            IEnumerable <string> primaryKeyNames = GetPrimaryKeys();

            DbEntityEntry current = Context.Entry(entity);

            foreach (string primaryKey in primaryKeyNames)
            {
                current.Property(primaryKey).CurrentValue =
                    matchingEntity.GetPropertyValue(primaryKey);
            }
        }
 protected override void Initialize(RequestContext requestContext)
 {
     this._DbContext = ContextFactory.GetContextPerRequest();
     base.Initialize(requestContext);
 }
예제 #34
0
 public ApiBlogsController(ContextFactory contextFactory)
 {
     _contextFactory = contextFactory;
 }
예제 #35
0
 public static UCategory GetCategory(string idCategory)
 {
     return(ContextFactory.GetDBContext().UCategories.FirstOrDefault(c => c.Code.Contains(idCategory)));
 }
예제 #36
0
 /// <summary>
 /// Gets the context.
 /// </summary>
 /// <returns>DataContextBase.</returns>
 protected DataContextBase GetContext()
 {
     return(ContextFactory.GetContext(this.currentClientUser.GetProfile()));
 }
예제 #37
0
 public BaseController()
 {
     unitOfWork = ContextFactory.CreateContext(typeof(T));
     Repository = unitOfWork.Repository <T>();
 }
예제 #38
0
파일: Context.cs 프로젝트: hazzik/Rhino.Net
		internal static Rhino.Context Enter(Rhino.Context cx, ContextFactory factory)
		{
			object helper = VMBridge.instance.GetThreadContextHelper();
			Rhino.Context old = VMBridge.instance.GetContext(helper);
			if (old != null)
			{
				cx = old;
			}
			else
			{
				if (cx == null)
				{
					cx = factory.MakeContext();
					if (cx.enterCount != 0)
					{
						throw new InvalidOperationException("factory.makeContext() returned Context instance already associated with some thread");
					}
					factory.OnContextCreated(cx);
					if (factory.IsSealed() && !cx.IsSealed())
					{
						cx.Seal(null);
					}
				}
				else
				{
					if (cx.enterCount != 0)
					{
						throw new InvalidOperationException("can not use Context instance already associated with some thread");
					}
				}
				VMBridge.instance.SetContext(helper, cx);
			}
			++cx.enterCount;
			return cx;
		}
예제 #39
0
 public TableController()
 {
     this.publishingService    = new PublishingService <Table, DraftTable, TableRepository>(ContextFactory.GetContext(System.Web.HttpContext.Current));
     this.productStatusService = new ProductStatusService(ContextFactory.GetContext(System.Web.HttpContext.Current));
     this.helperService        = new HelperService();
 }
예제 #40
0
파일: Context.cs 프로젝트: hazzik/Rhino.Net
		/// <summary>
		/// The method implements
		/// <see cref="ContextFactory.Call(ContextAction)">ContextFactory.Call(ContextAction)</see>
		/// logic.
		/// </summary>
		internal static object Call(ContextFactory factory, ContextAction action)
		{
			Rhino.Context cx = Enter(null, factory);
			try
			{
				return action.Run(cx);
			}
			finally
			{
				Exit();
			}
		}
        public FileExplorer(MSpecUnitTestProvider provider,
                            IUnitTestElementManager manager,
                            PsiModuleManager psiModuleManager,
                            CacheManager cacheManager,
                            UnitTestElementLocationConsumer consumer,
                            IFile file,
                            CheckForInterrupt interrupted)
        {
            if (file == null)
            {
                throw new ArgumentNullException("file");
            }

            if (provider == null)
            {
                throw new ArgumentNullException("provider");
            }

            _consumer    = consumer;
            _file        = file;
            _interrupted = interrupted;

            var project      = file.GetSourceFile().ToProjectFile().GetProject();
            var projectEnvoy = new ProjectModelElementEnvoy(project);
            var assemblyPath = UnitTestManager.GetOutputAssemblyPath(project).FullPath;

            var cache = new ElementCache();

            var contextFactory = new ContextFactory(provider,
                                                    manager,
                                                    psiModuleManager,
                                                    cacheManager,
                                                    project,
                                                    projectEnvoy,
                                                    assemblyPath,
                                                    cache);
            var contextSpecificationFactory = new ContextSpecificationFactory(provider,
                                                                              manager,
                                                                              psiModuleManager,
                                                                              cacheManager,
                                                                              project,
                                                                              projectEnvoy,
                                                                              cache);
            var behaviorFactory = new BehaviorFactory(provider,
                                                      manager,
                                                      psiModuleManager,
                                                      cacheManager,
                                                      project,
                                                      projectEnvoy,
                                                      cache);
            var behaviorSpecificationFactory = new BehaviorSpecificationFactory(provider,
                                                                                manager,
                                                                                psiModuleManager,
                                                                                cacheManager,
                                                                                project,
                                                                                projectEnvoy);

            _elementHandlers = new List <IElementHandler>
            {
                new ContextElementHandler(contextFactory),
                new ContextSpecificationElementHandler(contextSpecificationFactory),
                new BehaviorElementHandler(behaviorFactory, behaviorSpecificationFactory)
            };
        }
예제 #42
0
 public void setContextFactory(ContextFactory f)
 {
     this.factory = f;
 }
예제 #43
0
		/// <summary>
		/// Create helper object to create later proxies implementing the specified
		/// interfaces later.
		/// </summary>
		/// <remarks>
		/// Create helper object to create later proxies implementing the specified
		/// interfaces later. Under JDK 1.3 the implementation can look like:
		/// <pre>
		/// return java.lang.reflect.Proxy.getProxyClass(..., interfaces).
		/// getConstructor(new Class[] {
		/// java.lang.reflect.InvocationHandler.class });
		/// </pre>
		/// </remarks>
		/// <param name="interfaces">Array with one or more interface class objects.</param>
		protected internal virtual object GetInterfaceProxyHelper(ContextFactory cf, Type[] interfaces)
		{
			throw Context.ReportRuntimeError("VMBridge.getInterfaceProxyHelper is not supported");
		}
			internal MyContext(ContextFactory factory) : base(factory)
			{
			}
예제 #45
0
		private InterfaceAdapter(ContextFactory cf, Type cl)
		{
			this.proxyHelper = VMBridge.instance.GetInterfaceProxyHelper(cf, new Type[] { cl });
		}
예제 #46
0
파일: Program.cs 프로젝트: hazzik/Rhino.Net
		/// <summary>Entry point for embedded applications.</summary>
		/// <remarks>
		/// Entry point for embedded applications.  This method attaches
		/// to the given
		/// <see cref="Rhino.ContextFactory">Rhino.ContextFactory</see>
		/// with the given scope.  No
		/// I/O redirection is performed as with
		/// <see cref="Main(string[])">Main(string[])</see>
		/// .
		/// </remarks>
		public static Program MainEmbedded(ContextFactory factory, ScopeProvider scopeProvider, string title)
		{
			return MainEmbeddedImpl(factory, scopeProvider, title);
		}
예제 #47
0
파일: Dim.cs 프로젝트: hazzik/Rhino.Net
		/// <summary>Attaches the debugger to the given ContextFactory.</summary>
		/// <remarks>Attaches the debugger to the given ContextFactory.</remarks>
		public virtual void AttachTo(ContextFactory factory)
		{
			Detach();
			this.contextFactory = factory;
			this.listener = new Dim.DimIProxy(this, IPROXY_LISTEN);
			factory.AddListener(this.listener);
		}
예제 #48
0
 public CtaMovimientosDal(SecurityEntities context, ContextFactory contextFactory)
     : base(context, contextFactory)
 {
 }
예제 #49
0
        private void Blogreader()
        {
            ContextFactory         cfact   = new ContextFactory();
            AggregatorDBContext    adbcont = cfact.CreateDbContext(new string[] { "", "" });
            ICollection <Author>   authors = new List <Author>();
            ICollection <Category> cats    = new List <Category>();

            List <Blog> blogs = new List <Blog>();

            blogs = adbcont.Blogs.ToList();
            foreach (Blog b in blogs)
            {
                string blogURL = b.BlogURL;
                var    reader  = XmlReader.Create(blogURL);
                var    feed    = SyndicationFeed.Load(reader);

                foreach (SyndicationItem article in feed.Items)
                {
                    Post post = adbcont.Posts.FirstOrDefault(a => a.PostTitle == article.Title.Text && a.Lastupdated == article.LastUpdatedTime);

                    if (post == null)
                    {
                        Post post1 = new Post();
                        List <ArticleAuthor>   aa = new List <ArticleAuthor>();
                        List <ArticleCategory> ac = new List <ArticleCategory>();
                        post1.ArticleAuthors    = aa;
                        post1.ArticleCategories = ac;


                        post1.Lastupdated     = article.LastUpdatedTime.UtcDateTime;
                        post1.PostDateCreated = article.PublishDate.UtcDateTime;
                        ICollection <SyndicationLink> links = new List <SyndicationLink>();
                        links = article.Links;
                        foreach (SyndicationLink l in links)
                        {
                            post1.absURI = l.GetAbsoluteUri().AbsoluteUri;
                        }
                        if (article.Title.Text.Length >= 60)
                        {
                            post1.PostTitle = article.Title.Text.Substring(0, 59);
                        }
                        else
                        {
                            post1.PostTitle = article.Title.Text;
                        }
                        post1.BlogID = b.BlogID;

                        if (article.Summary.Text.Length > 999)
                        {
                            post1.Summary = article.Summary.Text.Substring(0, 998);
                        }
                        else
                        {
                            post1.Summary = article.Summary.Text;
                        }


                        foreach (SyndicationPerson author in article.Authors)
                        {
                            Author        author1 = (Author)adbcont.Authors.FirstOrDefault(a => a.AuthorName == author.Name && a.AuthorEmail == author.Email);
                            ArticleAuthor aaa     = new ArticleAuthor();

                            if (author1 == null)
                            {
                                author1             = new Author();
                                author1.AuthorEmail = author.Email;
                                author1.AuthorName  = author.Name;
                                author1.AuthorURI   = author.Uri;
                                adbcont.Authors.Add(author1);
                            }

                            aaa.Posts   = post;
                            aaa.Authors = author1;
                            post1.ArticleAuthors.Add(aaa);
                        }
                        foreach (SyndicationCategory cat in article.Categories)
                        {
                            if (cat != null && !string.IsNullOrEmpty(cat.Name) && cat.Name != "NULL")
                            {
                                Category        category1 = adbcont.Categories.FirstOrDefault(a => a.CategoryName == cat.Name && a.Label == cat.Label);
                                ArticleCategory acc       = new ArticleCategory();

                                if (category1 == null)
                                {
                                    Category category = new Category();
                                    category.CategoryName = cat.Name;
                                    category.Label        = cat.Label;
                                    adbcont.Categories.Add(category);
                                    acc.Categories = category;
                                    acc.Posts      = post1;
                                    post1.ArticleCategories.Add(acc);
                                }
                            }
                        }
                        adbcont.Posts.Add(post1);
                        adbcont.SaveChanges();
                    }
                }
            }
        }
예제 #50
0
		private void DoTest(int optimizationLevel, string expected, ContextAction action)
		{
			object o = new ContextFactory().Call(new _ContextAction_128(optimizationLevel, action));
			NUnit.Framework.Assert.AreEqual(expected, o);
		}
 public override Person First(ISpecification <Person> specification)
 {
     return(ContextFactory.GetContext().Person.Where(specification.Expression.Compile()).FirstOrDefault());
 }
예제 #52
0
		/// <summary>
		/// Create proxy object for
		/// <see cref="InterfaceAdapter">InterfaceAdapter</see>
		/// . The proxy should call
		/// <see cref="InterfaceAdapter.Invoke(ContextFactory, object, Scriptable, object, System.Reflection.MethodInfo, object[])">InterfaceAdapter.Invoke(ContextFactory, object, Scriptable, object, System.Reflection.MethodInfo, object[])</see>
		/// as implementation of interface methods associated with
		/// <tt>proxyHelper</tt>.
		/// </summary>
		/// <param name="proxyHelper">
		/// The result of the previous call to
		/// <see cref="GetInterfaceProxyHelper(ContextFactory, System.Type{T}[])">GetInterfaceProxyHelper(ContextFactory, System.Type&lt;T&gt;[])</see>
		/// .
		/// </param>
		protected internal virtual object NewInterfaceProxy(object proxyHelper, ContextFactory cf, InterfaceAdapter adapter, object target, Scriptable topScope)
		{
			throw Context.ReportRuntimeError("VMBridge.newInterfaceProxy is not supported");
		}
 public override IQueryable <Person> Filter(ISpecification <Person> specification)
 {
     return(ContextFactory.GetContext().Person.Where(specification.Expression.Compile()).AsQueryable());
 }
예제 #54
0
		public virtual object Invoke(ContextFactory cf, object target, Scriptable topScope, object thisObject, MethodInfo method, object[] args)
		{
			ContextAction action = new _ContextAction_80(this, target, topScope, thisObject, method, args);
			return cf.Call(action);
		}
 public override Person Update(Person itemToUpdate)
 {
     ContextFactory.GetContext().SaveChanges();
     return(itemToUpdate);
 }
예제 #56
0
파일: Dim.cs 프로젝트: hazzik/Rhino.Net
		/// <summary>Detaches the debugger from the current ContextFactory.</summary>
		/// <remarks>Detaches the debugger from the current ContextFactory.</remarks>
		public virtual void Detach()
		{
			if (listener != null)
			{
				contextFactory.RemoveListener(listener);
				contextFactory = null;
				listener = null;
			}
		}
 public override void SaveChanges()
 {
     ContextFactory.GetContext().SaveChanges();
 }
예제 #58
0
 public SNFichadasDal(SecurityEntities context, ContextFactory contextFactory)
     : base(context, contextFactory)
 {
 }
예제 #59
0
파일: Program.cs 프로젝트: hazzik/Rhino.Net
		/// <summary>
		/// Attaches the debugger to the given
		/// <see cref="Rhino.ContextFactory">Rhino.ContextFactory</see>
		/// .
		/// </summary>
		public virtual void AttachTo(ContextFactory factory)
		{
			dim.AttachTo(factory);
		}