Пример #1
0
        /*
         * [ExcelFunction(Description = "Test Excel object to Json string")]
         * public static object TestExcelObjToJson(string type, object o)
         * {
         *  return Utils.ExcelObjToString(type, o);
         * }
         */
        /*
         * [ExcelFunction(Description = "Test string to OADate")]
         * public static object TestString2OADate(string t)
         * {
         *  DateTime d = DateTime.Parse(t, null, System.Globalization.DateTimeStyles.RoundtripKind);
         *  return d.ToOADate();
         * }
         */

        private static Func <object> MakeExcelUDFArgs0(Utils.QLAPIInfo info)
        {
            return(() =>
            {
                return CallAPI(info, new List <object>());
            });
        }
Пример #2
0
 private static Func <object, object, object, object> MakeExcelUDFArgs3(Utils.QLAPIInfo info)
 {
     return((o1, o2, o3) =>
     {
         return CallAPI(info, new List <object> {
             o1, o2, o3
         });
     });
 }
Пример #3
0
 private static Func <object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object> MakeExcelUDFArgs21(Utils.QLAPIInfo info)
 {
     return((o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13, o14, o15, o16, o17, o18, o19, o20, o21) =>
     {
         return CallAPI(info, new List <object> {
             o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13, o14, o15, o16, o17, o18, o19, o20, o21
         });
     });
 }
Пример #4
0
 private static Func <object, object, object, object, object, object, object, object, object, object, object, object, object> MakeExcelUDFArgs12(Utils.QLAPIInfo info)
 {
     return((o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12) =>
     {
         return CallAPI(info, new List <object> {
             o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12
         });
     });
 }
Пример #5
0
        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);
        }
Пример #6
0
        private static object CallAPI(Utils.QLAPIInfo info, List <object> inputs)
        {
            if (ExcelDnaUtil.IsInFunctionWizard())
            {
                if (settings.display.Equals("chinese"))
                {
                    return("等待输入...");
                }
                else
                {
                    return("Waiting for inputs ...");
                }
            }

            List <Utils.QLAPIParam> argInfo = info.args;
            string api = info.method;

            bool          delayed = false;
            List <string> entries = new List <string>();

            for (int i = 0; i < argInfo.Count; ++i)
            {
                if (inputs[i] is ExcelMissing)
                {
                    continue;
                }
                if (argInfo[i].name == "delayed")
                {
                    delayed = (Boolean)inputs[i];
                    continue;
                }
                try
                {
                    entries.Add("\"" + argInfo[i].name + "\":" + Utils.ExcelObjToString(argInfo[i].type, inputs[i]));
                }
                catch (Exception e)
                {
                    return("Error while converting " + (i + 1).ToString() + "th input to Excel object with message: " + e.Message);
                }
            }
            string args = "{" + String.Join(",", entries) + "}";
            string body = "{\"jsonrpc\":\"2.0\",\"id\":\"100\",\"method\":\"" + api + "\",\"params\":" + args + "}";

            var request = new RestRequest(info.provider + "/rpc", Method.POST);

            request.RequestFormat = DataFormat.Json;
            request.AddParameter("Application/Json", body, ParameterType.RequestBody);
            //add header(for trade-service)
            request.AddHeader("Authorization", "Bearer " + settings.token);
            if (delayed)
            {
                return(DataDict.put(new Utils.QLDelayedCall {
                    body = body, retType = info.retType
                }, "DelayedJob"));
            }
            var response = settings.client.Execute <Utils.QLResult>(request);

            if (response.ErrorException != null)
            {
                return("Exception while executing the API: " + response.ErrorException.Message);
            }
            if ((int)response.StatusCode != 200)
            {
                return("Error: Server returned error: " + response.Data.error.message);
            }
            else
            {
                if (response.Data.result == null)
                {
                    if (response.Data.error != null)
                    {
                        return("Error: Server returned error: " + response.Data.error.message);
                    }
                    else
                    {
                        return(ExcelError.ExcelErrorNull);
                    }
                }
                // special data type: a DataDict is just a json object
                // we put it into a cache and then the user can query it for values by providing keys or maybe query criterion
                if (info.retType.Equals("DataDict"))
                {
                    return(DataDict.put(response.Data.result, api));
                }
                if (info.retType.Equals("Table")) // handling of table is different from all other types
                {
                    return(Utils.JsonToExcelObj(info.retType, response.Data.result));
                }
                if (info.retType.Equals("Json") || response.Data.result is Dictionary <string, object> )
                {
                    if (response.Data.result is List <object> )
                    {
                        List <object> arr      = new List <object>();
                        bool          isNested = false;
                        foreach (object o in (List <object>)response.Data.result)
                        {
                            if (!(o is List <object> || o is Dictionary <string, object>))
                            {
                                arr.Add(Utils.ParseJsonScalar(o));
                            }
                            else
                            {
                                isNested = true;
                                break;
                            }
                        }
                        if (isNested)
                        {
                            return(Utils.JsonToExcelObjWithoutTypeInfo(response.Data.result));
                        }
                        else
                        {
                            if (arr.Count == 1)
                            {
                                return(arr[0]);
                            }
                            object[,] ret = new object[arr.Count, 1];
                            for (int i = 0; i < arr.Count; ++i)
                            {
                                ret[i, 0] = arr[i];
                            }
                            return(ret);
                        }
                    }
                    else if (response.Data.result is Dictionary <string, object> )
                    {
                        return(Utils.JsonToExcelObjWithoutTypeInfo(response.Data.result));
                    }
                    else
                    {
                        return(Utils.ParseJsonScalar(response.Data.result));
                    }
                }
                else
                {
                    return(Utils.JsonToExcelObj(info.retType, response.Data.result));
                }
            }
        }