Ejemplo n.º 1
0
        private static async Task <string> HandleRazorText(RuntimeStepModel newrunmodel, AConFlowStep s, HttpContext httpContext, string template)
        {
            var    engine     = APP.Razorengine;
            string stepResult = "";

            StringBuilder stringbuilder = UsingNameSpace(s, engine);

            dynamic modelArg = null;
            var     module   = APPCommon.ModuleManager.GetModule(null, s.ModuleName);

            if (module == null)
            {
                modelArg = new { Step = s, Module = new { }, Item = newrunmodel.Res, Funs = newrunmodel.Funtions };
            }
            else
            {
                modelArg = new { Step = s, Module = module.AsDynamic(), Item = newrunmodel.Res, Funs = newrunmodel.Funtions };
            }
            var cachekey2   = template.ToMD5();
            var cacheResult = engine.Handler.Cache.RetrieveTemplate(cachekey2);

            template = stringbuilder.AppendLine("\r\n").Append(template).ToString();
            if (cacheResult.Success)
            {
                stepResult = await engine.RenderTemplateAsync(cacheResult.Template.TemplatePageFactory(), modelArg);
            }
            else
            {
                stepResult = await engine.CompileRenderStringAsync(cachekey2, template, modelArg);
            }



            return(stepResult);
        }
Ejemplo n.º 2
0
        public async Task Run(params object[] parameters)
        {
            var st         = new System.Diagnostics.StackTrace();
            var lastMethod = st.GetFrame(1).GetMethod();

            //var appconfigstring = Config.GetValue<AppConfig>("App").AppConfigs;

            if (appConfig.AppType == "aspnetcore")
            {
                ComposeEntity cons = null;

                cons = FindComposity(appConfig, null);
                if (cons == null)
                {
                    Logger.LogError(logName, "Run -> Find composity returns null ");
                    return;
                }

                var newrunmodel = new RuntimeStepModel(Config)
                {
                    ComposeEntity = cons,
                    HashCode      = cons.GetHash()
                };
                newrunmodel.Res["__actioncontext"] = parameters[0];
                newrunmodel.Res["__httpcontext"]   = parameters[0].GetProp("HttpContext");
                httpContext = newrunmodel.Res["__httpcontext"] as HttpContext;
                newrunmodel.Res["__session"] = httpContext.Session;
                newrunmodel.Res["__db"]      = DB.Kata;
                var pagetool = new RazorTool();
                pagetool.ActionContext      = parameters[0] as ActionExecutingContext;
                pagetool.ResouceInfos       = newrunmodel.Res;
                pagetool.Funs               = newrunmodel.Funtions;
                newrunmodel.Res["__page"]   = pagetool;
                newrunmodel.Res["__config"] = appConfig;

                if (!string.IsNullOrEmpty(cons.Templateid))
                {
                    newrunmodel.ComposeTemplate = FindComposeTemplet(cons.Templateid);
                }

                await RunComposity(parameters[0].GetHashCode(), httpContext, newrunmodel, DbFactory, CodeService, Config);
            }
            //var context = parameters[0] as ActionExecutingContext;
            //var resp = context.HttpContext.Response;
            //resp.ContentType = "text/html";

            //using (StreamWriter sw = new StreamWriter(resp.Body))
            //{
            //    sw.Write("Write a string to response in WriteResponseWithoutReturn!");
            //}
        }
Ejemplo n.º 3
0
        private static async Task <string> HandleRazorKey(RuntimeStepModel newrunmodel, AConFlowStep s)
        {
            dynamic modelArg = null;
            var     module   = APPCommon.ModuleManager.GetModule(null, s.ModuleName);

            if (module == null)
            {
                modelArg = new { Step = s, Module = new { }, Item = newrunmodel.Res, Funs = newrunmodel.Funtions };
            }
            else
            {
                modelArg = new { Step = s, Module = module.AsDynamic(), Item = newrunmodel.Res, Funs = newrunmodel.Funtions };
            }
            return(await APPCommon.RenderRazorKey(s.ProxyCode, modelArg));
        }
Ejemplo n.º 4
0
        private static object HandleGetData(HttpContext httpContext, RuntimeStepModel newrunmodel, ISqlSugarClient dbFactory, AConFlowStep s)
        {
            object dynaObject = null;

            //var objParams2 = new List<object>();
            //if (!string.IsNullOrEmpty(s.ArgNames))
            //{
            //    var args = s.ArgNames.Split(',');
            //    foreach (var aarg in args)
            //    {
            //        object obj = aarg;
            //        if (aarg.StartsWith("&"))
            //        {
            //            obj = newrunmodel.Resuce(aarg);

            //        }
            //        objParams2.Add(obj);
            //    }
            //}
            if (!String.IsNullOrEmpty(s.ArgNames))
            {
                if (s.ArgNames.Contains(','))
                {
                    dynaObject = newrunmodel.Resuce(s.ArgNames.Split(',')[0]);
                }
                else
                {
                    dynaObject = newrunmodel.Resuce(s.ArgNames);
                }
            }

            //if (objParams2 == null || objParams2.Count == 0)
            //{
            //    dynaObject = APP.GetData( s.InParamter1);
            //}
            //else
            //{
            dynaObject = APP.GetData(s.InParamter1, dynaObject);
            //}

            return(dynaObject);
        }
Ejemplo n.º 5
0
        private static async Task CheckAndRunNextRuntimeComposity(int requsetHash, HttpContext httpContext, RuntimeStepModel newrunmodel, ISqlSugarClient dbFactory, ISysDatabaseService codeService, IConfiguration config)
        {
            var resouce = newrunmodel.Resuce(newrunmodel.NextRunTimeKey);

            if (resouce != null)
            {
                var guid = (string)resouce;
                if (string.IsNullOrEmpty(guid))
                {
                    //newrunmodel.ResouceInfos.Remove(newrunmodel.NextRunTimeKey);
                    return;
                }
                var nextcon = codeService.GetConposity(guid).FirstOrDefault();
                if (nextcon == null)
                {
                    nextcon = new ComposeEntity()
                    {
                        Guid    = guid,
                        RunMode = RunMode.Coding
                    };
                    var reint = codeService.InsertCode(nextcon);
                }
                else
                {
                    var nextRnmodel = new RuntimeStepModel(config)
                    {
                        ParentRuntimeModel = newrunmodel,
                        Res           = newrunmodel.Res,
                        ComposeEntity = nextcon,
                        HashCode      = nextcon.GetHash()
                    };
                    nextRnmodel.Res.Remove(newrunmodel.NextRunTimeKey);
                    await RunComposity(requsetHash, httpContext, nextRnmodel, dbFactory, codeService, config);
                }
            }
        }
Ejemplo n.º 6
0
        private static object DealTheFunction(RuntimeStepModel newrunmodel, AConFlowStep s, HttpContext httpContext)
        {
            object rebject;
            var    defaultNamespace = @"using UniOrm;
using UniOrm.Application;
using UniOrm.Common;
using UniOrm.Model;
using UniOrm.Startup.Web ;
using System;
using System.Web;
using System.IO;
using System.Text;
using System.Text.Encodings;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Security.Claims;
using System.Threading;
using System.Threading.Tasks;
using System.Reflection;
using System.Dynamic ;
using System.Diagnostics ;
using System.Linq.Expressions;
using System.Xml;
using System.Xml.Linq;
using System.Configuration ;
using System.Data;
using System.Data.SqlClient;
using System.Data.Common;
using System.Data.OleDb;
using System.Globalization;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Mail;
using System.Net.Security;
using System.Net.Sockets;
using System.Net.WebSockets;
using System.Drawing;
using System.Drawing.Printing;
using Microsoft.Data.Sqlite;
using MySql.Data.MySqlClient;
using Npgsql;
//using PetaPoco.SqlKata;
using SqlKata.Compilers;
using SqlKata.Execution;
using SqlSugar;
using CSScriptLib;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Numerics ;
using Peachpie.AspNetCore.Web;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authorization;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Mvc;";
            var    functionName     = "FunctionName";
            var    selfnamespace    = s.OutPutText;

            var allcode =
                defaultNamespace + "\r\n"
                + selfnamespace + "\r\n"
                + "public object " + functionName + "(object __param){ \r\n"
                + "var __model=__param.AsDynamic();"
                + "var Page=__model.Res[\"__page\"];"
                + s.ProxyCode
                + "\r\n}";


            var runobj = CSScript.Evaluator.ReferenceAssembly(Assembly.GetExecutingAssembly())
                         .CreateDelegate(allcode);

            newrunmodel.Funtions.Add(s.StorePoolKey, runobj);
            var pagetool = newrunmodel.Res["__page"] as RazorTool;

            pagetool.Funs = newrunmodel.Funtions;
            rebject       = runobj(newrunmodel);
            return(rebject);
        }
Ejemplo n.º 7
0
        //public void GetRequestHash(ActionExecutingContext actionExecutingContext)
        //{
        //    //actionExecutingContext.HttpContext.req
        //}

        private async static Task RunComposity(int requsetHash, HttpContext httpContext, RuntimeStepModel newrunmodel, ISqlSugarClient dbFactory, ISysDatabaseService codeService, IConfiguration config)
        {
            var cons = newrunmodel.ComposeEntity;

            if (cons.RunMode == RunMode.Coding)
            {
                if (newrunmodel.ComposeTemplate != null)
                {
                    //TODO :add template
                }
                //Manager.RuntimeModels.Add(newrunmodel);
                else
                {
                    var steps = FindSteps(cons.Guid, codeService);

                    foreach (var s in steps)
                    {
                        object rebject    = null;
                        object DynaObject = null;

                        if (s.IsUsingAuth.ToBool())
                        {
                            await httpContext.AuthenticateAsync();

                            if (httpContext.User.Identity.Name != s.UserName || !httpContext.User.Identity.IsAuthenticated)
                            {
                                APPCommon.ResponseUnAuth((ActionExecutingContext)newrunmodel.Res["__actioncontext"], s.LoginUrl);

                                return;
                            }
                        }

                        var    cacheKey   = string.Concat(cons.Guid, "_", s.ExcuteType, "_", s.FlowStepType, "_", s.Guid, "_", s.ArgNames);
                        object stepResult = APP.RuntimeCache.GetOrCreate(cacheKey, entry =>
                        {
                            object newobj = null;
                            APP.RuntimeCache.Set(cacheKey, newobj);
                            return(newobj);
                        });

                        if (s.IsUsingCache && stepResult != null)
                        {
                            rebject = stepResult;
                        }
                        else
                        {
                            if (!s.IsUsingCache || stepResult == null)
                            {
                                switch (s.FlowStepType)
                                {
                                case FlowStepType.Declare:
                                {
                                    lock (lockobj)
                                    {
                                        //root.Usings[2].Name.ToString()
                                        // var rebject2 = Manager.GetData(spec.InParamter1, spec.InParamter2);
                                        var runcode    = APP.FindOrAddRumtimeCode(s.Guid);
                                        var so_default = ScriptOptions.Default;
                                        if (runcode == null)
                                        {
                                            runcode = new RuntimeCode()
                                            {
                                                StepGuid  = s.Guid,
                                                CodeLines = s.ProxyCode,
                                            };
                                            List <string> dlls = new List <string>();

                                            var    isref   = false;
                                            string dllbase = APPCommon.AppRootDir;


                                            if (!string.IsNullOrEmpty(s.TypeLib))
                                            {
                                                var dllfile = dllbase + s.TypeLib;
                                                if (APP.DynamicReferenceDlls.Contains(dllfile))
                                                {
                                                    isref = false;
                                                }
                                                else
                                                {
                                                    APP.DynamicReferenceDlls.Add(dllfile);
                                                    isref = true;
                                                    dlls.Add(dllfile);
                                                }
                                            }
                                            if (!string.IsNullOrEmpty(s.ReferenceDlls))
                                            {
                                                isref = true;
                                                string[] dllnams = s.ReferenceDlls.Split(',');
                                                foreach (var n in dllnams)
                                                {
                                                    APP.DynamicReferenceDlls.Add(dllbase + n);
                                                }

                                                dlls.AddRange(dllnams);
                                            }
                                            if (isref)
                                            {
                                                so_default = so_default.WithReferences(dlls.ToArray());
                                            }
                                            so_default = so_default.WithReferences(Assembly.GetExecutingAssembly());

                                            var state = CSharpScript.Create <object>(s.ProxyCode, so_default, typeof(Dictionary <string, object>));

                                            runcode.Script = state;
                                            APP.RuntimeCodes.Add(s.Guid, runcode);
                                        }
                                        if (!string.IsNullOrEmpty(s.ReferenceDlls))
                                        {
                                            string dllbase = APPCommon.AppRootDir;
                                        }
                                        rebject = runcode.Script.RunAsync(newrunmodel.Res).Result.ReturnValue;
                                        Logger.LogInfo(LoggerName, $"AComposityId id {s.AComposityId} ,step {s.StepOrder}, Declare: result {rebject}  ");
                                    }
                                }
                                break;

                                case FlowStepType.GetData:
                                {
                                    DynaObject = HandleGetData(httpContext, newrunmodel, dbFactory, s);
                                }
                                break;

                                case FlowStepType.CallMethod:
                                {
                                    var methodsub = APP.GetMethodFromConfig(s.IsBuildIn.Value, s.TypeLib, s.TypeFullName, s.MethodName);
                                    var objParams = new List <object>();
                                    if (!string.IsNullOrEmpty(s.ArgNames))
                                    {
                                        objParams = newrunmodel.GetPoolResuce(s.ArgNames.Split(','));
                                    }

                                    else
                                    {
                                        objParams = null;
                                    }
                                    try
                                    {
                                        if (methodsub.IsStatic)
                                        {
                                            DynaObject = methodsub.Invoke(null, objParams.ToArray());
                                        }
                                        else
                                        {
                                            var instance = newrunmodel.Res[s.InstanceName];
                                            DynaObject = methodsub.Invoke(instance, objParams.ToArray());
                                        }
                                    }
                                    catch (Exception exp)
                                    {
                                        Logger.LogError(logName, "Run -> FlowStepType.CallMethod error,composity:{0},step:{1},-------------exception:{2}", cons.Id, s.Guid, LoggerHelper.GetExceptionString(exp));
                                        break;
                                    }
                                    Logger.LogInfo(LoggerName, $"AComposityId id {s.AComposityId} ,step {s.StepOrder}, CallMethod {s.MethodName}: result {DynaObject}  ");
                                }
                                break;

                                case FlowStepType.Text:
                                {
                                    rebject = s.OutPutText;
                                }
                                break;

                                case FlowStepType.Function:
                                {
                                    DynaObject = DealTheFunction(newrunmodel, s, httpContext);
                                    Logger.LogInfo(LoggerName, $"DealTheFunction: result {DynaObject}  ");
                                }
                                break;

                                case FlowStepType.RazorKey:
                                    try
                                    {
                                        rebject = stepResult = await HandleRazorKey(newrunmodel, s);
                                    }
                                    catch (Exception exp)
                                    {
                                        Logger.LogError(logName, $"parser RazorText wrong: {exp.Message}-------{LoggerHelper.GetExceptionString(exp)}");
                                    }
                                    break;

                                case FlowStepType.RazorText:
                                    try
                                    {
                                        rebject = stepResult = await HandleRazorText(newrunmodel, s, httpContext, s.ProxyCode);
                                    }
                                    catch (Exception exp)
                                    {
                                        Logger.LogError(logName, $"parser RazorText wrong: {exp.Message}-------{LoggerHelper.GetExceptionString(exp)}");
                                    }
                                    break;

                                case FlowStepType.RazorFile:
                                    try
                                    {
                                        var    filePath = s.ProxyCode;
                                        string template = File.ReadAllText(Path.Combine(APPCommon.UserUploadBaseDir, filePath));
                                        rebject = stepResult = await HandleRazorText(newrunmodel, s, httpContext, template);
                                    }
                                    catch (Exception exp)
                                    {
                                        Logger.LogError(logName, "parser RazorFile wrong: " + exp.Message + "-------" + LoggerHelper.GetExceptionString(exp));
                                    }
                                    break;
                                }

                                if (rebject == null)
                                {
                                    rebject = MagicExtension.BackToInst(DynaObject);
                                }
                                if (s.IsUsingCache)
                                {
                                    APP.RuntimeCache.Set(cacheKey, rebject);
                                }
                            }
                        }

                        if (!string.IsNullOrEmpty(s.StorePoolKey) && rebject != null)
                        {
                            newrunmodel.SetComposityResourceValue(s.StorePoolKey, rebject);
                        }
                    }
                    await CheckAndRunNextRuntimeComposity(requsetHash, httpContext, newrunmodel, dbFactory, codeService, config);
                }

                //Manager.RuntimeModels.Remove(newrunmodel);
            }
        }