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