private static bool ParseCommandGroups <TOptions>(string[] args, ref TOptions options, TypeArgumentInfo arguments) where TOptions : new() { if (arguments.ActionArgument == null) { throw new ArgumentException("Cannot have groups unless Command argument has been specified"); } if (args.Length == 0) { throw new ArgumentException("Required parameters have not been specified"); } // parse based on the command passed in (the first arg). if (!arguments.ArgumentGroups.ContainsKey(args[0])) { throw new ArgumentException($"Unknown command [Cyan!{args[0]}]"); } // short circuit the request for help! if (args.Length == 2 && (args[1] == "/?" || args[1] == "-?")) { HelpGenerator.DisplayHelpForCommmand(args[0], arguments.ArgumentGroups[args[0]]); return(false); } options = InternalParse <TOptions>(args, 1, arguments.ArgumentGroups[args[0]]); arguments.ActionArgument.SetValue(options, PropertyHelpers.GetValueAsType(args[0], arguments.ActionArgument)); return(true); }
private static List <PropertyInfo> ParseOptionalParameters <TOptions>(string[] args, int offsetInArray, ArgumentGroupInfo TypeArgumentInfo, TOptions options, ref int currentLogicalPosition) where TOptions : new() { // we are going to assume that all optionl parameters are not matched to values in 'args' List <PropertyInfo> unmatched = new List <PropertyInfo>(TypeArgumentInfo.OptionalArguments.Values); // process the optional arguments while (offsetInArray + currentLogicalPosition < args.Length) { if (args[offsetInArray + currentLogicalPosition][0] != '-') { throw new ArgumentException("Optional parameter name should start with '-'"); } PropertyInfo optionalProp = null; var optionalParamName = args[offsetInArray + currentLogicalPosition].Substring(1); if (!TypeArgumentInfo.OptionalArguments.TryGetValue(optionalParamName, out optionalProp)) { throw new ArgumentException($"Could not find argument {args[currentLogicalPosition]}"); } // skip over the parameter name currentLogicalPosition++; var value = PropertyHelpers.GetValueFromArgsArray(args, offsetInArray, ref currentLogicalPosition, optionalProp); optionalProp.SetValue(options, value); unmatched.Remove(optionalProp); } return(unmatched); }
public void CanCreateBagsTest() { int numBags = 5; var bags = PropertyHelpers.CreateBags(numBags); Assert.AreEqual(bags.Count, numBags); }
private void UpdateBuffer() { uint packSize = AnnotationVariable.DataType.GetPackSizeScalar(); if (AnnotationVariable.IsMatrix && Values[0] is SerializableColor) { for (int i = 0; i < Values.Count; ++i) { uint stepOffset = packSize * AnnotationVariable.Rows; stepOffset = stepOffset.RoundUpMultiple16(); AnnotationVariable.CopyColorToBuffer((SerializableColor)Values.ElementAt(i), stepOffset, packSize * (uint)i); } } else { uint startOffset = 0; for (int column = 0; column < AnnotationVariable.Columns; ++column) { for (int row = 0; row < AnnotationVariable.Rows; ++row) { if (Values[row * column + column] != null) { AnnotationVariable.CopyToBuffer(PropertyHelpers.ConvertToCorrectType(AnnotationVariable.DataType, Values[row * (int)AnnotationVariable.Columns + column]), startOffset); } startOffset += packSize; } startOffset = startOffset.RoundUpMultiple16(); } } ITempHelper helper = ((App)Application.Current).ActiveViewport; AnnotationVariable.AnnotationGroup.MarshalBuffer(helper.ViewportHost, helper.IsStandardShaderActive); }
public void Replace(Operation operation, object objectToApplyTo) { var removeResult = Remove(operation.path, objectToApplyTo, operation); if (removeResult.HasError) { // return => currently not applicable, will throw exception in Remove method } if (!removeResult.HasError && removeResult.ActualType == null) { // the remove operation completed succesfully, but we could not determine the type. throw new JsonPatchException( new JsonPatchError( objectToApplyTo, operation, string.Format("Patch failed: could not determine type of property at location {0}", operation.path)), 422); } var conversionResult = PropertyHelpers.ConvertToActualType(removeResult.ActualType, operation.value); if (!conversionResult.CanBeConverted) { throw new JsonPatchException( new JsonPatchError( objectToApplyTo, operation, string.Format("Patch failed: property value cannot be converted to type of path location {0}", operation.path)), 422); } Add(operation.path, conversionResult.ConvertedInstance, objectToApplyTo, operation); }
/// <summary> /// Data property name that DataTables will use to set tr element DOM IDs. /// </summary> /// <param name="rowId"></param> /// <returns></returns> public TableOptionsFactory <TModel> RowId <T>(Expression <Func <TModel, T> > expression) { var propertyInfo = PropertyHelpers.GetPropertyInfo(expression); _jObject.Add("rowId", new JValue(propertyInfo.Name)); return(this); }
public void Process(SchemaProcessorContext context) { if (context.Type == typeof(ExternalRequirement)) { var schema = context.Schema.Properties.Where(s => s.Key == PropertyHelpers.GetPropertyName(() => new ExternalRequirement().Heading)).FirstOrDefault().Value; using (var db = new CSET_Context()) { var categories = db.QUESTION_GROUP_HEADING.Select(s => s.Question_Group_Heading1).Distinct().OrderBy(s => s).ToList(); categories.ForEach(s => schema.Enumeration.Add(s)); } schema = context.Schema.Properties.Where(s => s.Key == PropertyHelpers.GetPropertyName(() => new ExternalRequirement().Subheading)).FirstOrDefault().Value; using (var db = new CSET_Context()) { var tempSchema = new JsonSchema(); var subCategories = db.UNIVERSAL_SUB_CATEGORIES.Select(s => s.Universal_Sub_Category).Distinct().OrderBy(s => s).ToList(); subCategories.ForEach(s => tempSchema.Enumeration.Add(s)); schema.AnyOf.Add(tempSchema); schema.AnyOf.Add(new JsonSchema() { Type = JsonObjectType.String }); } schema = context.Schema.Properties.Where(s => s.Key == PropertyHelpers.GetPropertyName(() => new ExternalRequirement().SecurityAssuranceLevel)).FirstOrDefault().Value; using (var db = new CSET_Context()) { var subCategories = db.UNIVERSAL_SAL_LEVEL.Select(s => s.Sal_Level_Order).Distinct().OrderBy(s => s).ToList(); subCategories.ForEach(s => schema.Enumeration.Add(s)); } } else { throw new InvalidOperationException("Wrong type"); } }
public void Test() { var items = new[] { new PartySettings { Id = Guid.NewGuid().ToString(), ScopeId = Guid.NewGuid().ToString(), LastModificationDateTime = DateTime.UtcNow, }, new PartySettings { Id = Guid.NewGuid().ToString(), ScopeId = Guid.NewGuid().ToString(), PartyBoxesSettings = new PartyBoxesSettings { SupplierBoxSelectionStrategy = SupplierBoxSelectionStrategy.ShipperField }, } }; var properties = new List <string>(); var gettersList = new List <Func <object?, object?> >(); PropertyHelpers.BuildGettersForProperties(typeof(PartySettings), "", x => x, properties, gettersList, new CustomPropertyConfigurationProvider()); var getters = properties.Zip(gettersList, (name, getter) => (name, getter)).ToDictionary(x => x.name, x => x.getter); getters["Id"](items[0]).Should().Be(items[0].Id); getters["ScopeId"](items[0]).Should().Be(items[0].ScopeId); getters["PartyBoxesSettings.SupplierBoxSelectionStrategy"](items[0]).Should().BeNull(); getters["LastModificationDateTime"](items[0]).Should().Be(items[0].LastModificationDateTime); getters["Id"](items[1]).Should().Be(items[1].Id); getters["ScopeId"](items[1]).Should().Be(items[1].ScopeId); getters["PartyBoxesSettings.SupplierBoxSelectionStrategy"](items[1]).Should().Be(SupplierBoxSelectionStrategy.ShipperField); }
public void PostAddItemTest() { var store = PropertyHelpers.SamplePropertiesStore(); var bag1 = store.Find("GUID1"); var bagBad = store.Find("InvalidGUID"); // Validate our objects Assert.IsNotNull(bag1); Assert.IsNull(bagBad); // Attempt to add after the fact bag1.Add("A-NewKey3", "A-NewValue3"); // Output data var json = JsonConvert.SerializeObject(store, Formatting.Indented); Log.Debug(json); var tempBag1 = store.Find("GUID1"); json = JsonConvert.SerializeObject(tempBag1, Formatting.Indented); Log.Debug(json); var value = tempBag1.Items["A-NewKey3"]; Assert.IsNotNull(value); Assert.AreEqual("A-NewValue3", value); }
private static void ParseRequiredParameters <TOptions>(string[] args, int offsetInArray, ArgumentGroupInfo TypeArgumentInfo, TOptions options, ref int currentLogicalPosition) where TOptions : new() { if (args.Length == 0) { throw new ArgumentException("Required parameters have not been specified"); } int matchedRequiredParameters = 0; do { //set the required property PropertyInfo propInfo; if (!TypeArgumentInfo.RequiredArguments.TryGetValue(currentLogicalPosition, out propInfo)) { break; } //make sure that we don't run out of array if (offsetInArray + currentLogicalPosition >= args.Length) { throw new ArgumentException("Required parameters have not been specified"); } var value = PropertyHelpers.GetValueFromArgsArray(args, offsetInArray, ref currentLogicalPosition, propInfo); propInfo.SetValue(options, value); matchedRequiredParameters++; } while (currentLogicalPosition < args.Length); // no more? do we have any properties that we have not yet set? if (TypeArgumentInfo.RequiredArguments.Count != matchedRequiredParameters) { throw new ArgumentException("Not all required arguments have been specified"); } }
/// <summary> /// The "replace" operation replaces the value at the target location /// with a new value. The operation object MUST contain a "value" member /// whose content specifies the replacement value. /// /// The target location MUST exist for the operation to be successful. /// /// For example: /// /// { "op": "replace", "path": "/a/b/c", "value": 42 } /// /// This operation is functionally identical to a "remove" operation for /// a value, followed immediately by an "add" operation at the same /// location with the replacement value. /// </summary> /// <param name="operation">The replace operation</param> /// <param name="objectApplyTo">Object to apply the operation to</param> public void Replace(Operation <T> operation, T objectToApplyTo) { var removeResult = Remove(operation.path, objectToApplyTo, operation); if (removeResult.HasError) { // return => currently not applicable, will throw exception in Remove method } if (!removeResult.HasError && removeResult.ActualType == null) { // the remove operation completed succesfully, but we could not determine the type. throw new JsonPatchException( new JsonPatchError( objectToApplyTo, operation, string.Format("Patch failed: could not determine type of property at location {0}", operation.path)), 422); } ConversionResult conversionResult; var propType = removeResult.ActualType; var value = operation.value; if (!propType.IsValueType && propType != typeof(string) && value != null && value.GetType() == typeof(string)) { object newObj; if (CustomDeserializationHandler != null) { newObj = CustomDeserializationHandler(value.ToString(), propType); } else { newObj = JsonConvert.DeserializeObject(value.ToString(), propType); } conversionResult = new ConversionResult(true, newObj); } else { conversionResult = PropertyHelpers.ConvertToActualType(removeResult.ActualType, operation.value); } if (!conversionResult.CanBeConverted) { throw new JsonPatchException( new JsonPatchError( objectToApplyTo, operation, string.Format("Patch failed: property value cannot be converted to type of path location {0}", operation.path)), 422); } Add(operation.path, conversionResult.ConvertedInstance, objectToApplyTo, operation); }
public ObjectDescription GetMeta(string objectIdentifier) { var type = schemaRegistry.GetTypeByTypeIdentifier(objectIdentifier); var schema = schemaRegistry.GetSchemaByTypeIdentifier(objectIdentifier); var typeMeta = PropertyHelpers.BuildTypeMetaInformation(null, type, type, schema.PropertyDescriptionBuilder, schema.CustomPropertyConfigurationProvider); return(new ObjectDescription { Identifier = objectIdentifier, SchemaDescription = schema.Description, TypeMetaInformation = typeMeta, }); }
public static PropertyComponent?GetComponentsFromLine(string line) { if (PropertyHelpers.IsRowVersion(line)) { return(null); } if (PropertyHelpers.IsNameSpace(line)) { return(null); } PropertyComponent propertyComponent = new PropertyComponent { IsArray = PropertyHelpers.IsArray(line) }; string[] components = line.Trim().Split(" "); foreach (string component in components) { if (PropertyHelpers.IsAccessModifiers(component) || PropertyHelpers.IsGetOrSet(component)) { continue; } if (PropertyHelpers.IsPropertyType(component)) { propertyComponent.PropertyType = PropertyHelpers.GetPropertyTypeFromComponent(component); propertyComponent.PropertyTypeString = component; } else if (PropertyHelpers.IsVirtual(component)) { propertyComponent.PropertyType = PropertyType.PartOutput; } else { if (PropertyHelpers.IsArray(component)) { propertyComponent.ArrayType = PropertyHelpers.GetArrayTypeFromLine(component); } propertyComponent.Name = component; if (string.IsNullOrEmpty(propertyComponent.PropertyTypeString)) { propertyComponent.PropertyTypeString = component; } } } return(propertyComponent); }
public override void ShowTypeView(Type type, object instance = null) { if (type is null) { return; } m_InstancePropertys = new List <PropertyInfo>(PropertyHelpers.GetInstancePropertys(type)); m_InstancePropertys.Sort(Comparison); m_StaticPropertys = new List <PropertyInfo>(PropertyHelpers.GetStaticPropertys(type)); m_StaticPropertys.Sort(Comparison); base.ShowTypeView(type, instance); }
public async Task <DownloadResult> DownloadObjects([NotNull] string objectIdentifier, [NotNull][FromBody] ObjectSearchRequest query) { var type = schemaRegistry.GetTypeByTypeIdentifier(objectIdentifier); var schema = schemaRegistry.GetSchemaByTypeIdentifier(objectIdentifier); var downloadLimit = schema.Description.DownloadLimit; var count = await schemaRegistry.GetConnector(objectIdentifier).Count(query.GetFilters(), downloadLimit + 1).ConfigureAwait(false); if (count > downloadLimit) { return new DownloadResult { File = null, Count = (int)count, CountLimit = downloadLimit, } } ; var results = await schemaRegistry.GetConnector(objectIdentifier).Search(query.GetFilters(), query.GetSorts(), 0, downloadLimit).ConfigureAwait(false); var properties = new List <string>(); var getters = new List <Func <object, object> >(); PropertyHelpers.BuildGettersForProperties(type, "", x => x, properties, getters); var excludedIndices = properties.Select((x, i) => (x, i)).Where(x => query.ExcludedFields.Contains(x.x)).Select(x => x.i).ToArray(); var filteredProperties = properties.Where((x, i) => !excludedIndices.Contains(i)).ToArray(); var filteredGetters = getters.Where((x, i) => !excludedIndices.Contains(i)).ToArray(); var csvWriter = new CsvWriter(filteredProperties); foreach (var item in results) { csvWriter.AddRow(filteredGetters.Select(f => PropertyHelpers.ToString(f, item)).ToArray()); } return(new DownloadResult { Count = count ?? 0, CountLimit = downloadLimit, File = new FileInfo { Content = csvWriter.GetBytes(), ContentType = "text/csv", Name = $"{objectIdentifier}-{DateTime.UtcNow:yyyy-MM-dd-HHmm}.csv" } }); }
/// <summary> /// Copy values from one object to another, as long as they are the same type. /// </summary> /// <example> /// This sample shows how to use <see cref="ValuesFrom{T}(T, T, bool, string[])"/> to copy all values excluding <paramref name="properties"/> /// from one model to another. /// /// <code> /// user.ValuesFrom(model, true, /// nameof(model.DoNotCopyMe) /// ); /// </code> /// </example> /// <typeparam name="T">Type of object you are copying.</typeparam> /// <param name="targetObject">Target object for copying values to.</param> /// <param name="sourceObject">Source object for copying values from.</param> /// <param name="isExclusionList">Whether <paramref name="properties"/> is a list of properties to exclude or include.</param> /// <param name="properties">Properties to include or exclude from the copy.</param> public static void ValuesFrom <T>(this T targetObject, T sourceObject, bool isExclusionList, params string[] properties) { var type = typeof(T); var allProperties = !isExclusionList ? properties : type.GetProperties().Where(m => !properties.Contains(m.Name)).Select(m => m.Name); if (allProperties == null || allProperties.Count() == 0) { return; } foreach (var property in properties) { var newVal = PropertyHelpers.GetProperty(sourceObject, property); PropertyHelpers.SetPropertyValue(targetObject, property, newVal); } }
static void SingletonClass( ref ClusterDict classCluster, ClusterSubDict allClass) { classCluster.Add("Singleton##Class", NewClassDict()); bool added = false; foreach (var class2type in allClass) { added = false; if (class2type.Value.IsEnum) { continue; } PropertyInfo[] propertyInfos = PropertyHelpers.GetStaticPropertys(class2type.Value); FieldInfo[] fieldInfos = FieldHelpers.GetStaticFields(class2type.Value); //Seach propertys singleton foreach (PropertyInfo propertyInfo in propertyInfos) { if (propertyInfo.PropertyType.FullName == class2type.Value.FullName) { classCluster["Singleton##Class"].Add(class2type.Key, class2type.Value); added = true; break; } } if (added) { continue; } //Seach fields singleton foreach (FieldInfo fieldInfo in fieldInfos) { if (fieldInfo.FieldType.FullName == class2type.Value.FullName) { classCluster["Singleton##Class"].Add(class2type.Key, class2type.Value); break; } } } }
/// <summary> /// 统计Class的引用和静态成员 /// </summary> static int CountClassInclude( Type type, ClusterSubDict allClass ) { HashSet <Type> types = new HashSet <Type>(); int bias = 0; // PropertyInfo[] propertyInfos = PropertyHelpers.GetAllPropertys(type); FieldInfo[] fieldInfos = FieldHelpers.GetAllFields(type); //count field class include number foreach (FieldInfo fieldInfo in fieldInfos) { Caller.Try(() => { if (allClass.ContainsKey(fieldInfo.FieldType.Name)) { //static class field if (fieldInfo.IsStatic && fieldInfo.FieldType.IsEnum == false) { bias += 1; } types.Add(fieldInfo.FieldType); } }); } //count property class include number foreach (PropertyInfo propertyInfo in propertyInfos) { if (allClass.ContainsKey(propertyInfo.PropertyType.Name)) { //static class property if (propertyInfo.GetAccessors().Length > 0 && propertyInfo.GetAccessors()[0].IsStatic && propertyInfo.PropertyType.IsEnum == false) { bias += 1; } types.Add(propertyInfo.PropertyType); } } return(types.Count + bias); }
public void UpdateBuffer(bool marshalBuffer = true) { ITempHelper helper = ((App)Application.Current).ActiveViewport; if (helper == null || helper.ViewportHost == null) { return; } if (IsTexture) { if (helper.IsStandardShaderActive) { helper.ViewportHost.UpdateShaderImage(uint.Parse(Regex.Match(AnnotationGroup.Register, @"\d+").Value), (int)AnnotationGroup.AnnotationShaderGroup.Type, Value?.ToString() ?? ""); } else { helper.ViewportHost.UpdatePPShaderImage(uint.Parse(Regex.Match(AnnotationGroup.Register, @"\d+").Value), Value?.ToString() ?? ""); } return; } if (Value == null) { return; } if (IsScalar) { if (IsScalar) { CopyToBuffer(PropertyHelpers.ConvertToCorrectType(DataType, Value)); } } else if (IsVector) { if (Value is SerializableColor) { CopyColorToBuffer((SerializableColor)Value, DataType.GetPackSizeScalar()); } } if (marshalBuffer) { AnnotationGroup.MarshalBuffer(helper.ViewportHost, helper.IsStandardShaderActive); } }
public void Create2PropertiesAndSerializationTest() { var bag1 = PropertyHelpers.CreateBag("GUID-1"); var bag2 = PropertyHelpers.CreateBag("GUID-2"); var bag3 = PropertyHelpers.CreateBag("GUID-3"); var bags1 = new List <Properties>() { bag1, bag2, bag3 }; var json = JsonConvert.SerializeObject(bags1, Formatting.Indented); var bags2 = JsonConvert.DeserializeObject <List <Properties> >(json); Log.Debug(json); Assert.IsNotNull(bag2); Assert.AreEqual(bags1.Count, bags2.Count); }
public void SaveClearAndLoadPropertiesFileTest() { Log.Debug($"Tmp Path: {_settings.SettingsFilePath}"); var store = PropertyHelpers.SamplePropertiesStore(); _settings.PropertiesStore = store; _settings.SaveFile(); store.ClearAll(); Assert.AreEqual(store.PropertyBags.Count, 0); _settings.LoadFile(); Assert.AreNotEqual(store.PropertyBags.Count, 0); string json = JsonConvert.SerializeObject(store.PropertyBags, Formatting.Indented); Log.Debug(json); }
public void CreateUI() { AnnotationValue.PropertyChanged += new PropertyChangedEventHandler(OnResourcePropertyChanged); if (IsTexture) { UIElement = new ImagePicker(this); } else if (DataType.IsBool() && IsScalar) { UIElement = PropertyHelpers.CreateCheckBox(this, "Value", Value); } else if (!DataType.IsBool() && IsScalar && (IsSNorm || IsUNorm || (Annotations?.Contains(new KeyValuePair <string, string>("UIWidget", "Slider")) ?? false))) { object val = Value; if (val == null) { if (DataType.IsIntegral()) { Value = 0; } else { Value = 0.0; } } UIElement = PropertyHelpers.CreateSlider(this, "Value", this, val); } else if (!IsMatrix && (Columns == 3 || Columns == 4) && (Annotations?.Contains(new KeyValuePair <string, string>("UIWidget", "Color")) ?? false)) { UIElement = PropertyHelpers.CreateColorPicker(this, "Value", (Columns == 4) ? true : false, Value); } else if (IsScalar) { UIElement = PropertyHelpers.CreateSpinner(this, "Value", this, Value); } else { UIElement = new DropdownVecMatProperty(this); } }
public async Task <ObjectDetails> ReadObject(string objectIdentifier, ObjectReadRequest query) { var type = schemaRegistry.GetTypeByTypeIdentifier(objectIdentifier); var schema = schemaRegistry.GetSchemaByTypeIdentifier(objectIdentifier); var result = await schemaRegistry.GetConnector(objectIdentifier).Read(query.Conditions).ConfigureAwait(false); var typeMeta = PropertyHelpers.BuildTypeMetaInformation(result, type, type, schema.PropertyDescriptionBuilder, schema.CustomPropertyConfigurationProvider); var obj = ObjectsConverter.StoredToApiDeep(result, schema.CustomPropertyConfigurationProvider); return(new ObjectDetails { Object = obj, Meta = new ObjectDescription { Identifier = objectIdentifier, SchemaDescription = schema.Description, TypeMetaInformation = typeMeta, } }); }
public async Task <ObjectDetails> ReadObject([NotNull] string objectIdentifier, [NotNull][FromBody] ObjectSearchRequest query) { var type = schemaRegistry.GetTypeByTypeIdentifier(objectIdentifier); var schema = schemaRegistry.GetSchemaByTypeIdentifier(objectIdentifier); var typeMeta = PropertyHelpers.BuildTypeMetaInformation(type, schema.PropertyDescriptionBuilder, schema.CustomPropertyConfigurationProvider); var result = await schemaRegistry.GetConnector(objectIdentifier).Read(query.GetFilters()).ConfigureAwait(false); var typeInfo = TypeInfoExtractor.Extract(result, type, schema.PropertyDescriptionBuilder, schema.CustomPropertyConfigurationProvider); var obj = ObjectsConverter.StoredToApi(typeInfo, type, result, schema.CustomPropertyConfigurationProvider); return(new ObjectDetails { Object = obj, Meta = new ObjectDescription { Identifier = objectIdentifier, SchemaDescription = schema.Description, TypeMetaInformation = typeMeta, } }); }
///// <summary> ///// Add a column to the factory ///// </summary> ///// <typeparam name="T"></typeparam> ///// <returns></returns> //public DataTableColumnBuilder Add<T>() //{ // DataTableColumnBuilder column = new DataTableColumnBuilder(); // this.Columns.Add(column); // return column; //} /// <summary> /// Add a column to the factory /// </summary> /// <param name="expression"></param> /// <returns></returns> public DataTableColumnBuilder ColumnFor <T>(Expression <Func <TModel, T> > expression) { var propertyInfo = PropertyHelpers.GetPropertyInfo(expression); if (IndexesDic.ContainsKey(propertyInfo.Name)) { throw new Exception($"Column {propertyInfo.Name} is already Set."); } IndexesDic[propertyInfo.Name] = _currentColumnIndex++; DataTableColumnBuilder column = new DataTableColumnBuilder(propertyInfo) { Expression = expression, // TODO: try use InputExtensions.HiddenFor() }; //ViewContext viewContext = htmlHelper.ViewContext; // viewContext.ViewData.Model = //System.Web.Mvc.HtmlHelper<TModel> htmlHelper2 = new HtmlHelper<TModel>(htmlHelper.ViewContext, htmlHelper.ViewDataContainer);// htmlHelper; //var result=InputExtensions.HiddenFor(htmlHelper2, expression).ToHtmlString(); column.Type(GetType(propertyInfo)); this.Columns.Add(column); return(column); }
public void Process(SchemaProcessorContext context) { if (context.Type == typeof(ExternalStandard)) { var schema = context.Schema.Properties.Where(s => s.Key == PropertyHelpers.GetPropertyName(() => new ExternalStandard().Category)).FirstOrDefault().Value; using (var db = new CSET_Context()) { var categories = db.SETS_CATEGORY.Select(s => s.Set_Category_Name).Distinct().OrderBy(s => s).ToList(); categories.ForEach(s => schema.Enumeration.Add(s)); var setNames = db.SETS.Select(s => s.Set_Name).ToList().Union(db.SETS.Select(s => s.Short_Name).ToList()).Distinct().OrderBy(s => s).ToList(); var newSchema = new JsonSchema(); setNames.ForEach(s => newSchema.Enumeration.Add(s)); context.Schema.Properties.Where(s => s.Key == PropertyHelpers.GetPropertyName(() => new ExternalStandard().ShortName)).FirstOrDefault().Value.Not = newSchema; var reqs = context.Schema.Properties.Where(s => s.Key == PropertyHelpers.GetPropertyName(() => new ExternalStandard().Requirements)).FirstOrDefault().Value; reqs.MinLength = 1; } } else { throw new InvalidOperationException("Wrong type"); } }
private static TOptions InternalParse <TOptions>(string[] args, int offsetInArray, ArgumentGroupInfo arguments, ParserOptions parseOptions) where TOptions : new() { TOptions options = new TOptions(); int currentLogicalPosition = 0; // let's match them to actual required args, in positional if (arguments.RequiredArguments.Count > 0) { ParseRequiredParameters(args, offsetInArray, arguments, options, ref currentLogicalPosition); } // we are going to keep track of any properties that have not been specified so that we can set their default value. var unmatchedOptionalProperties = ParseOptionalParameters(args, offsetInArray, arguments, options, ref currentLogicalPosition); // for all the remaining optional properties, set their default value. foreach (var property in unmatchedOptionalProperties) { //get the default value.. var value = property.GetCustomAttribute <OptionalArgumentAttribute>(); object defaultValue = value.DefaultValue; // If we want to read values from the environment, try to get the value if (parseOptions.ReadFromEnvironment && !value.IsCollection && parseOptions.VariableNamePrefix != null) { var envVar = Environment.GetEnvironmentVariable($"{parseOptions.VariableNamePrefix}{value.Name}"); if (!string.IsNullOrEmpty(envVar)) { defaultValue = PropertyHelpers.GetValueForProperty(envVar, property); } } property.SetValue(options, Convert.ChangeType(defaultValue, property.PropertyType)); } return(options); }
public void CopyColorToBuffer(SerializableColor color, uint stepOffset, uint startOffset = 0) { if (DataType.IsIntegral()) { CopyToBuffer(PropertyHelpers.ConvertToCorrectType(DataType, color.R), startOffset); CopyToBuffer(PropertyHelpers.ConvertToCorrectType(DataType, color.G), startOffset + stepOffset); CopyToBuffer(PropertyHelpers.ConvertToCorrectType(DataType, color.B), startOffset + stepOffset * 2); if (Columns == 4) { CopyToBuffer(PropertyHelpers.ConvertToCorrectType(DataType, color.A), startOffset + stepOffset * 3); } } else { CopyToBuffer(PropertyHelpers.ConvertToCorrectType(DataType, color.scR), startOffset); CopyToBuffer(PropertyHelpers.ConvertToCorrectType(DataType, color.scG), startOffset + stepOffset); CopyToBuffer(PropertyHelpers.ConvertToCorrectType(DataType, color.scB), startOffset + stepOffset * 2); if (Columns == 4) { CopyToBuffer(PropertyHelpers.ConvertToCorrectType(DataType, color.scA), startOffset + stepOffset * 3); } } }
private void InitializeItemsSource() { DataType type = AnnotationVariable.DataType; if (type.IsBool()) { if (Values == null || Values.Count != AnnotationVariable.Rows * AnnotationVariable.Columns) { Values = new ObservableCollection <object>(new object[AnnotationVariable.Rows * AnnotationVariable.Columns]); } for (int row = 0; row < AnnotationVariable.Rows; ++row) { StackPanel panel = new StackPanel(); panel.Orientation = Orientation.Horizontal; for (int column = 0; column < AnnotationVariable.Columns; ++column) { UIElement element = PropertyHelpers.CreateCheckBox(this, $"Values[{row * (int)AnnotationVariable.Columns + column}]", Values[row * (int)AnnotationVariable.Columns + column]); panel.Children.Add(element); } Items.Add(panel); } } else if ((AnnotationVariable.Columns == 3 || AnnotationVariable.Columns == 4) && (AnnotationVariable.Annotations?.Contains(new KeyValuePair <string, string>("UIWidget", "Color")) ?? false)) { if (Values == null || Values.Count != AnnotationVariable.Rows) { Values = new ObservableCollection <object>(new object[AnnotationVariable.Rows]); } for (int row = 0; row < AnnotationVariable.Rows; ++row) { UIElement element = PropertyHelpers.CreateColorPicker(this, $"Values[{row}]", (AnnotationVariable.Columns == 4) ? true : false, Values[row]); Items.Add(element); } } else if (AnnotationVariable.Columns == 1 && (AnnotationVariable.Annotations?.Contains(new KeyValuePair <string, string>("UIWidget", "Slider")) ?? false)) { if (Values == null || Values.Count != AnnotationVariable.Rows) { Values = new ObservableCollection <object>(new object[AnnotationVariable.Rows]); } for (int row = 0; row < AnnotationVariable.Rows; ++row) { object val = Values[row]; if (val == null) { if (AnnotationVariable.DataType.IsIntegral()) { Values[row] = 0; } else { Values[row] = 0.0; } } UIElement element = PropertyHelpers.CreateSlider(this, $"Values[{row}]", AnnotationVariable, val); Items.Add(element); } } else { if (Values == null || Values.Count != AnnotationVariable.Rows * AnnotationVariable.Columns) { Values = new ObservableCollection <object>(new object[AnnotationVariable.Rows * AnnotationVariable.Columns]); } for (int row = 0; row < AnnotationVariable.Rows; ++row) { StackPanel panel = new StackPanel(); panel.Orientation = Orientation.Horizontal; for (int column = 0; column < AnnotationVariable.Columns; ++column) { UIElement element = PropertyHelpers.CreateSpinner(this, $"Values[{row * (int)AnnotationVariable.Columns + column}]", AnnotationVariable, Values[row * (int)AnnotationVariable.Columns + column]); panel.Children.Add(element); } Items.Add(panel); } } }
private GetValueResult GetValueAtLocation(string location, object objectToGetValueFrom, Operation operationToReport) { // get value from "objectToGetValueFrom" at location "location" object valueAtLocation = null; var pathResult = PropertyHelpers.GetActualPropertyPath( location, objectToGetValueFrom, operationToReport, false); var positionAsInteger = pathResult.NumericEnd; var actualFromProperty = pathResult.PathToProperty; // first, analyze the tree. var result = new ObjectTreeAnalysisResult(objectToGetValueFrom, actualFromProperty, ContractResolver); if (result.UseDynamicLogic) { // find the property if (result.Container.ContainsCaseInsensitiveKey(result.PropertyPathInParent)) { if (positionAsInteger > -1) { // get the actual type var typeOfPathProperty = result.Container .GetValueForCaseInsensitiveKey(result.PropertyPathInParent).GetType(); if (PropertyHelpers.IsNonStringArray(typeOfPathProperty)) { // now, get the generic type of the enumerable var genericTypeOfArray = PropertyHelpers.GetIListType(typeOfPathProperty); // get value var array = result.Container.GetValueForCaseInsensitiveKey(result.PropertyPathInParent) as IList; if (positionAsInteger >= array.Count) { throw new JsonPatchException( new JsonPatchError( objectToGetValueFrom, operationToReport, string.Format("Patch failed: property at location from: {0} does not exist", location)), 422); } valueAtLocation = array[positionAsInteger]; } else { throw new JsonPatchException( new JsonPatchError( objectToGetValueFrom, operationToReport, string.Format("Patch failed: provided from path is invalid for array property type at location from: {0}: expected array", location)), 422); } } else { // get the value valueAtLocation = result.Container.GetValueForCaseInsensitiveKey(result.PropertyPathInParent); } } else { throw new JsonPatchException( new JsonPatchError( objectToGetValueFrom, operationToReport, string.Format("Patch failed: property at location from: {0} does not exist.", location)), 422); } } else { // not dynamic. var patchProperty = result.JsonPatchProperty; // is the path an array (but not a string (= char[]))? In this case, // the path must end with "/position" or "/-", which we already determined before. if (positionAsInteger > -1) { if (PropertyHelpers.IsNonStringArray(patchProperty.Property.PropertyType)) { // now, get the generic type of the enumerable if (patchProperty.Property.Readable) { var array = (IList)patchProperty.Property.ValueProvider .GetValue(patchProperty.Parent); if (positionAsInteger >= array.Count) { throw new JsonPatchException( new JsonPatchError( objectToGetValueFrom, operationToReport, string.Format("Patch failed: property at location from: {0} does not exist", location)), 422); } valueAtLocation = array[positionAsInteger]; } else { throw new JsonPatchException( new JsonPatchError( objectToGetValueFrom, operationToReport, string.Format("Patch failed: cannot get property at location from from: {0}. Possible cause: the property doesn't have an accessible getter.", location)), 422); } } else { throw new JsonPatchException( new JsonPatchError( objectToGetValueFrom, operationToReport, string.Format("Patch failed: provided from path is invalid for array property type at location from: {0}: expected array", location)), 422); } } else { if (!patchProperty.Property.Readable) { throw new JsonPatchException( new JsonPatchError( objectToGetValueFrom, operationToReport, string.Format("Patch failed: cannot get property at location from from: {0}. Possible cause: the property doesn't have an accessible getter.", location)), 422); } valueAtLocation = patchProperty.Property.ValueProvider .GetValue(patchProperty.Parent); } } return(new GetValueResult(valueAtLocation, false)); }