示例#1
0
        public async Task <int> UpdateCache()
        {
            APP.Dlls.Clear();
            APP.Types.Clear();
            APP.MethodInfos.Clear();
            APP.RuntimeCodes.Clear();
            APP.Composeentitys.Clear();
            APP.DynamicReferenceDlls.Clear();
            APP.AConFlowSteps.Clear();
            APP.ComposeTemplates.Clear();
            APP.ClearCache();
            //var razorlist = m_codeService.GetSimpleCode<SystemHtml>(null);
            //foreach(var ss in razorlist)
            //{
            //    if(APP.Razorengine.Handler.Cache.Contains(ss.Name))
            //    {
            //        APP.Razorengine.Handler.Cache.Remove(ss.Name);
            //    }
            //}
            await WebSetup.ClearAllDynamicActions(_actionProvider, _dynamicChangeTokenProvider);

            await WebSetup.BuildAllDynamicActions(_actionProvider, _dynamicChangeTokenProvider);

            APPCommon.InitRazorEngine();
            return(0);
        }
示例#2
0
        public void Configuration(IAppBuilder app)
        {
            var kernel = WebSetup.SetupDependencyInjection(RegisterServices, ConfigurationManager.AppSettings);
            var config = kernel.Get <IConfigService>();

            JwtSecurityTokenHandler.InboundClaimTypeMap.Clear();

            app.UseIdentityServerBearerTokenAuthentication(new IdentityServerBearerTokenAuthenticationOptions
            {
                Authority      = config["auth:authority"],
                RequiredScopes = new [] { "database-api" }
            });

            WebSetup.SetupWebApi(app, kernel);
        }
示例#3
0
        static void Main(string[] commands)
        {
            try
            {
                /*
                 * commands = new[] { "generate", "font" };
                 */
//                commands = new[] { "init", "OrbitalCrash" };

                //            commands = new[] { "generate", "assets" };

                //                                                commands = new[] {   "add", "web" };
                //            commands = new[] {   "rm", "web" };
                //                                                commands = new[] {  "run", "wd" };
                var directory = Directory.GetCurrentDirectory();

                /*
                 *          directory = @"C:\code\penguio\orbitalcrash\";
                 */
//                directory = @"C:\code\penguio\";



                if (commands.Length == 0 || commands[0].ToLower() == "/h")
                {
                    Console.WriteLine("Penguio CLI");
                    Console.WriteLine("Usage:");
                    Console.WriteLine("peng init GameName");
                    Console.WriteLine("peng generate font");
                    Console.WriteLine("peng add WindowsDesktop");
                    Console.WriteLine("peng rm Android");
                    Console.WriteLine("peng build Web");
                    Console.WriteLine("peng clean WindowsDesktop");
                    Console.WriteLine("peng debug Android");
                    Console.WriteLine("peng run iOS");
                    return;
                }
                switch (commands[0].ToLower())
                {
                case "init":
                case "i":
                    if (commands.Length == 1)
                    {
                        Console.WriteLine("Missing Game Name");
                        return;
                    }
                    InitProject.Build(directory, commands[1]);
                    return;

                case "add":
                case "a":
                {
                    string path;

                    if (commands.Length == 2)
                    {
                        var workdirPath = Path.GetTempPath();
                        var framework   = Path.Combine(workdirPath, "penguio-framework", Guid.NewGuid().ToString());
                        if (Directory.Exists(framework))
                        {
                            Directory.Delete(framework, true);
                        }
                        Directory.CreateDirectory(framework);
                        Repository.Clone("https://github.com/Penguio-Framework/Penguio-Framework.git", framework);
                        path = framework;
                    }
                    else
                    {
                        path = commands[2] == "local" ? @"C:\code\penguio\Penguio-Framework" : commands[2];
                    }
                    switch (commands[1].ToLower())
                    {
                    case "windowsdesktop":
                    case "windows":
                    case "wd":
                        WindowsSetup.Add(directory, path, getProject(directory));
                        return;

                    case "web":
                    case "w":
                        WebSetup.Add(directory, path, getProject(directory));
                        return;

                    case "android":
                    case "a":
                        AndroidSetup.Add(directory, path, getProject(directory));
                        return;

                    case "ios":
                    case "i":
                        IOSSetup.Add(directory, path, getProject(directory));
                        return;
                    }
                }

                break;

                case "generate":
                case "g":

                    if (commands[1].ToLower() == "font")
                    {
                        FontGenerator.Generate(directory);
                    }
                    if (commands[1].ToLower() == "assets")
                    {
                        AssetGenerator.Generate(directory, getProject(directory).ProjectName);
                    }
                    return;

                case "clean":
                case "c":
                {
                    string path;

                    if (commands.Length == 2)
                    {
                        var workdirPath = Path.GetTempPath();
                        var framework   = Path.Combine(workdirPath, "penguio-framework", Guid.NewGuid().ToString());
                        if (Directory.Exists(framework))
                        {
                            Directory.Delete(framework, true);
                        }
                        Directory.CreateDirectory(framework);
                        Repository.Clone("https://github.com/Penguio-Framework/Penguio-Framework.git", framework);
                        path = framework;
                    }
                    else
                    {
                        path = commands[2] == "local" ? @"C:\code\penguio\Penguio-Framework" : commands[2];
                    }
                    switch (commands[1].ToLower())
                    {
                    case "windowsdesktop":
                    case "windows":
                    case "wd":
                        if (Directory.Exists(Path.Combine(directory, "platforms", "WindowsDesktop")))
                        {
                            Directory.Delete(Path.Combine(directory, "platforms", "WindowsDesktop"), true);
                        }
                        WindowsSetup.Add(directory, path, getProject(directory));
                        return;

                    case "web":
                    case "w":
                        if (Directory.Exists(Path.Combine(directory, "platforms", "Web")))
                        {
                            Directory.Delete(Path.Combine(directory, "platforms", "Web"), true);
                        }
                        WebSetup.Add(directory, path, getProject(directory));
                        return;

                    case "android":
                    case "a":
                        if (Directory.Exists(Path.Combine(directory, "platforms", "Android")))
                        {
                            Directory.Delete(Path.Combine(directory, "platforms", "Android"), true);
                        }
                        AndroidSetup.Add(directory, path, getProject(directory));
                        return;

                    case "ios":
                    case "i":
                        if (Directory.Exists(Path.Combine(directory, "platforms", "IOS")))
                        {
                            Directory.Delete(Path.Combine(directory, "platforms", "IOS"), true);
                        }
                        IOSSetup.Add(directory, path, getProject(directory));
                        return;
                    }
                }
                    return;

                case "remove":
                case "rm":
                    switch (commands[1].ToLower())
                    {
                    case "windowsdesktop":
                    case "windows":
                    case "wd":
                        if (Directory.Exists(Path.Combine(directory, "platforms", "WindowsDesktop")))
                        {
                            Directory.Delete(Path.Combine(directory, "platforms", "WindowsDesktop"), true);
                        }
                        return;

                    case "web":
                    case "w":
                        if (Directory.Exists(Path.Combine(directory, "platforms", "Web")))
                        {
                            Directory.Delete(Path.Combine(directory, "platforms", "Web"), true);
                        }
                        return;

                    case "android":
                    case "a":
                        if (Directory.Exists(Path.Combine(directory, "platforms", "Android")))
                        {
                            Directory.Delete(Path.Combine(directory, "platforms", "Android"), true);
                        }
                        return;

                    case "ios":
                    case "i":
                        if (Directory.Exists(Path.Combine(directory, "platforms", "IOS")))
                        {
                            Directory.Delete(Path.Combine(directory, "platforms", "IOS"), true);
                        }
                        return;
                    }

                    break;


                case "build":
                case "b":
                    AssetGenerator.Generate(directory, getProject(directory).ProjectName);
                    switch (commands[1].ToLower())
                    {
                    case "windowsdesktop":
                    case "windows":
                    case "wd":
                        WindowsSetup.Build(directory);
                        return;

                    case "web":
                    case "w":
                        WebSetup.Build(directory);
                        return;

                    case "android":
                    case "a":
                        AndroidSetup.Build(directory);
                        return;

                    case "ios":
                    case "i":
                        IOSSetup.Build(directory, getProject(directory));
                        return;
                    }
                    break;

                case "debug":
                case "d":
                    AssetGenerator.Generate(directory, getProject(directory).ProjectName);
                    switch (commands[1].ToLower())
                    {
                    case "windowsdesktop":
                    case "windows":
                    case "wd":
                        WindowsSetup.Build(directory);
                        WindowsSetup.Debug(directory);
                        return;

                    case "web":
                    case "w":
                        WebSetup.Build(directory);
                        WebSetup.Debug(directory);
                        return;

                    case "android":
                    case "a":
                        AndroidSetup.Build(directory);
                        AndroidSetup.Debug(directory);
                        return;

                    case "ios":
                    case "i":
                        IOSSetup.Build(directory, getProject(directory));
                        IOSSetup.Debug(directory);
                        return;
                    }

                    break;

                case "run":
                case "r":
                    AssetGenerator.Generate(directory, getProject(directory).ProjectName);
                    BuildResult build;
                    switch (commands[1].ToLower())
                    {
                    case "windowsdesktop":
                    case "windows":
                    case "wd":
                        build = WindowsSetup.Build(directory);
                        WindowsSetup.Run(build);
                        return;

                    case "web":
                    case "w":
                        build = WebSetup.Build(directory);
                        WebSetup.Run(directory, getProject(directory), build);
                        return;

                    case "android":
                    case "a":
                        build = AndroidSetup.Build(directory);
                        AndroidSetup.Run(directory, getProject(directory), build);
                        return;

                    case "ios":
                    case "i":
                        build = IOSSetup.Build(directory, getProject(directory));
                        IOSSetup.Run(directory, getProject(directory), build);
                        return;
                    }
                    break;
                }

                Console.WriteLine($"Command not understood: {string.Join(" ", commands)}");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }
示例#4
0
        public void Configuration(IAppBuilder app)
        {
            var kernel = WebSetup.SetupDependencyInjection(RegisterServices, ConfigurationManager.AppSettings);
            var config = kernel.Get <IConfigService>();
            var log    = kernel.Get <ILogger>();

            var userService = kernel.Get <SarUserService>();
            var clientStore = kernel.Get <IClientStore>();
            var corsService = new DefaultCorsPolicyService {
                AllowAll = true
            };

            var factory = new IdentityServerServiceFactory
            {
                UserService         = new Registration <IUserService>(resolver => userService),
                ClientStore         = new Registration <IClientStore>(resolver => clientStore),
                CorsPolicyService   = new Registration <ICorsPolicyService>(resolver => corsService),
                ViewService         = new Registration <IViewService, MvcViewService <AccountController> >(),
                TokenSigningService = new Registration <ITokenSigningService, MyTokenSigningService>()
            }
            .UseInMemoryScopes(Scopes.Get(kernel.Get <Func <IAuthDbContext> >()));

            // These registrations are also needed since these are dealt with using non-standard construction
            factory.Register(new Registration <HttpContext>(resolver => HttpContext.Current));
            factory.Register(new Registration <HttpContextBase>(resolver => new HttpContextWrapper(resolver.Resolve <HttpContext>())));
            factory.Register(new Registration <HttpRequestBase>(resolver => resolver.Resolve <HttpContextBase>().Request));
            factory.Register(new Registration <HttpResponseBase>(resolver => resolver.Resolve <HttpContextBase>().Response));
            factory.Register(new Registration <HttpServerUtilityBase>(resolver => resolver.Resolve <HttpContextBase>().Server));
            factory.Register(new Registration <HttpSessionStateBase>(resolver => resolver.Resolve <HttpContextBase>().Session));


            var options = new IdentityServerOptions
            {
                SiteName           = Strings.ThisServiceName,
                EnableWelcomePage  = false,
                SigningCertificate = Cert.Load(config["cert:key"], log),
                Factory            = factory,
                CspOptions         = new CspOptions
                {
                    ImgSrc = "'self' data:"
                },
                AuthenticationOptions = new IdentityServer3.Core.Configuration.AuthenticationOptions
                {
                    // Try to prevent "request too long" errors when authenticating with Google, etc
                    // https://github.com/IdentityServer/IdentityServer3/issues/1124
                    SignInMessageThreshold = 1,
                    IdentityProviders      = ConfigureIdentityProviders,
                    LoginPageLinks         = new LoginPageLink[] {
                        new LoginPageLink {
                            Text = "Register",
                            //Href = "~/localregistration"
                            Href = "localregistration"
                        }
                    }
                },

                EventsOptions = new EventsOptions
                {
                    RaiseSuccessEvents     = true,
                    RaiseErrorEvents       = true,
                    RaiseFailureEvents     = true,
                    RaiseInformationEvents = true
                }
            };

            app.UseIdentityServer(options);

            // This must come after .UseIdentityServer so APIs can get identity values off the OWIN context
            WebSetup.SetupWebApi(app, kernel);
        }