void IOperationCallbackManager.SetResult(IOperationResult result)
{
if (SetResult == null)
Tracer.Warn("OperationCallbackManagerMock: SetResult == null");
else
SetResult(result.Source, result);
}
/// <summary>
/// Copy properties from one IOperationResult to another. Does not use reflection.
/// Ony LCD properties are copied
/// </summary>
/// <param name="target"></param>
public static void Copy(this IOperationResult source, IOperationResult target)
{
target.Message = source.Message;
target.Success = source.Success;
target.Exception = source.Exception;
target.StatusCode = source.StatusCode;
}
public NestedOperationResult(string messageIfFailure, IOperationResult subOperationResult)
: base(messageIfFailure)
{
this.Setup();
this.SubOperationResults.Add(subOperationResult);
}
/// <summary>
/// Determines whether the specified response has persisted and if it has,
/// increases the <see cref="_persistedToCount"/> by one.
/// </summary>
/// <param name="response">The response.</param>
/// <returns></returns>
public void CheckPersisted(IOperationResult<ObserveSeqnoResponse> response)
{
var persisted = response.Value.LastPersistedSeqno >= Token.SequenceNumber;
if (persisted)
{
Interlocked.Increment(ref _persistedToCount);
}
}
/// <summary>
/// Combine will attempt to minimize the depth of InnerResults and maintain status codes
/// </summary>
/// <param name="target"></param>
public static void Combine(this IOperationResult source, IOperationResult target)
{
target.Message = source.Message;
target.Success = source.Success;
target.Exception = source.Exception;
target.StatusCode = source.StatusCode ?? target.StatusCode;
target.InnerResult = source.InnerResult ?? source;
}
public static void IsSuccessful(IOperationResult result)
{
if (!result.Success) {
var messages = result.Messages.ToArray();
messages.ForEach(Console.WriteLine);
Assert.Fail("Operation should succeed but failed with {0} message(s)",
messages.Length);
}
}
public void Invoke(IOperationResult result)
{
Should.NotBeNull(result, "result");
if (_asyncOperation == null)
{
if (_callback != null)
_callback.Invoke(result);
}
else
_asyncOperation.SetResult(result, true);
}
public IOperationResult DeleteEvent(Event ev)
{
Result.Reset();
Result = eventContext.Delete(ev);
if (Result.IsError)
{
Result.CustomMessage = "There was a problem deleting the requested Event";
}
return Result;
}
public IOperationResult DeleteRepeatType(RepeatType repeatType)
{
Result.Reset();
Result = repeatTypeContext.Delete(repeatType);
if (Result.IsError)
{
Result = repeatTypeContext.Result;
Result.CustomMessage = "There was a problem deleting the requested RepeatType";
}
return Result;
}
/* ----- Public Methods ----- */
public IOperationResult CreateEvent(Event ev)
{
Result.Reset();
Result = eventContext.Create(ev);
if (Result.IsError)
{
Result = eventContext.Result;
Result.CustomMessage = "There was a problem creating the Event";
}
return Result;
}
private static string ErrorFormatForOperation(IOperationResult result)
{
SourceResult result2 = result as SourceResult;
if (result2 != null)
{
switch (result2.Operation)
{
case SourceOperationType.LoadingCache:
return null;
case SourceOperationType.LoadingCacheFile:
return Resources.ErrLoadingCache;
case SourceOperationType.Verifying:
return null;
case SourceOperationType.VerifyingFile:
return Resources.ErrVerifyingFile;
case SourceOperationType.FileSystemChange:
return Resources.ErrFileSystemChange;
}
return Resources.UnknownOperation;
}
SyncResult result3 = result as SyncResult;
if (result3 != null)
{
switch (result3.Operation)
{
case SyncOperationType.TransferTo:
return Resources.ErrCopyToPhone;
case SyncOperationType.TransferFrom:
return Resources.ErrCopyToPc;
case SyncOperationType.DeferredTransferTo:
return Resources.ErrTranscode;
case SyncOperationType.Update:
return Resources.ErrUpdatePhone;
case SyncOperationType.Delete:
return Resources.ErrDeleteFromPhone;
}
}
return Resources.UnknownOperation;
}
public object Invoke(IOperationResult result)
{
var outType = Type.GetType(OutputType, true);
try
{
if (InputType != null)
{
var inType = Type.GetType(InputType, true);
result = OperationResult.Convert(inType, result);
}
if (MainCallback != null)
{
object obj = MainCallback.Invoke(result);
if (IsFunc)
result = OperationResult.CreateResult(outType, result.Operation, result.Source, obj,
result.OperationContext);
else
result = OperationResult.Convert(outType, result);
}
}
catch (Exception e)
{
Tracer.Error(e.Flatten(false));
if (result.Exception != null)
e = new AggregateException(result.Exception, e);
else if (e is OperationCanceledException)
e = null;
if (e == null)
result = OperationResult.CreateCancelResult(outType, result.Operation, result.Source,
result.OperationContext);
else
result = OperationResult.CreateErrorResult(outType, result.Operation, result.Source,
e, result.OperationContext);
}
finally
{
if (Callbacks != null)
{
for (int i = 0; i < Callbacks.Count; i++)
((ISerializableCallback)Callbacks[i]).Invoke(result);
}
}
return null;
}
public RepeatType ReadRepeatType(long repeatTypeID)
{
Result.Reset();
RepeatType repeatType = repeatTypeContext.Read(repeatTypeID);
if (repeatType == null)
{
Result.CustomMessage = "Could not find the requested RepeatType";
}
if (repeatTypeContext.Result.IsError)
{
Result = repeatTypeContext.Result;
Result.CustomMessage = "There was a problem retrieving the requested RepeatType";
}
return repeatType;
}
/* ----- Constructors ----- */
public RepeatTypeService(IOperationResult result, IRepeatTypeRepository repeatTypeR)
{
_result = result;
repeatTypeContext = repeatTypeR;
}
public void OnNext(IOperationResult <string> value)
{
LastResult = value;
}
private void CallbackMethod(IOperationResult <bool> result)
{
Result = result;
}
public bool Restore(Type targetType, object target, Dictionary <Type, object> items, ICollection <IViewModel> viewModels, string awaiterResultType, IOperationResult result)
{
var field = targetType.GetFieldEx(Name, MemberFlags.NonPublic | MemberFlags.Public | MemberFlags.Instance);
if (field == null)
{
TraceError(null, targetType);
return(false);
}
switch (FieldType)
{
case BuilderField:
var type = Type.GetType(TypeName, true);
var createMethod = type.GetMethodEx("Create", MemberFlags.NonPublic | MemberFlags.Public | MemberFlags.Static);
if (createMethod == null)
{
TraceError(field, targetType);
return(false);
}
var startMethod = type.GetMethodEx("Start", MemberFlags.NonPublic | MemberFlags.Public | MemberFlags.Instance);
if (startMethod == null || !startMethod.IsGenericMethodDefinition)
{
TraceError(field, targetType);
return(false);
}
var builder = createMethod.Invoke(null, Empty.Array <object>());
field.SetValueEx(target, builder);
startMethod.MakeGenericMethod(typeof(IAsyncStateMachine))
.Invoke(builder, new[] { target });
break;
case AwaiterField:
var awaiterType = typeof(SerializableAwaiter <>).MakeGenericType(Type.GetType(awaiterResultType, true));
var instance = Activator.CreateInstance(awaiterType, result);
field.SetValueEx(target, instance);
break;
case AnonymousClass:
var anonType = Type.GetType(TypeName, true);
object anonClass;
if (!items.TryGetValue(anonType, out anonClass))
{
anonClass = ServiceProvider.IocContainer.Get(anonType);
foreach (var snapshot in Snapshots)
{
snapshot.Restore(anonType, anonClass, items, viewModels, awaiterResultType, result);
}
items[anonType] = anonClass;
}
field.SetValueEx(target, anonClass);
break;
case NonSerializableField:
object service;
if (State == null)
{
var serviceType = Type.GetType(TypeName, true);
if (!items.TryGetValue(serviceType, out service))
{
service = ServiceProvider.IocContainer.Get(serviceType);
items[serviceType] = service;
}
}
else
{
var restoreValueState = RestoreValueState;
service = restoreValueState == null ? State : restoreValueState(State);
}
field.SetValueEx(target, service);
break;
case SerializableField:
field.SetValueEx(target, IsType ? Type.GetType((string)State, false) : State);
break;
case ViewModelField:
var viewModel = FindViewModel(viewModels);
if (viewModel == null)
{
TraceError(field, targetType);
return(false);
}
field.SetValueEx(target, viewModel);
break;
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="CouchbaseWriteException"/> class.
/// </summary>
/// <param name="failedResult">The <see cref="IOperationResult"/> of the failed operation.</param>
public CouchbaseWriteException(IOperationResult failedResult)
: base(failedResult.Message, failedResult.Exception)
{
_failedResult = failedResult;
}
/// <summary>
/// Invokes the callback using the specified operation result.
/// </summary>
void IOperationCallback.Invoke(IOperationResult result)
{
Invoke(result);
}
public DocumentExistsException(IOperationResult result, string key)
: base(result, key)
{
}
public SerializableAwaiter(IOperationResult result)
{
_result = result;
}
/* ----- Constructors ----- */
public EventService(IOperationResult result, IEventRepository eventR)
{
_result = result;
eventContext = eventR;
}
TResult IAsyncOperationAwaiter <TResult> .GetResult()
{
IOperationResult result = _result ?? _operation.Result;
return((TResult)result.Result);
}
/// <summary>
/// 审核业务对象
/// </summary>
/// <param name="ctx"></param>
/// <param name="formID">业务对象标识</param>
/// <param name="ids">业务对象ID集合</param>
/// <returns></returns>
public static IOperationResult Audit(Context ctx, string formID, Object[] ids)
{
ICommonService service = TLMBServiceFactory.GetService<ICommonService>(ctx);
IOperationResult auditResult = service.AuditBill(ctx, formID, ids);
return auditResult;
}
void IAsyncOperationAwaiter.GetResult()
{
IOperationResult result = _result ?? _operation.Result;
var o = result.Result;
}
public void CallbackAnonMethod(IOperationResult <bool> result, NavigableViewModelMock vm)
{
ResultAnon = result;
ViewModel = vm;
}
public CouchbaseDataException(IOperationResult result)
: this(result.Message, result.Exception)
{
Status = result.Status;
}
public List<RepeatType> GetAllRepeatTypes()
{
Result.Reset();
List<RepeatType> repeatTypes = repeatTypeContext.GetAll().ToList();
if (repeatTypes == null)
{
Result.CustomMessage = "Could not find the requested RepeatTypes";
}
if (repeatTypeContext.Result.IsError)
{
Result = repeatTypeContext.Result;
Result.CustomMessage = "There was a problem retrieving the requested RepeatTypes";
}
return repeatTypes;
}
public CouchbaseServerException(IOperationResult result, string key)
: base(result, key)
{
}
public DocumentNotFoundException(IOperationResult result, string key)
: base(result, key)
{
}
/// <summary>
/// 记录操作日志
/// </summary>
/// <param name="ctx"></param>
/// <param name="Operation">操作标识</param>
/// <param name="returnResult">操作结果</param>
/// <returns></returns>
public static void Log(Context ctx, string Operation, IOperationResult returnResult)
{
ICommonService service = TLMBServiceFactory.GetService<ICommonService>(ctx);
service.Log(ctx, Operation, returnResult);
}
public void Invoke(IOperationResult result)
{
_continuation();
}
public CouchbaseAuthenticationException(IOperationResult result)
: base(result)
{
}
public CouchbaseDataException(IOperationResult result, string key)
: this(result.Message, result.Exception)
{
Status = result.Status;
Key = key;
}
/// <summary>
/// Copy properties from one IOperationResult to another. Does not use reflection.
/// Ony LCD properties are copied
/// </summary>
/// <param name="target"></param>
public static IOperationResult PassOrFail(this IOperationResult source, bool success, string message = "", Exception ex = null)
{
return(success ? Pass(source) : Fail(source, message, ex));
}
/// <summary>
/// Invokes the callback using the specified operation result.
/// </summary>
object ISerializableCallback.Invoke(IOperationResult result)
{
if (Invoke == null)
return null;
return Invoke(result);
}
public void CallbackAnonMethod(IOperationResult<bool> result, NavigableViewModelMock vm)
{
ResultAnon = result;
ViewModel = vm;
}
public CouchbaseClientException(IOperationResult result, string key)
: base(result, key)
{
}
private void CallbackMethod(IOperationResult<bool> result)
{
Result = result;
}
private string Result(IOperationResult result, bool formatTypeJson)
{
string jsonResult = Newtonsoft.Json.JsonConvert.SerializeObject(result);
if (formatTypeJson)
return jsonResult;
else
return Newtonsoft.Json.JsonConvert.DeserializeObject(jsonResult).ToString();
}
public static bool AddCheck(Context ctx, IList <BudgetCtrlPlateformMain> lstHeaders, IList <BudgetCtrlPlateformEntity> LstDetails, IOperationResult operResult)
{
bool flag;
IBudgetCtrlPlateformService service = ServiceFactory.GetService <IBudgetCtrlPlateformService>(ctx);
try
{
flag = service.AddCheck(ctx, lstHeaders, LstDetails, operResult);
}
finally
{
ServiceFactory.CloseService(service);
}
return(flag);
}
public List<DateTime> GetAllEventDatesFromMonth(int year, int month)
{
Result.Reset();
List<DateTime> eventDates = eventContext.GetAllEventDatesFromMonth(year, month).ToList<DateTime>();
if (eventDates == null)
{
Result.CustomMessage = "Could not find the requested Event Dates";
}
if (eventContext.Result.IsError)
{
Result = eventContext.Result;
Result.CustomMessage = "There was a problem retrieving the requested Event Dates";
}
return eventDates;
}
/// <summary>
/// Set the result Success to true
/// </summary>
/// <param name="source">Result to update</param>
/// <param name="message">Message indicating a possible warning</param>
/// <returns>Updated source</returns>
public static IOperationResult Pass(this IOperationResult source, string message = null)
{
source.Success = true;
source.Message = message;
return(source);
}
