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>();
}
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;
}
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;
}
public override void Run(ServiceProviderContainer container, Assembly[] assemblies, CrudlessOptions options)
{
if (_mapper != null)
{
using (var scope = container.AllowOverrides())
container.RegisterInstance(_mapper);
}
}
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>();
}
static void RegisterTypes()
{
var container = new ServiceProviderContainer();
container.DefaultRegister();
container.RegisterType(typeof(IJsonSerializer), typeof(JsonNetSerializer));
container.RegisterType(typeof(VerificationCodeBase), typeof(SkiaSharpVerificationCode));
ContainerManager.Container = container;
}
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);
}
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>();
}
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);
}
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);
}
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();
}
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());
}
}
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(),
});
}
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);
}
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>();
}
public static CrudlessInitializer CreateInitializer(ServiceProviderContainer provider, IMapper mapper) => new CrudlessInitializer(provider, null, mapper);
public static CrudlessInitializer CreateInitializer(ServiceProviderContainer provider, Assembly[] assemblies) => new CrudlessInitializer(provider, assemblies, null);
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;
}
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);
}
public abstract void Run(ServiceProviderContainer container, Assembly[] assemblies, CrudlessOptions options);
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();
}
