/// <summary> /// Updates an attribute value, or appends a new attribute, in an NGSIv2 entity /// </summary> /// <param name="id">ID of the entity in the NGSIv2 endpoint</param> /// <param name="attributeName">Name of the attribute that should be updated</param> /// <param name="attributeUpdate">New attribute object according to NGSIv2 spec</param> public void UpdateOrAppend(string id, string attributeName, Dictionary <string, object> attributeUpdate) { Entity fivesEntity = new Entity(); bool entityExists = true; try { fivesEntity = World.Instance.First(entity => entity.ContainsComponent("ngsi") && entity["ngsi"]["id"].Value.Equals(id)); } catch { entityExists = false; } if (entityExists) { var entityComponent = fivesEntity[attributeName]; var attributeValue = attributeUpdate["value"]; foreach (KeyValuePair <string, object> attr in (Dictionary <string, object>)attributeValue) { entityComponent[attr.Key].Suggest(attr.Value); } } AttributeObject update = new AttributeObject(); update.value = attributeUpdate["value"]; ngsiClient.AttributeContext.UpdateAttribute(id, attributeName, update, r => { }); }
public AttributeObject HardCoding() { AttributeObject attribute = attributeDatabse.attributeObjects[Random.Range(0, attributeDatabse.attributeObjects.Length)]; return(attribute); }
private object HandleWildcard(string wildcard, EntityObject entityObject, AttributeObject attributeObject, EntityPropertyItem entityPropertyItem, UIHierarchyNodeObject appHierarchyNodeObject) { IEnumerable <EntityPropertyItem> hierarchy; EntityPropertyItem parent; if (attributeObject != null) { hierarchy = entityPropertyItem.GetAncestorProperties(attributeObject); parent = hierarchy.First(); } else { hierarchy = entityPropertyItem.GetAncestorProperties(entityObject); parent = hierarchy.First(); } if (entityPropertyItem.PropertyName == "UIHierarchyPath") { switch (parent.PropertyName) { case "IdentityField": case "UI": { var uiPath = appHierarchyNodeObject.GetUIPath(); } break; } } return(null); }
private AttributeObject LoadAttribute(AttributeObject curObject, string NameOFAttribute, string SizeOFAttribute) { curObject.Name = NameOFAttribute; curObject.Size = Int32.Parse(SizeOFAttribute); return curObject; }
public bool FindAvailabeGroupAndType(AttributeObject attribute, ItemObject item) { bool group = false; bool type = false; for (int i = 0; i < attribute.availableGroups.Length; i++) { if (item.group == attribute.availableGroups[i]) { group = true; break; } } for (int i = 0; i < attribute.availableTypes.Length; i++) { if (item.type == attribute.availableTypes[i]) { type = true; break; } } if (group == true && type == true) { return(true); } else { return(false); } }
/// <summary> /// Updates an attribute of an entity along with its metadata /// </summary> /// <param name="entityId">Id of the entity of which the attribute should be updated</param> /// <param name="attributeName">Name of the attribute that should be updated</param> /// <param name="newAttribute">New attribute data</param> /// <param name="callback">Callback that should be invoked when the request returned</param> public void UpdateAttribute (string entityId, string attributeName, AttributeObject newAttribute, Action <RequestResponse> callback) { string path = EntitiesResource + "/" + entityId + "/attrs/" + attributeName; RestRequest request = new RestRequest(path, Method.PUT); request.AddHeader("Content-Type", "application/json"); request.AddJsonBody(newAttribute); Client.SendRequest(request, callback); }
internal AttributeObject CreateNumAttribute(string NameOfAttribute, string SizeOfAttribute) { AttributeObject curObject = new AttributeObject(); curObject.Type = AttributeConstants.NUM; curObject = LoadAttribute(curObject, NameOfAttribute, SizeOfAttribute); return curObject; }
/// <summary> Process this. </summary> /// /// <remarks> Ken, 10/5/2020. </remarks> /// /// <param name="entityObject"> The entity object. </param> /// <param name="attributeObject"> The attribute object. </param> /// <param name="entityPropertyItem"> The entity property item. </param> /// <param name="annotationType"></param> /// <param name="propertyBuilder"> The property builder. </param> /// <param name="appHierarchyNodeObject"> The application hierarchy node object. </param> /// <param name="generatorConfiguration"> The generator configuration. </param> /// /// <returns> True if it succeeds, false if it fails. </returns> public bool Process(EntityObject entityObject, AttributeObject attributeObject, EntityPropertyItem entityPropertyItem, Type annotationType, PropertyBuilder propertyBuilder, AppUIHierarchyNodeObject appHierarchyNodeObject, IGeneratorConfiguration generatorConfiguration) { if (annotationType != null) { return(Process(entityObject, attributeObject, entityPropertyItem, appHierarchyNodeObject, annotationType, (c) => propertyBuilder.SetCustomAttribute(c))); } else { throw new Exception($"Cannot find Attribute type or custom handler to process property '{ entityPropertyItem.PropertyName }"); } }
public void DebugTest() { Debug.Log(attributeDatabse.attributeObjects.Length); int attributeID = Random.Range(0, attributeDatabse.attributeObjects.Length); AttributeObject attribute = attributeDatabse.attributeObjects[attributeID]; ItemObject itemObject = itemDatabase.ItemObjects[Random.Range(0, itemDatabase.ItemObjects.Length)]; Debug.Log(attribute.name); Debug.Log(itemObject.name); Debug.Log(FindAvailabeGroupAndType(attribute, itemObject)); }
public AttributeObject[] ItemSet(ItemObject item) { int attributeCount = AttributeCount(item.data.itemRank); AttributeObject[] attributes = new AttributeObject[attributeCount]; for (int i = 0; i < attributeCount; i++) { for (int j = 0; j < 10000; j++) { int attributeID = Random.Range(0, attributeDatabse.attributeObjects.Length); AttributeObject attribute = attributeDatabse.attributeObjects[attributeID]; if (attribute.isSelected == false) { if (FindAvailabeGroupAndType(attribute, item) == true) { if (item.level >= attribute.requiredLevel) { attributes[i] = attribute; //for (int k = 0; k < attributeDatabse.attributeObjects.Length; k++) //{ // if (attributeDatabse.attributeObjects[k].attributeType == attribute.attributeType) // { // attributeDatabse.attributeObjects[k].isSelected = true; // } //} break; } } } if (j == 9000) { Debug.Log("Break Point"); break; } } } for (int i = 0; i < attributeDatabse.attributeObjects.Length; i++) { attributeDatabse.attributeObjects[i].isSelected = false; } return(attributes); }
private async void cmdBurnEdge_Click(object sender, EventArgs e) { // Edge cannot go below 1. if (await AttributeObject.ValueAsync <= 0) { Program.ShowMessageBox(await LanguageManager.GetStringAsync("Message_CannotBurnEdge"), await LanguageManager.GetStringAsync("MessageTitle_CannotBurnEdge"), MessageBoxButtons.OK, MessageBoxIcon.Exclamation); return; } // Verify that the user wants to Burn a point of Edge. if (Program.ShowMessageBox(await LanguageManager.GetStringAsync("Message_BurnEdge"), await LanguageManager.GetStringAsync("MessageTitle_BurnEdge"), MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No) { return; } AttributeObject.Degrade(1); ValueChanged?.Invoke(this, e); }
internal AttributeObject Create(string NameOfAttribute, string TypeOfAttribute, string SizeOfAttribute) { AttributeObject currentAttribute = new AttributeObject(); switch(TypeOfAttribute) { case AllSpecialSymbols.CHAR: currentAttribute = AttributeService.CreateCharAttribute(NameOfAttribute, SizeOfAttribute); break; case AllSpecialSymbols.NUM: currentAttribute = AttributeService.CreateNumAttribute(NameOfAttribute, SizeOfAttribute); break; default: ErrorHandlerSURLY.AttributeErrors.UnrecoginizedType(TypeOfAttribute); break; } return currentAttribute; }
/// <summary> Parse file. </summary> /// /// <remarks> Ken, 10/1/2020. </remarks> /// /// <param name="path"> Full pathname of the file. </param> /// <param name="textReplacements"> The text replacements. </param> /// /// <returns> A List<TRecord> </returns> public override List <EntityDomainRecord> ParseFile(string path, Dictionary <string, string> textReplacements) { var records = base.ParseFile(path, textReplacements); EntityObject lastEntity = null; this.Entities = new List <EntityObject>(); foreach (var record in records) { if (record.EntityName != null) { var entity = new EntityObject(record.EntityName, record.ParentDataItem); if (record.Properties != null) { entity.Properties.AddRange(record.Properties); } this.Entities.Add(entity); lastEntity = entity; } else if (record.AttributeName != null) { var attribute = new AttributeObject(record.AttributeName, record.AttributeType); if (record.Properties != null) { attribute.Properties.AddRange(record.Properties); } lastEntity.Attributes.Add(attribute); } else { DebugUtils.Break(); } } return(records); }
private void cmdImproveATT_Click(object sender, EventArgs e) { int intUpgradeKarmaCost = AttributeObject.UpgradeKarmaCost; if (intUpgradeKarmaCost == -1) { return; //TODO: more descriptive } if (intUpgradeKarmaCost > _objCharacter.Karma) { Program.MainForm.ShowMessageBox(LanguageManager.GetString("Message_NotEnoughKarma"), LanguageManager.GetString("MessageTitle_NotEnoughKarma"), MessageBoxButtons.OK, MessageBoxIcon.Information); return; } string confirmstring = string.Format(GlobalSettings.CultureInfo, LanguageManager.GetString("Message_ConfirmKarmaExpense"), AttributeObject.DisplayNameFormatted, AttributeObject.Value + 1, intUpgradeKarmaCost); if (!CommonFunctions.ConfirmKarmaExpense(confirmstring)) { return; } AttributeObject.Upgrade(); ValueChanged?.Invoke(this, e); }
private string GetAllAttributesOfARelationThatTheUserRequested(RelationObject relationObjectToGrabAttributesFrom, IList<AttributeObject> attributesRequestedByUser) { EnsureObjectContainsAttributes(relationObjectToGrabAttributesFrom); string curSymbol = QueryParser.FindNextSymbol(); while(!AllSpecialSymbols.GetListOfAllSymbols().Contains(curSymbol)) { AttributeObject attributeToAddToAttributesRequestedByUser = new AttributeObject(); EnsureAttributeExistInObject(curSymbol, relationObjectToGrabAttributesFrom); attributeToAddToAttributesRequestedByUser = GetAttributeObjectFromRelationObject(curSymbol, relationObjectToGrabAttributesFrom); attributesRequestedByUser.Add(attributeToAddToAttributesRequestedByUser); curSymbol = QueryParser.FindNextSymbol(); } return curSymbol; }
internal void RenewObjects() { relationToCreate = new RelationObject(); attributesForRelationToCreate = new List<AttributeObject>(); currentAttribute = new AttributeObject(); currentSymbol = string.Empty; RelationNamesToDestroy = new List<String>(); RelationNameToDelete = string.Empty; reading = false; RelationCRUDService = new RelationCRUDServices(this); RelationService = new RelationServices(); QueryService = new QueryServices(); }
public TupleCellObject() { Value = string.Empty; AttributeAssociatedWithCell = new AttributeObject(); }
private bool Process(EntityObject entityObject, AttributeObject attributeObject, EntityPropertyItem entityPropertyItem, UIHierarchyNodeObject appHierarchyNodeObject, Type annotationType, Action <CustomAttributeBuilder> builderAction) { var argValues = new List <object>(); var namedFields = new List <FieldInfo>(); var fieldValues = new List <object>(); var namedProperties = new List <PropertyInfo>(); var propertyValues = new List <object>(); var constructor = annotationType.GetConstructors().FirstOrDefault(c => { var hasParmsFieldsOrProperties = false; var hasParm = false; var hasField = false; var hasProperty = false; var parameters = c.GetParameters(); var x = 0; if (entityPropertyItem.ChildProperties == null) { if (parameters.Length == 1 && !entityPropertyItem.PropertyValue.IsNullOrEmpty()) { var parm = parameters.FirstOrDefault(); if (parm == parameters.ElementAt(x)) { var value = this.GetValue(parm.ParameterType, entityPropertyItem, (w) => HandleWildcard(w, entityObject, attributeObject, entityPropertyItem, appHierarchyNodeObject)); argValues.Add(value); hasParmsFieldsOrProperties = true; x++; } } } else { foreach (var childProperty in entityPropertyItem.ChildProperties) { var propertyName = childProperty.PropertyName; var propertyNameCamelCase = propertyName.ToCamelCase(); object value; if (propertyName.StartsWith("UI")) { propertyNameCamelCase = "ui" + propertyName.RemoveStartIfMatches("UI"); } hasParm = parameters.Any(p => p.Name.IsOneOf(propertyName, propertyNameCamelCase)); if (hasParm) { var parm = parameters.Single(p => p.Name.IsOneOf(propertyName, propertyNameCamelCase)); if (parm == parameters.ElementAt(x)) { value = this.GetValue(parm.ParameterType, childProperty, (w) => HandleWildcard(w, entityObject, attributeObject, childProperty, appHierarchyNodeObject)); argValues.Add(value); hasParmsFieldsOrProperties = true; x++; } continue; } hasField = annotationType.GetFields().Any(f => f.Name.IsOneOf(propertyName, propertyNameCamelCase)); if (hasField) { var field = annotationType.GetFields().Single(f => f.Name.IsOneOf(propertyName, propertyNameCamelCase)); value = this.GetValue(field.FieldType, childProperty, (w) => HandleWildcard(w, entityObject, attributeObject, childProperty, appHierarchyNodeObject)); argValues.Add(value); namedFields.Add(field); hasParmsFieldsOrProperties = true; continue; } hasProperty = annotationType.GetProperties().Any(p => p.Name.IsOneOf(propertyName, propertyNameCamelCase)); if (hasProperty) { var property = annotationType.GetProperties().Single(p => p.Name.IsOneOf(propertyName, propertyNameCamelCase)); value = this.GetValue(property.PropertyType, childProperty, (w) => HandleWildcard(w, entityObject, attributeObject, childProperty, appHierarchyNodeObject)); argValues.Add(value); namedProperties.Add(property); hasParmsFieldsOrProperties = true; continue; } if (!hasParmsFieldsOrProperties) { break; } } } if (x != parameters.Length) { var remainingParms = parameters.Skip(x).ToArray(); if (remainingParms.Length == 0) { return(false); } else { foreach (var remainingParm in remainingParms) { if (remainingParm.HasDefaultValue) { argValues.Add(remainingParm.DefaultValue); } else { return(false); } } } } return(hasParmsFieldsOrProperties); }); if (constructor != null) { builderAction(new CustomAttributeBuilder(constructor, argValues.ToArray(), namedProperties.ToArray(), propertyValues.ToArray(), namedFields.ToArray(), fieldValues.ToArray())); return(true); } else { throw new Exception($"Cannot find appropriate constructor for annotation type '{ annotationType.AsDisplayText() }' matching property '{ entityPropertyItem.PropertyName }"); } }
private string CropValueToSize(AttributeObject attr, string curSymbol) { string convertedSizeOfCurSymbol = string.Empty; switch (attr.Type) { case AttributeConstants.CHAR: convertedSizeOfCurSymbol = CropRightmostCharacters(attr, curSymbol); break; case AttributeConstants.NUM: convertedSizeOfCurSymbol = CropLeftmostCharacters(attr, curSymbol); break; default: ErrorHandlerSURLY.TupleErrors.InvalidType(attr.Type); break; } return convertedSizeOfCurSymbol; }
private string CropRightmostCharacters(AttributeObject attr, string curSymbol) { string convertedSizeOfCurSymbol = curSymbol; if (curSymbol.Length > attr.Size) { convertedSizeOfCurSymbol = curSymbol.Remove(attr.Size); } return convertedSizeOfCurSymbol; }
private void ConfirmTupleValueMatchesAttributeType(AttributeObject attr, string curSymbol) { switch(attr.Type) { case AttributeConstants.CHAR: // Already string break; case AttributeConstants.NUM: ConfirmTypleIsANumber(curSymbol); break; default: ErrorHandlerSURLY.TupleErrors.InvalidType(attr.Type); break; } }