Exemple #1
0
        public override void Run(ServiceProviderContainer container, Assembly[] assemblies, CrudlessOptions options)
        {
            BulkConfigurationManager.Clear();

            using (container.AllowOverrides())
            {
                var bulkAgent = new BulkDataAgent();

                if ((_extensions & BulkExtensions.Create) == BulkExtensions.Create)
                {
                    container.RegisterInstance <IBulkCreateDataAgent>(bulkAgent);
                }

                if ((_extensions & BulkExtensions.Update) == BulkExtensions.Update)
                {
                    container.RegisterInstance <IBulkUpdateDataAgent>(bulkAgent);
                }

                if ((_extensions & BulkExtensions.Delete) == BulkExtensions.Delete)
                {
                    container.RegisterInstance <IBulkDeleteDataAgent>(bulkAgent);
                }
            }

            EntityFrameworkManager.ContextFactory =
                context => container.ProvideInstance <DbContext>();
        }
Exemple #2
0
        public override void Run(ServiceProviderContainer container, Assembly[] assemblies, CrudlessOptions options)
        {
            var universalProfiles = assemblies
                                    .SelectMany(x => x.GetExportedTypes())
                                    .Where(x => !x.IsAbstract &&
                                           x.BaseType != null &&
                                           x.BaseType.IsGenericType &&
                                           x.BaseType.GetGenericTypeDefinition() == typeof(UniversalRequestProfile <>))
                                    .ToArray();

            bool ShouldDecorate(DecoratorConditionalContext context)
            {
                var tRequest = context.ServiceType.GetGenericArguments()[0];

                foreach (var type in tRequest.BuildTypeHierarchyUp())
                {
                    if (type.GetInterface(typeof(ICrudlessRequest).Name) != null)
                    {
                        return(false);
                    }

                    if (universalProfiles.Any(x => x.BaseType.GetGenericArguments()[0] == type))
                    {
                        return(true);
                    }
                }

                return(false);
            }

            container.RegisterDecorator(typeof(IRequestHandler <>), typeof(UniversalRequestDecorator <>), ShouldDecorate);
            container.RegisterDecorator(typeof(IRequestHandler <,>), typeof(UniversalRequestDecorator <,>), ShouldDecorate);
        }
        public void SetUp()
        {
            var assemblies = new[] { typeof(UnitTestSetUp).Assembly };
            var container  = new Container();

            container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();

            Provider = container.AsServiceProvider();

            UnitTestSetUp.ConfigureDatabase(container);

            container.ConfigureAutoMapper(assemblies);

            Crudless.CreateInitializer(Provider, assemblies)
            .UseEntityFramework()
            .Initialize();

            container.Options.AllowOverridingRegistrations = true;
            container.Register <IErrorHandler, TestErrorHandler>(Lifestyle.Singleton);
            container.Options.AllowOverridingRegistrations = false;

            _scope = AsyncScopedLifestyle.BeginScope(container);

            Mediator = _scope.GetInstance <IMediator>();
            Context  = _scope.GetInstance <DbContext>();
            Context.Database.EnsureDeleted();

            Container = container;
        }
Exemple #4
0
 public DeleteRequestHandler(IEntityContext context,
                             ServiceProviderContainer container,
                             CrudlessConfigManager profileManager)
     : base(context, profileManager)
 {
     _container = container;
 }
        public static void UnitTestOneTimeSetUp()
        {
            var assemblies = new[] { typeof(UnitTestSetUp).Assembly };

            Container = new Container();

            Container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();

            Container.ConfigureAutoMapper();

            Provider = Container.AsServiceProvider();

            ConfigureDatabase(Container);
            Container.ConfigureAutoMapper(assemblies);
            ConfigureFluentValidation(Container, assemblies);

            // NOTE: License removed from repository

            //if (!LicenseManager.ValidateLicense(out var licenseErrorMessage))
            //{
            //    throw new Exception(licenseErrorMessage);
            //}

            Crudless.CreateInitializer(Provider, assemblies)
            .ValidateAllRequests(false)
            .UseDynamicMediator(false)
            .UseFluentValidation()
            .UseEntityFrameworkExtensions(BulkExtensions.Create | BulkExtensions.Update)
            .AddInitializer(new SoftDeleteInitializer())
            .Initialize();

            Container.Verify();
        }
 public override void Run(ServiceProviderContainer container, Assembly[] assemblies, CrudlessOptions options)
 {
     using (var scope = container.AllowOverrides())
     {
         container.RegisterSingleton <IDeleteDataAgent, SoftDeleteDataAgent>();
         container.RegisterSingleton <IBulkDeleteDataAgent, SoftDeleteDataAgent>();
     }
 }
        static void RegisterTypes()
        {
            var container = new ServiceProviderContainer();

            container.DefaultRegister();
            container.RegisterType(typeof(IJsonSerializer), typeof(JsonNetSerializer));
            ContainerManager.Container = container;
        }
Exemple #8
0
 public override void Run(ServiceProviderContainer container, Assembly[] assemblies, CrudlessOptions options)
 {
     if (_mapper != null)
     {
         using (var scope = container.AllowOverrides())
             container.RegisterInstance(_mapper);
     }
 }
Exemple #9
0
 public UniversalRequestDecorator(CrudlessConfigManager profileManager,
                                  ServiceProviderContainer container,
                                  Func <IRequestHandler <TRequest> > decorateeFactory)
 {
     _container        = container;
     _decorateeFactory = decorateeFactory;
     _requestConfig    = profileManager.GetRequestConfigFor <TRequest>();
 }
        public GetAllRequestHandler(IEntityContext context,
                                    ServiceProviderContainer container,
                                    CrudlessConfigManager profileManager)
            : base(context, profileManager)
        {
            _container = container;

            Options = RequestConfig.GetOptionsFor <TEntity>();
        }
Exemple #11
0
        static void RegisterTypes()
        {
            var container = new ServiceProviderContainer();

            container.DefaultRegister();
            container.RegisterType(typeof(IJsonSerializer), typeof(JsonNetSerializer));
            container.RegisterType(typeof(VerificationCodeBase), typeof(SkiaSharpVerificationCode));
            ContainerManager.Container = container;
        }
Exemple #12
0
        public override void Run(ServiceProviderContainer container, Assembly[] assemblies, CrudlessOptions options)
        {
            var requestAssemblies = new[] { typeof(CrudlessRequest <>).Assembly };

            container.Register(typeof(CrudlessRequest <>), requestAssemblies);
            container.Register(typeof(CrudlessRequest <,>), requestAssemblies);

            container.RegisterConditional(typeof(Turner.Infrastructure.Mediator.IRequestHandler <>), typeof(CrudlessRequestHandler <>), IfNotHandled);
            container.RegisterConditional(typeof(Turner.Infrastructure.Mediator.IRequestHandler <,>), typeof(CrudlessRequestHandler <,>), IfNotHandled);
        }
Exemple #13
0
        public override void Run(ServiceProviderContainer container, Assembly[] assemblies, CrudlessOptions options)
        {
            container.RegisterInitializer <ICrudlessRequestHandler>(handler =>
            {
                if (handler.ErrorDispatcher.Handler == null)
                {
                    handler.ErrorDispatcher.Handler = container.ProvideInstance <IErrorHandler>();
                }
            });

            container.RegisterSingleton <IErrorHandler, ErrorHandler>();
        }
Exemple #14
0
        public override void Run(ServiceProviderContainer container, Assembly[] assemblies, CrudlessOptions options)
        {
            var shouldValidate      = ShouldValidate(options.ValidateAllRequests);
            var shouldMaybeValidate = ShouldMaybeValidate(options.ValidateAllRequests);

            container.Register(typeof(IRequestValidator <>), assemblies);

            container.RegisterInstance(new ValidatorFactory(container));

            container.RegisterDecorator(typeof(IRequestHandler <>), ValidatorFactory, shouldValidate);
            container.RegisterDecorator(typeof(IRequestHandler <,>), ValidatorFactory, shouldValidate);

            container.RegisterDecorator(typeof(IRequestHandler <>), typeof(MaybeValidateDecorator <>), shouldMaybeValidate);
            container.RegisterDecorator(typeof(IRequestHandler <,>), typeof(MaybeValidateDecorator <,>), shouldMaybeValidate);
        }
Exemple #15
0
        public override void Run(ServiceProviderContainer container, Assembly[] assemblies, CrudlessOptions options)
        {
            container.RegisterScoped(typeof(DbContextFactory), DbContextFactoryType);

            container.RegisterScoped <IEntityContext, EntityFrameworkContext>();

            var dataAgent = new EntityFrameworkDataAgent();

            container.RegisterInstance <ICreateDataAgent>(dataAgent);
            container.RegisterInstance <IUpdateDataAgent>(dataAgent);
            container.RegisterInstance <IDeleteDataAgent>(dataAgent);
            container.RegisterInstance <IBulkCreateDataAgent>(dataAgent);
            container.RegisterInstance <IBulkUpdateDataAgent>(dataAgent);
            container.RegisterInstance <IBulkDeleteDataAgent>(dataAgent);
        }
Exemple #16
0
        public override void Run(ServiceProviderContainer container, Assembly[] assemblies, CrudlessOptions options)
        {
            switch (_transactionType)
            {
            default:
            case TransactionType.TransactionScope:
                container.RegisterDecorator(typeof(IRequestHandler <>), typeof(TransactionScopeTransactionDecorator <>), ShouldDecorate());
                container.RegisterDecorator(typeof(IRequestHandler <,>), typeof(TransactionScopeTransactionDecorator <,>), ShouldDecorate());
                break;

            case TransactionType.EntityFramework:
                container.RegisterDecorator(typeof(IRequestHandler <>), typeof(EntityFrameworkTransactionDecorator <>), ShouldDecorate());
                container.RegisterDecorator(typeof(IRequestHandler <,>), typeof(EntityFrameworkTransactionDecorator <,>), ShouldDecorate());
                break;
            }
        }
        public CrudlessConfigManager(ServiceProviderContainer container, params Assembly[] profileAssemblies)
        {
            _container = container ??
                         throw new ArgumentNullException(nameof(container));

            _allProfiles = profileAssemblies
                           .SelectMany(x => x.GetExportedTypes())
                           .Where(x =>
                                  x.BaseType != null &&
                                  x.BaseType.IsGenericType &&
                                  x.BaseType.GetGenericTypeDefinition() != typeof(InlineRequestProfile <>) &&
                                  (x.BaseType.GetGenericTypeDefinition() == typeof(UniversalRequestProfile <>) ||
                                   x.BaseType.GetGenericTypeDefinition() == typeof(RequestProfile <>) ||
                                   x.BaseType.GetGenericTypeDefinition() == typeof(BulkRequestProfile <,>)))
                           .ToArray();
        }
Exemple #18
0
        public Form1()
        {
            InitializeComponent();

            Console.SetOut(new ControlWriter(listBox1));
            Console.SetIn(rdtxt);
            engine      = new Engine();
            engine.Flag = Engine.ExecutanFlags.RamOptimized;

            ServiceProviderContainer.AddService(new EditorService(fastColoredTextBox1));

            foreach (var node in AddinManager.GetExtensionObjects("/EcIDE/StartupCommands"))
            {
                var cmd = node.CreateInstances <ICommand>();

                Array.ForEach(cmd, c => c.Init(new ServiceContainer()));
                Array.ForEach(cmd, c => c.Run());
            }
        }
Exemple #19
0
        public CrudlessInitializer(ServiceProviderContainer container, Assembly[] assemblies = null, IMapper mapper = null)
        {
            _container = container ?? throw new ArgumentNullException(nameof(container));

            _assemblies.Add(typeof(CrudlessInitializer).Assembly);

            if (assemblies != null)
            {
                _assemblies.AddRange(assemblies);
            }

            _tasks.AddRange(new CrudlessInitializationTask[]
            {
                new CrudlessAutoMapperInitializer(mapper),
                new DefaultMediatorInitializer(),
                new UniversalRequestInitializer(),
                new CrudlessValidationInitializer(),
                new CrudlessRequestInitializer(),
                new CrudlessErrorHandlingInitializer(),
            });
        }
Exemple #20
0
        public void SetUp()
        {
            Container = new Container();
            Container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();

            Container.ConfigureAutoMapper();

            Provider = Container.AsServiceProvider();

            Crudless.CreateInitializer(Provider)
            .WithAssemblies(GetType().GetTypeInfo().Assembly)
            .UseDynamicMediator()
            .UseEntityFramework()
            .UseFluentValidation()
            .UseTransactions()
            .ValidateAllRequests(false)
            .Initialize();

            Container.RegisterInstance <DbContext>(new FakeDbContext());

            _scope = AsyncScopedLifestyle.BeginScope(Container);
        }
Exemple #21
0
 public DynamicDispatchMediator(ServiceProviderContainer container, bool scopeRequests = true)
 {
     _container     = container;
     _scopeRequests = scopeRequests;
 }
 public ValidatorFactory(ServiceProviderContainer provider)
 {
     _provider = provider;
 }
        public ListOfNames()
        {
            this.InitializeComponent();

            DataContext = ServiceProviderContainer.GetService <ListOfNameViewModel>();
        }
Exemple #24
0
 public static CrudlessInitializer CreateInitializer(ServiceProviderContainer provider, IMapper mapper)
 => new CrudlessInitializer(provider, null, mapper);
Exemple #25
0
 public static CrudlessInitializer CreateInitializer(ServiceProviderContainer provider, Assembly[] assemblies)
 => new CrudlessInitializer(provider, assemblies, null);
Exemple #26
0
 public static CrudlessInitializer CreateInitializer(ServiceProviderContainer provider, Assembly[] assemblies = null, IMapper mapper = null)
 => new CrudlessInitializer(provider, assemblies, mapper);
 public static void UnitTestOneTimeTearDown()
 {
     Provider.Dispose();
     Provider = null;
 }
Exemple #28
0
        public override void Run(ServiceProviderContainer container, Assembly[] assemblies, CrudlessOptions options)
        {
            bool IfNotHandled(ConditionalContext c) => !c.Handled;

            container.Register(typeof(IRequestHandler <>), assemblies);
            container.Register(typeof(IRequestHandler <,>), assemblies);

            container.Register(typeof(CreateRequestHandler <,>), assemblies);
            container.Register(typeof(CreateRequestHandler <, ,>), assemblies);
            container.RegisterConditional(typeof(IRequestHandler <>), typeof(CreateRequestHandler <,>), IfNotHandled);
            container.RegisterConditional(typeof(IRequestHandler <,>), typeof(CreateRequestHandler <, ,>), IfNotHandled);

            container.Register(typeof(CreateAllRequestHandler <,>), assemblies);
            container.Register(typeof(CreateAllRequestHandler <, ,>), assemblies);
            container.RegisterConditional(typeof(IRequestHandler <>), typeof(CreateAllRequestHandler <,>), IfNotHandled);
            container.RegisterConditional(typeof(IRequestHandler <,>), typeof(CreateAllRequestHandler <, ,>), IfNotHandled);

            container.Register(typeof(GetRequestHandler <, ,>), assemblies);
            container.RegisterConditional(typeof(IRequestHandler <,>), typeof(GetRequestHandler <, ,>), IfNotHandled);

            container.Register(typeof(GetAllRequestHandler <, ,>), assemblies);
            container.RegisterConditional(typeof(IRequestHandler <,>), typeof(GetAllRequestHandler <, ,>), IfNotHandled);

            container.Register(typeof(PagedGetAllRequestHandler <, ,>), assemblies);
            container.RegisterConditional(typeof(IRequestHandler <,>), typeof(PagedGetAllRequestHandler <, ,>), IfNotHandled);

            container.Register(typeof(UpdateRequestHandler <,>), assemblies);
            container.Register(typeof(UpdateRequestHandler <, ,>), assemblies);
            container.RegisterConditional(typeof(IRequestHandler <>), typeof(UpdateRequestHandler <,>), IfNotHandled);
            container.RegisterConditional(typeof(IRequestHandler <,>), typeof(UpdateRequestHandler <, ,>), IfNotHandled);

            container.Register(typeof(UpdateAllRequestHandler <,>), assemblies);
            container.Register(typeof(UpdateAllRequestHandler <, ,>), assemblies);
            container.RegisterConditional(typeof(IRequestHandler <>), typeof(UpdateAllRequestHandler <,>), IfNotHandled);
            container.RegisterConditional(typeof(IRequestHandler <,>), typeof(UpdateAllRequestHandler <, ,>), IfNotHandled);

            container.Register(typeof(DeleteRequestHandler <,>), assemblies);
            container.Register(typeof(DeleteRequestHandler <, ,>), assemblies);
            container.RegisterConditional(typeof(IRequestHandler <>), typeof(DeleteRequestHandler <,>), IfNotHandled);
            container.RegisterConditional(typeof(IRequestHandler <,>), typeof(DeleteRequestHandler <, ,>), IfNotHandled);

            container.Register(typeof(DeleteAllRequestHandler <,>), assemblies);
            container.Register(typeof(DeleteAllRequestHandler <, ,>), assemblies);
            container.RegisterConditional(typeof(IRequestHandler <>), typeof(DeleteAllRequestHandler <,>), IfNotHandled);
            container.RegisterConditional(typeof(IRequestHandler <,>), typeof(DeleteAllRequestHandler <, ,>), IfNotHandled);

            container.Register(typeof(SaveRequestHandler <,>), assemblies);
            container.Register(typeof(SaveRequestHandler <, ,>), assemblies);
            container.RegisterConditional(typeof(IRequestHandler <>), typeof(SaveRequestHandler <,>), IfNotHandled);
            container.RegisterConditional(typeof(IRequestHandler <,>), typeof(SaveRequestHandler <, ,>), IfNotHandled);

            container.Register(typeof(MergeRequestHandler <,>), assemblies);
            container.Register(typeof(MergeRequestHandler <, ,>), assemblies);
            container.RegisterConditional(typeof(IRequestHandler <>), typeof(MergeRequestHandler <,>), IfNotHandled);
            container.RegisterConditional(typeof(IRequestHandler <,>), typeof(MergeRequestHandler <, ,>), IfNotHandled);

            container.Register(typeof(SynchronizeRequestHandler <,>), assemblies);
            container.Register(typeof(SynchronizeRequestHandler <, ,>), assemblies);
            container.RegisterConditional(typeof(IRequestHandler <>), typeof(SynchronizeRequestHandler <,>), IfNotHandled);
            container.RegisterConditional(typeof(IRequestHandler <,>), typeof(SynchronizeRequestHandler <, ,>), IfNotHandled);
        }
Exemple #29
0
 public abstract void Run(ServiceProviderContainer container, Assembly[] assemblies, CrudlessOptions options);
Exemple #30
0
        public MainForm()
        {
            var items = new List <AutocompleteItem>
            {
                new SnippetAutocompleteItem(
                    "if ^[expression]\r\n\r\t#do something\nend if"),
                new SnippetAutocompleteItem(
                    "try \r\n\r^#do something\n\rcatch ex\r\n#do something\n\nfinally\n#do something\nend try"),
                new SnippetAutocompleteItem(
                    "switch ^parent \r\n\r#do something\ncase condition:\r\n#do something\nbreak;\ndefault:\n#do something\nend switch")
            };

            //items.Add(new MethodAutocompleteItem2("Console.WriteLine"));

            foreach (ExtensionNode node in AddinManager.GetExtensionObjects("/EcIDE/Intellisense/Snippets"))
            {
                var cmd = node.CreateInstances <ISnippet>();

                cmd.ForEach(c => c.Init(new ServiceContainer()));
                cmd.ForEach(c => items.Add(new SnippetAutocompleteItem(c.GetSnippet())));
            }

            IntellisenseManager.PopulateClass(items, typeof(Console));
            IntellisenseManager.PopulateClass(items, typeof(MessageBox));

            foreach (ExtensionNode node in AddinManager.GetExtensionObjects("/EcIDE/Intellisense/Commands"))
            {
                var cmd = node.CreateInstances <IIntellisenseCommand>();

                cmd.ForEach(c => c.Init(new ServiceContainer()));

                foreach (IIntellisenseCommand intellisenseCommand in cmd)
                {
                    StyleManager.Add(
                        intellisenseCommand.GetPattern(),
                        intellisenseCommand.GetColor(),
                        intellisenseCommand.GetStyle());
                    InfoManager.Add(intellisenseCommand.GetPattern(), intellisenseCommand.GetDescription());

                    items.Add(new AutocompleteItem(intellisenseCommand.GetPattern(), 0));
                }
            }

            this.InitializeComponent();

            var menu = new AutocompleteMenu(this.fastColoredTextBox1)
            {
                SearchPattern = @"[\w\.]", AllowTabKey = true
            };

            menu.Items.SetAutocompleteItems(items);

            Console.SetOut(new ControlWriter(this.console));
            Console.SetIn(this.rdtxt);
            engine = new Engine {
                Flag = Engine.ExecutanFlags.RamOptimized
            };

            OptionsManager.Load();

            ServiceProviderContainer.AddService(new EditorService(this.fastColoredTextBox1));
            ServiceProviderContainer.AddService(new MenuService(this.MainMenu));
            ServiceProviderContainer.AddService(new AddinService(AddinManager.Registry));
            ServiceProviderContainer.AddService(new NotificationService(this.RadDesktopAlert));
            ServiceProviderContainer.AddService(new WindowService(this.dock));
            ServiceProviderContainer.AddService(new OptionsService());

            foreach (ExtensionNode node in AddinManager.GetExtensionObjects("/EcIDE/StartupCommands"))
            {
                var cmd = node.CreateInstances <ICommand>();

                cmd.ForEach(c => c.Init(new ServiceContainer()));
                cmd.ForEach(c => c.Run());

                var ecommand = node.GetCommand();

                foreach (var ec in ecommand)
                {
                    var ep = ec as window;
                    if (ep != null)
                    {
                        if (ep.title != "")
                        {
                            this.Text = ep.title;
                        }
                        if (ep.close != "")
                        {
                            cmd.ForEach(
                                c =>
                            {
                                this.FormClosing += (sender, args) => c.GetType().GetMethod(ep.close).Invoke(c, null);
                            });
                        }
                    }
                }
            }

            foreach (ExtensionNode node in AddinManager.GetExtensionObjects("/EcIDE/Menu"))
            {
                foreach (var ec in node.GetCommand())
                {
                    var ep = ec as menuitem;
                    if (ep != null)
                    {
                        var target = node.CreateInstances <IMenu>()[0];
                        target.Init(new ServiceContainer());

                        MainMenu.Items.Add(
                            new ToolStripMenuItem(ep.text, null, (sender, args) => target.GetType().GetMethod(ep.click).Invoke(target, new[] { sender, args })));
                    }
                }
            }

            MenuBinder.Bind(MainMenu);

            explorerTree.ExpandAll();

            projectProperties1.AddCurrentTabPage(new GeneralPage());
            this.AddPropertyTabPage("General", new GeneralPage());

            dock.CloseWindow(propertiesWindow);

            fastColoredTextBox1.Refresh();
        }