|
public static ThrowFaultException ( |
||
| ex | Exception to handle | |
| Результат | void | |
/// <summary>
/// Sets the content stream of the given Document instance ID
/// </summary>
/// <param name="blob">Information about the given blob</param>
/// <returns>the newly created Blob instance</returns>
public BlobResponse SetBlobStream(BlobMessage blob)
{
using (Logging.Facade.DebugTraceMethodCall("SetBlobStream"))
{
if (blob == null)
{
throw new ArgumentNullException("blob");
}
try
{
DebugLogIdentity();
using (IZetboxContext ctx = _ctxFactory())
{
var result = _sohFactory
.GetServerDocumentHandler()
.SetBlobStream(blob.Version, ctx, blob.Stream, blob.FileName, blob.MimeType);
BlobResponse resp = new BlobResponse();
resp.ID = result.ID;
resp.BlobInstance = SendObjects(new IDataObject[] { result }, true);
return(resp);
}
}
catch (Exception ex)
{
Helper.ThrowFaultException(ex);
// Never called, Handle errors throws an Exception
return(null);
}
}
}
/// <summary>
/// Fetches a list of CollectionEntry objects of the Relation
/// <paramref name="relId"/> which are owned by the object with the
/// ID <paramref name="parentObjID"/> in the role <paramref name="serializableRole"/>.
/// </summary>
/// <param name="version">Current version of generated Zetbox.Objects assembly</param>
/// <param name="relId">the requested Relation</param>
/// <param name="serializableRole">the parent role (1 == A, 2 == B)</param>
/// <param name="parentObjID">the ID of the parent object</param>
/// <returns>the requested collection entries</returns>
public byte[] FetchRelation(Guid version, Guid relId, int serializableRole, int parentObjID)
{
using (Logging.Facade.DebugTraceMethodCallFormat("FetchRelation", "relId = [{0}], role = [{1}], parentObjID = [{2}]", relId, serializableRole, parentObjID))
{
try
{
DebugLogIdentity();
using (IZetboxContext ctx = _ctxFactory())
{
var endRole = (RelationEndRole)serializableRole;
// TODO: Use FrozenContext
Relation rel = ctx.FindPersistenceObject <Relation>(relId);
var ifTypeA = _iftFactory(rel.A.Type.GetDataType());
var ifTypeB = _iftFactory(rel.B.Type.GetDataType());
var ifType = endRole == RelationEndRole.A ? ifTypeA : ifTypeB;
int resultCount = 0;
var ticks = _perfCounter.IncrementFetchRelation(ifType);
try
{
var lst = _sohFactory
.GetServerCollectionHandler(
ctx,
ifTypeA,
ifTypeB,
endRole)
.GetCollectionEntries(version, ctx, relId, endRole, parentObjID);
resultCount = lst.Count();
return(SendObjects(lst.Cast <IStreamable>(), true).ToArray());
}
finally
{
_perfCounter.DecrementFetchRelation(ifType, resultCount, ticks);
}
}
}
catch (Exception ex)
{
Helper.ThrowFaultException(ex);
// Never called, Handle errors throws an Exception
return(null);
}
}
}
/// <summary>
/// Puts a number of changed objects into the database. The resultant objects are sent back to the client.
/// </summary>
/// <param name="version">Current version of generated Zetbox.Objects assembly</param>
/// <param name="msgArray">a streamable list of <see cref="IPersistenceObject"/>s</param>
/// <param name="notificationRequests">A list of objects the client wants to be notified about, if they change.</param>
/// <returns>a streamable list of <see cref="IPersistenceObject"/>s</returns>
public byte[] SetObjects(Guid version, byte[] msgArray, ObjectNotificationRequest[] notificationRequests)
{
using (Logging.Facade.DebugTraceMethodCall("SetObjects"))
{
DebugLogIdentity();
int resultCount = 0;
var ticks = _perfCounter.IncrementSetObjects();
try
{
if (msgArray == null)
{
throw new ArgumentNullException("msgArray");
}
MemoryStream msg = new MemoryStream(msgArray);
msg.Seek(0, SeekOrigin.Begin);
using (IZetboxContext ctx = _ctxFactory())
{
var objects = ReadObjects(msg, ctx);
// Set Operation
var changedObjects = _sohFactory
.GetServerObjectSetHandler()
.SetObjects(version, ctx, objects, notificationRequests ?? new ObjectNotificationRequest[0])
.Cast <IStreamable>();
resultCount = objects.Count;
return(SendObjects(changedObjects, true).ToArray());
}
}
catch (Exception ex)
{
Helper.ThrowFaultException(ex);
// Never called, Handle errors throws an Exception
return(null);
}
finally
{
_perfCounter.DecrementSetObjects(resultCount, ticks);
}
}
}
/// <summary>
/// Returns a list of objects from the datastore, matching the specified filters.
/// </summary>
/// <param name="version">Current version of generated Zetbox.Objects assembly</param>
/// <param name="type">Type of Objects</param>
/// <param name="maxListCount">Max. ammount of objects</param>
/// <param name="eagerLoadLists">If true list properties will be eager loaded</param>
/// <param name="filter">Serializable linq expression used a filter</param>
/// <param name="orderBy">List of derializable linq expressions used as orderby</param>
/// <returns>the found objects</returns>
public byte[] GetList(Guid version, SerializableType type, int maxListCount, bool eagerLoadLists, SerializableExpression[] filter, OrderByContract[] orderBy)
{
using (Logging.Facade.DebugTraceMethodCallFormat("GetList", "type={0}", type))
{
DebugLogIdentity();
try
{
if (type == null)
{
throw new ArgumentNullException("type");
}
var ifType = _iftFactory(type.GetSystemType());
int resultCount = 0;
var ticks = _perfCounter.IncrementGetList(ifType);
try
{
using (IZetboxContext ctx = _ctxFactory())
{
var filterExpresstions = filter != null?filter.Select(f => SerializableExpression.ToExpression(f)).ToList() : null;
IEnumerable <IStreamable> lst = _sohFactory
.GetServerObjectHandler(ifType)
.GetList(version, ctx, maxListCount,
filterExpresstions,
orderBy != null ? orderBy.Select(o => new OrderBy(o.Type, SerializableExpression.ToExpression(o.Expression))).ToList() : null);
resultCount = lst.Count();
return(SendObjects(lst, eagerLoadLists).ToArray());
}
}
finally
{
_perfCounter.DecrementGetList(ifType, resultCount, ticks);
}
}
catch (Exception ex)
{
Helper.ThrowFaultException(ex);
// Never called, Handle errors throws an Exception
return(null);
}
}
}
public byte[] GetListOf(Guid version, SerializableType type, int ID, string property)
{
using (Logging.Facade.DebugTraceMethodCallFormat("GetListOf", "type={0}", type))
{
DebugLogIdentity();
try
{
if (type == null)
{
throw new ArgumentNullException("type");
}
using (var ctx = _ctxFactory())
{
var ifType = _iftFactory(type.GetSystemType());
int resultCount = 0;
var ticks = _perfCounter.IncrementGetListOf(ifType);
try
{
IEnumerable <IStreamable> lst = _sohFactory
.GetServerObjectHandler(ifType)
.GetListOf(version, ctx, ID, property);
resultCount = lst.Count();
return(SendObjects(lst, false /*true*/).ToArray());
}
finally
{
_perfCounter.DecrementGetListOf(ifType, resultCount, ticks);
}
}
}
catch (Exception ex)
{
Helper.ThrowFaultException(ex);
// Never called, Handle errors throws an Exception
return(null);
}
}
}
/// <summary>
/// Gets the content stream of the given Document instance ID
/// </summary>
/// <param name="version">Current version of generated Zetbox.Objects assembly</param>
/// <param name="ID">ID of an valid Document instance</param>
/// <returns>Stream containing the Document content</returns>
public Stream GetBlobStream(Guid version, int ID)
{
using (Logging.Facade.DebugTraceMethodCallFormat("GetBlobStream", "ID={0}", ID))
{
try
{
DebugLogIdentity();
using (IZetboxContext ctx = _ctxFactory())
{
return(_sohFactory
.GetServerDocumentHandler()
.GetBlobStream(version, ctx, ID));
}
}
catch (Exception ex)
{
Helper.ThrowFaultException(ex);
// Never called, Handle errors throws an Exception
return(null);
}
}
}
public byte[] InvokeServerMethod(Guid version, SerializableType type, int ID, string method, SerializableType[] parameterTypes, byte[] parameterArray, byte[] changedObjectsArray, ObjectNotificationRequest[] notificationRequests, out byte[] retChangedObjects)
{
using (Logging.Facade.DebugTraceMethodCallFormat("InvokeServerMethod:" + method, "method={0}, ID={1}", method, ID))
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (string.IsNullOrEmpty(method))
{
throw new ArgumentNullException("method");
}
if (parameterTypes == null)
{
throw new ArgumentNullException("parameterTypes");
}
if (parameterArray == null)
{
throw new ArgumentNullException("parameterArray");
}
if (changedObjectsArray == null)
{
throw new ArgumentNullException("changedObjectsArray");
}
_perfCounter.IncrementServerMethodInvocation();
retChangedObjects = null;
try
{
DebugLogIdentity();
using (IZetboxContext ctx = _ctxFactory())
{
var parameter = new MemoryStream(parameterArray);
parameter.Seek(0, SeekOrigin.Begin);
List <object> parameterList = new List <object>();
var parameterReader = _readerFactory(new BinaryReader(parameter));
foreach (var t in parameterTypes)
{
object val;
parameterReader.Read(out val,
t.GetSystemType().IsIStreamable()
? ctx.ToImplementationType(ctx.GetInterfaceType(t.GetSystemType())).Type
: t.GetSystemType());
parameterList.Add(val);
}
var changedObjects = new MemoryStream(changedObjectsArray);
changedObjects.Seek(0, SeekOrigin.Begin);
IEnumerable <IPersistenceObject> changedObjectsList;
var result = _sohFactory
.GetServerObjectHandler(_iftFactory(type.GetSystemType()))
.InvokeServerMethod(version, ctx, ID, method,
parameterTypes.Select(t => t.GetSystemType()),
parameterList,
ReadObjects(changedObjects, ctx),
notificationRequests ?? new ObjectNotificationRequest[0],
out changedObjectsList);
retChangedObjects = SendObjects(changedObjectsList.Cast <IStreamable>(), true).ToArray();
if (Logging.Facade.IsDebugEnabled && result != null)
{
Logging.Facade.DebugFormat("Serializing method result type is '{0}'", result.GetType().FullName);
}
if (result != null && result.GetType() == typeof(string))
{
Logging.Facade.Debug("Serializing method result as string");
// string is also a IEnumerable, but FindElementTypes returns nothing
MemoryStream resultStream = new MemoryStream();
new BinaryFormatter().Serialize(resultStream, result);
return(resultStream.ToArray());
}
else if (result != null && result.GetType().IsIStreamable())
{
Logging.Facade.Debug("Serializing method result as IStreamable");
IStreamable resultObj = (IStreamable)result;
return(SendObjects(new IStreamable[] { resultObj }, true).ToArray());
}
else if (result != null && result.GetType().IsIEnumerable() && result.GetType().FindElementTypes().Any(t => t.IsIStreamable()))
{
Logging.Facade.Debug("Serializing method result as IEnumerable<IStreamable>");
var lst = ((IEnumerable)result).AsQueryable().Cast <IStreamable>().Take(Zetbox.API.Helper.MAXLISTCOUNT);
return(SendObjects(lst, true).ToArray());
}
else if (result != null)
{
Logging.Facade.Debug("Serializing method result as object with BinaryFormatter");
MemoryStream resultStream = new MemoryStream();
new BinaryFormatter().Serialize(resultStream, result);
return(resultStream.ToArray());
}
else
{
Logging.Facade.Debug("Serializing empty method");
return(new byte[] { });
}
}
}
catch (Exception ex)
{
Helper.ThrowFaultException(ex);
// Never called, Handle errors throws an Exception
return(null);
}
}
}