Exemplo n.º 1
0
        /// <summary>
        /// Checks if the provided repository path exists and creates the missing containers all the way up to the root.
        /// </summary>
        /// <param name="path">The path to create containers for.</param>
        /// <param name="containerTypeName">Optional: content type name of created containers. Default is Folder.</param>
        /// <param name="server">Target server.</param>
        /// <returns>The newly created container. If it already exists, this method returns null.</returns>
        public static async Task <Content> EnsurePathAsync(string path, string containerTypeName = null,
                                                           ServerContext server = null)
        {
            if (string.IsNullOrEmpty(path) || string.CompareOrdinal(path, "/Root") == 0)
            {
                return(null);
            }

            if (await Content.ExistsAsync(path, server).ConfigureAwait(false))
            {
                return(null);
            }

            var parentPath = RepositoryPath.GetParentPath(path);

            // ensure parent
            await EnsurePathAsync(parentPath, containerTypeName, server).ConfigureAwait(false);

            var name   = RepositoryPath.GetFileName(path);
            var folder = Content.CreateNew(parentPath, containerTypeName ?? "Folder", name, null, server);

            try
            {
                await folder.SaveAsync().ConfigureAwait(false);

                return(folder);
            }
            catch (ClientException ex)
            {
                // this particular exception is not an error, so move on
                if (ex.ErrorData.ExceptionType == "NodeAlreadyExistsException")
                {
                    return(null);
                }

                throw;
            }
        }
Exemplo n.º 2
0
        private static HttpWebRequest CreateChunkUploadWebRequest(string url, ServerContext server, UploadData uploadData, string boundary, out Stream requestStream)
        {
            var myRequest = GetRequest(url, server);

            myRequest.Method      = "POST";
            myRequest.ContentType = "multipart/form-data; boundary=" + boundary;

            myRequest.Headers.Add("Content-Disposition", "attachment; filename=\"" + Uri.EscapeUriString(uploadData.FileName) + "\"");

            var boundarybytes = Encoding.ASCII.GetBytes("\r\n--" + boundary + "\r\n");

            // we must not close the stream after this as we need to write the chunk into it in the caller method
            requestStream = myRequest.GetRequestStream();

            //write form data values
            foreach (var kvp in uploadData.ToDictionary())
            {
                requestStream.Write(boundarybytes, 0, boundarybytes.Length);

                var formitem      = string.Format(UPLOAD_FORMDATA_TEMPLATE, kvp.Key, kvp.Value);
                var formitembytes = Encoding.UTF8.GetBytes(formitem);

                requestStream.Write(formitembytes, 0, formitembytes.Length);
            }

            //write a boundary
            requestStream.Write(boundarybytes, 0, boundarybytes.Length);

            //write file name and content type
            var header      = string.Format(UPLOAD_HEADER_TEMPLATE, "files[]", Uri.EscapeUriString(uploadData.FileName));
            var headerbytes = Encoding.UTF8.GetBytes(header);

            requestStream.Write(headerbytes, 0, headerbytes.Length);

            return(myRequest);
        }
Exemplo n.º 3
0
 /// <summary>
 /// Loads children of a container.
 /// </summary>
 /// <param name="path">Path of the container.</param>
 /// <param name="server">Target server.</param>
 /// <returns></returns>
 public static async Task <IEnumerable <Content> > LoadCollectionAsync(string path, ServerContext server = null)
 {
     return(await RESTCaller.GetCollectionAsync(path, server));
 }
Exemplo n.º 4
0
        /// <summary>
        /// Gets the raw response of a general HTTP request from the server.
        /// </summary>
        /// <param name="uri">Request URI.</param>
        /// <param name="method">HTTP method (SenseNet.Client.HttpMethods class has a few predefined methods).</param>
        /// <param name="body">Request body.</param>
        /// <param name="server">Target server.</param>
        /// <returns>Raw HTTP response.</returns>
        public static async Task <string> GetResponseStringAsync(Uri uri, ServerContext server = null, HttpMethod method = null, string body = null)
        {
            var retryCount = 0;

            while (retryCount < REQUEST_RETRY_COUNT)
            {
                SnTrace.Category(ClientContext.TraceCategory).Write("###>REQ: {0}", uri);

                var myRequest = GetRequest(uri, server);

                if (method != null)
                {
                    myRequest.Method = method.Method;
                }

                if (!string.IsNullOrEmpty(body))
                {
                    try
                    {
                        using (var requestWriter = new StreamWriter(myRequest.GetRequestStream()))
                        {
                            requestWriter.Write(body);
                        }
                    }
                    catch (Exception ex)
                    {
                        throw new ClientException("Error during writing to request stream: " + ex.Message, ex);
                    }
                }
                else
                {
                    myRequest.ContentLength = 0;
                }

                try
                {
                    using (var wr = await myRequest.GetResponseAsync())
                    {
                        return(await ReadResponseStringAsync(wr));
                    }
                }
                catch (WebException ex)
                {
                    var webResponse = ex.Response as HttpWebResponse;

                    // a 404 result is not an error in case of simple get requests, so return silently
                    if (webResponse != null && webResponse.StatusCode == HttpStatusCode.NotFound && (method == null || method != HttpMethod.Post))
                    {
                        return(null);
                    }

                    if (retryCount >= REQUEST_RETRY_COUNT - 1)
                    {
                        throw await GetClientExceptionAsync(ex, uri.ToString(), method, body);
                    }
                    else
                    {
                        var responseString = await ReadResponseStringAsync(ex.Response);

                        Thread.Sleep(50);

                        SnTrace.Category(ClientContext.TraceCategory).Write("###>REQ: {0} ERROR:{1}", uri,
                                                                            responseString.Replace(Environment.NewLine, " ").Replace("\r\n", " ") + " " + ex);
                    }
                }

                retryCount++;
            }

            return(string.Empty);
        }
Exemplo n.º 5
0
 /// <summary>
 /// Loads a content from the server. Use this method to specify a detailed
 /// content request, for example wich fields you want to expand or select.
 /// </summary>
 /// <param name="requestData">Detailed information that will be sent as part of the request.</param>
 /// <param name="server">Target server.</param>
 public static async Task <Content> LoadAsync(ODataRequest requestData, ServerContext server = null)
 {
     return(await RESTCaller.GetContentAsync(requestData, server));
 }
Exemplo n.º 6
0
        //----------------------------------------------------------------------------- Security

        /// <summary>
        /// Checks whether a user has the provided permissions on the content.
        /// </summary>
        /// <param name="permissions">Permission names to check.</param>
        /// <param name="user">The user who's permissions need to be checked. If it is not provided, the server checks the current user.</param>
        /// <param name="server">Target server.</param>
        public async Task <bool> HasPermissionAsync(string[] permissions, string user = null, ServerContext server = null)
        {
            return(await SecurityManager.HasPermissionAsync(this.Id, permissions, user, server));
        }
Exemplo n.º 7
0
        //============================================================================= Constructors

        /// <summary>
        /// Internal constructor for client content.
        /// </summary>
        /// <param name="server">Target server. If null, the first one will be used from the configuration.</param>
        protected Content(ServerContext server)
        {
            Server  = server ?? ClientContext.Current.Servers[0];
            _fields = new Dictionary <string, object>();
        }
Exemplo n.º 8
0
        /// <summary>
        /// Executes a query on the server and returns results filtered and expanded
        /// based on the provided parameters.
        /// </summary>
        /// <param name="queryText">Content query text.</param>
        /// <param name="select">Fields to select.</param>
        /// <param name="expand">Fields to expand.</param>
        /// <param name="settings">Query settings.</param>
        /// <param name="server">Target server.</param>
        public static async Task <IEnumerable <Content> > QueryAsync(string queryText, string[] select = null, string[] expand = null, QuerySettings settings = null, ServerContext server = null)
        {
            if (settings == null)
            {
                settings = QuerySettings.Default;
            }

            var oreq = new ODataRequest
            {
                Path    = "/Root",
                Select  = select,
                Expand  = expand,
                Top     = settings.Top,
                Skip    = settings.Skip,
                SiteUrl = ServerContext.GetUrl(server)
            };

            oreq.Parameters.Add("query", Uri.EscapeDataString(queryText));

            if (settings.EnableAutofilters != FilterStatus.Default)
            {
                oreq.Parameters.Add("enableautofilters", settings.EnableAutofilters.ToString().ToLower());
            }
            if (settings.EnableLifespanFilter != FilterStatus.Default)
            {
                oreq.Parameters.Add("enablelifespanfilter", settings.EnableLifespanFilter.ToString().ToLower());
            }

            return(await Content.LoadCollectionAsync(oreq, server));
        }
Exemplo n.º 9
0
        private static async Task SaveAndFinalizeBlobInternalAsync(string initResponse, long fileSize,
                                                                   Func <int, int, string, Task> blobCallback, string fileName = null,
                                                                   string propertyName = null, ServerContext server = null)
        {
            // parse the response of the initial request
            var    response  = JsonHelper.Deserialize(initResponse);
            int    contentId = response.id;
            string token     = response.token;
            int    versionId = response.versionId;

            // save binary through the blob storage
            await blobCallback(contentId, versionId, token);

            // send final request
            await RESTCaller.GetResponseStringAsync(contentId, "FinalizeBlobUpload", HttpMethod.Post,
                                                    JsonHelper.Serialize(new
            {
                token,
                fullSize  = fileSize,
                fieldName = propertyName,
                fileName
            }),
                                                    server);
        }
Exemplo n.º 10
0
 /// <summary>
 /// Queries the server for content items using the provided request data.
 /// </summary>
 /// <param name="requestData">Detailed information that will be sent as part of the request.
 /// For example Top, Skip, Select, etc.</param>
 /// <param name="server">Target server.</param>
 public static async Task <IEnumerable <Content> > LoadCollectionAsync(ODataRequest requestData, ServerContext server = null)
 {
     return(await RESTCaller.GetCollectionAsync(requestData, server));
 }
Exemplo n.º 11
0
        private static async Task <IEnumerable <Content> > LoadReferencesAsync(string path, int id, string fieldName, string[] select = null, ServerContext server = null)
        {
            if (select == null || select.Length == 0)
            {
                select = new[] { "*" }
            }
            ;
            var projection = new[] { "Id", "Path", "Type" };

            projection = projection.Union(select.Select(p => fieldName + "/" + p)).ToArray();

            var oreq = new ODataRequest
            {
                SiteUrl   = ServerContext.GetUrl(server),
                Expand    = new[] { fieldName },
                Select    = projection,
                ContentId = id,
                Path      = path
            };

            dynamic content = await Content.LoadAsync(oreq, server);

            // we assume that this is an array of content json objects
            var items = (JArray)content[fieldName];

            return(items.Select(c => CreateFromResponse(c, server)));
        }
Exemplo n.º 12
0
        /// <summary>
        /// Uploads a file to the server into the provided container.
        /// </summary>
        /// <param name="binaryStream">File contents.</param>
        /// <param name="uploadData">Upload parameters.</param>
        /// <param name="parentPath">Parent path.</param>
        /// <param name="server">Target server.</param>
        /// <param name="progressCallback">An optional callback method that is called after each chunk is uploaded to the server.</param>
        /// <returns>The uploaded file content returned at the end of the upload request.</returns>
        public static async Task <Content> UploadAsync(Stream binaryStream, UploadData uploadData, string parentPath, ServerContext server = null, Action <int> progressCallback = null)
        {
            var requestData = new ODataRequest()
            {
                SiteUrl    = ServerContext.GetUrl(server),
                ActionName = "Upload",
                Path       = parentPath
            };

            return(await UploadInternalAsync(binaryStream, uploadData, requestData, server, progressCallback));
        }
Exemplo n.º 13
0
        private static async Task <Content> UploadInternalAsync(Stream binaryStream, UploadData uploadData, ODataRequest requestData, ServerContext server = null, Action <int> progressCallback = null)
        {
            // force set values
            uploadData.UseChunk = binaryStream.Length > ClientContext.Current.ChunkSizeInBytes;
            if (uploadData.FileLength == 0)
            {
                uploadData.FileLength = binaryStream.Length;
            }

            requestData.Parameters["create"] = "1";

            dynamic uploadedContent = null;
            var     retryCount      = 0;

            // send initial request
            while (retryCount < REQUEST_RETRY_COUNT)
            {
                try
                {
                    var myReq = CreateInitUploadWebRequest(requestData.ToString(), server, uploadData);

                    SnTrace.Category(ClientContext.TraceCategory).Write("###>REQ: {0}", myReq.RequestUri);

                    using (var wr = await myReq.GetResponseAsync())
                    {
                        uploadData.ChunkToken = await ReadResponseStringAsync(wr);
                    }

                    // succesful request: skip out from retry loop
                    break;
                }
                catch (WebException ex)
                {
                    if (retryCount >= REQUEST_RETRY_COUNT - 1)
                    {
                        var ce = new ClientException("Error during binary upload.", ex);

                        ce.Data["SiteUrl"]     = requestData.SiteUrl;
                        ce.Data["Parent"]      = requestData.ContentId != 0 ? requestData.ContentId.ToString() : requestData.Path;
                        ce.Data["FileName"]    = uploadData.FileName;
                        ce.Data["ContentType"] = uploadData.ContentType;

                        throw ce;
                    }
                    else
                    {
                        Thread.Sleep(50);
                    }
                }

                retryCount++;
            }

            var boundary = "---------------------------" + DateTime.UtcNow.Ticks.ToString("x");
            var trailer  = Encoding.ASCII.GetBytes("\r\n--" + boundary + "--\r\n");

            // send subsequent requests
            var buffer = new byte[ClientContext.Current.ChunkSizeInBytes];
            int bytesRead;
            var start = 0;

            // reuse previous request data, but remove unnecessary parameters
            requestData.Parameters.Remove("create");

            while ((bytesRead = binaryStream.Read(buffer, 0, buffer.Length)) != 0)
            {
                retryCount = 0;

                //get the request object for the actual chunk
                while (retryCount < REQUEST_RETRY_COUNT)
                {
                    Stream         requestStream = null;
                    HttpWebRequest chunkRequest;

                    try
                    {
                        chunkRequest = CreateChunkUploadWebRequest(requestData.ToString(), server, uploadData, boundary, out requestStream);

                        SnTrace.Category(ClientContext.TraceCategory).Write("###>REQ: {0}", chunkRequest.RequestUri);

                        if (uploadData.UseChunk)
                        {
                            chunkRequest.Headers.Set("Content-Range", string.Format("bytes {0}-{1}/{2}", start, start + bytesRead - 1, binaryStream.Length));
                        }

                        //write the chunk into the request stream
                        requestStream.Write(buffer, 0, bytesRead);
                        requestStream.Write(trailer, 0, trailer.Length);

                        await requestStream.FlushAsync();
                    }
                    finally
                    {
                        if (requestStream != null)
                        {
                            requestStream.Close();
                        }
                    }

                    //send the request
                    try
                    {
                        using (var wr = await chunkRequest.GetResponseAsync())
                        {
                            var rs = await ReadResponseStringAsync(wr);

                            uploadedContent = JsonHelper.Deserialize(rs);
                        }

                        // successful request: skip out from the retry loop
                        break;
                    }
                    catch (WebException ex)
                    {
                        if (retryCount >= REQUEST_RETRY_COUNT - 1)
                        {
                            var ce = new ClientException("Error during binary upload.", ex);

                            ce.Data["SiteUrl"]     = requestData.SiteUrl;
                            ce.Data["Parent"]      = requestData.ContentId != 0 ? requestData.ContentId.ToString() : requestData.Path;
                            ce.Data["FileName"]    = uploadData.FileName;
                            ce.Data["ContentType"] = uploadData.ContentType;

                            throw ce;
                        }
                        else
                        {
                            Thread.Sleep(50);
                        }
                    }

                    retryCount++;
                }

                start += bytesRead;

                // notify the caller about every chunk that was uploaded successfully
                if (progressCallback != null)
                {
                    progressCallback(start);
                }
            }

            if (uploadedContent == null)
            {
                return(null);
            }

            int contentId = uploadedContent.Id;
            var content   = Content.Create(contentId);

            content.Name = uploadedContent.Name;
            content.Path = uploadedContent.Url;

            return(content);
        }
Exemplo n.º 14
0
        private static async Task <dynamic> PostContentInternalAsync(int contentId, object postData, HttpMethod method, ServerContext server = null)
        {
            var reqData = new ODataRequest()
            {
                SiteUrl   = ServerContext.GetUrl(server),
                ContentId = contentId
            };

            var rs = await GetResponseStringAsync(reqData.GetUri(), server, method, JsonHelper.GetJsonPostModel(postData));

            return(JsonHelper.Deserialize(rs).d);
        }
Exemplo n.º 15
0
 /// <summary>
 /// Sends a PUT OData request to the server containing the specified data.
 /// </summary>
 /// <param name="path">Content path</param>
 /// <param name="postData">A .NET object to serialize as post data.</param>
 /// <param name="server">Target server.</param>
 /// <returns>A deserialized dynamic JSON object parsed from the response.</returns>
 public static async Task <dynamic> PutContentAsync(string path, object postData, ServerContext server = null)
 {
     return(await PostContentInternalAsync(path, postData, HttpMethod.Put, server));
 }
Exemplo n.º 16
0
 /// <summary>
 /// Sends a PATCH OData request to the server containing the specified data.
 /// </summary>
 /// <param name="contentId">Content id</param>
 /// <param name="postData">A .NET object to serialize as post data.</param>
 /// <param name="server">Target server.</param>
 /// <returns>A deserialized dynamic JSON object parsed from the response.</returns>
 public static async Task <dynamic> PatchContentAsync(int contentId, object postData, ServerContext server = null)
 {
     return(await PostContentInternalAsync(contentId, postData, HttpMethods.PATCH, server));
 }
Exemplo n.º 17
0
        /// <summary>
        /// Assembles an http request that gets a stream from the portal containing binary data.
        /// Use this inside a using block to asynchronously get the response stream.
        /// Please catch WebExceptions and parse them using the GetClientExceptionAsync method.
        /// </summary>
        /// <param name="id">Content id.</param>
        /// <param name="version">Content version (e.g. V2.3D). If not provided, the highest version
        /// accessible to the current user will be served.</param>
        /// <param name="propertyName">Binary field name. Default is Binary.</param>
        /// <param name="server">Target server.</param>
        public static HttpWebRequest GetStreamRequest(int id, string version = null, string propertyName = null, ServerContext server = null)
        {
            var url = $"{ServerContext.GetUrl(server)}/binaryhandler.ashx?nodeid={id}&propertyname={propertyName ?? "Binary"}";

            if (!string.IsNullOrEmpty(version))
            {
                url += "&version=" + version;
            }

            return(GetRequest(url, server));
        }
Exemplo n.º 18
0
        /// <summary>
        /// Gets the response of an OData request as a dynamic JSON object.
        /// </summary>
        /// <param name="requestData">OData request parameters, for example select or expand.</param>
        /// <param name="server">Target server.</param>
        /// <param name="method">Http method (e.g. Post). Default is Get.</param>
        /// <param name="postData">An object containing properties to be sent in the body. It will be serialized to JSON.</param>
        /// <returns>A dynamic JSON object deserialized from the response.</returns>
        public static async Task <dynamic> GetResponseJsonAsync(ODataRequest requestData, ServerContext server = null, HttpMethod method = null, object postData = null)
        {
            // it wouldn't work if we tried to post some data with the default GET verb
            if (postData != null && method == null)
            {
                method = HttpMethod.Post;
            }

            var rs = await GetResponseStringAsync(requestData.GetUri(), server, method, postData == null?null : JsonHelper.Serialize(postData));

            try
            {
                return(JsonHelper.Deserialize(rs));
            }
            catch (Exception)
            {
                throw new ClientException(string.Format("Invalid response. Request: {0}. Response: {1}", requestData.GetUri(), rs));
            }
        }
Exemplo n.º 19
0
 /// <summary>
 /// Loads referenced content from a reference field.
 /// </summary>
 /// <param name="path">Content path.</param>
 /// <param name="fieldName">Reference field name.</param>
 /// <param name="select">Field names of the referenced content items to select.</param>
 /// <param name="server">Target server.</param>
 public static async Task <IEnumerable <Content> > LoadReferencesAsync(string path, string fieldName, string[] select = null, ServerContext server = null)
 {
     return(await LoadReferencesAsync(path, 0, fieldName, select, server));
 }
Exemplo n.º 20
0
 private static HttpWebRequest GetRequest(string url, ServerContext server)
 {
     return(GetRequest(new Uri(url), server));
 }
Exemplo n.º 21
0
        /// <summary>
        /// Executes a query on the server and returns results filtered and expanded
        /// based on the provided parameters. Both lifespan and system content filters
        /// are disabled.
        /// </summary>
        /// <param name="queryText">Content query text.</param>
        /// <param name="select">Fields to select.</param>
        /// <param name="expand">Fields to expand.</param>
        /// <param name="settings">Query settings.</param>
        /// <param name="server">Target server.</param>
        public static async Task <IEnumerable <Content> > QueryForAdminAsync(string queryText, string[] select = null, string[] expand = null, QuerySettings settings = null, ServerContext server = null)
        {
            if (settings == null)
            {
                settings = new QuerySettings();
            }
            settings.EnableAutofilters    = FilterStatus.Disabled;
            settings.EnableLifespanFilter = FilterStatus.Disabled;

            return(await QueryAsync(queryText, select, expand, settings, server));
        }
Exemplo n.º 22
0
 /// <summary>
 /// Loads children of a container.
 /// </summary>
 /// <param name="path">Content path.</param>
 /// <param name="server">Target server.</param>
 public static async Task <IEnumerable <Content> > GetCollectionAsync(string path, ServerContext server = null)
 {
     return(await GetCollectionAsync(new ODataRequest()
     {
         SiteUrl = ServerContext.GetUrl(server),
         Path = path,
         IsCollectionRequest = true
     }));
 }
Exemplo n.º 23
0
        /// <summary>
        /// Uploads a file to the server into the provided container.
        /// </summary>
        /// <param name="parentId">Parent id.</param>
        /// <param name="fileName">Name of the file to upload.</param>
        /// <param name="stream">File contents.</param>
        /// <param name="contentType">Content type of the file. Default is determined by the container.</param>
        /// <param name="propertyName">Name of the field to upload to. Default is Binary.</param>
        /// <param name="server">Target server.</param>
        /// <param name="progressCallback">An optional callback method that is called after each chunk is uploaded to the server.</param>
        /// <returns>The uploaded file content returned at the end of the upload request.</returns>
        public static async Task <Content> UploadAsync(int parentId, string fileName, Stream stream, string contentType = null, string propertyName = null, ServerContext server = null, Action <int> progressCallback = null)
        {
            var uploadData = new UploadData()
            {
                FileName   = fileName,
                FileLength = stream.Length
            };

            if (!string.IsNullOrEmpty(contentType))
            {
                uploadData.ContentType = contentType;
            }

            if (!string.IsNullOrEmpty(propertyName))
            {
                uploadData.PropertyName = propertyName;
            }

            return(await RESTCaller.UploadAsync(stream, uploadData, parentId, server, progressCallback));
        }
Exemplo n.º 24
0
 /// <summary>
 /// Creates a new content in memory without saving it.
 /// </summary>
 /// <param name="parentPath">Parent content path in the Content Repository.</param>
 /// <param name="contentType">Content type name.</param>
 /// <param name="name">Name of the new content.</param>
 /// <param name="contentTemplate">Content template path.</param>
 /// <param name="server">Target server.</param>
 public static Content CreateNew(string parentPath, string contentType, string name, string contentTemplate = null, ServerContext server = null)
 {
     return(CreateNew <Content>(parentPath, contentType, name, contentTemplate, server));
 }
Exemplo n.º 25
0
        /// <summary>
        /// Gets a blob storage token that identifies a binary in the storage.
        /// </summary>
        /// <param name="path">Content path.</param>
        /// <param name="version">Content version (e.g. V2.3D). If not provided, the highest version
        /// accessible to the current user will be served.</param>
        /// <param name="propertyName">Binary field name. Default is Binary.</param>
        /// <param name="server">Target server.</param>
        /// <returns>A token that can be used with the Blob storage API.</returns>
        public static async Task <string> GetBlobToken(string path, string version = null, string propertyName = null, ServerContext server = null)
        {
            var responseText = await RESTCaller.GetResponseStringAsync(path, "GetBinaryToken", HttpMethod.Post,
                                                                       JsonHelper.Serialize(new { version, fieldName = propertyName }), server);

            var response = JsonHelper.Deserialize(responseText);

            return(response.token);
        }
Exemplo n.º 26
0
        /// <summary>
        /// Creates a new specialized content in memory without saving it.
        /// </summary>
        /// <typeparam name="T">One of the specialized client content types inheriting from Content (e.g. Group).</typeparam>
        /// <param name="parentPath">Parent content path in the Content Repository.</param>
        /// <param name="contentType">Content type name.</param>
        /// <param name="name">Name of the new content.</param>
        /// <param name="contentTemplate">Content template path.</param>
        /// <param name="server">Target server.</param>
        public static T CreateNew <T>(string parentPath, string contentType, string name, string contentTemplate = null, ServerContext server = null) where T : Content
        {
            if (string.IsNullOrEmpty(parentPath))
            {
                throw new ArgumentNullException(nameof(parentPath));
            }
            if (string.IsNullOrEmpty(contentType))
            {
                throw new ArgumentNullException(nameof(contentType));
            }

            var ctor = typeof(T).GetConstructor(
                BindingFlags.NonPublic | BindingFlags.Instance,
                null, new[] { typeof(ServerContext) }, null);

            dynamic dc = ctor.Invoke(new object[] { server }) as T;

            if (dc == null)
            {
                throw new ClientException("Constructor not found or type could not be initialized. " + typeof(T).FullName);
            }

            dc.ParentPath = parentPath;
            dc.Name       = name;
            dc.Existing   = false;

            // set dynamic properties
            dc.__ContentType = contentType;

            if (!string.IsNullOrEmpty(contentTemplate))
            {
                dc.__ContentTemplate = contentTemplate;
            }

            return(dc);
        }
Exemplo n.º 27
0
 /// <summary>
 /// Removes permission break on the content.
 /// </summary>
 /// <param name="server">Target server.</param>
 public async Task UnbreakInheritanceAsync(ServerContext server = null)
 {
     await SecurityManager.UnbreakInheritanceAsync(this.Id, server);
 }
Exemplo n.º 28
0
        //============================================================================= Static API

        /// <summary>
        /// Loads a content from the server.
        /// </summary>
        /// <param name="id">Content id.</param>
        /// <param name="server">Target server.</param>
        public static async Task <Content> LoadAsync(int id, ServerContext server = null)
        {
            return(await RESTCaller.GetContentAsync(id, server));
        }
Exemplo n.º 29
0
 /// <summary>
 /// Internal constructor for client content.
 /// </summary>
 /// <param name="server">Target server. If null, the first one will be used from the configuration.</param>
 /// <param name="responseContent">A JSON response that contains content fields.</param>
 protected Content(ServerContext server, dynamic responseContent) : this(server)
 {
     InitializeFromResponse(responseContent);
 }
Exemplo n.º 30
0
 /// <summary>
 /// Loads a content from the server.
 /// </summary>
 /// <param name="path">Content path.</param>
 /// <param name="server">Target server.</param>
 public static async Task <Content> LoadAsync(string path, ServerContext server = null)
 {
     return(await RESTCaller.GetContentAsync(path, server));
 }