Beispiel #1
0
        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 static SurveyPersonCampaign CreatePersonCampaign(UserSurvey survey, string name)
        {
            var campaign = Entity.Create <SurveyPersonCampaign>();

            campaign.Name = name;
            campaign.SurveyForCampaign = survey;

            survey.SurveyCampaigns.Add(campaign.Cast <SurveyCampaign>());

            return(campaign);
        }
Beispiel #3
0
 private IStateMonad CreateMonad(MockRepository repo)
 {
     return
         (new StateMonad(
              repo.OneOf <ILogger>(),
              new SCLSettings(Entity.Create()),
              StepFactoryStore.Create(Array.Empty <ConnectorData>()),
              repo.OneOf <IExternalContext>(),
              repo.OneOf <IReadOnlyDictionary <string, object> >()
              ));
 }
        void AddReply(SmsSendRecord send, string body)
        {
            var reply = Entity.Create <ReplyRecord>();

            reply.RrReply     = body;
            reply.RrReplyDate = DateTime.UtcNow;
            reply.RrToSend    = send.As <SendRecord>();
            reply.Save();

            EventLog.Application.WriteInformation($"SMS matched and reply created");
        }
        private static ManagedTenant CreateTestTenant(IManagedPlatform platform)
        {
            var tenant = Entity.Create <ManagedTenant>();

            tenant.Name = TestTenantName;

            platform.ContainsTenants.Add(tenant);
            tenant.Platform = platform;

            return(tenant);
        }
        Workflow CreatePausedWorkflow()
        {
            var workflow = CreateWorkflow();

            var run = Entity.Create <WorkflowRun>();

            run.WorkflowRunStatus_Enum = WorkflowRunState_Enumeration.WorkflowRunPaused;
            workflow.RunningInstances.Add(run);

            return(workflow);
        }
        /// <summary>
        /// Create a task used to review someone elses answers.
        /// </summary>
        /// <param name="survey"></param>
        /// <param name="reviewer"></param>
        /// <param name="result"></param>
        UserSurveyTask CreateReviewTask(UserSurvey survey, Person reviewer, SurveyResponse result)
        {
            var task = Entity.Create <UserSurveyTask>();

            task.UserSurveyTaskForReview      = true;
            task.AssignedToUser               = reviewer;
            task.UserSurveyTaskSurveyResponse = result;
            task.UserTaskDueOn = null;                      // The review can be completed after the campaign finshes
            task.Name          = string.Format(reviewTaskName, result.SurveyTaker.Name ?? "[Unnamed]", survey.Name ?? "[Unnamed]");

            return(task);
        }
        private UserAccount CreateSelfServeUser(string userName)
        {
            Role        role = Entity.Get <Role>("core:selfServeRole");
            UserAccount userAccount;

            userAccount      = Entity.Create <UserAccount>( );
            userAccount.Name = userName;
            userAccount.UserHasRole.Add(role);
            userAccount.Save( );

            return(userAccount);
        }
        private static ManagedUser CreateTestUser(IManagedTenant tenant)
        {
            var user = Entity.Create <ManagedUser>();

            user.RemoteId = TestUserRemoteId.ToString();
            user.Name     = TestUserName;

            tenant.Users.Add(user);
            user.Tenant = tenant;

            return(user);
        }
Beispiel #10
0
        public void NoComments()
        {
            SurveyResponse result = CreateResult();

            var reviewer = Entity.Create <Person>();

            var task = ReviewSurveyImplementation.ReviewSurvey(result, reviewer, null, 0, false, "taskName");

            task.Save();

            Assert.That(task.UserSurveyTaskAllowComments, Is.False);
        }
Beispiel #11
0
        public void NoDueDate()
        {
            SurveyResponse result = CreateResult();

            var reviewer = Entity.Create <Person>();

            var task = ReviewSurveyImplementation.ReviewSurvey(result, reviewer, null, 0, true, "taskName");

            task.Save();

            Assert.That(task.UserTaskDueOn, Is.Null);
        }
        Workflow CreateWf(string name)
        {
            var wf = Entity.Create <Workflow>();

            wf.Name = name;
            wf.AddDefaultExitPoint()
            .AddInput <ResourceArgument>("campaign", SurveyCampaign.SurveyCampaign_Type)
            .AddStartSurvey("Start Survey", "[campaign]");

            wf.Save();
            return(wf);
        }
Beispiel #13
0
		/// <summary>
		///     Creates the tenant.
		/// </summary>
		/// <param name="name">The name.</param>
		/// <param name="description">The description.</param>
		/// <returns></returns>
		public static long CreateTenant( string name = DefaultTenantName, string description = DefaultTenantDescription )
		{
			using ( new GlobalAdministratorContext( ) )
			{
				var tenant = Entity.Create<Tenant>( );
				tenant.Name = name;
				tenant.Description = description;
				tenant.Save( );

				return tenant.Id;
			}
		}
Beispiel #14
0
 Func <Workflow> DisplayFormWfFactory(IEntity person, IEntity form)
 {
     return(() =>
            Entity
            .Create <Workflow>()
            .AddDefaultExitPoint()
            .AddVariable <ResourceArgument>("vPerson", null, Person.Person_Type)
            .AddEntityExpressionToVariable("vPerson", person.Id)
            .AddVariable <ResourceArgument>("vForm", null, CustomEditForm.CustomEditForm_Type)
            .AddEntityExpressionToVariable("vForm", form.Id)
            .AddDisplayForm("Display Form", new string[] { "Exit1" }, "vForm", null, "vPerson"));
 }
Beispiel #15
0
        Role CreateRole()
        {
            var role = Entity.Create <Role>();

            role.Name = "test role " + Guid.NewGuid();
            role.Save();

            new AccessRuleFactory().AddAllowReadQuery(role.As <Subject>(),
                                                      Person.Person_Type.As <SecurableEntity>(), TestQueries.EntitiesWithNameA().ToReport());

            return(role);
        }
        public void Test_CascadingDeleteOfPermission()
        {
            Folder          folder;
            Report          report;
            AccessRule      accessRule;
            SecurableEntity securableEntity;
            Permission      permission;
            Subject         subject;

            using (DatabaseContext.GetContext(true))
            {
                folder = new Folder();
                folder.Save();

                report = Entity.Create <Report>();
                report.SecurityReportInFolder = folder;
                report.Save();

                report = Entity.Create <Report>();
                report.Save();

                securableEntity      = Entity.Create <SecurableEntity>();
                securableEntity.Name = "Test Securable Entity";
                securableEntity.Save();

                permission      = Entity.Create <Permission>();
                permission.Name = "Test Permission";
                permission.Save();

                subject      = Entity.Create <Subject>();
                subject.Name = "Test Subject";
                subject.Save();

                accessRule                  = Entity.Create <AccessRule>();
                accessRule.Name             = "Test Access Rule";
                accessRule.AllowAccessBy    = subject;
                accessRule.AccessRuleReport = report;
                accessRule.ControlAccess    = securableEntity;
                accessRule.PermissionAccess.Add(permission);
                accessRule.Save();

                Assert.That(Entity.Exists(permission), Is.True, "Permission exists");

                Entity.Delete(permission);

                Assert.That(Entity.Exists(accessRule), Is.True, "Access rule does not exist after delete");
                Assert.That(Entity.Exists(securableEntity), Is.True, "Securable entity does not exist after delete");
                Assert.That(!Entity.Exists(permission), Is.True, "Permission still exists after delete");
                Assert.That(Entity.Exists(subject), Is.True, "Subject does not exist after delete");
                Assert.That(Entity.Exists(report), Is.True, "Report does not exist after delete");
                Assert.That(Entity.Exists(folder), Is.True, "Folder still exists after delete");
            }
        }
Beispiel #17
0
 public GameObject Instantiate(MapEvent mapEvent)
 {
     return(Entity.Create("teleport", mapEvent.Position)
            .Add(new Collision {
         IsBlocking = false
     })
            .Add(x => new BoxCollider(x.World))
            .Add(new StepTrigger())
            .Add(new OnCollision {
         Action = _ => Navigate(mapEvent)
     }));
 }
        /// <summary>
        /// Start the activity running
        /// </summary>
        /// <returns>True if the activity has completed, false if it is paused. Along with a sequence number of if it is paused</returns>
        public override bool OnStart(IRunState context, ActivityInputs inputs)
        {
            var survey       = GetArgumentEntity <UserSurvey>(inputs, "inLaunchPersonSurvey");
            var recipients   = GetArgumentEntityList <Person>(inputs, "inLaunchPersonRecipients").ToList();
            var targetObject = GetArgumentEntity <UserResource>(inputs, "inLaunchPersonTarget");
            var taskName     = GetArgumentValue <string>(inputs, "inLaunchPersonTaskName");
            var dueInDays    = GetArgumentValue(inputs, "inLaunchPersonDueDays", 0m);
            var pause        = GetArgumentValue(inputs, "inLaunchPersonPause", false);

            // ensure that there is at least one recipient
            if (recipients.Count <= 0)
            {
                throw new WorkflowRunException("The recipients list for the Survey was empty.");
            }

            var campaign = Entity.Create <SurveyPersonCampaign>();

            campaign.Name = $"Person Campaign ({survey.Name})";
            campaign.SurveyForCampaign = survey;
            campaign.CampaignPersonRecipients.AddRange(recipients);
            if (dueInDays > 0)
            {
                campaign.SurveyClosesOn = DateTime.UtcNow.AddDays(decimal.ToDouble(dueInDays));
            }

            var tasks = campaign.Launch(campaign.SurveyClosesOn, targetObject, taskName).ToList();

            if (pause)
            {
                foreach (var task in tasks)
                {
                    // this will do the save for us.
                    context.SetUserTask(task.Cast <BaseUserTask>());
                }
            }
            else
            {
                Entity.Save(tasks);
            }

            var responses = tasks.Select(t => t.UserSurveyTaskSurveyResponse);

            context.SetArgValue(ActivityInstance, GetArgumentKey("core:outLaunchPersonResponses"), responses);

            // Deal with time-outs. Time-outs can only occur if there is due date and we are pausing.
            if (pause)
            {
                SetTimeoutIfNeeded(context, dueInDays);
            }

            // Note that there is no need to set an exit point if we are not pausing as the default exit point will be used.
            return(!pause);
        }
        private bool TryResolveFields(Entity owner, string key, IType type, out Entity result)
        {
            metaDataTemplate metaDataTemplate = templateRepository.FieldTemplates
                                                .FirstOrDefault(t => t.name.Plural().Equals(key,
                                                                                            StringComparison
                                                                                            .OrdinalIgnoreCase));

            if (metaDataTemplate != null)
            {
                IEnumerable <IField> fields = type.Fields
                                              .Where(f => f.Attributes
                                                     .Any(a => a.Name
                                                          .Equals(metaDataTemplate.name,
                                                                  StringComparison.OrdinalIgnoreCase)));
                result = owner.Create(key, fields.Select(f => owner.Create(metaDataTemplate.name, f.Name, f)));
                return(true);
            }

            result = null;
            return(false);
        }
    private void BtnSalvar_Click(object sender, EventArgs e)
    {
        Handle            handle          = new Handle(dropPaises.SelectedValue);
        EntityAssociation paisAssociation = new EntityAssociation(handle, paisDefinition);
        EntityBase        pessoa          = Entity.Create(pessoaDefinition);

        pessoa.Fields["NOME"] = txtNome.Text;
        pessoa.Fields["CPF"]  = txtCPF.Text;
        pessoa.Fields["PAIS"] = paisAssociation;
        pessoa.Save();
        PintaGrid();
    }
        public void RegisteredTriggerHandlersFires_OnReverseRelUpdate()
        {
            Relationship rel            = null;
            IEntity      dummyObj       = null;
            IEntity      dummyOtherObj1 = null;
            IEntity      dummyOtherObj2 = null;

            var testHandler = new TestHandler
            {
                ExpectedBeforeReverseAddCount = 1,
                ExpectedAfterReverseAddCount  = 1,
            };

            TestTrigger(testHandler,
                        (policy) =>
            {
                var otherType = Entity.Create <EntityType>();
                otherType.Save();
                _toDelete.Add(otherType.Id);

                rel                  = Entity.Create <Relationship>();
                rel.FromType         = policy.TriggeredOnType;
                rel.ToType           = otherType;
                rel.RelType_Enum     = RelTypeEnum_Enumeration.RelLookup;
                rel.Cardinality_Enum = CardinalityEnum_Enumeration.ManyToOne;
                rel.Save();
                _toDelete.Add(rel.Id);

                var writablePolicy = policy.AsWritable <ResourceTriggerFilterDef>();
                writablePolicy.UpdatedRelationshipsToTriggerOn.Add(rel);
                writablePolicy.Save();

                dummyOtherObj1 = Entity.Create(otherType);
                dummyOtherObj1.Save();
                _toDelete.Add(dummyOtherObj1.Id);

                dummyOtherObj2 = Entity.Create(otherType);
                dummyOtherObj2.Save();
                _toDelete.Add(dummyOtherObj2.Id);

                dummyObj = Entity.Create(policy.TriggeredOnType);
                dummyObj.GetRelationships(rel, Direction.Reverse).Add(dummyOtherObj1);      // add an exsiting item to ensure we a are only triggering on the new one.
                dummyObj.Save();
                _toDelete.Add(dummyObj.Id);
            },
                        (policy) =>
            {
                var writable = dummyOtherObj2.AsWritable <IEntity>();
                writable.GetRelationships(rel, Direction.Reverse).Add(dummyObj);
                writable.Save();
            }
                        );
        }
 public GameObject CreateMovingObject(Tsx tsx, Vector2 location, ZIndex zIndex)
 {
     return(Entity.Create("TsxMovingObject", new Transform2(location, new Size2(tsx.TileWidth, tsx.TileHeight), zIndex))
            .Add((o, r) => new Texture(r.LoadTexture(tsx.ImageSource, o)))
            .Add(o => new Animation(0, o.Get <Texture>()))
            .Add(o => CreateMotionAnimationStates(tsx, o.Get <Texture>().Value))
            .Add(new Motion2(new Velocity2()))
            .Add(new Collision())
            .Add(new BoxCollider(Transform2.Zero))
            .Add(new MotionState())
            .Add(CreateBoxColliderStates(tsx)));
 }
        protected override void OnAwake()
        {
            var prefab = Box.Load <GameObject>("MonoPoint");

            for (int i = 0, length = CountInput.CountEntities; i < length; i++)
            {
                var     entity = Entity.Create(prefab);
                ref var eBench = ref entity.Set <ComponentBench>();
                eBench.transform = entity.transform;
                eBench.position  = new Vector3(Random.Range(-100f, 100f), Random.Range(-100f, 100f), Random.Range(-100f, 100f));
                entity.transform.localPosition = eBench.position;
            }
Beispiel #24
0
        public void Test_IncludedRoles( )
        {
            // Note: ExpectedResult is null when we expect no grant

            Definition     type       = null; // needs to be definition, otherwise gets filtered from the report.
            Role           parentRole = null;
            Role           childRole  = null;
            List <IEntity> cleanup    = new List <IEntity>( );

            try
            {
                EntityType editableResource = UserResource.UserResource_Type;

                // Setup scenario
                type      = Entity.Create <Definition>( );
                type.Name = Guid.NewGuid().ToString( );
                type.Inherits.Add(editableResource);
                type.Save( );
                cleanup.Add(type);

                // Set up roles
                parentRole = Entity.Create <Role>( );
                childRole  = Entity.Create <Role>( );
                parentRole.IncludesRoles.Add(childRole);
                parentRole.Save( );

                cleanup.Add(parentRole);
                cleanup.Add(childRole);

                new AccessRuleFactory( ).AddAllowReadQuery(parentRole.As <Subject>( ), type.As <SecurableEntity>( ), TestQueries.Entities(type).ToReport( ));
                new AccessRuleFactory( ).AddAllowModifyQuery(childRole.As <Subject>( ), type.As <SecurableEntity>( ), TestQueries.Entities(type).ToReport( ));

                // Tests
                ITypeAccessReasonService service = Factory.Current.Resolve <ITypeAccessReasonService>( );
                var reasons = service.GetTypeAccessReasons(childRole.Id, TypeAccessReasonSettings.Default);

                Assert.That(reasons.Where(reason => reason.SubjectId == WellKnownAliases.CurrentTenant.EveryoneRole).Count(), Is.GreaterThan(0));

                // Sanity check for the type we explicitly grant accses
                AccessReason childReason  = reasons.SingleOrDefault(r => r.SubjectId == childRole.Id);
                AccessReason parentReason = reasons.SingleOrDefault(r => r.SubjectId == parentRole.Id);

                Assert.That(childReason, Is.Not.Null, "child reason");
                Assert.That(parentReason, Is.Not.Null, "parent reason");
                Assert.That(childReason.TypeId, Is.EqualTo(type.Id), "child reason type");
                Assert.That(parentReason.TypeId, Is.EqualTo(type.Id), "parent reason type");
            }
            finally
            {
                Entity.Delete(cleanup.Select(e => new EntityRef(e)));
            }
        }
Beispiel #25
0
        //[TestCase("core:modify", false, true)]  // unsupported
        //[TestCase("core:delete", false, false)] // unsupported
        //[TestCase( "core:modify,core:delete", false, true )] // unsupported
        public void Test_Save(string permissionAliases, bool canGetEntity, bool canSaveEntity)
        {
            UserAccount userAccount = null;
            EntityType  entityType  = null;
            IEntity     entity1     = null;
            IEntity     entity2     = null;
            IEntity     loadedEntity;

            userAccount      = Entity.Create <UserAccount>();
            userAccount.Name = "Test user " + Guid.NewGuid().ToString();
            userAccount.Save();

            entityType = new EntityType();
            entityType.Inherits.Add(UserResource.UserResource_Type);
            entityType.Save();

            entity1 = Entity.Create(new EntityRef(entityType));
            entity1.SetField("core:name", "A");
            entity1.Save();

            entity2 = Entity.Create(new EntityRef(entityType));
            entity2.SetField("core:name", "B");
            entity2.Save();

            if (permissionAliases.Length > 0)
            {
                new AccessRuleFactory().AddAllowByQuery(userAccount.As <Subject>(), entityType.As <SecurableEntity>(),
                                                        permissionAliases.Split(',').Select(x => new EntityRef(x)),
                                                        TestQueries.EntitiesWithNameA().ToReport());
            }

            using (new SetUser(userAccount))
            {
                // Only check read permission, even when getting a writable version
                loadedEntity = null;
                Assert.That(() => loadedEntity = Entity.Get <IEntity>(new EntityRef(entity1), true),
                            canGetEntity
                        ? (Constraint)Is.EqualTo(entity1).Using(EntityRefComparer.Instance)
                        : (Constraint)Throws.TypeOf <PlatformSecurityException>(), "Entity 1 Get is incorrect");
                Assert.That(() => Entity.Get <IEntity>(new EntityRef(entity2), true),
                            Throws.TypeOf <PlatformSecurityException>(), "Entity 2 access failed");

                if (canGetEntity)
                {
                    // Requires modify permission
                    Assert.That(() => loadedEntity.Save(),
                                canSaveEntity
                            ? (Constraint)Throws.Nothing
                            : (Constraint)Throws.TypeOf <PlatformSecurityException>());
                }
            }
        }
        public void RegisteredTriggerHandlersFires_OnDeleteOfOther()
        {
            Relationship rel = null;
            IEntity      dummyObj = null;
            IEntity      dummyOtherObj1 = null, dummyOtherObj2 = null;

            var testHandler = new TestHandler
            {
                ExpectedBeforeReverseRemoveCount = 2,
                ExpectedAfterReverseRemoveCount  = 2,
            };

            TestTrigger(testHandler,
                        (policy) =>
            {
                var otherDummyType = Entity.Create <EntityType>();
                otherDummyType.Save();
                _toDelete.Add(otherDummyType.Id);

                rel                  = Entity.Create <Relationship>();
                rel.FromType         = policy.TriggeredOnType;
                rel.ToType           = otherDummyType;
                rel.RelType_Enum     = RelTypeEnum_Enumeration.RelLookup;
                rel.Cardinality_Enum = CardinalityEnum_Enumeration.ManyToMany;
                rel.Save();
                _toDelete.Add(rel.Id);

                var writablePolicy = policy.AsWritable <ResourceTriggerFilterDef>();
                writablePolicy.UpdatedRelationshipsToTriggerOn.Add(rel);
                writablePolicy.Save();

                dummyObj = Entity.Create(policy.TriggeredOnType);
                dummyObj.Save();
                _toDelete.Add(dummyObj.Id);

                dummyOtherObj1 = Entity.Create(otherDummyType);
                dummyOtherObj1.GetRelationships(rel, Direction.Reverse).Add(dummyObj);
                dummyOtherObj1.Save();
                _toDelete.Add(dummyOtherObj1.Id);

                dummyOtherObj2 = Entity.Create(otherDummyType);
                dummyOtherObj2.GetRelationships(rel, Direction.Reverse).Add(dummyObj);
                dummyOtherObj2.Save();
                _toDelete.Add(dummyOtherObj2.Id);
            },
                        (policy) =>
            {
                Entity.Delete(dummyOtherObj1.Id);
                Entity.Delete(dummyOtherObj2.Id);
            }
                        );
        }
        public void Test_CascadingDeleteOfAccessRules()
        {
            Folder          folder;
            Report          report;
            AccessRule      accessRule;
            SecurableEntity resourceType;
            Permission      readPermission;
            Subject         subject;

            using (DatabaseContext.GetContext(true))
            {
                folder = new Folder();
                folder.Save();

                report = Entity.Create <Report>();
                report.SecurityReportInFolder = folder;
                report.Save();

                resourceType = Entity.Get <SecurableEntity>(new EntityRef("core:resource"));
                Assert.That(resourceType, Is.Not.Null, "Resource type not loaded");

                readPermission = Entity.Get <Permission>(new EntityRef("core:read"));
                Assert.That(readPermission, Is.Not.Null, "Read permission not loaded");

                subject      = Entity.Create <Subject>();
                subject.Name = "Test Subject";
                subject.Save();

                accessRule                  = Entity.Create <AccessRule>();
                accessRule.Name             = "Test Access Rule";
                accessRule.AllowAccessBy    = subject;
                accessRule.AccessRuleReport = report;
                accessRule.ControlAccess    = resourceType;
                accessRule.PermissionAccess.Add(readPermission);
                accessRule.Save();

                Assert.That(Entity.Exists(accessRule), Is.True, "Access rule existential crisis!");
                Assert.That(Entity.Exists(resourceType), Is.True, "Resource type existential crisis!");
                Assert.That(Entity.Exists(readPermission), Is.True, "Read permission existential crisis!");
                Assert.That(Entity.Exists(subject), Is.True, "Subject existential crisis!");
                Assert.That(Entity.Exists(report), Is.True, "Report existential crisis!");

                Entity.Delete(accessRule);

                Assert.That(!Entity.Exists(accessRule), Is.True, "Access rule still exists after delete");
                Assert.That(Entity.Exists(resourceType), Is.True, "Resource type does not exist after delete");
                Assert.That(Entity.Exists(readPermission), Is.True, "Read permission type does not exist after delete");
                Assert.That(Entity.Exists(subject), Is.True, "Subject does not exist after delete");
                Assert.That(!Entity.Exists(report), Is.True, "Report still exists after delete");
                Assert.That(!Entity.Exists(folder), Is.True, "Folder still exists after delete");
            }
        }
        public override bool TryGetMember(GetMemberBinder binder, out object?result)
        {
            var name = binder.Name.Convert <TKey>();
            var type = binder.ReturnType;

            result = (_syntaxOptions.HasFlag(SyntaxOptions.AutoCreate)
                ? typeof(TEntity).IsAssignableFrom(type)
                    ? _dictionary.GetOrAdd(name, () => (TEntity)Entity.Create(type))
                    : _dictionary.GetOrAdd(name, () => (TEntity)Entity.Create(typeof(IEntitySubject <>).MakeGenericType(type)))
                : _dictionary.Get(name))
                     ?.AsDynamic();
            return(result != null);
        }
        public void PolicyHandlerMapSetUp()
        {
            var dummyType = Entity.Create <EntityType>();

            dummyType.Name = "ResourceTriggerFilterTest type";
            dummyType.Save();

            var factory = new TestFactory(dummyType, new TestHandler());

            var policyCache = new ResourceTriggerFilterPolicyCache(factory.ToEnumerable());

            Assert.That(policyCache.PolicyTypeHandlerMap.Count(), Is.EqualTo(1));
        }
Beispiel #30
0
        public void SubmitForm(OperationalPlanEntity headEntity, List <OperationalPlanEquipEntryEntity> entitylist)
        {
            if (entitylist.Count > 0)
            {
                foreach (OperationalPlanEquipEntryEntity Entity in entitylist)
                {
                    Entity.FItemId = headEntity.FId;
                    Entity.Create();
                }

                service.Insert(entitylist);
            }
        }
Beispiel #31
0
 private GameObject Create(Card card)
 {
     return(Entity.Create(new Transform2(Sizes.Card))
            .Add(card)
            .Add(card.Sprite)
            .Add(new ZGravity())
            .Add(new MouseDrag())
            .Add(x => new MouseStateActions
     {
         OnPressed = () => x.Transform.ZIndex = 100,
         OnReleased = () => card.Flip()
     }));
 }
Beispiel #32
0
        protected override void ExecuteImpl(EntityCollection entities)
        {
            var powerupP = new Entity("powerup") {
                Textured.Instance,

                { Textured.Texture, this.powerupTexture },
                { Properties.IsPowerup, true },

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

            entities.EnqueueSpawn(powerupP.Create().Configure((e) => {
                e.Set(Located.Position, new Vector2(200, 100));
            }));

            entities.EnqueueSpawn(powerupP.Create().Configure((e) => {
                e.Set(Located.Position, new Vector2(300, 300));
            }));
        }