/// <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); } } }