public DataPortalAsyncResult(T result, Csla.Core.ContextDictionary globalContext, Exception error, object userState)
{
this.Result = result;
this.GlobalContext = globalContext;
this.UserState = userState;
this.Error = error;
}
/// <summary>
/// Executes when the async operation is completed.
///
/// Set the global context and then call the RunWorkerCompleted
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.ComponentModel.RunWorkerCompletedEventArgs"/> instance containing the event data.</param>
private void InternalRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
Exception error = null;
object result = null;
if (!e.Cancelled)
{
var workerResult = (WorkerAsyncResult)e.Result;
// always set GlobalContext returned in the BW
// so it can be addressed in RunWorkerCompleted.
GlobalContext = workerResult.GlobalContext;
// must check for error as accessing e.Result will throw exception
// if e.Error is not null.
error = workerResult.Error;
if (workerResult.Error == null)
{
result = workerResult.Result;
}
}
if (_myWorkerCompleted != null)
{
_myWorkerCompleted.Invoke(this, new RunWorkerCompletedEventArgs(result, error, e.Cancelled));
}
}
internal async Task DoDeleteAsync(Type objectType, object criteria, bool isSync)
{
Server.DataPortalResult result = null;
Server.DataPortalContext dpContext = null;
try
{
DataPortal.OnDataPortalInitInvoke(null);
if (!Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.DeleteObject, objectType, Server.DataPortal.GetCriteriaArray(criteria)))
{
throw new Csla.Security.SecurityException(string.Format(Resources.UserNotAuthorizedException,
"delete",
objectType.Name));
}
var method = Reflection.ServiceProviderMethodCaller.FindDataPortalMethod <DeleteAttribute>(objectType, Server.DataPortal.GetCriteriaArray(criteria), false);
var proxy = GetDataPortalProxy(objectType, method);
dpContext = new Server.DataPortalContext(GetPrincipal(), proxy.IsServerRemote);
DataPortal.OnDataPortalInvoke(new DataPortalEventArgs(dpContext, objectType, criteria, DataPortalOperations.Delete));
try
{
result = await proxy.Delete(objectType, criteria, dpContext, isSync);
}
catch (AggregateException ex)
{
if (ex.InnerExceptions.Count > 0)
{
var dpe = ex.InnerExceptions[0] as Server.DataPortalException;
if (dpe != null)
{
HandleDeleteDataPortalException(dpe, isSync, proxy);
}
}
throw new DataPortalException(
string.Format("DataPortal.Delete {0}", Resources.Failed),
ex, null);
}
catch (Server.DataPortalException ex)
{
HandleDeleteDataPortalException(ex, isSync, proxy);
}
GlobalContext = result.GlobalContext;
if (proxy.IsServerRemote && isSync)
{
ApplicationContext.ContextManager.SetGlobalContext(result.GlobalContext);
}
DataPortal.OnDataPortalInvokeComplete(new DataPortalEventArgs(dpContext, objectType, criteria, DataPortalOperations.Delete));
}
catch (Exception ex)
{
DataPortal.OnDataPortalInvokeComplete(new DataPortalEventArgs(dpContext, objectType, criteria, DataPortalOperations.Delete, ex));
throw;
}
}
private void Delete_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
{
if (e.Error == null)
{
var result = e.Result as DataPortalAsyncResult;
if (result != null)
{
_globalContext = result.GlobalContext;
OnDeleteCompleted(new DataPortalResult <T>(default(T), result.Error, result.UserState));
return;
}
}
OnDeleteCompleted(new DataPortalResult <T>(default(T), e.Error, null));
}
private void HandleDataPortalException(string operation, Server.DataPortalException ex, bool isSync, Csla.DataPortalClient.IDataPortalProxy proxy)
{
var result = ex.Result;
GlobalContext = result.GlobalContext;
if (proxy.IsServerRemote && isSync)
{
ApplicationContext.ContextManager.SetGlobalContext(GlobalContext);
}
var original = ex.InnerException;
if (original.InnerException != null)
{
original = original.InnerException;
}
throw new DataPortalException(
String.Format("DataPortal.{2} {0} ({1})", Resources.Failed, original.Message, operation),
ex.InnerException, result.ReturnObject);
}
public WorkerAsyncResult(object result, Csla.Core.ContextDictionary globalContext, Exception error)
{
this.Result = result;
this.GlobalContext = globalContext;
this.Error = error;
}
private async Task <object> DoCreateAsync(Type objectType, object criteria, bool isSync)
{
Server.DataPortalResult result = null;
Server.DataPortalContext dpContext = null;
try
{
DataPortal.OnDataPortalInitInvoke(null);
if (!Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.CreateObject, objectType))
{
throw new Csla.Security.SecurityException(string.Format(
Resources.UserNotAuthorizedException,
"create",
objectType.Name));
}
var method = Server.DataPortalMethodCache.GetCreateMethod(objectType, criteria);
DataPortalClient.IDataPortalProxy proxy;
proxy = GetDataPortalProxy(objectType, method.RunLocal);
dpContext =
new Csla.Server.DataPortalContext(GetPrincipal(), proxy.IsServerRemote);
DataPortal.OnDataPortalInvoke(new DataPortalEventArgs(dpContext, objectType, criteria, DataPortalOperations.Create));
try
{
result = await proxy.Create(objectType, criteria, dpContext, isSync);
GlobalContext = result.GlobalContext;
if (isSync && proxy.IsServerRemote)
{
ApplicationContext.ContextManager.SetGlobalContext(GlobalContext);
}
}
catch (AggregateException ex)
{
if (ex.InnerExceptions.Count > 0)
{
var dpe = ex.InnerExceptions[0] as Server.DataPortalException;
if (dpe != null)
{
HandleCreateDataPortalException(dpe, isSync, proxy);
}
}
throw new DataPortalException(
string.Format("DataPortal.Create {0}", Resources.Failed),
ex, null);
}
catch (Server.DataPortalException ex)
{
HandleCreateDataPortalException(ex, isSync, proxy);
}
DataPortal.OnDataPortalInvokeComplete(new DataPortalEventArgs(dpContext, objectType, criteria, DataPortalOperations.Create));
}
catch (Exception ex)
{
DataPortal.OnDataPortalInvokeComplete(new DataPortalEventArgs(dpContext, objectType, criteria, DataPortalOperations.Create, ex));
throw;
}
return(result.ReturnObject);
}
internal async Task <T> DoUpdateAsync(T obj, bool isSync)
{
Server.DataPortalResult result = null;
Server.DataPortalContext dpContext = null;
DataPortalOperations operation = DataPortalOperations.Update;
Type objectType = obj.GetType();
try
{
DataPortal.OnDataPortalInitInvoke(null);
Csla.Server.DataPortalMethodInfo method = null;
var factoryInfo = Csla.Server.ObjectFactoryAttribute.GetObjectFactoryAttribute(objectType);
if (factoryInfo != null)
{
var factoryType = Csla.Server.FactoryDataPortal.FactoryLoader.GetFactoryType(factoryInfo.FactoryTypeName);
if (obj is Core.ICommandObject)
{
if (!Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.EditObject, obj))
{
throw new Csla.Security.SecurityException(string.Format(Resources.UserNotAuthorizedException,
"execute",
objectType.Name));
}
if (factoryType != null)
{
method = Server.DataPortalMethodCache.GetMethodInfo(factoryType, factoryInfo.ExecuteMethodName, new object[] { obj });
}
}
else
{
var bbase = obj as Core.BusinessBase;
if (bbase != null)
{
if (bbase.IsDeleted)
{
if (!Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.DeleteObject, obj))
{
throw new Csla.Security.SecurityException(string.Format(Resources.UserNotAuthorizedException,
"delete",
objectType.Name));
}
if (factoryType != null)
{
method = Server.DataPortalMethodCache.GetMethodInfo(factoryType, factoryInfo.DeleteMethodName,
new object[] { obj });
}
}
// must check the same authorization rules as for DataPortal_XYZ methods
else if (bbase.IsNew)
{
if (!Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.CreateObject, obj))
{
throw new Csla.Security.SecurityException(string.Format(Resources.UserNotAuthorizedException,
"create",
objectType.Name));
}
if (factoryType != null)
{
method = Server.DataPortalMethodCache.GetMethodInfo(factoryType, factoryInfo.UpdateMethodName,
new object[] { obj });
}
}
else
{
if (!Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.EditObject, obj))
{
throw new Csla.Security.SecurityException(string.Format(Resources.UserNotAuthorizedException,
"save",
objectType.Name));
}
if (factoryType != null)
{
method = Server.DataPortalMethodCache.GetMethodInfo(factoryType, factoryInfo.UpdateMethodName,
new object[] { obj });
}
}
}
else
{
if (!Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.EditObject, obj))
{
throw new Csla.Security.SecurityException(string.Format(Resources.UserNotAuthorizedException,
"save",
objectType.Name));
}
if (factoryType != null)
{
method = Server.DataPortalMethodCache.GetMethodInfo(factoryType, factoryInfo.UpdateMethodName,
new object[] { obj });
}
}
}
if (method == null)
{
method = new Csla.Server.DataPortalMethodInfo();
}
}
else
{
string methodName;
if (obj is Core.ICommandObject)
{
methodName = "DataPortal_Execute";
operation = DataPortalOperations.Execute;
if (!Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.EditObject, obj))
{
throw new Csla.Security.SecurityException(string.Format(Resources.UserNotAuthorizedException,
"execute",
objectType.Name));
}
}
else
{
var bbase = obj as Core.BusinessBase;
if (bbase != null)
{
if (bbase.IsDeleted)
{
methodName = "DataPortal_DeleteSelf";
if (!Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.DeleteObject, obj))
{
throw new Csla.Security.SecurityException(string.Format(Resources.UserNotAuthorizedException,
"delete",
objectType.Name));
}
}
else
if (bbase.IsNew)
{
methodName = "DataPortal_Insert";
if (!Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.CreateObject, obj))
{
throw new Csla.Security.SecurityException(string.Format(Resources.UserNotAuthorizedException,
"create",
objectType.Name));
}
}
else
{
methodName = "DataPortal_Update";
if (!Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.EditObject, obj))
{
throw new Csla.Security.SecurityException(string.Format(Resources.UserNotAuthorizedException,
"save",
objectType.Name));
}
}
}
else
{
methodName = "DataPortal_Update";
if (!Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.EditObject, obj))
{
throw new Csla.Security.SecurityException(string.Format(Resources.UserNotAuthorizedException,
"save",
objectType.Name));
}
}
}
method = Server.DataPortalMethodCache.GetMethodInfo(obj.GetType(), methodName);
}
DataPortalClient.IDataPortalProxy proxy;
proxy = GetDataPortalProxy(objectType, method.RunLocal);
dpContext =
new Server.DataPortalContext(GetPrincipal(), proxy.IsServerRemote);
DataPortal.OnDataPortalInvoke(new DataPortalEventArgs(dpContext, objectType, obj, operation));
try
{
if (!proxy.IsServerRemote && ApplicationContext.AutoCloneOnUpdate)
{
// when using local data portal, automatically
// clone original object before saving
ICloneable cloneable = obj as ICloneable;
if (cloneable != null)
{
obj = (T)cloneable.Clone();
}
}
result = await proxy.Update(obj, dpContext, isSync);
}
catch (AggregateException ex)
{
if (ex.InnerExceptions.Count > 0)
{
var dpe = ex.InnerExceptions[0] as Server.DataPortalException;
if (dpe != null)
{
HandleUpdateDataPortalException(dpe, isSync, proxy);
}
}
throw new DataPortalException(
string.Format("DataPortal.Update {0}", Resources.Failed),
ex, null);
}
catch (Server.DataPortalException ex)
{
HandleUpdateDataPortalException(ex, isSync, proxy);
}
GlobalContext = result.GlobalContext;
if (proxy.IsServerRemote && isSync)
{
ApplicationContext.ContextManager.SetGlobalContext(GlobalContext);
}
DataPortal.OnDataPortalInvokeComplete(new DataPortalEventArgs(dpContext, objectType, obj, operation));
}
catch (Exception ex)
{
DataPortal.OnDataPortalInvokeComplete(new DataPortalEventArgs(dpContext, objectType, obj, operation, ex));
throw;
}
return((T)result.ReturnObject);
}
/// <summary>
/// Executes when the async operation is completed.
///
/// Set the global context and then call the RunWorkerCompleted
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.ComponentModel.RunWorkerCompletedEventArgs"/> instance containing the event data.</param>
private void InternalRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
Exception error = null;
object result = null;
if (!e.Cancelled)
{
var workerResult = (WorkerAsyncResult)e.Result;
// always set GlobalContext returned in the BW
// so it can be addressed in RunWorkerCompleted.
GlobalContext = workerResult.GlobalContext;
// must check for error as accessing e.Result will throw exception
// if e.Error is not null.
error = workerResult.Error;
if (workerResult.Error == null)
{
result = workerResult.Result;
}
}
if (_myWorkerCompleted != null)
{
_myWorkerCompleted.Invoke(this, new RunWorkerCompletedEventArgs(result, error, e.Cancelled));
}
}
