public ExcelParamsArgumentAttribute(ExcelArgumentAttribute original) { // Just copy all the fields AllowReference = original.AllowReference; Description = original.Description; Name = original.Name; }
} // Should not be null, and elements should not be null public ExcelParameterRegistration(ExcelArgumentAttribute argumentAttribute) { if (argumentAttribute == null) { throw new ArgumentNullException("argumentAttribute"); } ArgumentAttribute = argumentAttribute; CustomAttributes = new List <object>(); }
} // The method this entry was originally constructed with (may be useful for transformations). // NOTE: 16 parameter max for Expression.GetDelegateType public RegistrationEntry(MethodInfo methodInfo) { MethodInfo = methodInfo; var paramExprs = methodInfo.GetParameters() .Select(pi => Expression.Parameter(pi.ParameterType, pi.Name)) .ToArray(); FunctionLambda = Expression.Lambda(Expression.Call(methodInfo, paramExprs), methodInfo.Name, paramExprs); // Need to make sure we have explicit FunctionAttribute = methodInfo.GetCustomAttribute <ExcelFunctionAttribute>(); if (FunctionAttribute == null) { FunctionAttribute = new ExcelFunctionAttribute { Name = methodInfo.Name } } ; else if (string.IsNullOrEmpty(FunctionAttribute.Name)) { FunctionAttribute.Name = methodInfo.Name; } ArgumentAttributes = new List <ExcelArgumentAttribute>(); foreach (var pi in methodInfo.GetParameters()) { var argAtt = pi.GetCustomAttribute <ExcelArgumentAttribute>(); if (argAtt == null) { argAtt = new ExcelArgumentAttribute { Name = pi.Name } } ; else if (string.IsNullOrEmpty(argAtt.Name)) { argAtt.Name = pi.Name; } ArgumentAttributes.Add(argAtt); } // Special check for final Params argument - transform to an ExcelParamsArgumentAttribute // NOTE: This won't work with a custom derived attribute... var lastParam = methodInfo.GetParameters().LastOrDefault(); if (lastParam != null && lastParam.GetCustomAttribute <ParamArrayAttribute>() != null) { var excelParamsAtt = new ExcelParamsArgumentAttribute(ArgumentAttributes.Last()); ArgumentAttributes[ArgumentAttributes.Count - 1] = excelParamsAtt; } }
public static RegistrationResults RegisterApi(OpenApiDocument apiDefinition, bool reregister = false) { List <Delegate> delegates = new List <Delegate>(); List <object> funcAttribs = new List <object>(); List <List <object> > argAttribsList = new List <List <object> >(); var functionsAdded = new List <string>(); foreach (var path in apiDefinition.Paths) { foreach (var operation in path.Value.Operations) { delegates.Add(CreateDelegateForOperation(path.Key, path.Value, operation.Key, operation.Value)); ExcelFunctionAttribute att = new ExcelFunctionAttribute(); att.Name = operation.Value.OperationId; att.Description = operation.Value.Description; att.HelpTopic = apiDefinition.ExternalDocs?.Url?.ToString(); att.SuppressOverwriteError = reregister; funcAttribs.Add(att); List <object> argAttribs = new List <object>(); foreach (var parameter in operation.Value.Parameters) { ExcelArgumentAttribute atta1 = new ExcelArgumentAttribute(); atta1.Name = parameter.Name; atta1.Description = parameter.Description; argAttribs.Add(atta1); } argAttribsList.Add(argAttribs); functionsAdded.Add(att.Name); } } ExcelIntegration.RegisterDelegates(delegates, funcAttribs, argAttribsList); var registrationResults = new RegistrationResults { FunctionsAdded = functionsAdded }; return(registrationResults); }
/// <summary> /// Also craetes attributes from Optional / Default Value /// </summary> /// <param name="parameterInfo"></param> public ExcelParameterRegistration(ParameterInfo parameterInfo) { CustomAttributes = new List <object>(); var allParameterAttributes = parameterInfo.GetCustomAttributes(true); foreach (var att in allParameterAttributes) { var argAtt = att as ExcelArgumentAttribute; if (argAtt != null) { ArgumentAttribute = argAtt; if (string.IsNullOrEmpty(ArgumentAttribute.Name)) { ArgumentAttribute.Name = parameterInfo.Name; } } else { CustomAttributes.Add(att); } } // Check that the ExcelArgumentAttribute has been set if (ArgumentAttribute == null) { ArgumentAttribute = new ExcelArgumentAttribute { Name = parameterInfo.Name }; } // Extra processing for Optional / Default values // TODO: Also consider DefaultValueAttribute (which is wrong, but might be used...) if (parameterInfo.IsOptional && parameterInfo.DefaultValue != DBNull.Value) { Debug.Assert(CustomAttributes.OfType <OptionalAttribute>().Any()); Debug.Assert(!CustomAttributes.OfType <DefaultParameterValueAttribute>().Any()); CustomAttributes.Add(new DefaultParameterValueAttribute(parameterInfo.DefaultValue)); } }
/// <summary> /// Registers a single function that is exposed by a manually and automatically written method. /// see http://www.quantsa.org/home_expose_to_excel.html /// </summary> /// <param name="method">The generated method.</param> /// <param name="manualMethod">The manual method.</param> /// <param name="isHidden">Is this function hidden.</param> private void AddSingleAutoFunction(MethodInfo method, MethodInfo manualMethod, bool?isHidden) { //Create the function attribute QuantSAExcelFunctionAttribute quantsaAttribute = manualMethod.GetCustomAttribute <QuantSAExcelFunctionAttribute>(); if (isHidden != null) { quantsaAttribute.IsHidden = isHidden.Value; } functionAttributes.Add(quantsaAttribute.CreateExcelFunctionAttribute()); // Create the function argument attributes List <object> thisArgumentAttributes = new List <object>(); if (manualMethod.GetParameters().Length < method.GetParameters().Length) { ExcelArgumentAttribute argAttrib = new ExcelArgumentAttribute(); argAttrib.Name = "objectName"; argAttrib.Description = "The name of the object to be created."; //Note that the above 2 strings are the same as those added in GenerateDocs, if they are changed here they should be changed there too. thisArgumentAttributes.Add(argAttrib); } foreach (ParameterInfo param in manualMethod.GetParameters()) { var argAttrib = param.GetCustomAttribute <ExcelArgumentAttribute>(); if (argAttrib != null) { argAttrib.Name = param.Name; } if (ExcelUtilities.InputTypeShouldHaveHelpLink(param.ParameterType)) { string typeName = param.ParameterType.IsArray ? param.ParameterType.GetElementType().Name : param.ParameterType.Name; argAttrib.Description += "(" + typeName + ")"; } thisArgumentAttributes.Add(argAttrib); } functionArgumentAttributes.Add(thisArgumentAttributes); }
public static IEnumerable <SsqExcelFunction> GetSsqExcelFunctions(SsqJson ssqJson) { List <SsqExcelFunction> ssqExcelFunctions = null; try { ssqExcelFunctions = new List <SsqExcelFunction>(); foreach (KeyValuePair <string, UserDefinedFunction> udf in GetUserDefinedFunctions(ssqJson)) { UserDefinedFunction userDefinedFunction = udf.Value; QueryInformation queryInformation = userDefinedFunction.QueryInformation; QueryParameter queryParameter = userDefinedFunction.QueryParameter; Delegate excelFunction = new Func <string, object>(wkn_isin_ticker => { object value; try { Ssq ssq = new Ssq(queryParameter, udf.Key); value = ssq.TryQ(wkn_isin_ticker); } catch (Exception ex) { log.Error(ex.Message); return(ExcelError.ExcelErrorGettingData); } return(value); }); ExcelFunctionAttribute excelFunctionAttribute = new ExcelFunctionAttribute { Name = queryInformation.Name, Description = queryInformation.Description + "\n" + "Author: " + queryInformation.Author + " (" + queryInformation.AuthorEmail + ")\n" + "Version " + queryInformation.Version + " of " + queryInformation.VersionDate + ", Provider: " + queryInformation.Provider, Category = "FFE", IsThreadSafe = true, HelpTopic = !String.IsNullOrEmpty(queryInformation.HelpTopic) ? queryInformation.HelpTopic : null }; ExcelArgumentAttribute excelArgumentAttribute = new ExcelArgumentAttribute { Name = queryInformation.ExcelArgNameStockIdentifier, Description = queryInformation.ExcelArgDescStockIdentifier }; ssqExcelFunctions.Add(new SsqExcelFunction(queryInformation.Name, excelFunction, excelFunctionAttribute, excelArgumentAttribute)); log.Debug("Created SSQ Excel function: {@SsqExcelFunction}", queryInformation.Name); } } catch (Exception ex) { log.Error("Exception while creating SSQ Excel functions. {@ExceptionMessage}", ex.Message); throw; } return(ssqExcelFunctions); }
private static ExcelFunctionRegistration ToExcelFunctionRegistration(IScript script, string FunctionName) { var paramExprs = script .Parameters .Select(x => Expression.Parameter(GetExcelRegistrationTypeFor(x), x.Name)) .ToList(); var methodInfo = typeof(ExcelScriptAddin).GetMethod(nameof(InternalRun), BindingFlags.Static | BindingFlags.NonPublic); var paramsToObj = paramExprs.Select(x => Expression.Convert(x, typeof(object))); // cast parameter to object, otherwise won't match function signature of ExcelScriptAddin.Run var paramsArray = Expression.NewArrayInit(typeof(object), paramsToObj.ToArray()); var methodArgs = new Expression[] { Expression.Constant(script, typeof(IScript)), paramsArray }; LambdaExpression lambdaExpression = Expression.Lambda(Expression.Call(methodInfo, methodArgs), FunctionName, paramExprs); ExcelFunctionAttribute excelFunctionAttribute = new ExcelFunctionAttribute() { Name = FunctionName }; if (!String.IsNullOrEmpty(script.Description)) { excelFunctionAttribute.Description = script.Description; } IEnumerable <ExcelParameterRegistration> paramRegistrations = script .Parameters .Select((IParameter x) => { var argumentAttribute = new ExcelArgumentAttribute() { Name = x.Name }; var parameterRegistration = new ExcelParameterRegistration(argumentAttribute); if (x.Type == typeof(Excel.Range) || x.Type == typeof(ExcelReference)) { argumentAttribute.AllowReference = true; } if (x.IsOptional) { var optionalAttribute = new OptionalAttribute(); parameterRegistration.CustomAttributes.Add(optionalAttribute); var defaultValueAttribute = new DefaultParameterValueAttribute(x.DefaultValue); parameterRegistration.CustomAttributes.Add(defaultValueAttribute); } if (!String.IsNullOrEmpty(x.Description)) { argumentAttribute.Description = x.Description; } return(parameterRegistration); }); var reg = new ExcelFunctionRegistration(lambdaExpression, excelFunctionAttribute, paramRegistrations); return(reg); }
public SsqExcelFunction(string name, Delegate func, ExcelFunctionAttribute excelFunctionAttribute, ExcelArgumentAttribute excelArgumentAttribute) { Name = name; Delegate = func; ExcelFunctionAttribute = excelFunctionAttribute; ExcelArgumentAttributes = new List <object>() { excelArgumentAttribute }; }
private static bool registerOneFunction(string method) { var request = new RestRequest("excel-service/info/" + method, Method.GET); request.AddHeader("Authorization", "Bearer " + settings.token); var response = settings.client.Execute <Utils.QLAPIInfo>(request); Utils.QLAPIInfo info = response.Data; if (info == null) { return(false); } info.provider = "excel-service"; var apiAttr = new ExcelFunctionAttribute { Name = info.method, Category = "BCT Excel Addin", Description = info.description }; List <Utils.QLAPIParam> args = info.args; List <object> argAttrs = new List <object>(); foreach (var arg in args) { var attr = new ExcelArgumentAttribute { Name = arg.name, Description = arg.description }; argAttrs.Add(attr); } Delegate func = null; switch (args.Count) { case 0: func = MakeExcelUDFArgs0(info); break; case 1: func = MakeExcelUDFArgs1(info); break; case 2: func = MakeExcelUDFArgs2(info); break; case 3: func = MakeExcelUDFArgs3(info); break; case 4: func = MakeExcelUDFArgs4(info); break; case 5: func = MakeExcelUDFArgs5(info); break; case 6: func = MakeExcelUDFArgs6(info); break; case 7: func = MakeExcelUDFArgs7(info); break; case 8: func = MakeExcelUDFArgs8(info); break; case 9: func = MakeExcelUDFArgs9(info); break; case 10: func = MakeExcelUDFArgs10(info); break; case 11: func = MakeExcelUDFArgs11(info); break; case 12: func = MakeExcelUDFArgs12(info); break; case 13: func = MakeExcelUDFArgs13(info); break; case 14: func = MakeExcelUDFArgs14(info); break; case 15: func = MakeExcelUDFArgs15(info); break; case 16: func = MakeExcelUDFArgs16(info); break; case 17: func = MakeExcelUDFArgs17(info); break; case 18: func = MakeExcelUDFArgs18(info); break; case 19: func = MakeExcelUDFArgs19(info); break; case 20: func = MakeExcelUDFArgs20(info); break; case 21: func = MakeExcelUDFArgs21(info); break; } if (func != null) { ExcelIntegration.RegisterDelegates(new List <Delegate> { func }, new List <object> { apiAttr }, new List <List <object> > { argAttrs }); return(true); } return(false); }