private RawUploadResult UploadResourceForTestArchive <T>(string archiveTag, bool useFileName = false, double imageWidth = 0.0) where T : RawUploadParams { var filesMap = new Dictionary <Type, string> { { typeof(ImageUploadParams), m_testImagePath }, { typeof(VideoUploadParams), m_testVideoPath }, { typeof(RawUploadParams), m_testPdfPath } }; var uploadParams = Activator.CreateInstance <T>(); uploadParams.File = new FileDescription(filesMap[typeof(T)]); uploadParams.Tags = $"{archiveTag},{m_apiTag}"; uploadParams.UseFilename = useFileName; if (imageWidth > 0 && uploadParams is ImageUploadParams) { (uploadParams as ImageUploadParams).EagerTransforms = new List <Transformation> { new Transformation().Crop("scale").Width(imageWidth) }; } return(uploadParams.GetType() != typeof(RawUploadParams) ? m_cloudinary.Upload(uploadParams) : m_cloudinary.Upload(uploadParams, ApiShared.GetCloudinaryParam(ResourceType.Raw))); }
/// <inheritdoc /> /// <summary> /// Maps object model to dictionary of parameters in cloudinary notation /// </summary> /// <returns>Sorted dictionary of parameters</returns> public override SortedDictionary <string, object> ToParamsDictionary() { var dict = base.ToParamsDictionary(); var contextPairs = new List <string>(); if (ContextDict?.SafePairs != null) { contextPairs.AddRange(ContextDict.SafePairs); } if (!string.IsNullOrEmpty(Context)) { contextPairs.Add(Context); } if (contextPairs.Count > 0) { AddParam(dict, Constants.CONTEXT_PARAM_NAME, Utils.SafeJoin("|", contextPairs)); } AddParam(dict, Constants.PUBLIC_IDS, PublicIds); AddParam(dict, Constants.COMMAND, ApiShared.GetCloudinaryParam(Command)); return(dict); }
public void TestDestroyRaw() { var uploadResult = UploadTestRawResource(type: ApiShared.GetCloudinaryParam(ResourceType.Raw)); var deletionParams = GetDeletionParams(uploadResult.PublicId); var destroyResult = m_cloudinary.Destroy(deletionParams); AssertDestroyed(destroyResult); }
public async Task TestDestroyRawAsync() { var uploadResult = await UploadTestRawResourceAsync(type : ApiShared.GetCloudinaryParam(ResourceType.Raw)); var deletionParams = GetDeletionParams(uploadResult.PublicId); var destroyResult = await m_cloudinary.DestroyAsync(deletionParams); AssertDestroyed(destroyResult); }
public void TestDownloadZipForVideo() { var archiveTag = GetMethodTag(); UploadResourceForTestArchive <VideoUploadParams>(archiveTag); var resourceType = ApiShared.GetCloudinaryParam(ResourceType.Video); var archiveUrl = m_cloudinary.DownloadZip(archiveTag, null, resourceType); Assert.True(UrlExists(archiveUrl)); }
private void AssertExplicitAbsoluteUri(ExplicitResult result) { var url = new Url(m_account.Cloud) .ResourceType(ApiShared.GetCloudinaryParam(ResourceType.Image)) .Add(_storageTypeFacebook) .Transform(m_explicitTransformation) .Format(FILE_FORMAT_PNG) .Version(result.Version) .BuildUrl(_cloudinaryPublicId); Assert.AreEqual(url, result.Eager[0].Url.AbsoluteUri); }
public void TestDownloadArchiveUrlForRaw() { var archiveTag = GetMethodTag(); var uploadResult = UploadResourceForTestArchive <RawUploadParams>(archiveTag); var publicIds = new List <string> { uploadResult.PublicId }; var resourceType = ApiShared.GetCloudinaryParam(ResourceType.Raw); var archiveParams = new ArchiveParams().ResourceType(resourceType).PublicIds(publicIds); var archiveUrl = m_cloudinary.DownloadArchiveUrl(archiveParams); Assert.True(UrlExists(archiveUrl)); }
/// <summary> /// <para>Asserts that a given object fits the generic structure of a metadata field.</para> /// /// <para>Asserts that a metadata field has expected structure and property values. /// See <a href="https://cloudinary.com/documentation/admin_api#generic_structure_of_a_metadata_field"> /// Generic structure of a metadata field in API reference.</a></para> /// </summary> /// <param name="metadataField">The object to test.</param> /// <param name="type">The type of metadata field we expect.</param> /// <param name="label">The label of the metadata field for display purposes.</param> /// <param name="externalId">(Optional) A unique identification string for the metadata field.</param> /// <param name="mandatory">(Optional) Whether a value must be given for this field.</param> /// <param name="defaultValue">(Optional) The default value for the field.</param> private void AssertMetadataField(MetadataFieldResult metadataField, MetadataFieldType type, string label, string externalId = null, bool mandatory = false, object defaultValue = null) { Assert.AreEqual(ApiShared.GetCloudinaryParam(type), metadataField.Type); if (metadataField.Type == ApiShared.GetCloudinaryParam(MetadataFieldType.Enum) || metadataField.Type == ApiShared.GetCloudinaryParam(MetadataFieldType.Set)) { AssertMetadataFieldDataSource(metadataField.DataSource); } Assert.AreEqual(label, metadataField.Label); Assert.AreEqual(mandatory, metadataField.Mandatory); if (!string.IsNullOrEmpty(externalId)) { Assert.AreEqual(externalId, metadataField.ExternalId); } if (defaultValue != null) { Assert.AreEqual(defaultValue, metadataField.DefaultValue); } }
/// <summary> /// Maps object model to dictionary of parameters in cloudinary notation. /// </summary> /// <returns>Sorted dictionary of parameters.</returns> public override SortedDictionary <string, object> ToParamsDictionary() { SortedDictionary <string, object> dict = base.ToParamsDictionary(); AddParam(dict, "public_id", PublicId); AddParam(dict, "tags", Tags); AddParam(dict, "type", Type); AddParam(dict, "categorization", Categorization); AddParam(dict, "detection", Detection); AddParam(dict, "ocr", Ocr); AddParam(dict, "similarity_search", SimilaritySearch); AddParam(dict, "background_removal", BackgroundRemoval); if (!string.IsNullOrWhiteSpace(NotificationUrl)) { AddParam(dict, "notification_url", NotificationUrl); } if (ModerationStatus != Actions.ModerationStatus.Pending) { AddParam(dict, "moderation_status", ApiShared.GetCloudinaryParam(ModerationStatus)); } if (AutoTagging.HasValue) { AddParam(dict, "auto_tagging", AutoTagging.Value); } AddParam(dict, "raw_convert", RawConvert); if (Context != null && Context.Count > 0) { AddParam(dict, Constants.CONTEXT_PARAM_NAME, Utils.SafeJoin("|", Context.SafePairs)); } AddCoordinates(dict, "face_coordinates", FaceCoordinates); AddCoordinates(dict, "custom_coordinates", CustomCoordinates); if (!string.IsNullOrWhiteSpace(QualityOverride)) { AddParam(dict, "quality_override", QualityOverride); } if (Headers != null && Headers.Count > 0) { StringBuilder sb = new StringBuilder(); foreach (var item in Headers) { sb.AppendFormat("{0}: {1}\n", item.Key, item.Value); } dict.Add("headers", sb.ToString()); } if (AccessControl != null && AccessControl.Count > 0) { AddParam(dict, "access_control", JsonConvert.SerializeObject(AccessControl)); } return(dict); }
public void TestCreateArchiveMultipleResourceTypes() { var raw = ApiShared.GetCloudinaryParam(ResourceType.Raw); var tag = GetMethodTag(); var rawUploadParams = new RawUploadParams() { File = new FileDescription(m_testPdfPath), Tags = $"{tag},{m_apiTag}" }; var upRes1 = m_cloudinary.Upload(rawUploadParams, raw); var imageUploadParams = new ImageUploadParams() { File = new FileDescription(m_testImagePath), Tags = $"{tag},{m_apiTag}" }; var upRes2 = m_cloudinary.Upload(imageUploadParams); var videoUploadParams = new VideoUploadParams() { File = new FileDescription(m_testVideoPath), Tags = $"{tag},{m_apiTag}" }; var upRes3 = m_cloudinary.Upload(videoUploadParams); var fQPublicIds = new List <string> { upRes1.FullyQualifiedPublicId, upRes2.FullyQualifiedPublicId, upRes3.FullyQualifiedPublicId }; var parameters = new ArchiveParams() .UseOriginalFilename(true) .TargetTags(new List <string> { tag, m_apiTag }); var ex = Assert.Throws <ArgumentException>(() => m_cloudinary.CreateArchive(parameters)); StringAssert.StartsWith("At least one of the following", ex.Message); parameters.ResourceType("auto").Tags(new List <string> { "tag" }); ex = Assert.Throws <ArgumentException>(() => m_cloudinary.CreateArchive(parameters)); StringAssert.StartsWith("To create an archive with multiple types of assets", ex.Message); parameters.ResourceType("").Tags(null).FullyQualifiedPublicIds(fQPublicIds); ex = Assert.Throws <ArgumentException>(() => m_cloudinary.CreateArchive(parameters)); StringAssert.StartsWith("To create an archive with multiple types of assets", ex.Message); Assert.AreEqual(fQPublicIds, parameters.FullyQualifiedPublicIds()); parameters.ResourceType("auto"); var result = m_cloudinary.CreateArchive(parameters); Assert.AreEqual(3, result.FileCount); }