private static void AddParameterRefs(TSObject operationSpec, string propertyName, IEnumerable <Parameter> requestParameters) { if (requestParameters != null && requestParameters.Any()) { operationSpec.ArrayProperty(propertyName, parameterArray => { foreach (ParameterTS requestParameter in requestParameters) { parameterArray.Value(v => v.Text("Parameters." + requestParameter.MapperName)); } }); } }
private static void GenerateParameters(TSObject operationSpec, string propertyName, IEnumerable <Parameter> parameters, Action <TSObject, Parameter> extraParameterProperties = null) { if (parameters != null && parameters.Any()) { operationSpec.ArrayProperty(propertyName, parameterArray => { foreach (ParameterTS parameter in parameters) { parameterArray.Object(parameterObject => { parameterObject.QuotedStringProperty("parameterName", parameter.Name); extraParameterProperties?.Invoke(parameterObject, parameter); parameterObject.Property("mapper", mapper => ClientModelExtensions.ConstructMapper(mapper, parameter.ModelType, parameter.SerializedName, parameter, false, false, false)); }); } }); } }
public void GetEUM() { TSObject tso = new TSObject(); tso.Connection.FilePath = @"..\..\..\TestData\Units.dfs0"; tso.Connection.Open(); //head elevation Assert.AreEqual(171, tso.Item(1).EumType); Assert.AreEqual(1, tso.Item(1).EumUnit); //Pumping rate Assert.AreEqual(330,tso.Item(2).EumType); Assert.AreEqual(3,tso.Item(2).EumUnit); //Flow Assert.AreEqual(2, tso.Item(3).EumType); Assert.AreEqual(1, tso.Item(3).EumUnit); }
internal static void GenerateRequestParameter(TSObject parameterObject, ParameterTS requestParameter, ParameterTransformations parameterTransformations) { GenerateRequestParameterPath(parameterObject, requestParameter, parameterTransformations); parameterObject.Property("mapper", mapper => ClientModelExtensions.ConstructMapper(mapper, requestParameter.ModelType, requestParameter.SerializedName, requestParameter, false, false, false)); ParameterLocation location = requestParameter.Location; if (location == ParameterLocation.Path || location == ParameterLocation.Query) { AddSkipEncodingProperty(parameterObject, requestParameter); } if (location == ParameterLocation.Query) { if (requestParameter.CollectionFormat != CollectionFormat.None) { parameterObject.TextProperty("collectionFormat", $"msRest.QueryCollectionFormat.{requestParameter.CollectionFormat}"); } } }
/// <summary> /// Reads in the wells defined in detailed timeseries input section /// </summary> /// <param name="Mshe"></param> public static IEnumerable <IWell> ReadInDetailedTimeSeries(Model Mshe) { MikeSheWell CurrentWell; IIntake CurrentIntake; TSObject _tso = null; foreach (var dt in Mshe.Input.MIKESHE_FLOWMODEL.StoringOfResults.DetailedTimeseriesOutput.Item_1s) { CurrentWell = new MikeSheWell(dt.Name); CurrentWell.X = dt.X; CurrentWell.Y = dt.Y; CurrentWell.UsedForExtraction = false; CurrentIntake = CurrentWell.AddNewIntake(1); Screen sc = new Screen(CurrentIntake); sc.DepthToTop = dt.Z; sc.DepthToBottom = dt.Z; CurrentWell.Row = Mshe.GridInfo.GetRowIndex(CurrentWell.X); CurrentWell.Column = Mshe.GridInfo.GetColumnIndex(CurrentWell.Y); CurrentWell.Terrain = Mshe.GridInfo.SurfaceTopography.Data[CurrentWell.Row, CurrentWell.Column]; //Read in observations if they are included if (dt.InclObserved == 1) { if (_tso == null || _tso.Connection.FilePath != dt.TIME_SERIES_FILE.FILE_NAME) { _tso = new TSObjectClass(); _tso.Connection.FilePath = dt.TIME_SERIES_FILE.FILE_NAME; _tso.Connection.Open(); } //Loop the observations and add for (int i = 1; i <= _tso.Time.NrTimeSteps; i++) { CurrentIntake.HeadObservations.Items.Add(new TimestampValue((DateTime)_tso.Time.GetTimeForTimeStepNr(i), (float)_tso.Item(dt.TIME_SERIES_FILE.ITEM_NUMBERS).GetDataForTimeStepNr(i))); } } yield return(CurrentWell); } }
public void GenerateOperationArguments(TSObject operationArguments) { ParameterTransformations transformations = GetParameterTransformations(); // Remember that Parameters contains the parameters of the REST API method, not the // generated method. foreach (Parameter parameter in Parameters) { if (parameter.IsRequired && !parameter.IsConstant && !parameter.IsClientProperty && !operationArguments.ContainsProperty(parameter.Name) && !transformations.IsCreatedFromTransformation(parameter.Name) && parameter.Name != "options") { operationArguments.TextProperty(parameter.Name, parameter.Name); } } operationArguments.TextProperty("options", "options"); }
public void Write(uint index, string type, object obj) { objects[index] = new TSObject(type, obj as byte[]); }
public static void ConstructMapper(TSObject mapper, IModelType type, string serializedName, IVariable parameter, bool isPageable, bool expandComposite, bool isXML, bool isCaseSensitive = true, string xmlName = null) { string defaultValue = null; bool isRequired = false; bool isConstant = false; bool isReadOnly = false; Dictionary <Constraint, string> constraints = null; var property = parameter as Property; if (parameter != null) { defaultValue = parameter.DefaultValue; isRequired = parameter.IsRequired; isConstant = parameter.IsConstant; constraints = parameter.Constraints; } string xmlPrefix = !isXML ? null : property?.XmlPrefix ?? type?.XmlPrefix; bool addXmlNameFromParameterValue = isXML && !string.IsNullOrEmpty(xmlName) && xmlName != serializedName; if (addXmlNameFromParameterValue) { if (!string.IsNullOrEmpty(xmlPrefix)) { xmlName = $"{xmlPrefix}:{xmlName}"; } mapper.QuotedStringProperty("xmlName", xmlName); } if (isXML && !string.IsNullOrEmpty(serializedName) && !string.IsNullOrEmpty(xmlPrefix)) { serializedName = $"{xmlPrefix}:{serializedName}"; } if (property != null) { isReadOnly = property.IsReadOnly; if (isXML) { if (property.XmlIsAttribute) { mapper.BooleanProperty("xmlIsAttribute", true); } if (property.XmlIsWrapped) { mapper.BooleanProperty("xmlIsWrapped", true); } string propertyXmlName = property.ModelType.XmlProperties?.Name ?? property.XmlName; if (!addXmlNameFromParameterValue && !string.IsNullOrEmpty(propertyXmlName)) { if (!string.IsNullOrEmpty(xmlPrefix)) { propertyXmlName = $"{xmlPrefix}:{propertyXmlName}"; } // For some reason we can't omit xmlName in this scenario if it is equal to // serializedName. It might have to do with whether or not xmlElementName // is present, but I'm not sure at this time. mapper.QuotedStringProperty("xmlName", propertyXmlName); } } } CompositeTypeTS composite = type as CompositeTypeTS; if (composite != null && composite.ContainsConstantProperties && (parameter != null && parameter.IsRequired)) { defaultValue = "{}"; } SequenceType sequence = type as SequenceType; if (sequence != null && isXML) { if (sequence.ElementXmlIsWrapped) { mapper.BooleanProperty("xmlElementIsWrapped", true); } string xmlElementName = sequence.ElementType.XmlProperties?.Name ?? sequence.ElementXmlName; if (!string.IsNullOrEmpty(xmlElementName)) { mapper.QuotedStringProperty("xmlElementName", xmlElementName); } } if (isRequired) { mapper.BooleanProperty("required", true); } if (parameter?.IsXNullable != null) { if (parameter.IsXNullable.Value) { mapper.BooleanProperty("nullable", true); } else { mapper.BooleanProperty("nullable", false); } } if (isReadOnly) { mapper.BooleanProperty("readOnly", true); } if (isConstant) { mapper.BooleanProperty("isConstant", true); } if (serializedName != null) { if (!isCaseSensitive) { serializedName = serializedName.ToLower(); } mapper.QuotedStringProperty("serializedName", serializedName); } if (!string.IsNullOrEmpty(defaultValue)) { mapper.TextProperty("defaultValue", defaultValue); } DictionaryType dictionary = type as DictionaryType; PrimaryType primary = type as PrimaryType; EnumType enumType = type as EnumType; void applyConstraints(TSObject obj) { bool useClientSideValidation = (bool)(Settings.Instance?.CustomSettings[CodeModelTS.ClientSideValidationSettingName] ?? false); if (useClientSideValidation && constraints != null && constraints.Any()) { obj.ObjectProperty("constraints", constraintsObject => { foreach (KeyValuePair <Constraint, string> constraintEntry in constraints) { Constraint constraint = constraintEntry.Key; string constraintValue = constraintEntry.Value; if (constraint == Constraint.Pattern) { constraintValue = CreateRegexPatternConstraintValue(constraintValue); } constraintsObject.TextProperty(constraint.ToString(), constraintValue); } }); } } // Apply header collection constraints only to dictionary values, not the dictionary itself string prefix = parameter?.Extensions?.GetValue <string>(SwaggerExtensions.HeaderCollectionPrefix); bool skipConstraints = !string.IsNullOrEmpty(prefix) && dictionary != null; if (!skipConstraints) { applyConstraints(mapper); } if (primary != null) { switch (primary.KnownPrimaryType) { case KnownPrimaryType.Base64Url: case KnownPrimaryType.Boolean: case KnownPrimaryType.ByteArray: case KnownPrimaryType.Date: case KnownPrimaryType.DateTime: case KnownPrimaryType.DateTimeRfc1123: case KnownPrimaryType.Object: case KnownPrimaryType.Stream: case KnownPrimaryType.String: case KnownPrimaryType.TimeSpan: case KnownPrimaryType.UnixTime: case KnownPrimaryType.Uuid: AddTypeProperty(mapper, primary.KnownPrimaryType.ToString()); break; case KnownPrimaryType.Int: case KnownPrimaryType.Long: case KnownPrimaryType.Decimal: case KnownPrimaryType.Double: AddTypeProperty(mapper, "Number"); break; default: throw new NotImplementedException($"{primary} is not a supported Type."); } } else if (enumType != null) { if (enumType.ModelAsString) { AddTypeProperty(mapper, "String"); } else { AddTypeProperty(mapper, "Enum", typeObject => { typeObject.ArrayProperty("allowedValues", allowedValues => { foreach (EnumValue enumValue in enumType.Values) { allowedValues.QuotedString(enumValue.SerializedName); } }); }); } } else if (sequence != null) { AddTypeProperty(mapper, "Sequence", typeObject => { typeObject.Property("element", element => { ConstructMapper(element, sequence.ElementType, null, null, false, false, isXML, isCaseSensitive); }); }); } else if (dictionary != null) { AddTypeProperty(mapper, "Dictionary", typeObject => { typeObject.ObjectProperty("value", dictionaryValue => { ConstructMapper(dictionaryValue, dictionary.ValueType, null, null, false, false, isXML, isCaseSensitive); applyConstraints(dictionaryValue); }); }); if (!string.IsNullOrEmpty(prefix)) { mapper.QuotedStringProperty("headerCollectionPrefix", prefix); } } else if (composite != null) { AddTypeProperty(mapper, "Composite", typeObject => { if (expandComposite) { if (composite.IsPolymorphic) { // Note: If the polymorphicDiscriminator has a dot in it's name then do not escape that dot for // it's serializedName, the way it is done for other properties. This makes it easy to find the // discriminator property from the responseBody during deserialization. Please, do not get confused // between the definition of the discriminator and the definition of the property that is // marked as the discriminator. typeObject.ObjectProperty("polymorphicDiscriminator", polymorphicDiscriminator => { polymorphicDiscriminator.QuotedStringProperty("serializedName", composite.PolymorphicDiscriminator); polymorphicDiscriminator.QuotedStringProperty("clientName", Singleton <CodeNamerTS> .Instance.GetPropertyName(composite.PolymorphicDiscriminator)); }); typeObject.QuotedStringProperty("uberParent", composite.Name); } else { CompositeType baseType = composite; while (baseType.BaseModelType != null) { baseType = baseType.BaseModelType; } if (baseType.IsPolymorphic) { typeObject.TextProperty("polymorphicDiscriminator", baseType.Name + ".type.polymorphicDiscriminator"); typeObject.QuotedStringProperty("uberParent", baseType.Name); } } } typeObject.QuotedStringProperty("className", composite.Name); if (expandComposite) { typeObject.ObjectProperty("modelProperties", modelProperties => { if (composite.BaseModelType != null && composite.BaseModelType.ComposedProperties.Any()) { modelProperties.Spread(composite.BaseModelType.Name + ".type.modelProperties"); } foreach (Property prop in composite.Properties) { var serializedPropertyName = prop.SerializedName; if (isPageable) { PropertyInfo itemName = composite.GetType().GetProperty("ItemName"); PropertyInfo nextLinkName = composite.GetType().GetProperty("NextLinkName"); string nextLinkNameValue = (string)nextLinkName.GetValue(composite); if (itemName != null && ((string)itemName.GetValue(composite) == prop.Name)) { serializedPropertyName = ""; } if (prop.Name.Contains("nextLink") && nextLinkName != null && nextLinkNameValue == null) { continue; } } if (modelProperties.ContainsProperty(prop.Name)) { // throw new InvalidOperationException($"Mapper \"{serializedName}\" contains multiple modelProperties with the name \"{prop.Name}\"."); } else { modelProperties.Property(prop.Name, propertyValue => ConstructMapper(propertyValue, prop.ModelType, serializedPropertyName, prop, false, false, isXML, isCaseSensitive)); } } }); } if (composite.AdditionalProperties != null) { typeObject.ObjectProperty("additionalProperties", additionalProperties => { ConstructMapper(additionalProperties, composite.AdditionalProperties, serializedName: null, parameter: null, isPageable: false, expandComposite: false, isXML: isXML); }); } else { CompositeTypeTS baseType = composite; while (true) { baseType = (CompositeTypeTS)baseType.BaseModelType; if (baseType == null) { break; } else if (baseType.AdditionalProperties != null) { typeObject.TextProperty("additionalProperties", $"{baseType.Name}.type.additionalProperties"); break; } } } }); } else { throw new NotImplementedException($"{type} is not a supported Type."); } }
public static void ConstructParameterMapper(TSObject obj, ParameterTS parameter) { MethodTS.GenerateRequestParameter(obj, parameter, parameter.MethodTS.GetParameterTransformations()); }
private static void GenerateRequestParameterPath(TSObject parent, Parameter requestParameter, ParameterTransformations parameterTransformations) { GenerateRequestParameterPath(parent, "parameterPath", requestParameter.Name, !requestParameter.IsClientProperty && !requestParameter.IsRequired, parameterTransformations); }
public void GenerateOperationSpec(TSObject operationSpec) { operationSpec.QuotedStringProperty("httpMethod", HttpMethod.ToString().ToUpper()); if (IsAbsoluteUrl) { operationSpec.QuotedStringProperty("baseUrl", CodeModelTS.BaseUrl); } string path = Path; if (!string.IsNullOrEmpty(path)) { operationSpec.QuotedStringProperty("path", path); } Parameter[] logicalParameters = LogicalParameters.ToArray(); AddParameterRefs(operationSpec, "urlParameters", logicalParameters.Where(p => p.Location == ParameterLocation.Path)); AddParameterRefs(operationSpec, "queryParameters", logicalParameters.Where(p => p.Location == ParameterLocation.Query)); AddParameterRefs(operationSpec, "headerParameters", logicalParameters.Where(p => p.Location == ParameterLocation.Header)); bool addContentTypeProperty = (!string.IsNullOrEmpty(RequestContentType) && RequestContentType != CodeModelTS.RequestContentType); if (Body != null) { operationSpec.ObjectProperty("requestBody", requestBodyObject => { GenerateRequestParameterPath(requestBodyObject, Body, GetParameterTransformations()); requestBodyObject.Property("mapper", requestBodyMapper => ClientModelExtensions.ConstructRequestBodyMapper(requestBodyMapper, Body)); }); } else { IEnumerable <Parameter> formDataParameters = logicalParameters.Where(p => p.Location == ParameterLocation.FormData); if (formDataParameters.Any()) { AddParameterRefs(operationSpec, "formDataParameters", formDataParameters); addContentTypeProperty = true; } } if (addContentTypeProperty) { operationSpec.QuotedStringProperty("contentType", RequestContentType); } operationSpec.ObjectProperty("responses", responses => { bool isXml = CodeModelTS.ShouldGenerateXmlSerialization; foreach (KeyValuePair <HttpStatusCode, Response> statusCodeResponsePair in Responses) { HttpStatusCode statusCode = statusCodeResponsePair.Key; Response response = statusCodeResponsePair.Value; responses.ObjectProperty(((int)statusCode).ToString(), responseObject => { if (response.Body != null) { responseObject.Property("bodyMapper", responseBodyMapper => ClientModelExtensions.ConstructResponseBodyMapper(responseBodyMapper, response, this)); } if (response.Headers != null) { responseObject.Property("headersMapper", responseHeadersMapper => responseHeadersMapper.Text($"Mappers.{response.Headers.Name}")); } }); } responses.ObjectProperty("default", defaultResponseObject => { Response defaultResponse = DefaultResponse; if (defaultResponse != null && defaultResponse.Body != null) { defaultResponseObject.Property("bodyMapper", responseBodyMapper => ClientModelExtensions.ConstructResponseBodyMapper(responseBodyMapper, defaultResponse, this)); } }); }); if (CodeModel.ShouldGenerateXmlSerialization) { operationSpec.BooleanProperty("isXML", true); } operationSpec.TextProperty("serializer", "serializer"); }
// the function CallStaticFunction (and its overload) allows for calling any public static function of the running!!! UI // currently the only public functions of the UI are gathered in the class EM_UI.PlugInService.UISessionInfo // these functions (providing info about pathes, active countries, etc.) are replicated by EM_Common.dll for more convenient calling // for this purpose the class EM_Common.UISessionInfo uses the function CallStaticFunction below // in principle plug-ins can use CallStaticFunction themselves, provided we extend the UI by public static functions public static bool CallStaticFunction(string className, string functionName, out TSObject returnValue, out string errMsg, TSDictionary parameters = null) { returnValue = new TSObject(); errMsg = string.Empty; // initialise out-parameters try { Assembly assembly = GetUIAssembly(); // search for class (must be unique match) Type classType = null; foreach (Type t in assembly.GetExportedTypes()) { if (t.Name == className) { classType = t; } } if (classType == null) { throw new Exception($"class {className} not found"); } // searching for function is more complicated as there could be overloads List <MethodInfo> possibleMatches = new List <MethodInfo>(); foreach (MethodInfo possibleMatch in classType.GetMethods()) { if (possibleMatch.Name != functionName) { continue; } possibleMatches.Add(possibleMatch); } if (possibleMatches.Count == 0) { throw new Exception($"function {functionName} not found"); } // now try calling all overloads of the function to hopefully find a matching one foreach (MethodInfo possibleMatch in possibleMatches) { try { object[] outParameters = CompileParameterArray(possibleMatch, parameters); // put parameters from dictionary into array with correct order object[] inParameters = new object[outParameters.Count()]; outParameters.CopyTo(inParameters, 0); returnValue.SetValue(possibleMatch.Invoke(classType, outParameters)); // gather out- and ref-parameters for appropriate returning if (parameters != null) { parameters.Clear(); ParameterInfo[] parameterInfo = possibleMatch.GetParameters(); for (int i = 0; i < parameterInfo.Count(); ++i) { if (parameterInfo[i].ParameterType.IsByRef || parameterInfo[i].IsOut) { parameters.SetItem(parameterInfo[i].Name, outParameters[i]); } } } return(true); } catch (Exception exception) // remark: try/catch seems the most secure way to check parameter-matching { // "manual" check is quite problematic (consider: derived types, numeric parameters (is it int/long/double), etc.) if (exception is TargetParameterCountException || exception is ArgumentException) { if (possibleMatch != possibleMatches.Last()) { continue; // continue search as there may be an overload with matching parameters } } throw new Exception("no overload with matching parameters found"); } } return(true); } catch (Exception exception) { errMsg = $"Calling UI-function {className}.{functionName} from other assembly failed: {exception.Message}"; return(false); } }