C# ShareFile.Api.Client.Requests.Query.Uri方法代码示例

 public IQuery<ShareAlias> CreateRecipients(Uri url, string Email = null, string FirstName = null, string LastName = null, string Company = null)
 {
     var sfApiQuery = new ShareFile.Api.Client.Requests.Query<ShareAlias>(Client);
     sfApiQuery.Action("Recipients");
     sfApiQuery.Uri(url);
     sfApiQuery.QueryString("Email", Email);
     sfApiQuery.QueryString("FirstName", FirstName);
     sfApiQuery.QueryString("LastName", LastName);
     sfApiQuery.QueryString("Company", Company);
     sfApiQuery.HttpMethod = "POST";
     return sfApiQuery;
 }

        /// <summary>
        /// Create or Update multiple AccessControls for a given Item
        /// </summary>
        /// <example>
        /// {
        /// "NotifyUser":true,
        /// "NotifyMessage":"msg",
        /// 
        /// "AccessControlParams":
        /// [
        /// {
        /// "AccessControl":
        /// {
        /// "Principal" : { "Id":"existing_user_id" },
        /// "CanUpload" : true,
        /// "CanDownload" : false,
        /// "CanView" : true
        /// },
        /// "NotifyUser":false
        /// },
        /// {
        /// "AccessControl":
        /// {
        /// "Principal" : { "Id":"group_id" },
        /// "CanUpload" : false,
        /// "CanDownload" : true,
        /// "CanView" : true
        /// },
        /// "Recursive":true
        /// },
        /// {
        /// "AccessControl":
        /// {
        /// "Principal" : { "Email":"[email protected]" },
        /// "CanUpload" : false,
        /// "CanDownload" : true,
        /// "CanView" : true
        /// }
        /// }
        /// ]
        /// }
        /// </example>
        /// <remarks>
        /// All the AccessControls are created or updated for a single Item identified by the Item id in the URI. AccessControl.Item Ids are not allowed.
        /// If an AccessControl doesn't specify NotifyUser or NotifyMessage property their values are inherited from the corresponding
        /// top-level properties.
        /// The Principal can be identified by Id or Email (Users). If a User with the specified email does not exist it will be created.
        /// Defaults for NotifyUser and Recursive are false.
        /// See AccessControlsBulkParams for other details.
        /// </remarks>
        /// <param name="url"></param>
        /// <param name="bulkParams"></param>
        /// <returns>
        /// AccessControlBulkResult
        /// </returns>
        public IQuery<AccessControlBulkResult> BulkSet(Uri url, AccessControlsBulkParams bulkParams)
        {
            var sfApiQuery = new ShareFile.Api.Client.Requests.Query<AccessControlBulkResult>(Client);
		    sfApiQuery.Action("AccessControls");
            sfApiQuery.Uri(url);
            sfApiQuery.SubAction("BulkSet");
            sfApiQuery.Body = bulkParams;
            sfApiQuery.HttpMethod = "POST";	
		    return sfApiQuery;
        }

        /// <summary>
        /// Run Report
        /// </summary>
        /// <remarks>
        /// Run a report and get the run id.
        /// </remarks>
        /// <returns>
        /// ReportRecord
        /// </returns>
        public IQuery<ReportRecord> GetRun(Uri url)
        {
            var sfApiQuery = new ShareFile.Api.Client.Requests.Query<ReportRecord>(Client);
		    sfApiQuery.Action("Run");
            sfApiQuery.Uri(url);
            sfApiQuery.HttpMethod = "GET";	
		    return sfApiQuery;
        }

        /// <summary>
        /// Create or update StorageCenter Metadata
        /// </summary>
        /// <example>
        /// [
        /// {"Name":"metadataName1", "Value":"metadataValue1", "IsPublic":"true"},
        /// {"Name":"metadataName2", "Value":"metadataValue2", "IsPublic":"false"},
        /// ...
        /// ]
        /// </example>
        /// <remarks>
        /// Creates or updates Metadata entries associated with the specified storage center
        /// </remarks>
        /// <param name="zUrl"></param>
        /// <param name="scid"></param>
        /// <param name="metadata"></param>
        /// <returns>
        /// the storage center metadata feed
        /// </returns>
        public IQuery<ODataFeed<Metadata>> CreateMetadata(Uri zUrl, string scid, IEnumerable<Metadata> metadata)
        {
            var sfApiQuery = new ShareFile.Api.Client.Requests.Query<ODataFeed<Metadata>>(Client);
		    sfApiQuery.Action("StorageCenters");
            sfApiQuery.Uri(zUrl);
            sfApiQuery.ActionIds(scid);
            sfApiQuery.SubAction("Metadata");
            sfApiQuery.Body = metadata;
            sfApiQuery.HttpMethod = "POST";	
		    return sfApiQuery;
        }

        /// <summary>
        /// Create AccessControl
        /// </summary>
        /// <example>
        /// {
        /// "Principal":{"url":"https://account.sf-api.com/v3/Groups(id)"},
        /// "CanUpload":true,
        /// "CanDownload":true,
        /// "CanView":true,
        /// "CanDelete":true,
        /// "CanManagePermissions":true,
        /// "Message":"Message"
        /// }
        /// </example>
        /// <remarks>
        /// Creates a new Access Controls entry for a given Item. Access controls can only define a single Principal,
        /// which can be either a Group or User. The 'Principal' element is specified as an object - you should populate
        /// either the URL or the ID reference.
        /// </remarks>
        /// <param name="url"></param>
        /// <param name="accessControl"></param>
        /// <param name="recursive"></param>
        /// <param name="message"></param>
        /// <param name="sendDefaultNotification"></param>
        /// <returns>
        /// the created or modified AccessControl instance
        /// </returns>
        public IQuery<AccessControl> CreateByItem(Uri url, AccessControl accessControl, bool recursive = false, bool sendDefaultNotification = false, string message = null)
        {
            var sfApiQuery = new ShareFile.Api.Client.Requests.Query<AccessControl>(Client);
		    sfApiQuery.Action("AccessControls");
            sfApiQuery.Uri(url);
            sfApiQuery.QueryString("recursive", recursive);
            sfApiQuery.QueryString("sendDefaultNotification", sendDefaultNotification);
            accessControl.AddProperty("message", message);
            sfApiQuery.Body = accessControl;
            sfApiQuery.HttpMethod = "POST";	
		    return sfApiQuery;
        }

        /// <summary>
        /// Get List of StorageCenters from Zone
        /// </summary>
        /// <remarks>
        /// Lists Storage Centers of a given Zone
        /// </remarks>
        /// <param name="url"></param>
        /// <returns>
        /// A list of Storage Centers associated with the provided zone
        /// </returns>
        public IQuery<ODataFeed<StorageCenter>> GetByZone(Uri url)
        {
            var sfApiQuery = new ShareFile.Api.Client.Requests.Query<ODataFeed<StorageCenter>>(Client);
		    sfApiQuery.Action("StorageCenters");
            sfApiQuery.Uri(url);
            sfApiQuery.HttpMethod = "GET";	
		    return sfApiQuery;
        }

        /// <summary>
        /// Update StorageCenter
        /// </summary>
        /// <example>
        /// {
        /// "ExternalAddress":"https://server/",
        /// "Version":"4.12.20",
        /// "HostName":"hostname"
        /// }
        /// </example>
        /// <remarks>
        /// Updates an existing Storage Center
        /// </remarks>
        /// <param name="zUrl"></param>
        /// <param name="scid"></param>
        /// <param name="storageCenter"></param>
        /// <returns>
        /// the modified storage center
        /// </returns>
        public IQuery<StorageCenter> UpdateByZone(Uri zUrl, string scid, StorageCenter storageCenter)
        {
            var sfApiQuery = new ShareFile.Api.Client.Requests.Query<StorageCenter>(Client);
		    sfApiQuery.Action("StorageCenters");
            sfApiQuery.Uri(zUrl);
            sfApiQuery.ActionIds(scid);
            sfApiQuery.Body = storageCenter;
            sfApiQuery.HttpMethod = "PATCH";	
		    return sfApiQuery;
        }

 /// <summary>
 /// Get List of Protocol Links of a Share item
 /// </summary>
 /// <param name="shareUrl"></param>
 /// <param name="itemid"></param>
 /// <param name="platform"></param>
 /// <returns>
 /// A list of protocol links depending on the input parameter 'platform', 404 (Not Found) if not supported by the item
 /// </returns>
 public IQuery<ODataFeed<ItemProtocolLink>> ProtocolLinks(Uri shareUrl, string itemid, PreviewPlatform platform)
 {
     var sfApiQuery = new ShareFile.Api.Client.Requests.Query<ODataFeed<ItemProtocolLink>>(Client);
     sfApiQuery.Action("Items");
     sfApiQuery.Uri(shareUrl);
     sfApiQuery.ActionIds(itemid);
     sfApiQuery.SubAction("ProtocolLinks", platform);
     sfApiQuery.HttpMethod = "GET";
     return sfApiQuery;
 }

 /// <summary>
 /// Get Thumbnail of a Share Item
 /// </summary>
 /// <remarks>
 /// Retrieve a thumbnail link for the specified Item in the Share.
 /// </remarks>
 /// <param name="shareUrl"></param>
 /// <param name="itemid"></param>
 /// <param name="size"></param>
 /// <param name="redirect"></param>
 /// <returns>
 /// A 302 redirection to the Thumbnail link
 /// </returns>
 public IQuery<Stream> Thumbnail(Uri shareUrl, string itemid, int size = 75, bool redirect = false)
 {
     var sfApiQuery = new ShareFile.Api.Client.Requests.Query<Stream>(Client);
     sfApiQuery.Action("Items");
     sfApiQuery.Uri(shareUrl);
     sfApiQuery.ActionIds(itemid);
     sfApiQuery.SubAction("Thumbnail");
     sfApiQuery.QueryString("size", size);
     sfApiQuery.QueryString("redirect", redirect);
     sfApiQuery.HttpMethod = "GET";
     return sfApiQuery;
 }

 /// <summary>
 /// Get Recipients of a Share
 /// </summary>
 /// <remarks>
 /// Retrieve the list of Recipients in the share. Recipients represent the target users of the Share, containing
 /// access information, such as number of times that user downloaded files from the share. Each Recipient is
 /// identified by an Alias, which is an unique ID given to each user - allowing tracking of downloads for
 /// non-authenticated users.
 /// </remarks>
 /// <param name="url"></param>
 /// <returns>
 /// A feed of Share Aliases representing recipients of the Share
 /// </returns>
 public IQuery<ODataFeed<ShareAlias>> GetRecipients(Uri url)
 {
     var sfApiQuery = new ShareFile.Api.Client.Requests.Query<ODataFeed<ShareAlias>>(Client);
     sfApiQuery.Action("Recipients");
     sfApiQuery.Uri(url);
     sfApiQuery.HttpMethod = "GET";
     return sfApiQuery;
 }

 /// <summary>
 /// Get Items of a Send Share
 /// </summary>
 /// <remarks>
 /// Retrieve a single Item in the Send Share
 /// </remarks>
 /// <param name="shareUrl"></param>
 /// <param name="itemid"></param>
 /// <returns>
 /// An item in the Share
 /// </returns>
 public IQuery<Item> GetItems(Uri shareUrl, string itemid)
 {
     var sfApiQuery = new ShareFile.Api.Client.Requests.Query<Item>(Client);
     sfApiQuery.Action("Items");
     sfApiQuery.Uri(shareUrl);
     sfApiQuery.ActionIds(itemid);
     sfApiQuery.HttpMethod = "GET";
     return sfApiQuery;
 }

 /// <summary>
 /// Download Items from a Share for a Recipient
 /// </summary>
 /// <example>
 /// GET https://account.sf-api.com/sf/v3/Shares(shareid)/Recipients(aliasid)/DownloadWithAlias?id=itemid
 /// GET https://account.sf-api.com/sf/v3/Shares(shareid)/Recipients(aliasid)/DownloadWithAlias(itemid)
 /// </example>
 /// <remarks>
 /// Downloads items from the Share. The default action will download all Items in the Share.
 /// If a Share has a single item, the download attachment name
 /// will use the item name. Otherwise, the download will contain a ZIP archive containing all
 /// files and folders in the share, named Files.zip.To download Shares that require user informaion ( Email, First Name, Last Name and Company), make sure
 /// to create an Recipient (alias)To download Shares that require authentication, make sure this request is authenticated.
 /// Anyone can download files from anonymous shares.You can also download individual Items in the Share. Use the Shares(id)/Recipients(aliasid)/Download action. The
 /// item ID must be a top-level item in the Share - i.e., you cannot download or address files contained inside
 /// a shared folder.
 /// </remarks>
 /// <param name="shareUrl"></param>
 /// <param name="aliasid"></param>
 /// <param name="itemId"></param>
 /// <param name="redirect"></param>
 /// <returns>
 /// Redirects the caller (302) to the download address for the share contents.
 /// </returns>
 public IQuery<Stream> DownloadWithAlias(Uri shareUrl, string aliasid, string itemId = null, bool redirect = true)
 {
     var sfApiQuery = new ShareFile.Api.Client.Requests.Query<Stream>(Client);
     sfApiQuery.Action("Recipients");
     sfApiQuery.Uri(shareUrl);
     sfApiQuery.ActionIds(aliasid);
     sfApiQuery.SubAction("DownloadWithAlias");
     sfApiQuery.QueryString("id", itemId);
     sfApiQuery.QueryString("redirect", redirect);
     sfApiQuery.HttpMethod = "GET";
     return sfApiQuery;
 }

 /// <summary>
 /// Downloads Share Items
 /// </summary>
 /// <remarks>
 /// Downloads items from the Share. The default action will download all Items in the Share.
 /// If a Share has a single item, the download attachment name
 /// will use the item name. Otherwise, the download will contain a ZIP archive containing all
 /// files and folders in the share, named Files.zip.To download Shares that require authentication, make sure this request is authenticated. To download
 /// shares that require require user information, provide the Name, Email and Company parameters in the URI
 /// query. Anyone can download files from anonymous shares.You can also download individual Items in the Share. Use the Share(id)/Items(id)/Download action. The
 /// item ID must be a top-level item in the Share - i.e., you cannot download or address files contained inside
 /// a shared folder.
 /// </remarks>
 /// <param name="shareUrl"></param>
 /// <param name="itemId"></param>
 /// <param name="Name"></param>
 /// <param name="Email"></param>
 /// <param name="Company"></param>
 /// <param name="redirect"></param>
 /// <returns>
 /// Redirects the caller (302) to the download address for the share contents.
 /// </returns>
 public IQuery<Stream> Download(Uri shareUrl, string itemId = null, string Name = null, string Email = null, string Company = null, bool redirect = true)
 {
     var sfApiQuery = new ShareFile.Api.Client.Requests.Query<Stream>(Client);
     sfApiQuery.Action("Download");
     sfApiQuery.Uri(shareUrl);
     sfApiQuery.QueryString("id", itemId);
     sfApiQuery.QueryString("Name", Name);
     sfApiQuery.QueryString("Email", Email);
     sfApiQuery.QueryString("Company", Company);
     sfApiQuery.QueryString("redirect", redirect);
     sfApiQuery.HttpMethod = "GET";
     return sfApiQuery;
 }

        /// <summary>
        /// Create or update Zone Metadata
        /// </summary>
        /// <example>
        /// [
        /// {"Name":"metadataName1", "Value":"metadataValue1", "IsPublic":"true"},
        /// {"Name":"metadataName2", "Value":"metadataValue2", "IsPublic":"false"},
        /// ...
        /// ]
        /// </example>
        /// <remarks>
        /// Creates or updates Metadata entries associated with the specified zone
        /// </remarks>
        /// <param name="url"></param>
        /// <param name="metadata"></param>
        /// <returns>
        /// the zone metadata feed
        /// </returns>
        public IQuery<ODataFeed<Metadata>> CreateMetadata(Uri url, IEnumerable<Metadata> metadata)
        {
            var sfApiQuery = new ShareFile.Api.Client.Requests.Query<ODataFeed<Metadata>>(Client);
		    sfApiQuery.Action("Metadata");
            sfApiQuery.Uri(url);
            sfApiQuery.Body = metadata;
            sfApiQuery.HttpMethod = "POST";	
		    return sfApiQuery;
        }

 /// <summary>
 /// Upload File to Request Share
 /// </summary>
 /// <example>
 /// POST https://account.sf-api.com/sf/v3/Shares(id)/Upload2
 /// {
 /// "Method":"Method",
 /// "Raw": false,
 /// "FileName":"FileName"
 /// "FileLength": length
 /// }
 /// </example>
 /// <remarks>
 /// Prepares the links for uploading files to the target Share.
 /// This method returns an Upload Specification object. The fields are
 /// populated based on the upload method, provider, and resume parameters passed to the
 /// upload call.
 /// The Method determines how the URLs must be called.
 /// 
 /// Standard uploads use a single HTTP POST message to the ChunkUri address provided in
 /// the response. All other fields will be empty. Standard uploads do not support Resume.
 /// 
 /// Streamed uploads use multiple HTTP POST calls to the ChunkUri address. The client must
 /// append the parameters index, offset and hash to the end of the ChunkUri address. Index
 /// is a sequential number representing the data block (zero-based); Offset represents the
 /// byte offset for the block; and hash contains the MD5 hash of the block. The last HTTP
 /// POST must also contain finish=true parameter.
 /// 
 /// Threaded uploads use multiple HTTP POST calls to ChunkUri, and can have a number of
 /// threads issuing blocks in parallel. Clients must append index, offset and hash to
 /// the end of ChunkUri, as explained in Streamed. After all chunks were sent, the client
 /// must call the FinishUri provided in this spec.
 /// 
 /// For all uploaders, the contents of the POST Body can either be "raw", if the "Raw" parameter
 /// was provided to the Uploader, or use MIME multi-part form encoding otherwise. Raw uploads
 /// simply put the block content in the POST body - Content-Length specifies the size. Multi-part
 /// form encoding has to pass the File as a Form parameter named "File1".
 /// 
 /// For streamed and threaded, if Resume options were provided to the Upload call, then the
 /// fields IsResume, ResumeIndex, ResumeOffset and ResumeFileHash MAY be populated. If they are,
 /// it indicates that the server has identified a partial upload with that specification, and is
 /// ready to resume on the provided parameters. The clients can then verify the ResumeFileHash to
 /// ensure the file has not been modified; and continue issuing ChunkUri calls from the ResumeIndex
 /// ResumeOffset parameters. If the client decides to restart, it should simply ignore the resume
 /// parameters and send the blocks from Index 0.
 /// 
 /// For all uploaders: the result code for the HTTP POST calls to Chunk and Finish Uri can either
 /// be a 401 - indicating authentication is required; 4xx/5xx indicating some kind of error; or
 /// 200 with a Content Body of format 'ERROR:message'. Successful calls will return either a 200
 /// response with no Body, or with Body of format 'OK'.
 /// </remarks>
 /// <param name="url"></param>
 /// <param name="method"></param>
 /// <param name="raw"></param>
 /// <param name="fileName"></param>
 /// <param name="fileSize"></param>
 /// <param name="batchId"></param>
 /// <param name="batchLast"></param>
 /// <param name="canResume"></param>
 /// <param name="startOver"></param>
 /// <param name="unzip"></param>
 /// <param name="tool"></param>
 /// <param name="overwrite"></param>
 /// <param name="title"></param>
 /// <param name="details"></param>
 /// <param name="isSend"></param>
 /// <param name="sendGuid"></param>
 /// <param name="opid"></param>
 /// <param name="threadCount"></param>
 /// <param name="responseFormat"></param>
 /// <param name="notify"></param>
 /// <returns>
 /// an Upload Specification element, containing the links for uploading, and the parameters for resume.
 /// The caller must know the protocol for sending the prepare, chunk and finish URLs returned in the spec; as well as
 /// negotiate the resume upload.
 /// </returns>
 public IQuery<UploadSpecification> Upload(Uri url, UploadMethod method = UploadMethod.Standard, bool raw = false, string fileName = null, long fileSize = 0, string batchId = null, bool batchLast = false, bool canResume = false, bool startOver = false, bool unzip = false, string tool = "apiv3", bool overwrite = false, string title = null, string details = null, bool isSend = false, string sendGuid = null, string opid = null, int threadCount = 4, string responseFormat = "json", bool notify = false, DateTime? clientCreatedDateUTC = null, DateTime? clientModifiedDateUTC = null, int? expirationDays = null)
 {
     var sfApiQuery = new ShareFile.Api.Client.Requests.Query<UploadSpecification>(Client);
     sfApiQuery.Action("Upload");
     sfApiQuery.Uri(url);
     sfApiQuery.QueryString("method", method);
     sfApiQuery.QueryString("raw", raw);
     sfApiQuery.QueryString("fileName", fileName);
     sfApiQuery.QueryString("fileSize", fileSize);
     sfApiQuery.QueryString("batchId", batchId);
     sfApiQuery.QueryString("batchLast", batchLast);
     sfApiQuery.QueryString("canResume", canResume);
     sfApiQuery.QueryString("startOver", startOver);
     sfApiQuery.QueryString("unzip", unzip);
     sfApiQuery.QueryString("tool", tool);
     sfApiQuery.QueryString("overwrite", overwrite);
     sfApiQuery.QueryString("title", title);
     sfApiQuery.QueryString("details", details);
     sfApiQuery.QueryString("isSend", isSend);
     sfApiQuery.QueryString("sendGuid", sendGuid);
     sfApiQuery.QueryString("opid", opid);
     sfApiQuery.QueryString("threadCount", threadCount);
     sfApiQuery.QueryString("responseFormat", responseFormat);
     sfApiQuery.QueryString("notify", notify);
//.........这里部分代码省略.........