internal IList<Response> HandleRemotingRequest(HttpContext context, Request[] requests)
        {
            if (Culture != null)
                Thread.CurrentThread.CurrentCulture = Culture;

            HttpContext = context;

            var responses = new List<Response>();
            foreach (var request in requests)
            {

                /* This part blocks out of order processing of direct transactions for 2 seconds.
                 * This is important as two sequential http request can come in different order than sent.
                 * Luckily Ext.direct has tid field.
                 */
                int waitCounter = 20;
                while (request.tid > lastTid + 1 && --waitCounter>0)
                {
                    Thread.Sleep(100);
                }

                if (request.tid > lastTid)
                    lastTid = request.tid;

                var call = new DextopRemoteMethodCall
                {
                    FormSubmit = request.FormSubmit,
                    RemoteId = request.data[0],
                    Arguments = DextopUtil.Decode<String[]>(request.data[2]),
                    MethodName = request.data[1]
                };
                var response = new Response
                {
                    type = "rpc",
                    method = request.method,
                    tid = request.tid,
                    action = request.action
                };
                responses.Add(response);
                try
                {
                    response.result = ExecuteMethodCall(call);
                }
                catch (Exception ex)
                {
                    response.result = new DextopRemoteMethodCallResult
                    {
                        success = false,
                        result = new DextopRemoteMethodCallException
                        {
                            type = "rpc",
                            exception = ex.Message,
                            stackTrace = ex.StackTrace
                        }
                    };
                }
            }

            HttpContext = null;

            return responses;
        }
Example #2
0
        Request[] GetUploadRequest(HttpContext context)
        {
            var files = new Dictionary<String, DextopFile>();
            for (var i = 0; i < context.Request.Files.Count; i++)
            {
                if (context.Request.Files[i].ContentLength > 0)
                {
                    var fi = new FileInfo(context.Request.Files[i].FileName);
                    files.Add(context.Request.Files.AllKeys[i], new DextopFile
                    {
                        FileStream = context.Request.Files[i].InputStream,
                        FileLength = context.Request.Files[i].ContentLength,
                        FileName = fi.Name,
                        FileExtension = fi.Extension,
                        ContentType = context.Request.Files[i].ContentType
                    });
                }
            }

            List<String> parameters = new List<string>();
            parameters.Add(context.Request.Form["_rcpId"]);
            parameters.Add(context.Request.Form["_rcpMethod"]);
            parameters.Add(context.Request.Form["_rcpArguments"]);

            var formSumbit = new DextopFormSubmit
            {
                Files = files,
                Context = context,
                FieldValuesJSON = context.Request["_rcpFieldValues"]
            };

            var request = new Request
            {
                tid = int.Parse(context.Request.Form["extTID"]),
                action = context.Request.Form["extAction"],
                method = context.Request.Form["extMethod"],
                type = context.Request.Form["extType"],
                FormSubmit = formSumbit,
                data = parameters.ToArray(),
                RequestType = RequestType.FormSubmit
            };

            return new[] { request };
        }