/// <summary>
/// Returns the value of an argument, used to call a command
/// </summary>
/// <param name="context">The <see cref="HttpContext"/> of the HTTP-request</param>
/// <param name="parMeta">The metadata of the parameter</param>
/// <param name="queryDict">A dictionary of query values</param>
/// <returns></returns>
private object GetArgumentValue(HttpContext context, Metadata.Parameter parMeta, IDictionary <string, string> queryDict)
{
if (parMeta.IsPlatformSpecific)
{
if (parMeta.ParameterType.Type == typeof(HttpContext))
{
return(context);
}
else
{
throw new ServiceException(HttpStatusCode.InternalServerError, $"Unsupported platform specific parameter: {parMeta.Name}");
}
}
else
{
bool found = queryDict.TryGetValue(parMeta.Name, out string value);
if (!found && !parMeta.IsOptional)
{
throw new ServiceException(HttpStatusCode.BadRequest, $"Parameter missing: {parMeta.Name}");
}
if (found)
{
return(String.IsNullOrEmpty(value) ? null : ParseQueryValue(parMeta, value));
}
}
return(null);
}
MethodImpl CreateMethod()
{
var parameters = new List <Component_MemberParameter>();
foreach (var p in GetComponents <Component_MemberParameter>(false, false))
{
if (p.Enabled)
{
parameters.Add(p);
}
}
var parameters2 = new List <Metadata.Parameter>();
foreach (var p in parameters)
{
Metadata.Parameter p2 = p.CreateMetadataParameter();
if (p2 == null)
{
//!!!!
return(null);
}
parameters2.Add(p2);
}
//!!!!isConstructor
//!!!!isOperator
var method = new MethodImpl(Parent, Name, Static, parameters2.ToArray(), false, false, this);
method.Description = Description;
return(method);
}
//
public PropertyImpl(object owner, string name, bool isStatic, Metadata.TypeInfo type, Metadata.TypeInfo typeUnreferenced, Metadata.Parameter[] indexers, bool readOnly, string category, string displayName, bool referenceSupport, Metadata.Parameter parameter, bool invoke)
: base(owner, name, isStatic, type, typeUnreferenced, indexers, readOnly)
{
this.category = category;
this.displayName = displayName;
this.referenceSupport = referenceSupport;
this.parameter = parameter;
this.invoke = invoke;
}
MethodParameterPropertyImpl OneMethod_AddPropertyOfParameter(Metadata.Parameter parameter)
{
////!!!!имя еще как-то фиксить?
string name = null;
if (parameter.ReturnValue)
{
name = "ReturnValue";
}
else
{
name = parameter.Name.Substring(0, 1).ToUpper() + parameter.Name.Substring(1);
}
//!!!!поддержать ByReference. еще какие?
bool readOnly = parameter.Output || parameter.ReturnValue || parameter.ByReference;
//bool readOnly = parameter.Output || parameter.ReturnValue;
//!!!!
//var parameterType = GetOverrideParameterType( parameter, out bool error );
//if( error )
//{
// unableToInit = true;
// goto unableToInitLabel;
//}
//var parameterType = parameter.Type;
Metadata.TypeInfo type;
bool referenceSupport = !readOnly;
if (referenceSupport)
{
Type unrefNetType = parameter.Type.GetNetType();
var refNetType = typeof(Reference <>).MakeGenericType(unrefNetType);
type = MetadataManager.GetTypeOfNetType(refNetType);
}
else
{
type = parameter.Type;
}
bool invoke = parameter.ReturnValue || parameter.ByReference || parameter.Output;
string namePrefix = "__parameter_";
string displayName = TypeUtility.DisplayNameAddSpaces(name);
var prop = new MethodParameterPropertyImpl(this, namePrefix + name, false, type, parameter.Type, new Metadata.Parameter[0], readOnly, "Method's Parameters", displayName, referenceSupport, parameter, invoke);
prop.Description = "";
if (!readOnly)
{
prop.Serializable = SerializeType.Enable;
}
return(prop);
}
public virtual Metadata.Parameter CreateMetadataParameter()
{
var type = Type.Value;
if (type == null)
{
//!!!!
//Log.Warning( "The type with name \"{0}\" is not exists.", type );
return(null);
}
//!!!!
bool defaultValueSpecified2 = false;
object defaultValue2 = null;
//!!!!!inIn
var p = new Metadata.Parameter(Name, type, ByReference, false, Output, ReturnValue, Optional, defaultValueSpecified2, defaultValue2);
return(p);
}
private object ParseQueryValue(Metadata.Parameter parMeta, string value)
{
// Is it an enum value?
if (parMeta.ParameterType.Type.IsEnum)
{
if (!Int32.TryParse(value, out int intValue))
{
throw new ServiceException(HttpStatusCode.BadRequest, $"Enum-arguments should be represented by their numeric value: {parMeta.Name}");
}
return(Enum.ToObject(parMeta.ParameterType.Type, intValue));
}
// Is it a primitive value?
if (!Enum.TryParse(parMeta.ParameterType.Name, out Metadata.PrimitiveType primitiveType))
{
throw new ServiceException(HttpStatusCode.BadRequest, $"Argument is not a primitive type: {parMeta.Name}");
}
// Do we have a binder for it?
if (!primitiveBinders.TryGetValue(primitiveType, out Func <string, object> conv))
{
throw new ServiceException(HttpStatusCode.InternalServerError, $"Primitive type {primitiveType} not supported: {parMeta.Name}");
}
return(conv(value));
}
public void Update()
{
if (DisableUpdate)
{
return;
}
//check disabled
if (!Enabled)
{
Clear();
return;
}
var newCode = Code.Value;
needUpdate = false;
if (newCode == compiledCode)
{
return;
}
////check for updates
//if( !needUpdate && newCode != compiledCode )
// needUpdate = true;
////nothing to update
//if( !needUpdate )
// return;
//do update
Clear();
compiledCode = newCode;
needUpdate = false;
if (!string.IsNullOrEmpty(newCode))
{
compiledScript = ScriptingCSharpEngine.GetOrCompileScript(compiledCode, out var error);
if (!string.IsNullOrEmpty(error))
{
Log.Warning($"Unable to compile script.\r\n\r\nComponent \"{GetPathFromRoot( true )}\".\r\n\r\n" + error);
return;
}
CreateScriptInstance();
//fields
foreach (var netField in compiledScript.Fields)
{
if (netField.IsPublic && netField.Name != "Owner")
{
var type = MetadataManager.GetTypeOfNetType(netField.FieldType);
var member = new PropertyImpl(this, netField.Name, netField.IsStatic, type, type, Array.Empty <Metadata.Parameter>(), false, compiledScript, netField);
compiledMembers.Add(member);
compiledMemberBySignature[member.Signature] = member;
}
}
//properties
foreach (var netProperty in compiledScript.Properties)
{
if (netProperty.GetMethod != null && netProperty.GetMethod.IsPublic)
{
var type = MetadataManager.GetTypeOfNetType(netProperty.PropertyType);
var unrefType = ReferenceUtility.GetUnreferencedType(type);
var netParameters = netProperty.GetIndexParameters();
var indexers = new List <Metadata.Parameter>();
for (int n = 0; n < netParameters.Length; n++)
{
var netParam = netParameters[n];
var netType = netParam.ParameterType;
bool isByReference = netType.IsByRef;
if (isByReference)
{
netType = netType.GetElementType();
}
var type2 = MetadataManager.GetTypeOfNetType(netType);
var p = new Metadata.Parameter(netParam.Name, type2, isByReference, netParam.IsIn, netParam.IsOut, netParam.IsRetval,
netParam.IsOptional, netParam.HasDefaultValue, netParam.DefaultValue);
indexers.Add(p);
}
var member = new PropertyImpl(this, netProperty.Name, ReflectionUtility.PropertyIsStatic(netProperty), type, unrefType, indexers.Count != 0 ? indexers.ToArray() : Array.Empty <Metadata.Parameter>(), !netProperty.CanWrite, compiledScript, netProperty);
compiledMembers.Add(member);
compiledMemberBySignature[member.Signature] = member;
}
}
//methods
foreach (var netMethod in compiledScript.Methods)
{
if (netMethod.IsSpecialName)
{
if (netMethod.Name.Length > 4 && (netMethod.Name.Substring(0, 4) == "get_" || netMethod.Name.Substring(0, 4) == "set_"))
{
continue;
}
if (netMethod.Name.Length > 4 && netMethod.Name.Substring(0, 4) == "add_")
{
continue;
}
if (netMethod.Name.Length > 7 && netMethod.Name.Substring(0, 7) == "remove_")
{
continue;
}
}
if (netMethod.GetBaseDefinition() != netMethod)
{
continue;
}
var netParams = netMethod.GetParameters();
var parameters = new List <Metadata.Parameter>();
for (int n = 0; n < netParams.Length; n++)
{
var netParam = netParams[n];
var netType = netParam.ParameterType;
bool isByReference = netType.IsByRef;
if (isByReference)
{
netType = netType.GetElementType();
}
var type = MetadataManager.GetTypeOfNetType(netType);
var p = new Metadata.Parameter(netParam.Name, type, isByReference, netParam.IsIn, netParam.IsOut, netParam.IsRetval,
netParam.IsOptional, netParam.HasDefaultValue, netParam.DefaultValue);
parameters.Add(p);
}
if (netMethod.ReturnType != null && netMethod.ReturnType != typeof(void))
{
var netType = netMethod.ReturnType;
bool isRef = netType.IsByRef;
if (isRef)
{
netType = netType.GetElementType();
}
var paramType = MetadataManager.GetTypeOfNetType(netType);
//"_return"
var p = new Metadata.Parameter("ReturnValue", paramType, isRef, false, true, true, false, false, null);
parameters.Add(p);
}
bool isOperator = netMethod.IsSpecialName && netMethod.Name.Length > 3 && netMethod.Name.Substring(0, 3) == "op_";
var member = new MethodImpl(this, netMethod.Name, netMethod.IsStatic, parameters.ToArray(), false, isOperator, compiledScript, netMethod);
compiledMembers.Add(member);
compiledMemberBySignature[member.Signature] = member;
}
//One method mode
if (compiledScript != null && compiledMembers.Count == 1)
{
compiledOneMethod = (MethodImpl)compiledMembers[0];
OneMethod_AddProperties(compiledOneMethod);
//var parameters = new List<Metadata.Parameter>();
//parameters.Add( new Metadata.Parameter( "a", MetadataManager.GetTypeOfNetType( typeof( int ) ), false, true, false, false, false, false, null ) );
//parameters.Add( new Metadata.Parameter( "ReturnValue", MetadataManager.GetTypeOfNetType( typeof( int ) ), false, true, false, true, false, false, null ) );
//xx xx;
//var method = new MethodImpl( this, "Method", true, parameters.ToArray(), false, false, compiledScript, compiledScript.PublicMethods[ 0 ] );
//compiledMembers.Add( method );
//compiledMemberBySignature[ method.Signature ] = method;
//compiledOneMethod = method;
////create properties
//if( method != null )
//{
// //parameters
// propertyMethodParameters = new List<PropertyImpl>();
// for( int nParameter = 0; nParameter < method.Parameters.Length; nParameter++ )
// {
// var parameter = method.Parameters[ nParameter ];
// ////!!!!имя еще как-то фиксить?
// //string name = null;
// //!!!!
// //if( parameter.ReturnValue )
// // name = "ReturnValue";
// //if( name == null )
// var name = parameter.Name.Substring( 0, 1 ).ToUpper() + parameter.Name.Substring( 1 );
// //!!!!поддержать ByReference. еще какие?
// bool readOnly = parameter.Output || parameter.ReturnValue;
// //!!!!
// //var parameterType = GetOverrideParameterType( parameter, out bool error );
// //if( error )
// //{
// // unableToInit = true;
// // goto unableToInitLabel;
// //}
// //var parameterType = parameter.Type;
// Metadata.TypeInfo type;
// bool referenceSupport = !readOnly;
// if( referenceSupport )
// {
// Type unrefNetType = parameter.Type.GetNetType();
// var refNetType = typeof( Reference<> ).MakeGenericType( unrefNetType );
// type = MetadataManager.GetTypeOfNetType( refNetType );
// }
// else
// type = parameter.Type;
// bool invoke = parameter.ReturnValue || parameter.ByReference || parameter.Output;
// string namePrefix = "__parameter_";
// string displayName = TypeUtils.DisplayNameAddSpaces( name );
// var p = new PropertyImpl( this, namePrefix + name, false, type, parameter.Type, new Metadata.Parameter[ 0 ], readOnly, "Method's Parameters", displayName, referenceSupport, parameter, invoke );
// p.Description = "";
// if( !readOnly )
// p.Serializable = true;
// properties.Add( p );
// propertyBySignature[ p.Signature ] = p;
// //!!!!так? если несколько?
// if( parameter.ReturnValue )
// propertyMethodReturnParameter = p;
// else
// propertyMethodParameters.Add( p );
// }
//}
}
//update child handlers
try
{
foreach (var handler in GetComponents <Component_EventHandler>())
{
handler.UpdateSubscription();
}
}
catch { }
}
}
