public void Test_EntityPathThrowsErrorOnInvalidConstruct() { EntityPath entityPath; Assert.ThrowsException <ArgumentException>(() => { // only types derived from Entity can use entity path. entityPath = new EntityPath(typeof(string)); }); Assert.ThrowsException <ArgumentNullException>(() => { entityPath = new EntityPath((Type)null); }); Assert.ThrowsException <ArgumentNullException>(() => { entityPath = new EntityPath("", typeof(Event)); }); Assert.ThrowsException <ArgumentNullException>(() => { entityPath = new EntityPath((Entity)null); }); Assert.ThrowsException <ArgumentNullException>(() => { entityPath = new EntityPath(new Event()); }); }
public NestedCommand Select(string requestPath) { var _requestPath = new EntityPath(from.root.Entity.ID, requestPath).Path; var p = SelectCommandHelper.ValidatePath(_requestPath); (string[], string)item; if (p.Count() > 1) { throw new ArgumentException("Only one field should be returned by sub queries"); } else if (p.Count() == 0) { throw new ArgumentException("At least one field should be returned by sub queries"); } else { item = p.First(); } if (item.Item2 == "*") { throw new ArgumentException("Select all not allowed in sub queries."); } outputField = SelectCommandHelper.GenerateSingleSelectNode(item, from); return(this); }
/// <summary> /// Return sub entity path. /// </summary> /// <param name="subEntity">Sub entity.</param> /// <returns></returns> public override string GetSubEntityFullPath(EntityPath subEntity) { // if it works with User graph object then just forward // actual entity path. subEntity.ThrowIfNull(nameof(subEntity)); if (subEntity.Path.StartsWith("users", StringComparison.OrdinalIgnoreCase)) { if (subEntity.Id.Equals("") || this.Id.Equals(subEntity.Id, StringComparison.OrdinalIgnoreCase)) { return($"{this.EntityPath.Path}"); } if (Guid.TryParse(subEntity.Id, out Guid id)) { // navigation property case, return subEntity path as // correct path will be there. return($"{subEntity.Path}"); } return($"{this.EntityPath.Path}/{subEntity.Id}"); } return(base.GetSubEntityFullPath(subEntity)); }
static bool match(World world, ref SmallList <EntityQueryPart> queryParts, string entityPath) { var pathParts = new EntityQuery(entityPath).EnumerateParts(); ReadOnlySpan <EntityQueryPart> remainingQueryParts = queryParts.AsSpan(); bool matches = false; foreach (EntityQueryPart pathPart in pathParts) { if (remainingQueryParts.IsEmpty) { return(false); } EntityQueryPart queryPart = remainingQueryParts[0]; if (!queryPart.SearchInAliases && !matchParts(queryPart, pathPart)) { return(false); } if (queryPart.SearchInAliases && queryPart.IsLast) { var path = new EntityPath(queryPart.Value.ToString()); return(world._aliases.TryGetValue(path, out EntityId id) && id.Path.Equals(entityPath, StringComparison.Ordinal)); } remainingQueryParts = remainingQueryParts[1..];
public void Test_MessageEntityPath() { EntityPath entityPath = new EntityPath(typeof(Message)); Assert.IsTrue(entityPath.IsRootContainer); Assert.AreEqual("", entityPath.Id); Assert.AreEqual("Messages", entityPath.Path); Assert.AreEqual("Messages", entityPath.RootContainer); Assert.IsNull(entityPath.SubEntity); entityPath = new EntityPath("Abc", typeof(MailFolder)); Assert.IsFalse(entityPath.IsRootContainer); Assert.AreEqual("Abc", entityPath.Id); Assert.AreEqual("MailFolders/Abc", entityPath.Path); Assert.AreEqual("MailFolders", entityPath.RootContainer); Assert.IsNull(entityPath.SubEntity); entityPath = new EntityPath("Abc", typeof(MailFolder)); entityPath.SubEntity = new EntityPath(typeof(Message)); Assert.IsFalse(entityPath.IsRootContainer); Assert.AreEqual("Abc", entityPath.Id); Assert.AreEqual("MailFolders/Abc/Messages", entityPath.Path); Assert.AreEqual("MailFolders", entityPath.RootContainer); Assert.IsTrue(entityPath.SubEntity.IsRootContainer); Assert.AreEqual("", entityPath.SubEntity.Id); Assert.AreEqual("Messages", entityPath.SubEntity.Path); Assert.AreEqual("Messages", entityPath.SubEntity.RootContainer); }
private static void WriteEntityPath(TextWriter writer, EntityPath entityPath) { foreach (var entity in entityPath.GenerateEntities()) { WriteEntity(writer, entity); } }
public bool MoveMob( Point3d targetPosition) { bool success = false; if (path == null) { PathComputer pathComputer = new PathComputer(); success = pathComputer.BlockingPathRequest( moveRequest.Room.runtime_nav_mesh, moveRequest.Room.room_key, new Point3d(mob.Position), new Point3d(targetPosition)); if (success) { RoomKey roomKey = moveRequest.Room.room_key; PathStep lastPathStep = pathComputer.FinalPath[pathComputer.FinalPath.Count - 1]; PathStep secondLastPathStep = pathComputer.FinalPath[pathComputer.FinalPath.Count - 2]; Vector3d lastPathHeading = lastPathStep.StepPoint - secondLastPathStep.StepPoint; float targetAngle = MathConstants.GetAngleForVector(lastPathHeading); path = new EntityPath() { entity_id = mob.ID, path = pathComputer.FinalPath }; // Post an event that we moved output_game_events.Add( new GameEvent_MobMoved() { mob_id = mob.ID, room_x = roomKey.x, room_y = roomKey.y, room_z = roomKey.z, from_x = mob.Position.x, from_y = mob.Position.y, from_z = mob.Position.z, from_angle = mob.Angle, to_x = targetPosition.x, to_y = targetPosition.y, to_z = targetPosition.z, to_angle = targetAngle }); // Update the mob position and facing mob.Position = targetPosition; mob.Angle = targetAngle; // TODO: Update the mob energy based on the distance traveled } } return(success); }
public SmallList <Entity> Query(uint contextId, EntityQuery query) { if (EntityPath.IsValidPath(query, out EntityPath simplePath) && Get(contextId, simplePath) is Entity result) { return(new SmallList <Entity>(result)); } return(QuerySlow(contextId, query)); }
public void Test_EventMessageEntityPath() { EntityPath entityPath = new EntityPath(typeof(EventMessage)); Assert.IsTrue(entityPath.IsRootContainer); Assert.AreEqual("", entityPath.Id); Assert.AreEqual("Messages", entityPath.Path); Assert.AreEqual("Messages", entityPath.RootContainer); Assert.IsNull(entityPath.SubEntity); }
/// <summary> /// Create new instance of <see cref="GraphUri"/> /// </summary> /// <param name="identity">Identity.</param> /// <param name="subEntity">Sub entity.</param> /// <param name="beta">Connect to beta endpoint.</param> internal GraphUri(IGraphIdentity identity, EntityPath subEntity, bool beta) { identity.ThrowIfNull(nameof(identity)); subEntity.ThrowIfNull(nameof(subEntity)); this.IsBeta = beta; this.Identity = identity; this.restUri = new HttpRestUri( $"{GraphUri.baseGraphUri}/{this.GetServiceInstance()}/{this.Identity.GetSubEntityFullPath(subEntity)}"); }
public MobUpdateContext( AIMoveRequestProcessor moveRequest, Mob mob) { this.moveRequest = moveRequest; this.otherMobs = moveRequest.MobContexts.Where(c => c.mob.ID != mob.ID).Select(c => c.mob).ToList(); this.mob = mob; this.path = null; output_game_events = new List <GameEventParameters>(); }
/// <summary> /// Determines if the entity at the given path requires a new Guid value when it's imported /// onto the target system. On import, if an entity of that type and Guid already exists then /// it is not imported and a reference to the existing entity is used instead. /// </summary> /// <param name="path">The path to the queued entity object that is being checked.</param> /// <returns> /// <c>true</c> if the path requires a new Guid value; otherwise, <c>false</c> /// </returns> public bool DoesPathNeedNewGuid(EntityPath path) { return(path == "" || path == "AttributeTypes" || path == "AttributeTypes.AttributeQualifiers" || path == "ActivityTypes" || path == "ActivityTypes.AttributeTypes" || path == "ActivityTypes.AttributeTypes.AttributeQualifiers" || path == "ActivityTypes.ActionTypes" || path == "ActivityTypes.ActionTypes.AttributeValues" || path == "ActivityTypes.ActionTypes.WorkflowFormId" || path == "ActivityTypes.ActionTypes.WorkflowFormId.FormAttributes"); }
public void Test_MessageRuleEntityPath() { MessageRule rule = new MessageRule() { Id = "abc" }; EntityPath entityPath = new EntityPath(rule); Assert.IsFalse(entityPath.IsRootContainer); Assert.AreEqual("MailFolders/Inbox/MessageRules", entityPath.RootContainer); Assert.AreEqual("abc", entityPath.Id); Assert.AreEqual("MailFolders/Inbox/MessageRules/abc", entityPath.Path); Assert.IsNull(entityPath.SubEntity); }
public void Test_OutlookTaskEntityPath() { EntityPath entityPath = new EntityPath(typeof(OutlookTask)); Assert.IsTrue(entityPath.IsRootContainer); Assert.AreEqual("Outlook/Tasks", entityPath.RootContainer); Assert.AreEqual("Outlook/Tasks", entityPath.Path); Assert.IsNull(entityPath.SubEntity); entityPath = new EntityPath("abcd", typeof(OutlookTask)); Assert.IsFalse(entityPath.IsRootContainer); Assert.AreEqual("Outlook/Tasks", entityPath.RootContainer); Assert.AreEqual("Outlook/Tasks/abcd", entityPath.Path); Assert.IsNull(entityPath.SubEntity); }
public void Test_OutlookCategoryEntityPath() { EntityPath entityPath = new EntityPath(typeof(OutlookCategory)); Assert.IsTrue(entityPath.IsRootContainer); Assert.AreEqual("Outlook/MasterCategories", entityPath.RootContainer); Assert.AreEqual("Outlook/MasterCategories", entityPath.Path); Assert.IsNull(entityPath.SubEntity); entityPath = new EntityPath("abcd", typeof(OutlookCategory)); Assert.IsFalse(entityPath.IsRootContainer); Assert.AreEqual("Outlook/MasterCategories", entityPath.RootContainer); Assert.AreEqual("Outlook/MasterCategories/abcd", entityPath.Path); Assert.IsNull(entityPath.SubEntity); }
public void Test_ContactEntityPath() { Contact contact = new Contact() { Id = "cId" }; EntityPath entityPath = new EntityPath(contact); Assert.IsFalse(entityPath.IsRootContainer); Assert.AreEqual("Contacts", entityPath.RootContainer); Assert.AreEqual("Contacts/cId", entityPath.Path); Assert.AreEqual("cId", entityPath.Id); Assert.IsNull(entityPath.SubEntity); }
private static EntityPath ReadPath(Stream stream) { var entityPath = new EntityPath(); entityPath.Name = stream.ReadString(128); entityPath.ClassName = stream.ReadString(128); entityPath.Type = (PathType)stream.ReadInt(); var nodeCount = stream.ReadInt(); for (int i = 0; i < nodeCount; i++) { entityPath.Nodes.Add(ReadPathNode(stream)); } return(entityPath); }
/// <summary> /// Determines if the property at the given path should be followed to it's referenced entity. /// This is called for both referenced entities and child entities. /// </summary> /// <param name="path">The path.</param> /// <returns></returns> public bool ShouldFollowPathProperty(EntityPath path) { if (path == "CategoryId") { return(false); } if (path.Count > 0) { var lastComponent = path.Last(); if (lastComponent.Entity.TypeName == "Rock.Model.DefinedType" && lastComponent.PropertyName == "DefinedValues") { return(false); } } return(true); }
private static EntityPath ReadEntityPath(Stream stream) { var path = new EntityPath(); path.ClassName = stream.ReadLengthPrefixedString(); path.Name = stream.ReadLengthPrefixedString(); path.Type = (PathType)stream.ReadInt(); var unknown1 = stream.ReadBytes(4); var color = ReadColor(stream); var nodeCount = stream.ReadInt(); for (int i = 0; i < nodeCount; i++) { path.Nodes.Add(ReadPathNode(stream)); } return(path); }
public SelectCommand Select(string requestPath) { var _requestPath = new EntityPath(from.root.Entity.ID, requestPath).Path; var p = SelectCommandHelper.ValidatePath(_requestPath); foreach (var item in p) { var x = from.Resolve(item.Item1); IEnumerable <SelectNode> fields; if (item.Item2 != "*") { fields = x.Entity.entityFields .Where(ef => ef.CodeName == item.Item2) .Select(ef => { return(new SelectNode() { FullPath = new FieldPath(x.FullPath.Root, x.FullPath.Path, ef.CodeName), EntityField = ef, FromNode = x }); }); } else //wildcard = select all { fields = x.Entity.entityFields .Select(ef => { return(new SelectNode() { FullPath = new FieldPath(x.FullPath.Root, x.FullPath.Path, ef.CodeName), EntityField = ef, FromNode = x }); }); } selectFields.AddRange(fields); } ((BaseCommand)this).CommandLog(LogLevel.Info, "SelectCommand", $"{{\"Action\":\"Select\", \"Path\":\"{requestPath}\"}}"); return(this); }
/// <summary> /// Get next page. /// </summary> /// <returns></returns> public async Task <FindEntityResults <T> > GetNextPage() { this.propertyBag.TryGetKey( nameof(Entity.EntityService), out PropertyDefinition entityServicePropDef); entityServicePropDef.ThrowIfNull(nameof(entityServicePropDef)); this.propertyBag.TryGetKey( nameof(Entity.EntityPath), out PropertyDefinition entityPathPropDef); entityPathPropDef.ThrowIfNull(nameof(entityPathPropDef)); IEntityService entityService = (IEntityService)this.propertyBag[entityServicePropDef]; EntityPath entityPath = (EntityPath)this.propertyBag[entityPathPropDef]; entityPath.SubEntity = new EntityPath(typeof(T)); FindEntityResults <T> result = await entityService.Navigate <T>(entityPath, this.pageQuery); this.pageQuery.Offset += this.pageQuery.PageSize; return(result); }
public void Test_NonTypedEntityPath() { EntityPath entityPath = new EntityPath( "abc==", "calCheck"); Assert.IsFalse(entityPath.IsRootContainer); Assert.AreEqual("calCheck/abc==", entityPath.Path); Assert.AreEqual("abc==", entityPath.Id); Assert.AreEqual("calCheck", entityPath.RootContainer); Assert.IsNull(entityPath.SubEntity); entityPath.SubEntity = new EntityPath(typeof(MailFolder)); Assert.AreEqual("calCheck/abc==/MailFolders", entityPath.Path); Assert.IsNotNull(entityPath.SubEntity); entityPath = new EntityPath(nameof(AutomaticRepliesSetting)); Assert.IsTrue(entityPath.IsRootContainer); Assert.AreEqual("AutomaticRepliesSetting", entityPath.RootContainer); Assert.AreEqual("AutomaticRepliesSetting", entityPath.Path); Assert.IsNull(entityPath.SubEntity); }
public WorldTests() { var levels = new List <EntityPath> [3]; for (int i = 0; i < 3; i++) { levels[i] = new List <EntityPath>(); } void entity(string name) { var path = new EntityPath(name); ResolvedEntityPath resolvedPath = _world.ResolvePath(0, path); _world.Add(new BasicEntity(resolvedPath)); int level = name.Count(c => c == '/'); levels[level].Add(path); } _world = new World(); entity("root"); entity("root1"); entity("root/e11"); entity("root/e12"); entity("root/e11/e21"); entity("root/e11/e22"); entity("root/e11/e23"); entity("root/e12/e21"); entity("root/e12/e22"); entity("root/e12/e23"); entity("root/MouseOver/img"); _treeLevels = new EntityPath[3][]; for (int i = 0; i < 3; i++) { _treeLevels[i] = levels[i].ToArray(); } }
public EntityId(ref MessagePackReader reader) { reader.ReadArrayHeader(); Context = reader.ReadUInt32(); string?value = reader.ReadString(); if (value is not null) { var path = new EntityPath(value); _nameStart = 0; MouseState = path.MouseState; Path = path.Value; _hashCode = HashCode.Combine(Path.GetHashCode(), Context); } else { Path = null !; _nameStart = 0; Context = 0; _hashCode = 0; MouseState = default; } }
private IEnumerable <IDbEntity> GetCollection(IDbEntity entity) { return((entity.Eval(EntityPath.Substring(1, EntityPath.LastIndexOf("[") - 1)) as IEnumerable).Cast <IDbEntity>()); }
/// <summary> /// Create sub entity path. /// </summary> /// <param name="subEntity">Sub entity.</param> /// <returns></returns> public virtual string GetSubEntityFullPath(EntityPath subEntity) { subEntity.ThrowIfNull(nameof(subEntity)); return($"{this.EntityPath.Path}/{subEntity.Path}"); }
/// <summary> /// Gets any custom references for the entity at the given path. /// </summary> /// <param name="parentEntity">The entity that will later be encoded.</param> /// <param name="path">The path to the parent entity.</param> /// <returns> /// A collection of references that should be applied to the encoded entity. /// </returns> public ICollection <Reference> GetUserReferencesForPath(IEntity parentEntity, EntityPath path) { if (path == "") { return(new List <Reference> { Reference.UserDefinedReference("CategoryId", "WorkflowCategory") }); } return(null); }
/// <summary> /// Determines whether the path to an entity should be considered critical. A critical /// entity is one that MUST exist on the target system in order for the export/import to /// succeed, as such a critical entity is always included. /// </summary> /// <param name="path">The path to the queued entity object that is being checked.</param> /// <returns> /// <c>true</c> if the path is critical; otherwise, <c>false</c>. /// </returns> public bool IsPathCritical(EntityPath path) { return(DoesPathNeedNewGuid(path)); }
public static IEnumerable <Entity> GenerateEntities(this EntityPath path) { // NOTE: This always yields the previous entity, because its target may have been updated by the current entity, // and it may be too late to update an entity after it has already been yielded. var index = 0; Entity previousEntity = null; foreach (var node in path.Nodes) { var entity = CreateEntityForNode(node); if (previousEntity != null) { yield return(previousEntity); } previousEntity = entity; index += 1; } if (path.Type == PathType.Circular) { // Point the last node back at the first: previousEntity.Properties[Attributes.Target] = path.Name; } else if (path.Type == PathType.PingPong) { // Generate additional nodes for the way back (in reverse order, excluding the first and last corner): foreach (var node in path.Nodes.Skip(1).Take(path.Nodes.Count - 2).Reverse()) { var entity = CreateEntityForNode(node); if (previousEntity != null) { yield return(previousEntity); } previousEntity = entity; index += 1; } previousEntity.Properties[Attributes.Target] = path.Name; } if (previousEntity != null) { yield return(previousEntity); } Entity CreateEntityForNode(EntityPathNode node) { var entity = new Entity(); foreach (var property in node.Properties) { entity.Properties[property.Key] = property.Value; } entity.ClassName = path.ClassName; entity.Origin = node.Position; var targetname = node.NameOverride; if (string.IsNullOrEmpty(targetname)) { targetname = (index == 0) ? path.Name : FormattableString.Invariant($"{path.Name}{index:00}"); } entity.Properties[Attributes.Targetname] = targetname; if (previousEntity != null) { previousEntity.Properties[Attributes.Target] = targetname; } return(entity); } }
private void UpdateAIPropVisibility( MobUpdateContext context) { Mob ownerMob = context.mob; NavMesh navMesh = context.moveRequest.Room.runtime_nav_mesh; foreach (EntityProp prop in ai_props) { Point3d oldPropPosition = prop.GetPosition(); // Find the player associated with the player id MobUpdateContext otherMobContext = context.moveRequest.MobContexts.Find(m => m.mob.ID == prop.target_object_id); Mob otherMob = otherMobContext.mob; // Can the mob see the other mob at their current location bool canSee = CanMobSeePoint(navMesh, ownerMob, otherMob.Position); TypedFlags <EntityProp.ePropVisibilityFlags> oldVisibilityFlags = new TypedFlags <EntityProp.ePropVisibilityFlags>(prop.visibilityFlags); prop.visibilityFlags.Set(EntityProp.ePropVisibilityFlags.canSee, canSee); prop.visibilityFlags.Set(EntityProp.ePropVisibilityFlags.caughtGlimpse, canSee); if (canSee) { // If so, we get to pull the entity properties prop.RefeshEntityProperties(ownerMob, otherMob); prop.visibilityFlags.Set(EntityProp.ePropVisibilityFlags.seenAtLeastOnce, true); } else { EntityPath entityPath = otherMobContext.path; if (entityPath != null) { // Find the last place we saw the player along their path, if at all for (int pathStepIndex = entityPath.path.Count - 1; pathStepIndex >= 0; pathStepIndex--) { PathStep pathStep = entityPath.path[pathStepIndex]; if (CanMobSeePoint(navMesh, ownerMob, pathStep.StepPoint)) { prop.position_x = pathStep.StepPoint.x; prop.position_y = pathStep.StepPoint.y; prop.position_z = pathStep.StepPoint.z; prop.visibilityFlags.Set(EntityProp.ePropVisibilityFlags.caughtGlimpse, true); prop.visibilityFlags.Set(EntityProp.ePropVisibilityFlags.seenAtLeastOnce, true); break; } } } } // Post an event if we just spotted another mob that we've never seen before if (!oldVisibilityFlags.Test(EntityProp.ePropVisibilityFlags.canSee) && !oldVisibilityFlags.Test(EntityProp.ePropVisibilityFlags.seenAtLeastOnce) && (prop.visibilityFlags.Test(EntityProp.ePropVisibilityFlags.canSee) || prop.visibilityFlags.Test(EntityProp.ePropVisibilityFlags.caughtGlimpse))) { context.output_game_events.Add( new GameEvent_MobAIPropSpotted() { mob_id = ownerMob.ID, spotted_mob_id = prop.target_object_id, x = prop.position_x, y = prop.position_y, z = prop.position_z }); } } }