private async Task <(IList <SmintIoAsset>, string, bool)> LoadAssetsAsync(string continuationUuid, bool compoundAssetsSupported, bool binaryUpdatesSupported)
{
await SetupClapicOpenApiClientAsync();
var smintIoSettingsDatabaseModel = await _smintIoSettingsDatabaseProvider.GetSmintIoSettingsDatabaseModelAsync();
IList <SmintIoAsset> assets = new List <SmintIoAsset>();
SyncLicensePurchaseTransactionQueryResult syncLptQueryResult = await _retryPolicy.ExecuteAsync(async() =>
{
// get a new access token in case it was refreshed
var tokenDatabaseModel = await _smintIoTokenDatabaseProvider.GetTokenDatabaseModelAsync();
_clapicOpenApiClient.AccessToken = tokenDatabaseModel.AccessToken;
return(await _clapicOpenApiClient.GetLicensePurchaseTransactionsForSyncAsync(
continuationUuid: continuationUuid,
limit: 10));
});
if (syncLptQueryResult.Count == 0)
{
return(assets, syncLptQueryResult.Continuation_uuid, false);
}
bool hasAssets = false;
foreach (var lpt in syncLptQueryResult.License_purchase_transactions)
{
bool?isEditorialUse = null;
foreach (var license_term in lpt.License_terms)
{
// make sure we do not store editorial use information if no information is there!
if (license_term.Is_editorial_use != null)
{
if (license_term.Is_editorial_use == true)
{
// if we have a restrictions, always indicate
isEditorialUse = true;
}
else if (license_term.Is_editorial_use == false)
{
// if we have no restriction, only store, if we have no other restriction
if (isEditorialUse == null)
{
isEditorialUse = false;
}
}
}
}
string url = $"https://{smintIoSettingsDatabaseModel.TenantId}.smint.io/project/{lpt.Project_uuid}/content-element/{lpt.Content_element.Uuid}";
var importLanguages = smintIoSettingsDatabaseModel.ImportLanguages;
var asset = new SmintIoAsset()
{
ContentElementUuid = lpt.Content_element.Uuid,
LicensePurchaseTransactionUuid = lpt.Uuid,
ReusedLicensePurchaseTransactionUuid = lpt.Reused_license_purchase_transaction_uuid,
CartPurchaseTransactionUuid = lpt.Cart_purchase_transaction_uuid,
State = lpt.State,
Provider = lpt.Content_element.Provider,
ContentType = lpt.Content_element.Content_type,
Name = GetValuesForImportLanguages(importLanguages, lpt.Content_element.Name),
Description = GetValuesForImportLanguages(importLanguages, lpt.Content_element.Description),
Keywords = GetGroupedValuesForImportLanguages(importLanguages, lpt.Content_element.Keywords),
Category = lpt.Content_element.Content_category,
ReleaseDetails = GetReleaseDetails(importLanguages, lpt),
CopyrightNotices = GetValuesForImportLanguages(importLanguages, lpt.Content_element.Copyright_notices),
ProjectUuid = lpt.Project_uuid,
ProjectName = GetValuesForImportLanguages(importLanguages, lpt.Project_name),
CollectionUuid = lpt.Collection_uuid,
CollectionName = GetValuesForImportLanguages(importLanguages, lpt.Collection_name),
LicenseeUuid = lpt.Licensee_uuid,
LicenseeName = lpt.Licensee_name,
LicenseType = lpt.Offering.License_type,
LicenseText = GetValuesForImportLanguages(importLanguages, lpt.License_text.Effective_text),
LicenseUrls = GetGroupedUrlValuesForImportLanguages(importLanguages, lpt.Offering.License_urls),
LicenseTerms = GetLicenseTerms(importLanguages, lpt),
DownloadConstraints = GetDownloadConstraints(lpt),
IsEditorialUse = isEditorialUse,
HasRestrictiveLicenseTerms = lpt.Has_potentially_restrictive_license_terms ?? false,
SmintIoUrl = url,
PurchasedAt = lpt.Purchased_at,
CreatedAt = (DateTimeOffset)lpt.Created_at,
LastUpdatedAt = lpt.Last_updated_at ?? lpt.Created_at ?? DateTimeOffset.Now,
RawLicensePurchaseTransaction = lpt
};
// we need to store this separately because list will be empty if all assets of the batch have Can_be_synced == false
hasAssets = true;
if (lpt.Can_be_synced ?? false)
{
var syncBinaries =
await _clapicOpenApiClient.GetLicensePurchaseTransactionBinariesForSyncAsync(asset.CartPurchaseTransactionUuid, asset.LicensePurchaseTransactionUuid);
asset.Binaries = GetBinaries(importLanguages, syncBinaries, compoundAssetsSupported, binaryUpdatesSupported);
assets.Add(asset);
}
}
return(assets, syncLptQueryResult.Continuation_uuid, hasAssets);
}
private void SetContentMetadata(TSyncAsset targetAsset, SmintIoAsset rawAsset, SmintIoBinary binary)
{
var contentTypeString = !string.IsNullOrEmpty(binary?.ContentType) ? binary.ContentType : rawAsset.ContentType;
targetAsset.SetContentElementUuid(rawAsset.ContentElementUuid);
targetAsset.SetContentProvider(GetContentProviderKey(rawAsset.Provider));
targetAsset.SetContentType(GetContentTypeKey(contentTypeString));
targetAsset.SetContentCategory(GetContentCategoryKey(rawAsset.Category));
targetAsset.SetSmintIoUrl(rawAsset.SmintIoUrl);
targetAsset.SetPurchasedAt(rawAsset.PurchasedAt);
targetAsset.SetCreatedAt(rawAsset.CreatedAt);
targetAsset.SetCartUuid(rawAsset.CartPurchaseTransactionUuid);
targetAsset.SetHasBeenCancelled(rawAsset.State == Client.Generated.LicensePurchaseTransactionStateEnum.Cancelled);
if (!string.IsNullOrEmpty(binary?.BinaryType))
{
targetAsset.SetBinaryType(GetBinaryTypeKey(binary.BinaryType));
}
if (rawAsset.LastUpdatedAt != null)
{
targetAsset.SetLastUpdatedAt((DateTimeOffset)rawAsset.LastUpdatedAt);
}
if (binary?.Name?.Count > 0)
{
targetAsset.SetNameInternal(binary.Name);
}
else if (rawAsset.Name?.Count > 0)
{
targetAsset.SetNameInternal(rawAsset.Name);
}
if (binary?.Description?.Count > 0)
{
targetAsset.SetDescription(binary.Description);
}
else if (rawAsset.Description?.Count > 0)
{
targetAsset.SetDescription(rawAsset.Description);
}
if (!string.IsNullOrEmpty(rawAsset.ProjectUuid))
{
targetAsset.SetProjectUuid(rawAsset.ProjectUuid);
}
if (rawAsset.ProjectName?.Count > 0)
{
targetAsset.SetProjectName(rawAsset.ProjectName);
}
if (!string.IsNullOrEmpty(rawAsset.CollectionUuid))
{
targetAsset.SetCollectionUuid(rawAsset.CollectionUuid);
}
if (rawAsset.CollectionName?.Count > 0)
{
targetAsset.SetCollectionName(rawAsset.CollectionName);
}
if (rawAsset.Keywords?.Count > 0)
{
targetAsset.SetKeywords(rawAsset.Keywords);
}
if (rawAsset.CopyrightNotices?.Count > 0)
{
targetAsset.SetCopyrightNotices(rawAsset.CopyrightNotices);
}
if (binary != null)
{
targetAsset.SetBinaryUuidInternal(binary.Uuid);
if (binary.Usage?.Count > 0)
{
targetAsset.SetBinaryUsageInternal(binary.Usage);
}
var binaryCulture = binary.Culture;
if (!string.IsNullOrEmpty(binaryCulture))
{
targetAsset.SetBinaryCulture(binaryCulture);
}
targetAsset.SetBinaryVersionInternal(binary.Version);
}
}
private void SetLicenseMetadata(TSyncAsset targetAsset, SmintIoAsset rawAsset)
{
targetAsset.SetLicenseType(GetLicenseTypeKey(rawAsset.LicenseType));
targetAsset.SetLicenseeUuid(rawAsset.LicenseeUuid);
targetAsset.SetLicenseeName(rawAsset.LicenseeName);
if (rawAsset.LicenseText?.Count > 0)
{
targetAsset.SetLicenseText(rawAsset.LicenseText);
}
if (rawAsset.LicenseUrls?.Count > 0)
{
targetAsset.SetLicenseUrls(rawAsset.LicenseUrls);
}
if (rawAsset.LicenseTerms?.Count > 0)
{
targetAsset.SetLicenseTerms(GetLicenseTerms(rawAsset.LicenseTerms));
}
if (rawAsset.DownloadConstraints != null)
{
var rawDownloadConstraints = rawAsset.DownloadConstraints;
var targetDownloadConstraints = _syncTargetDataFactory.CreateSyncDownloadConstraints();
if (rawDownloadConstraints.MaxDownloads != null)
{
targetDownloadConstraints.SetMaxDownloads((int)rawDownloadConstraints.MaxDownloads);
}
if (rawDownloadConstraints.MaxUsers != null)
{
targetDownloadConstraints.SetMaxUsers((int)rawDownloadConstraints.MaxUsers);
}
if (rawDownloadConstraints.MaxReuses != null)
{
targetDownloadConstraints.SetMaxReuses((int)rawDownloadConstraints.MaxReuses);
}
targetAsset.SetDownloadConstraints(targetDownloadConstraints);
}
if (rawAsset.ReleaseDetails != null)
{
var rawReleaseDetails = rawAsset.ReleaseDetails;
var targetReleaseDetails = _syncTargetDataFactory.CreateSyncReleaseDetails();
string modelReleaseState = null;
if (!string.IsNullOrEmpty(rawReleaseDetails.ModelReleaseState))
{
modelReleaseState = GetReleaseStateKey(rawReleaseDetails.ModelReleaseState);
}
string propertyReleaseState = null;
if (!string.IsNullOrEmpty(rawReleaseDetails.PropertyReleaseState))
{
propertyReleaseState = GetReleaseStateKey(rawReleaseDetails.PropertyReleaseState);
}
if (!string.IsNullOrEmpty(modelReleaseState))
{
targetReleaseDetails.SetModelReleaseState(modelReleaseState);
}
if (!string.IsNullOrEmpty(propertyReleaseState))
{
targetReleaseDetails.SetPropertyReleaseState(propertyReleaseState);
}
if (rawReleaseDetails.ProviderAllowedUseComment?.Count > 0)
{
targetReleaseDetails.SetProviderAllowedUseComment(rawReleaseDetails.ProviderAllowedUseComment);
}
if (rawReleaseDetails.ProviderReleaseComment?.Count > 0)
{
targetReleaseDetails.SetProviderReleaseComment(rawReleaseDetails.ProviderReleaseComment);
}
if (rawReleaseDetails.ProviderUsageConstraints?.Count > 0)
{
targetReleaseDetails.SetProviderUsageConstraints(rawReleaseDetails.ProviderUsageConstraints);
}
targetAsset.SetReleaseDetails(targetReleaseDetails);
}
if (rawAsset.IsEditorialUse != null)
{
targetAsset.SetIsEditorialUse((bool)rawAsset.IsEditorialUse);
}
if (rawAsset.HasRestrictiveLicenseTerms != null)
{
targetAsset.SetHasRestrictiveLicenseTerms((bool)rawAsset.HasRestrictiveLicenseTerms);
}
}
internal void SetAsset(SmintIoAsset asset)
{
Asset = asset;
}
