示例#1
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(
            IServiceProvider locator,
            ISerialization <TInput> input,
            ISerialization <TOutput> output,
            IPrincipal principal,
            TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }

            try
            {
                var result = FindAndReturn(locator, input, output, principal, either.Argument);
                return(CommandResult <TOutput> .Success(result.Result, "Found {0} item(s)", result.Count));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#2
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(ISerialization <TInput> input, ISerialization <TOutput> output, TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var serviceType = TypeResolver.Resolve(argument.Name);

            if (serviceType == null)
            {
                return
                    (CommandResult <TOutput> .Fail(
                         "Couldn't find service: {0}".With(argument.Name),
                         @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            var serviceInterface =
                serviceType.GetInterfaces()
                .FirstOrDefault(it => it.IsGenericType && typeof(IServerService <,>) == it.GetGenericTypeDefinition());

            if (serviceInterface == null)
            {
                return
                    (CommandResult <TOutput> .Fail(
                         "Object: {0} is not a valid service.".With(argument.Name),
                         "{0} must implement {1} to be executed as a service call".With(argument.Name, typeof(IServerService <,>).FullName)));
            }

            if (!Permissions.CanAccess(serviceType))
            {
                return
                    (CommandResult <TOutput> .Return(
                         HttpStatusCode.Forbidden,
                         default(TOutput),
                         "You don't have permission to access: {0}.",
                         argument.Name));
            }

            try
            {
                var commandType = typeof(ExecuteServiceCommand <,>).MakeGenericType(serviceInterface.GetGenericArguments());
                var command     = Activator.CreateInstance(commandType) as IExecuteServiceCommand;
                var result      = command.Execute(input, output, Locator, serviceType, argument.Data);

                return(CommandResult <TOutput> .Return(HttpStatusCode.Created, result, "Service executed"));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#3
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(ISerialization <TInput> input, ISerialization <TOutput> output, TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }

            try
            {
                var table = PopulateTable(input, output, Locator, DomainModel, either.Argument, Permissions);
                if (either.Argument.UseDataTable)
                {
                    return(CommandResult <TOutput> .Return(HttpStatusCode.Created, output.Serialize(table), "Data analyzed"));
                }
                var result = ConvertTable.Convert(output, table);
                return(CommandResult <TOutput> .Return(HttpStatusCode.Created, result, "Data analyzed"));
            }
            catch (SecurityException ex)
            {
                return(CommandResult <TOutput> .Return(HttpStatusCode.Forbidden, default(TOutput), ex.Message));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#4
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(
            IServiceProvider locator,
            ISerialization <TInput> input,
            ISerialization <TOutput> output,
            IPrincipal principal,
            TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var rootType = DomainModel.Find(argument.Name);

            if (rootType == null)
            {
                return(CommandResult <TOutput> .Fail(
                           "Couldn't find domain object type {0}.".With(argument.Name),
                           @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            if (!typeof(IObjectHistory).IsAssignableFrom(rootType))
            {
                return(CommandResult <TOutput> .Fail(@"Specified type ({0}) does not support history tracking. 
Please check your arguments.".With(argument.Name), null));
            }

            if (!Permissions.CanAccess(rootType.FullName, principal))
            {
                return(CommandResult <TOutput> .Forbidden(argument.Name));
            }
            if (argument.Uri == null || argument.Uri.Length == 0)
            {
                return(CommandResult <TOutput> .Fail(
                           "Uri not specified.",
                           @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            try
            {
                var commandType = typeof(FindCommand <>).MakeGenericType(rootType);
                var command     = Activator.CreateInstance(commandType) as IFindCommand;
                var result      = command.Find(output, locator, argument.Uri);

                return(CommandResult <TOutput> .Success(result.Result, "Found {0} item(s)", result.Count));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#5
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(
            IServiceProvider locator,
            ISerialization <TInput> input,
            ISerialization <TOutput> output,
            IPrincipal principal,
            TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }

            try
            {
                var command = PrepareCommand(principal, either.Argument.Name, either.Argument.SpecificationName);
                var exists  = command.CheckExists(input, locator, either.Argument.Specification);
                return(CommandResult <TOutput> .Success(output.Serialize(exists), exists.ToString()));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
        public ICommandResult <TOutput> Execute <TInput, TOutput>(
            IServiceProvider locator,
            ISerialization <TInput> input,
            ISerialization <TOutput> output,
            IPrincipal principal,
            TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }

            try
            {
                var result = Execute <TInput>(locator, principal, input, either.Argument);
                return(CommandResult <TOutput> .Success(Serialize(output, result), "Document created"));
            }
            catch (FileNotFoundException fnf)
            {
                return(CommandResult <TOutput> .Fail(fnf.Message, null));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#7
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(ISerialization <TInput> input, ISerialization <TOutput> output, TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var commands = Locator.Resolve <IEnumerable <IServerCommandDescription <TInput> > >();
            var results  = Locator.Resolve <IEnumerable <ICommandResultDescription <TOutput> > >();

            var resultCommand = results.FirstOrDefault(it => it.RequestID == argument.ResultID);

            if (resultCommand == null)
            {
                return(CommandResult <TOutput> .Fail("Couldn't find executed command {0}".With(argument.ResultID), null));
            }

            var inputCommand = commands.FirstOrDefault(it => it.RequestID == argument.InputID);

            if (inputCommand == null)
            {
                return(CommandResult <TOutput> .Fail("Couldn't find command description {0}".With(argument.InputID), null));
            }

            var transformation = input.Deserialize <TInput, ITransformation <TOutput, TInput> >(argument.Transformation);

            inputCommand.Data = transformation.Transform(output, input, resultCommand.Result.Data);

            return(CommandResult <TOutput> .Success(default(TOutput), "Data propagated"));
        }
示例#8
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(
            IServiceProvider locator,
            ISerialization <TInput> input,
            ISerialization <TOutput> output,
            IPrincipal principal,
            TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            if (either.Argument.Uri == null)
            {
                return(CommandResult <TOutput> .Fail("Uri not provided.", @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
            try
            {
                var arg = new GetDomainObject.Argument {
                    Name = either.Argument.Name, Uri = new[] { either.Argument.Uri }
                };
                var result = GetDomainObject.GetData(locator, arg, principal);
                return(CommandResult <TOutput> .Success(output.Serialize(result.Length == 1), result.Length == 1? "Found" : "Not found"));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#9
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(ISerialization <TInput> input, ISerialization <TOutput> output, TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var rootType = DomainModel.Find(argument.Name);

            if (rootType == null)
            {
                return(CommandResult <TOutput> .Fail(
                           "Couldn't find aggregate root type {0}.".With(argument.Name),
                           @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            if (!typeof(IAggregateRoot).IsAssignableFrom(rootType))
            {
                return(CommandResult <TOutput> .Fail(@"Specified type ({0}) is not an aggregate root. 
Please check your arguments.".With(argument.Name), null));
            }

            if (!Permissions.CanAccess(rootType))
            {
                return
                    (CommandResult <TOutput> .Return(
                         HttpStatusCode.Forbidden,
                         default(TOutput),
                         "You don't have permission to access: {0}.",
                         argument.Name));
            }

            if (argument.Data == null)
            {
                return(CommandResult <TOutput> .Fail("Data to create not specified.", @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output, rootType))));
            }

            try
            {
                var commandType = typeof(CreateCommand <>).MakeGenericType(rootType);
                var command     = Activator.CreateInstance(commandType) as ICreateCommand;
                var result      = command.Create(input, output, Locator, argument.Data);

                return(CommandResult <TOutput> .Return(HttpStatusCode.Created, result, "Object created"));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output, rootType))));
            }
        }
示例#10
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(
            IServiceProvider locator,
            ISerialization <TInput> input,
            ISerialization <TOutput> output,
            IPrincipal principal,
            TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var eventType = DomainModel.Find(argument.Name);

            if (eventType == null)
            {
                return
                    (CommandResult <TOutput> .Fail(
                         "Couldn't find event type {0}.".With(argument.Name),
                         @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
            if (!typeof(IEvent).IsAssignableFrom(eventType))
            {
                return(CommandResult <TOutput> .Fail(@"Specified type ({0}) is not an event. 
Please check your arguments.".With(argument.Name), null));
            }
            if (!Permissions.CanAccess(eventType.FullName, principal))
            {
                return(CommandResult <TOutput> .Forbidden(argument.Name));
            }
            try
            {
                ISubmitCommand command;
                if (!Cache.TryGetValue(eventType, out command))
                {
                    var commandType = typeof(SubmitEventCommand <>).MakeGenericType(eventType);
                    command = Activator.CreateInstance(commandType) as ISubmitCommand;
                    var newCache = new Dictionary <Type, ISubmitCommand>(Cache);
                    newCache[eventType] = command;
                    Cache = newCache;
                }
                var result = command.Submit(input, output, locator, argument.ReturnInstance ?? false, argument.Data);

                return(CommandResult <TOutput> .Return(HttpStatusCode.Created, result, "Event stored"));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#11
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(ISerialization <TInput> input, ISerialization <TOutput> output, TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var objectType = DomainModel.Find(argument.Name);

            if (objectType == null)
            {
                return(CommandResult <TOutput> .Fail("Couldn't find domain object type {0}.".With(argument.Name), null));
            }

            if (!Permissions.CanAccess(objectType))
            {
                return
                    (CommandResult <TOutput> .Return(
                         HttpStatusCode.Forbidden,
                         default(TOutput),
                         "You don't have permission to access: {0}.",
                         argument.Name));
            }

            if (argument.Uri == null)
            {
                return(CommandResult <TOutput> .Fail(
                           "Uri to read not specified.",
                           @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output, objectType))));
            }

            try
            {
                var commandType = typeof(FindCommand <>).MakeGenericType(objectType);
                var command     = Activator.CreateInstance(commandType) as IFindCommand;
                var result      = command.Find(output, Locator, Permissions, argument.Uri);

                return(result != null
                                        ? CommandResult <TOutput> .Success(result, "Object found")
                                        : CommandResult <TOutput> .Return(
                           HttpStatusCode.NotFound,
                           result,
                           "Can't find {0} with Uri: {1}.".With(objectType.FullName, argument.Uri)));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output, objectType))));
            }
        }
示例#12
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(ISerialization <TInput> input, ISerialization <TOutput> output, TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var reportType = DomainModel.Find(argument.ReportName);

            if (reportType == null)
            {
                return(CommandResult <TOutput> .Fail(
                           "Couldn't find report type {0}.".With(argument.ReportName),
                           @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            var ri = reportType.GetInterfaces().FirstOrDefault(it => it.IsGenericType && it.GetGenericTypeDefinition() == typeof(IReport <>));

            if (ri == null)
            {
                return(CommandResult <TOutput> .Fail(@"Specified type ({0}) is not an report. 
Please check your arguments.".With(argument.ReportName), null));
            }

            if (!Permissions.CanAccess(reportType))
            {
                return
                    (CommandResult <TOutput> .Return(
                         HttpStatusCode.Forbidden,
                         default(TOutput),
                         "You don't have permission to access: {0}.",
                         argument.ReportName));
            }

            try
            {
                var commandType = typeof(PopulateReportCommand <,>).MakeGenericType(reportType, ri.GetGenericArguments()[0]);
                var command     = Activator.CreateInstance(commandType) as IPopulateReport;
                var result      = command.Populate(input, output, Locator, argument.Data);

                return(CommandResult <TOutput> .Success(result, "Report populated"));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#13
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(
            IServiceProvider locator,
            ISerialization <TInput> input,
            ISerialization <TOutput> output,
            IPrincipal principal,
            TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var eventType = DomainModel.Find(argument.Name);

            if (eventType == null)
            {
                return
                    (CommandResult <TOutput> .Fail(
                         "Couldn't find event type {0}.".With(argument.Name),
                         @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
            if (!Permissions.CanAccess(eventType.FullName, principal))
            {
                return(CommandResult <TOutput> .Forbidden(argument.Name));
            }
            try
            {
                IQueueCommand command;
                if (!Cache.TryGetValue(eventType, out command))
                {
                    var commandType = typeof(QueueEventCommand <>).MakeGenericType(eventType);
                    command = Activator.CreateInstance(commandType) as IQueueCommand;
                    var newCache = new Dictionary <Type, IQueueCommand>(Cache);
                    newCache[eventType] = command;
                    Cache = newCache;
                }
                command.Queue(input, locator, DataContext, argument.Data);

                return(CommandResult <TOutput> .Return(HttpStatusCode.Accepted, default(TOutput), "Event queued"));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
        public ICommandResult <TOutput> Execute <TInput, TOutput>(
            IServiceProvider locator,
            ISerialization <TInput> input,
            ISerialization <TOutput> output,
            IPrincipal principal,
            TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var eventType = DomainModel.Find(argument.Name);

            if (eventType == null)
            {
                return
                    (CommandResult <TOutput> .Fail(
                         "Couldn't find event type {0}.".With(argument.Name),
                         @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            var aggregateInterface = eventType.GetInterfaces().FirstOrDefault(it => it.IsGenericType && it.GetGenericTypeDefinition() == typeof(IDomainEvent <>));
            var aggregateType      = aggregateInterface != null?aggregateInterface.GetGenericArguments()[0] : null;

            if (aggregateType == null)
            {
                return
                    (CommandResult <TOutput> .Fail(
                         "{0} does not implement IDomainEvent<TAggregate>.".With(eventType.FullName),
                         @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            if (!Permissions.CanAccess(eventType.FullName, principal))
            {
                return(CommandResult <TOutput> .Forbidden(eventType.FullName));
            }
            if (!Permissions.CanAccess(aggregateType.FullName, principal))
            {
                return(CommandResult <TOutput> .Forbidden(aggregateType.FullName));
            }
            try
            {
                IQueueCommand command;
                if (!Cache.TryGetValue(eventType, out command))
                {
                    var commandType = typeof(QueueEventCommand <,>).MakeGenericType(eventType, aggregateType);
                    command = Activator.CreateInstance(commandType) as IQueueCommand;
                    var newCache = new Dictionary <Type, IQueueCommand>(Cache);
                    newCache[eventType] = command;
                    Cache = newCache;
                }
                var result = command.Queue(input, output, locator, argument.Uri, argument.Data);

                return(CommandResult <TOutput> .Return(HttpStatusCode.Accepted, result, "Event queued"));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#15
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(
            IServiceProvider locator,
            ISerialization <TInput> input,
            ISerialization <TOutput> output,
            IPrincipal principal,
            TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var rootType = DomainModel.Find(argument.RootName);

            if (rootType == null)
            {
                return(CommandResult <TOutput> .Fail("Couldn't find root type: {0}".With(argument.RootName), @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            if (!typeof(IAggregateRoot).IsAssignableFrom(rootType))
            {
                return(CommandResult <TOutput> .Fail(@"Specified type ({0}) is not an aggregate root. 
Please check your arguments.".With(argument.RootName), null));
            }

            if (!Permissions.CanAccess(rootType.FullName, principal))
            {
                return(CommandResult <TOutput> .Forbidden(argument.RootName));
            }
            if (argument.ToInsert == null && argument.ToUpdate == null && argument.ToDelete == null)
            {
                return(CommandResult <TOutput> .Fail("Data to persist not specified.", @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output, rootType))));
            }

            try
            {
                IPersistCommand command;
                if (!Cache.TryGetValue(rootType, out command))
                {
                    var commandType = typeof(PersistAggregateRootCommand <>).MakeGenericType(rootType);
                    command = Activator.CreateInstance(commandType) as IPersistCommand;
                    var newCache = new Dictionary <Type, IPersistCommand>(Cache);
                    newCache[rootType] = command;
                    Cache = newCache;
                }
                var uris = command.Persist(input, locator, argument.ToInsert, argument.ToUpdate, argument.ToDelete);

                return(CommandResult <TOutput> .Success(output.Serialize(uris), "Data persisted"));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#16
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(ISerialization <TInput> input, ISerialization <TOutput> output, TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var eventType = DomainModel.Find(argument.Name);

            if (eventType == null)
            {
                return
                    (CommandResult <TOutput> .Fail(
                         "Couldn't find event type {0}.".With(argument.Name),
                         @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            var aggregateInterface = eventType.GetInterfaces().FirstOrDefault(it => it.IsGenericType && it.GetGenericTypeDefinition() == typeof(IDomainEvent <>));
            var aggregateType      = aggregateInterface != null?aggregateInterface.GetGenericArguments()[0] : null;

            if (aggregateType == null)
            {
                return
                    (CommandResult <TOutput> .Fail(
                         "{0} does not implement IDomainEvent<TAggregate>.".With(eventType.FullName),
                         @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            if (!Permissions.CanAccess(eventType))
            {
                return
                    (CommandResult <TOutput> .Return(
                         HttpStatusCode.Forbidden,
                         default(TOutput),
                         "You don't have permission to access: {0}.",
                         eventType.FullName));
            }

            if (!Permissions.CanAccess(aggregateType))
            {
                return
                    (CommandResult <TOutput> .Return(
                         HttpStatusCode.Forbidden,
                         default(TOutput),
                         "You don't have permission to access: {0}.",
                         aggregateType.FullName));
            }

            try
            {
                var commandType = typeof(SubmitEventCommand <,>).MakeGenericType(eventType, aggregateType);
                var command     = Activator.CreateInstance(commandType) as ISubmitEventCommand;
                var result      = command.Submit(input, output, Locator, EventStore, argument.Uri, argument.Data);

                return(CommandResult <TOutput> .Return(HttpStatusCode.Created, result, "Event applied"));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#17
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(
            IServiceProvider locator,
            ISerialization <TInput> input,
            ISerialization <TOutput> output,
            IPrincipal principal,
            TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var documentType = DomainModel.FindNested(argument.CubeName, argument.TemplaterName);

            if (documentType == null)
            {
                return(CommandResult <TOutput> .Fail(
                           "Couldn't find Templater type {0} for {1}.".With(argument.TemplaterName, argument.CubeName),
                           @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            if (!Permissions.CanAccess(documentType.FullName, principal))
            {
                return(CommandResult <TOutput> .Forbidden("{0} in {1}.".With(argument.TemplaterName, argument.CubeName)));
            }
            if (!typeof(IDocumentReport <DataTable>).IsAssignableFrom(documentType))
            {
                return
                    (CommandResult <TOutput> .Fail(
                         "Templater type {0} for {1} is not IDocumentReport<DataTable>. Check {0}.".With(
                             documentType.FullName,
                             argument.CubeName),
                         null));
            }

            IDocumentReport <DataTable> report;

            try
            {
                report = locator.Resolve <IDocumentReport <DataTable> >(documentType);
            }
            catch (Exception ex)
            {
                return(CommandResult <TOutput> .Fail(
                           @"Can't create document report. Is report {0} registered in system?".With(documentType.FullName),
                           ex.GetDetailedExplanation()));
            }
            try
            {
                var table  = AnalyzeOlapCube.PopulateTable(input, output, locator, DomainModel, argument, principal, Permissions);
                var result = report.Create(table);
                return(CommandResult <TOutput> .Return(HttpStatusCode.Created, Serialize(output, result), "Report created"));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#18
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(
            IServiceProvider locator,
            ISerialization <TInput> input,
            ISerialization <TOutput> output,
            IPrincipal principal,
            TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            IEvaluateCommand command;

            if (!Cache.TryGetValue(argument.QueryName, out command))
            {
                var queryType = DomainModel.Find(argument.QueryName);
                if (queryType == null)
                {
                    return(CommandResult <TOutput> .Fail(
                               "Couldn't find query type {0}.".With(argument.QueryName),
                               @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
                }

                var returnMethods =
                    (from m in queryType.GetMethods(BindingFlags.Static | BindingFlags.Public)
                     where m.Name == "Return"
                     let p = m.GetParameters()
                             where p != null && p.Length == 1 && typeof(ICommand).IsAssignableFrom(p[0].ParameterType)
                             select new { command = p[0].ParameterType, output = m.ReturnType, method = m }).ToList();
                if (returnMethods.Count != 1)
                {
                    return(CommandResult <TOutput> .Fail("Invalid query type {0}.".With(argument.QueryName), null));
                }
                var acceptMethods =
                    (from m in queryType.GetMethods(BindingFlags.Static | BindingFlags.Public)
                     where m.Name == "Accept"
                     let p = m.GetParameters()
                             where p != null && p.Length < 2 && typeof(ICommand).IsAssignableFrom(m.ReturnType)
                             select new { method = m, accept = p.Length == 1 ? p[0].ParameterType : null }).ToList();
                if (acceptMethods.Count != 1)
                {
                    return(CommandResult <TOutput> .Fail("Invalid query type {0}.".With(argument.QueryName), null));
                }
                var commandType = acceptMethods[0].accept == null
                                        ? typeof(EvaluateCommand <,>).MakeGenericType(returnMethods[0].command, returnMethods[0].output)
                                        : typeof(EvaluateCommand <, ,>).MakeGenericType(returnMethods[0].command, acceptMethods[0].accept, returnMethods[0].output);
                command = Activator.CreateInstance(commandType, new object[] { acceptMethods[0].method, returnMethods[0].method }) as IEvaluateCommand;
                var newCache = new Dictionary <string, IEvaluateCommand>(Cache);
                newCache[argument.QueryName] = command;
                Cache = newCache;
            }

            try
            {
                var result = command.Evaluate(input, output, locator, argument.Data);
                return(CommandResult <TOutput> .Success(result, "Evaluated"));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#19
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(
            IServiceProvider locator,
            ISerialization <TInput> input,
            ISerialization <TOutput> output,
            IPrincipal principal,
            TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var objectType = DomainModel.Find(argument.Name);

            if (objectType == null)
            {
                return(CommandResult <TOutput> .Fail("Couldn't find domain object type {0}.".With(argument.Name), null));
            }

            if (!Permissions.CanAccess(objectType.FullName, principal))
            {
                return(CommandResult <TOutput> .Forbidden(argument.Name));
            }
            if (argument.Uri == null)
            {
                return(CommandResult <TOutput> .Fail(
                           "Uri to read not specified.",
                           @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output, objectType))));
            }

            try
            {
                IFindCommand command;
                if (!Cache.TryGetValue(objectType, out command))
                {
                    var commandType = typeof(FindCommand <>).MakeGenericType(objectType);
                    command = Activator.CreateInstance(commandType) as IFindCommand;
                    var newCache = new Dictionary <Type, IFindCommand>(Cache);
                    newCache[objectType] = command;
                    Cache = newCache;
                }
                var result = command.Find(output, locator, Permissions, principal, argument.Uri);

                return(result != null
                                        ? CommandResult <TOutput> .Success(result, "Object found")
                                        : CommandResult <TOutput> .Return(
                           HttpStatusCode.NotFound,
                           result,
                           "Can't find {0} with Uri: {1}.".With(objectType.FullName, argument.Uri)));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output, objectType))));
            }
        }
示例#20
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(ISerialization <TInput> input, ISerialization <TOutput> output, TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            Type domainType = DomainModel.Find(argument.DomainObjectName);

            if (domainType == null)
            {
                return(CommandResult <TOutput> .Fail(
                           "Couldn't find domain object type {0}.".With(argument.DomainObjectName),
                           @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            if (!Permissions.CanAccess(domainType))
            {
                return
                    (CommandResult <TOutput> .Return(
                         HttpStatusCode.Forbidden,
                         default(TOutput),
                         "You don't have permission to access: {0}.",
                         argument.DomainObjectName));
            }

            Type validationType = DomainModel.FindNested(domainType.FullName, argument.ValidationName);

            if (validationType == null)
            {
                return
                    (CommandResult <TOutput> .Fail(
                         "Couldn't find validation {0} for {1}".With(
                             argument.ValidationName,
                             argument.DomainObjectName),
                         null));
            }

            if (!Permissions.CanAccess(validationType))
            {
                return
                    (CommandResult <TOutput> .Return(
                         HttpStatusCode.Forbidden,
                         default(TOutput),
                         "You don't have permission to access: {0}.",
                         argument.ValidationName));
            }

            Type bindingType = string.IsNullOrWhiteSpace(argument.BindingObjectName) ? null : DomainModel.Find(argument.BindingObjectName);

            try
            {
                var commandType = typeof(FindInvalidDataCommand <>).MakeGenericType(domainType);
                var command     = Activator.CreateInstance(commandType) as IFindInvalidDataCommand;
                var result      = command.FindInvalid(input, output, DomainModel, Locator, validationType, bindingType, argument.Specification);
                return(CommandResult <TOutput> .Success(result.Result, "Found {0} item(s)", result.Count));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }
示例#21
0
        public ICommandResult <TOutput> Execute <TInput, TOutput>(
            IServiceProvider locator,
            ISerialization <TInput> input,
            ISerialization <TOutput> output,
            IPrincipal principal,
            TInput data)
        {
            var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument);

            if (either.Error != null)
            {
                return(either.Error);
            }
            var argument = either.Argument;

            var reportType = DomainModel.Find(argument.ReportName);

            if (reportType == null)
            {
                return(CommandResult <TOutput> .Fail(
                           "Couldn't find report type {0}.".With(argument.ReportName),
                           @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            var ri = reportType.GetInterfaces().FirstOrDefault(it => it.IsGenericType && it.GetGenericTypeDefinition() == typeof(IReport <>));

            if (ri == null)
            {
                return(CommandResult <TOutput> .Fail(@"Specified type ({0}) is not an report. 
Please check your arguments.".With(argument.ReportName), null));
            }

            if (!Permissions.CanAccess(reportType.FullName, principal))
            {
                return(CommandResult <TOutput> .Forbidden(argument.ReportName));
            }
            var documentType = DomainModel.FindNested(argument.ReportName, argument.TemplaterName);

            if (documentType == null)
            {
                return
                    (CommandResult <TOutput> .Fail(
                         "Couldn't find Templater type {0} for {1}.".With(argument.TemplaterName, argument.ReportName),
                         @"Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }

            if (!Permissions.CanAccess(documentType.FullName, principal))
            {
                return(CommandResult <TOutput> .Forbidden("{0} in {1}.".With(argument.TemplaterName, argument.ReportName)));
            }
            if (!typeof(IDocumentReport <>).MakeGenericType(reportType).IsAssignableFrom(documentType))
            {
                return
                    (CommandResult <TOutput> .Fail(
                         "Templater type {0} for {1} is not IDocumentReport<{1}>. Check {0}.".With(
                             documentType.FullName,
                             reportType.FullName),
                         null));
            }

            try
            {
                var commandType = typeof(GenerateReportCommand <,>).MakeGenericType(reportType, ri.GetGenericArguments()[0]);
                var command     = Activator.CreateInstance(commandType) as IGenerateReport;
                var result      = command.Convert(input, locator, documentType, argument.Data);

                return(CommandResult <TOutput> .Return(HttpStatusCode.Created, Serialize(output, result), "Report created"));
            }
            catch (ArgumentException ex)
            {
                return(CommandResult <TOutput> .Fail(
                           ex.Message,
                           ex.GetDetailedExplanation() + @"
Example argument: 
" + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output))));
            }
        }