|
1 | 1 | using RoyalCode.Commands.Abstractions;
|
2 | 2 | using RoyalCode.Entities;
|
3 |
| -using RoyalCode.OperationResults; |
| 3 | +using RoyalCode.SmartProblems; |
4 | 4 | using RoyalCode.WorkContext.Abstractions;
|
5 | 5 |
|
6 | 6 | namespace RoyalCode.Commands.Handlers;
|
@@ -45,27 +45,27 @@ public CreateCommandHandler(
|
45 | 45 | /// <param name="model">The input model.</param>
|
46 | 46 | /// <param name="token">The cancellation token.</param>
|
47 | 47 | /// <returns>The result of the operation with the created entity.</returns>
|
48 |
| - public async Task<OperationResult<TEntity>> HandleAsync(TModel model, CancellationToken token) |
| 48 | + public async Task<Result<TEntity>> HandleAsync(TModel model, CancellationToken token) |
49 | 49 | {
|
50 | 50 | foreach (var validator in validators)
|
51 | 51 | {
|
52 | 52 | var result = validator.Validate(model);
|
53 |
| - if (result.TryGetError(out var error)) |
54 |
| - return error; |
| 53 | + if (result.HasProblems(out var problems)) |
| 54 | + return problems; |
55 | 55 | }
|
56 | 56 |
|
57 | 57 | if (creationHandler is IValidationHandler<TModel> validationHandler)
|
58 | 58 | {
|
59 | 59 | var result = validationHandler.Validate(context, model);
|
60 |
| - if (result.TryGetError(out var error)) |
61 |
| - return error; |
| 60 | + if (result.HasProblems(out var problems)) |
| 61 | + return problems; |
62 | 62 | }
|
63 | 63 |
|
64 | 64 | var entity = creationHandler.Create(model);
|
65 | 65 | context.Repository<TEntity>().Add(entity);
|
66 | 66 |
|
67 | 67 | var saveResult = await context.SaveAsync(token);
|
68 |
| - return saveResult.Convert(entity); |
| 68 | + return saveResult.Map(entity); |
69 | 69 | }
|
70 | 70 | }
|
71 | 71 |
|
@@ -111,38 +111,38 @@ public CreateCommandHandler(
|
111 | 111 | /// <param name="model">The input model.</param>
|
112 | 112 | /// <param name="token">The cancellation token.</param>
|
113 | 113 | /// <returns>The result of the operation with the created entity.</returns>
|
114 |
| - public async Task<OperationResult<TEntity>> HandleAsync(TModel model, CancellationToken token) |
| 114 | + public async Task<Result<TEntity>> HandleAsync(TModel model, CancellationToken token) |
115 | 115 | {
|
116 | 116 | foreach (var validator in validators)
|
117 | 117 | {
|
118 | 118 | var result = validator.Validate(model);
|
119 |
| - if (result.TryGetError(out var error)) |
120 |
| - return error; |
| 119 | + if (result.HasProblems(out var problems)) |
| 120 | + return problems; |
121 | 121 | }
|
122 | 122 |
|
123 | 123 | if (creationHandler is IValidationHandler<TModel> validationHandler)
|
124 | 124 | {
|
125 | 125 | var result = validationHandler.Validate(context, model);
|
126 |
| - if (result.TryGetError(out var error)) |
127 |
| - return error; |
| 126 | + if (result.HasProblems(out var problems)) |
| 127 | + return problems; |
128 | 128 | }
|
129 | 129 |
|
130 |
| - var creationContextResult = await creationHandler.CreateContextAsync(context, model, token); |
131 |
| - if (creationContextResult.IsFailureOrGetValue(out var creationContext)) |
132 |
| - return creationContextResult.Convert<TEntity>(); |
133 |
| - |
134 |
| - if (creationContext is IValidableContext validable) |
135 |
| - { |
136 |
| - var result = validable.Validate(); |
137 |
| - if (result.TryGetError(out var error)) |
138 |
| - return error; |
139 |
| - } |
140 |
| - |
141 |
| - var entity = creationHandler.Create(creationContext); |
142 |
| - context.Repository<TEntity>().Add(entity); |
143 |
| - |
144 |
| - var saveResult = await context.SaveAsync(token); |
145 |
| - return saveResult.Convert(entity); |
| 130 | + return await creationHandler.CreateContextAsync(context, model, token) |
| 131 | + .MapAsync(async creationContext => |
| 132 | + { |
| 133 | + if (creationContext is IValidableContext validable) |
| 134 | + { |
| 135 | + var result = validable.Validate(); |
| 136 | + if (result.HasProblems(out var problems)) |
| 137 | + return problems; |
| 138 | + } |
| 139 | + |
| 140 | + var entity = creationHandler.Create(creationContext); |
| 141 | + context.Repository<TEntity>().Add(entity); |
| 142 | + |
| 143 | + var saveResult = await context.SaveAsync(token); |
| 144 | + return saveResult.Map(entity); |
| 145 | + }); |
146 | 146 | }
|
147 | 147 | }
|
148 | 148 |
|
@@ -193,41 +193,41 @@ public CreateCommandHandler(
|
193 | 193 | /// <param name="model">The input model.</param>
|
194 | 194 | /// <param name="token">The cancellation token.</param>
|
195 | 195 | /// <returns>The result of the operation with the created entity.</returns>
|
196 |
| - public async Task<OperationResult<TEntity>> HandleAsync(TRootId id, TModel model, CancellationToken token) |
| 196 | + public async Task<Result<TEntity>> HandleAsync(TRootId id, TModel model, CancellationToken token) |
197 | 197 | {
|
198 | 198 | foreach (var validator in validators)
|
199 | 199 | {
|
200 | 200 | var result = validator.Validate(model);
|
201 |
| - if (result.TryGetError(out var error)) |
| 201 | + if (result.HasProblems(out var error)) |
202 | 202 | return error;
|
203 | 203 | }
|
204 | 204 |
|
205 | 205 | if (creationHandler is IValidationHandler<TModel> validationHandler)
|
206 | 206 | {
|
207 | 207 | var result = validationHandler.Validate(context, model);
|
208 |
| - if (result.TryGetError(out var error)) |
209 |
| - return error; |
| 208 | + if (result.HasProblems(out var problems)) |
| 209 | + return problems; |
210 | 210 | }
|
211 | 211 |
|
212 | 212 | var rootEntity = await context.Repository<TRootEntity>().FindAsync(id!);
|
213 | 213 | if (rootEntity is null)
|
214 |
| - return ResultMessage.NotFound(CommandsErrorMessages.CreateNotFoundMessage<TRootEntity>(id), nameof(id)); |
215 |
| - |
216 |
| - var creationContextResult = await creationHandler.CreateContextAsync(context, model, rootEntity, token); |
217 |
| - if (creationContextResult.IsFailureOrGetValue(out var creationContext)) |
218 |
| - return creationContextResult.Convert<TEntity>(); |
219 |
| - |
220 |
| - if (creationContext is IValidableContext validable) |
221 |
| - { |
222 |
| - var result = validable.Validate(); |
223 |
| - if (result.TryGetError(out var error)) |
224 |
| - return error; |
225 |
| - } |
226 |
| - |
227 |
| - var entity = creationHandler.Create(creationContext); |
228 |
| - context.Repository<TEntity>().Add(entity); |
229 |
| - |
230 |
| - var saveResult = await context.SaveAsync(token); |
231 |
| - return saveResult.Convert(entity); |
| 214 | + return Problems.NotFound(CommandsErrorMessages.CreateNotFoundMessage<TRootEntity>(id), nameof(id)); |
| 215 | + |
| 216 | + return await creationHandler.CreateContextAsync(context, model, rootEntity, token) |
| 217 | + .MapAsync(async creationContext => |
| 218 | + { |
| 219 | + if (creationContext is IValidableContext validable) |
| 220 | + { |
| 221 | + var result = validable.Validate(); |
| 222 | + if (result.HasProblems(out var problems)) |
| 223 | + return problems; |
| 224 | + } |
| 225 | + |
| 226 | + var entity = creationHandler.Create(creationContext); |
| 227 | + context.Repository<TEntity>().Add(entity); |
| 228 | + |
| 229 | + var saveResult = await context.SaveAsync(token); |
| 230 | + return saveResult.Map(entity); |
| 231 | + }); |
232 | 232 | }
|
233 | 233 | }
|
0 commit comments