public void AssetFilterOptionalPropertiesTest()
{
using (MockContext context = this.StartMockContextAndInitializeClients(this.GetType()))
{
try
{
CreateMediaServicesAccount();
string assetName = TestUtilities.GenerateName("assetoptionalfilter");
string assetDescription = "A test asset";
string filterName = TestUtilities.GenerateName("assetoptionalfilter");
// Create an asset
Asset inputForAsset = new Asset(description: assetDescription);
Asset createdAsset = MediaClient.Assets.CreateOrUpdate(ResourceGroup, AccountName, assetName, inputForAsset);
// Get AssetFilter, which should not exist
Assert.Equal(System.Net.HttpStatusCode.NotFound, Assert.Throws <ErrorResponseException>(() => MediaClient.AssetFilters.Get(ResourceGroup, AccountName, assetName, filterName)).Response.StatusCode);
// List AssetFilters, which should be empty
var assetFilters = MediaClient.AssetFilters.List(ResourceGroup, AccountName, assetName);
Assert.Empty(assetFilters);
// Create an AssetFilter
// Some of the AssetFilter parameters are for Live. Create a filter for VOD that does not specify Live parameters
var ptr = new PresentationTimeRange(startTimestamp: 1, endTimestamp: 600 * HNSTimescale);
AssetFilter input = new AssetFilter(presentationTimeRange: ptr);
AssetFilter createdAssetFilter = MediaClient.AssetFilters.CreateOrUpdate(ResourceGroup, AccountName, assetName, filterName, input);
ValidateAssetFilter(createdAssetFilter, expectedFirstQuality: null, expectedName: filterName, expectedPresentationTimeRange: ptr, expectedTracks: null);
// List asset filters and validate the created filter shows up
assetFilters = MediaClient.AssetFilters.List(ResourceGroup, AccountName, assetName);
Assert.Single(assetFilters);
ValidateAssetFilter(assetFilters.First(), expectedFirstQuality: null, expectedName: filterName, expectedPresentationTimeRange: ptr, expectedTracks: null);
// Get the newly created asset
AssetFilter assetFilter = MediaClient.AssetFilters.Get(ResourceGroup, AccountName, assetName, filterName);
Assert.NotNull(assetFilter);
ValidateAssetFilter(assetFilter, expectedFirstQuality: null, expectedName: filterName, expectedPresentationTimeRange: ptr, expectedTracks: null);
// Delete the asset filter
MediaClient.AssetFilters.Delete(ResourceGroup, AccountName, assetName, filterName);
// List asset filters, which should be empty again
assetFilters = MediaClient.AssetFilters.List(ResourceGroup, AccountName, assetName);
Assert.Empty(assetFilters);
// Get the asset filter, which should not exist
Assert.Equal(System.Net.HttpStatusCode.NotFound, Assert.Throws <ErrorResponseException>(() => MediaClient.AssetFilters.Get(ResourceGroup, AccountName, assetName, filterName)).Response.StatusCode);
// Delete the asset
MediaClient.Assets.Delete(ResourceGroup, AccountName, assetName);
}
finally
{
DeleteMediaServicesAccount();
}
}
}
protected void Store1_RefreshData(object sender, StoreReadDataEventArgs e)
{
//GEtting the filter from the page
string filter = string.Empty;
int totalCount = 1;
//Fetching the corresponding list
//in this test will take a list of News
AssetManagementLoanListRequest request = new AssetManagementLoanListRequest();
var d = jobInfo1.GetJobInfo();
request.branchId = d.BranchId.HasValue ? d.BranchId.Value.ToString() : "0";
request.departmentId = d.DepartmentId.HasValue ? d.DepartmentId.Value.ToString() : "0";
request.positionId = d.PositionId.HasValue ? d.PositionId.Value.ToString() : "0";
request.categoryId = categoryIdFilter.GetCategoryId();
request.employeeId = employeeFilter.GetEmployee().employeeId.ToString();
request.assetId = AssetFilter.GetAssetId();
request.Filter = "";
ListResponse <AssetManagementLoan> resp = _assetManagementService.ChildGetAll <AssetManagementLoan>(request);
if (!resp.Success)
{
Common.errorMessage(resp);
return;
}
this.Store1.DataSource = resp.Items;
e.Total = resp.count;
this.Store1.DataBind();
}
public PagedResultDto <AssetDto> GetAssets(AssetFilter input)
{
var query = assetRepository.GetAll().Where(x => !x.IsDelete);
// filter by value
if (input.AssetName != null)
{
query = query.Where(x => x.AssetName.ToLower().Equals(input.AssetName));
}
var totalCount = query.Count();
// sorting
if (!string.IsNullOrWhiteSpace(input.Sorting))
{
query = query.OrderBy(input.Sorting);
}
// paging
var items = query.PageBy(input).ToList();
// result
return(new PagedResultDto <AssetDto>(
totalCount,
items.Select(item => ObjectMapper.Map <AssetDto>(item)).ToList()));
}
private void ImportScenes()
{
SceneHunter scenePopulator = serializedSceneManager.ScenePopulator.
targetObject as SceneHunter;
AssetFilter filter = serializedSceneManager.SerializedSceneFilter.
targetObject as AssetFilter;
IEnumerable <string> retrievedScenes = scenePopulator.GetScenePaths();
IEnumerable <string> includedFiles = filter.FilesToInclude;
List <string> allFiles = new List <string>();
allFiles.AddUniqueRange(retrievedScenes);
allFiles.AddUniqueRange(includedFiles);
allFiles.RemoveAll((x) => !filter.ShouldBeIncluded(x));
OnSceneImport.SafeInvoke(this,
new EventArgs <IEnumerable <string> >()
{
Value = allFiles
});
}
public static void ItemCheck(AssetFilter filter)
{
ICheck checkTypd = (ICheck)Activator.CreateInstance(Type.GetType(filter.CheckTagString));
string[] guids = AssetDatabase.FindAssets(checkTypd.SearchTag, new string[] { filter.path });
float count = guids.Length;
float index = 1;
List <string> fixList = new List <string>();
foreach (string guid in guids)
{
string assetPath = AssetDatabase.GUIDToAssetPath(guid);
string info = String.Format("{0}/{1} {2}", index, count, assetPath);
ICheck _check = (ICheck)Activator.CreateInstance(Type.GetType(filter.CheckTagString));
EditorUtility.DisplayProgressBar(_check.GetType().Name + " Check", info, (float)(index / count));
if (!string.IsNullOrEmpty(assetPath))
{
if (!_check.Check(AssetDatabase.GUIDToAssetPath(guid)))
{
fixList.Add(assetPath);
mDictionaryCheck[filter.CheckTagString].Add(_check);
if (!_check.CanFix)
{
Debug.LogError(info + " can not auto fix");
}
}
}
else
{
Debug.LogError(info + " error" + _check.GetType().Name);
}
index++;
}
List <ICheck> list = mDictionaryCheck[filter.CheckTagString];
if (checkTypd.CanFix)
{
index = 1;
count = fixList.Count;
foreach (var assetPath in fixList)
{
string info = String.Format("{0}/{1} {2}", index, count, assetPath);
EditorUtility.DisplayProgressBar(checkTypd.GetType().Name + " Fix", info, (float)(index / count));
if (checkTypd.Fix(assetPath))
{
Debug.Log(info + " Fixed");
}
else
{
Debug.LogError(info + "auto fix fail");
}
index++;
}
}
EditorUtility.ClearProgressBar();
}
public AssetFilter CreateFilter(string assetName, string filterName, int firstBitrate)
{
AssetFilter assetFilter = new AssetFilter()
{
FirstQuality = new FirstQuality(firstBitrate)
};
return(_media.AssetFilters.CreateOrUpdate(MediaAccount.ResourceGroupName, MediaAccount.Name, assetName, filterName, assetFilter));
}
private void InitializeDefaults()
{
SceneManagerAssetPath = AssetDatabase.GetAssetPath(SerializedManager.targetObject);
bool wasCreated = false;
AssetFilter assetFilter = AssetDatabaseExtensions.
FindOrCreateSubScriptableObject <AssetFilter>(SceneManagerAssetPath, "SceneFilter", out wasCreated);
if (wasCreated)
{
assetFilter.IncludeIfNoMatch = true;
}
SerializedSceneFilter = new SerializedObject(assetFilter);
SceneHunter sceneHunter = AssetDatabaseExtensions.
GetFirstSubAssetOf <SceneHunter>(SceneManagerAssetPath);
if (sceneHunter == null)
{
sceneHunter = AssetDatabaseExtensions.
CreateSubScriptableObject <UnitySceneHunter>(SceneManagerAssetPath, "SceneHunter");
}
ScenePopulator = new SerializedObject(sceneHunter);
SceneNodes = AssetDatabaseExtensions.
FindOrCreateSubScriptableObject <SceneNodeCollection>(SceneManagerAssetPath, "SceneNodes", out wasCreated);
if (wasCreated)
{
SceneNodes.SceneManager = TargetManager;
}
SceneNodes.PopulateSceneInfos();
SceneNodesObject = new SerializedObject(SceneNodes);
SceneNodesProp = SceneNodesObject.FindProperty("sceneNodes");
if (AssetDatabaseExtensions.GetSubAssetsOfType <SceneVariableContainer>(TargetManager).Count() == 0)
{
TargetManager.SceneVariables.name = "ManagerVariables";
AssetDatabase.AddObjectToAsset(TargetManager.SceneVariables, TargetManager);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(TargetManager));
}
SerializedManager.ApplyModifiedProperties();
ScenesProp = SerializedManager.FindProperty("scenes");
EntrySceneIdProp = SerializedManager.FindProperty("entrySceneId");
AnyScenesProp = SerializedManager.FindProperty("anyScene");
UseOnPlayProp = SerializedManager.FindProperty("useOnPlay");
GoToOnPlay = SerializedManager.FindProperty("goToOnPlay");
SerializedVariables = new SerializedSceneVariableCollection(TargetManager.SceneVariables);
}
public AssetFilter CreateFilter(string assetName, string filterName, Dictionary <FilterTrackPropertyType, string> trackFilters)
{
AssetFilter assetFilter = new AssetFilter()
{
Tracks = GetTrackSelections(trackFilters)
};
return(_media.AssetFilters.CreateOrUpdate(MediaAccount.ResourceGroupName, MediaAccount.Name, assetName, filterName, assetFilter));
}
private void MakeRefineryItemList()
{
UInt32 characterID = ((TextItemWithUInt32)TlbCmbCharacter.SelectedItem).Data;
ItemAssets container = (ItemAssets)TextItemWithObject.GetData(TlbCmbContainer.SelectedItem);
m_SelectedAssets = null;
if (character_AllItems != characterID)
{
AssetFilter assetFilter = 0;
if (TlbChkIgnoreContainers.Checked)
{
assetFilter |= AssetFilter.NoAssembledContainers;
}
if (TlbChkIgnoreShips.Checked)
{
assetFilter |= AssetFilter.NoAssembledShips;
}
if (TlbChkIgnoreAssembled.Checked)
{
assetFilter |= AssetFilter.NoAssembled;
}
m_SelectedAssets = m_Assets.GetAssetsList(container, assetFilter);
}
ItemFilter filter = new ItemFilter();
filter.Published = TristateFilter.Yes;
filter.PlainMaterials = TristateFilter.Yes;
if (m_SelectedAssets != null)
{
filter.AssetsFilter = m_SelectedAssets;
}
SetupListItemsData(m_ItemsDB.FilterItems(filter), m_SelectedAssets);
UpdateTotalsRow();
// Optimization: pre-fill all column data (saves around 1 sec)
Hashtable columnData = new Hashtable();
foreach (MainListItem listItem in m_ItemList)
{
Object[] columnValues = GetListItemColumnData(listItem);
columnData.Add(listItem.TypeID, columnValues);
}
CompareItemBase comparer = new CompareColumn(m_SortType, columnData);
comparer.SetParameters(m_SortDirection);
Array.Sort(m_ItemList, comparer);
LstRefinery.VirtualListSize = m_ItemList.Count();
UpdateLstRefinery();
}
public PagedResultDto <AssetDto> GetAssets(AssetFilter input)
{
IQueryable <Asset> query = assetRepository.GetAll().Where(x => x.IsDelete == false);
// filter by Area
if (input.Area != null)
{
query = query.Where(x => x.Area.Contains(input.Area));
}
// filter by Area Code
if (input.Areacode != null)
{
query = query.Where(x => x.Areacode.ToLower().Contains(input.Areacode.ToLower()));
}
//filter by Assetname
if (input.Assetname != null)
{
query = query.Where(x => x.Assetname.ToLower().Contains(input.Assetname.ToLower()));
}
//filter by UnitCode
if (input.Unitcode != null)
{
query = query.Where(x => x.Unitcode.ToLower().Contains(input.Assetname.ToLower()));
}
//filter by Transaction
if (input.Transaction != null)
{
query = query.Where(x => x.Transaction.ToLower().Contains(input.Transaction.ToLower()));
}
//filter by AssetCode
if (input.Assetcode != null)
{
query = query.Where(x => x.Assetcode.ToLower().Contains(input.Assetcode.ToLower()));
}
//filter by SeriNumber
if (input.Serinumber != null)
{
query = query.Where(x => x.Serinumber.ToLower().Contains(input.Serinumber.ToLower()));
}
int totalCount = query.Count();
// sorting
if (!string.IsNullOrWhiteSpace(input.Sorting))
{
query = query.OrderBy(input.Sorting);
}
// paging
List <Asset> items = query.PageBy(input).ToList();
// result
return(new PagedResultDto <AssetDto>(
totalCount,
items.Select(item => ObjectMapper.Map <AssetDto>(item)).ToList()));
}
public void NotContains()
{
var valid = new Asset(1, new IComponent[] { _component1 });
var notValid = new Asset(2, new IComponent[] { _component2 });
var filter = new AssetFilter <TestComponent1>(new[] { valid, notValid });
filter.Should().Contain(asset => asset.Id == valid.Id);
filter.Should().NotContain(asset => asset.Id == notValid.Id);
}
public AssetFilter CreateFilter(string assetId, string filterName, FilterTrackPropertyType trackType, string trackValue)
{
string assetName = GetAssetName(assetId);
AssetFilter assetFilter = new AssetFilter()
{
Tracks = GetTrackSelections(trackType, trackValue)
};
return(_media.AssetFilters.CreateOrUpdate(MediaAccount.ResourceGroupName, MediaAccount.Name, assetName, filterName, assetFilter));
}
public static void TestAssetFilter_TemporaryFilter_Mismatch_False()
{
var asset = new StratusAsset {
Id = Guid.Parse("d5c70f1f606340c58b9382c5c5a31d69"),
};
var filter = new AssetFilter {
IdFilter = new Regex("^000"),
};
Assert.False(filter.MatchAsset(asset));
}
public static void TestAssetFilter_CreateTimeRangeFilter_Nothing_True()
{
var asset = new StratusAsset {
CreateTime = new DateTime(123456789L, DateTimeKind.Utc),
};
var filter = new AssetFilter {
CreateTimeRangeFilter = new DateRange(),
};
Assert.True(filter.MatchAsset(asset));
}
public static void TestAssetFilter_NameFilter_Mismatch_False()
{
var asset = new StratusAsset {
Name = "Qwerty",
};
var filter = new AssetFilter {
NameFilter = new Regex("^Asdf", RegexOptions.IgnoreCase),
};
Assert.False(filter.MatchAsset(asset));
}
public static void TestAssetFilter_DescriptionFilter_Match_True()
{
var asset = new StratusAsset {
Description = "Qwerty",
};
var filter = new AssetFilter {
DescriptionFilter = new Regex("^qwe", RegexOptions.IgnoreCase),
};
Assert.True(filter.MatchAsset(asset));
}
public static void TestAssetFilter_TypeFilter_Match_True()
{
var asset = new StratusAsset {
Id = Guid.Parse("d5c70f1f606340c58b9382c5c5a31d69"),
};
var filter = new AssetFilter {
IdFilter = new Regex("^d5c"),
};
Assert.True(filter.MatchAsset(asset));
}
public AssetFilter CreateFilter(string assetName, string filterName, long startSeconds, long endSeconds)
{
AssetFilter assetFilter = new AssetFilter()
{
PresentationTimeRange = new PresentationTimeRange()
{
Timescale = Constant.Media.Filter.Timescale,
StartTimestamp = startSeconds,
EndTimestamp = endSeconds
}
};
return(_media.AssetFilters.CreateOrUpdate(MediaAccount.ResourceGroupName, MediaAccount.Name, assetName, filterName, assetFilter));
}
public static void TestAssetFilter_CreateTimeRangeFilter_Null_Past_False()
{
var asset = new StratusAsset {
CreateTime = new DateTime(123456789L, DateTimeKind.Utc),
};
var filter = new AssetFilter {
CreateTimeRangeFilter = new DateRange(
null,
new DateTime(012345678L, DateTimeKind.Utc)
),
};
Assert.False(filter.MatchAsset(asset));
}
public static void TestAssetFilter_CreateTimeRangeFilter_WrongKind_WrongKind_False()
{
var asset = new StratusAsset {
CreateTime = new DateTime(123456789L, DateTimeKind.Utc),
};
var filter = new AssetFilter {
CreateTimeRangeFilter = new DateRange(
new DateTime(012345678L, DateTimeKind.Local),
new DateTime(234567890L, DateTimeKind.Local)
),
};
Assert.False(filter.MatchAsset(asset));
}
public static void TestAssetFilter_CreateTimeRangeFilter_Past_Future_True()
{
var asset = new StratusAsset {
CreateTime = new DateTime(123456789L, DateTimeKind.Utc),
};
var filter = new AssetFilter {
CreateTimeRangeFilter = new DateRange(
new DateTime(012345678L, DateTimeKind.Utc),
new DateTime(234567890L, DateTimeKind.Utc)
),
};
Assert.True(filter.MatchAsset(asset));
}
public AssetFilter CreateFilter(string assetName, string filterName, long?dvrWindowSeconds, long?liveBackoffSeconds, bool?forceEndTimestamp)
{
AssetFilter assetFilter = new AssetFilter()
{
PresentationTimeRange = new PresentationTimeRange()
{
Timescale = Constant.Media.Filter.Timescale,
PresentationWindowDuration = dvrWindowSeconds,
LiveBackoffDuration = liveBackoffSeconds,
ForceEndTimestamp = forceEndTimestamp
}
};
return(_media.AssetFilters.CreateOrUpdate(MediaAccount.ResourceGroupName, MediaAccount.Name, assetName, filterName, assetFilter));
}
public AssetFilter CreateFilter(string assetId, string filterName, long timescale, long startTimestamp, long endTimestamp)
{
string assetName = GetAssetName(assetId);
AssetFilter assetFilter = new AssetFilter()
{
PresentationTimeRange = new PresentationTimeRange()
{
Timescale = timescale,
StartTimestamp = startTimestamp,
EndTimestamp = endTimestamp
}
};
return(_media.AssetFilters.CreateOrUpdate(MediaAccount.ResourceGroupName, MediaAccount.Name, assetName, filterName, assetFilter));
}
/// <summary>
/// Gets the list of filter names to be applied to this asset, given filtering parameters.
/// </summary>
/// <param name="startTime">The optional start time for filtering.</param>
/// <param name="endTime">The optional end time for filtering.</param>
/// <returns>The list of filter names to be applied to this asset.</returns>
private async Task <List <string> > GetListFiltersAsync(TimeSpan?startTime, TimeSpan?endTime, string uniqueness, string assetName)
{
List <string> listFilters = null;
if (startTime != null || endTime != null)
{
string filterName = "filter-time-" + uniqueness;
PresentationTimeRange presTimeRange = new PresentationTimeRange(
startTime?.Ticks,
endTime?.Ticks,
null,
null,
TimeSpan.TicksPerSecond);
listFilters = new List <string>()
{
filterName
};
try
{
AssetFilter newAssetFilter = await this.MediaServicesV3SdkWrapper.AssetFiltersCreateOrUpdateAsync(
assetName,
filterName,
new AssetFilter()
{
PresentationTimeRange = presTimeRange
}).ConfigureAwait(false);
}
catch (Exception ex)
{
var msg = "AMS v3 Publish. Error when creating asset filter.";
var exceptionToThrow = new GridwichPublicationAssetFilterCreateException(
assetName,
msg,
ex);
// Providing additional specific details:
exceptionToThrow.Data.Add("startTime", startTime?.ToString());
exceptionToThrow.Data.Add("endTime", endTime?.ToString());
throw exceptionToThrow;
}
}
return(listFilters);
}
public IAssetFilter <TComponent> GetFilter <TComponent>() where TComponent : IComponent
{
var filterId = Typeof <IAssetFilter <TComponent> > .Id;
IAssetFilter filter;
using (Lock.Enter(_filters))
{
// ReSharper disable once InvertIf
if (!_filters.TryGetValue(filterId, out filter))
{
filter = new AssetFilter <TComponent>(_assets);
_filters.Add(filterId, filter);
}
}
return((IAssetFilter <TComponent>)filter);
}
private void RenderTestSection()
{
queryString = EditorGUILayout.TextField("Query String: ", queryString);
RenderDefaultInclusionRuleProperty();
if (GUILayout.Button("Test Filter"))
{
AssetFilter filter = target as AssetFilter;
IEnumerable <string> results = filter.FindAssetPaths(queryString);
foreach (string result in results)
{
Debug.Log(result);
}
}
}
/// <summary>
/// Compiles assets into a list, iterating through any nested ones
/// </summary>
/// <param name="a_Container">null or container. If null, all known assets are compiled.</param>
/// <returns>Compiled assets</returns>
public AssetsMap GetAssetsList(ItemAssets a_Container, AssetFilter a_Filter)
{
ItemAssets container = new ItemAssets(0, false);
container.NestedPacked = new AssetsMap();
if (a_Container != null)
{
GetAssetsList_FillNested(a_Container, container, a_Filter);
return(container.NestedPacked);
}
foreach (ItemAssets locationAssets in Assets.Values)
{
GetAssetsList_FillNested(locationAssets, container, a_Filter);
}
return(container.NestedPacked);
}
/// <summary>
/// Create an asset filter.
/// </summary>
/// <param name="client">The Media Services client.</param>
/// <param name="resourceGroupName">The name of the resource group within the Azure subscription.</param>
/// <param name="accountName">The Media Services account name.</param>
/// <param name="assetName">The asset name.</param>
/// <param name="assetFilterName"> The AssetFilter name.</param>
/// <returns></returns>
private async static Task <AssetFilter> CreateAssetFilterAsync(IAzureMediaServicesClient client, string resourceGroupName,
string accountName, string assetName, string assetFilterName)
{
// startTimestamp = 100000000 and endTimestamp = 300000000 using the default timescale will generate
// a play-list that contains fragments from between 10 seconds and 30 seconds of the VoD presentation.
// If a fragment straddles the boundary, the entire fragment will be included in the manifest.
AssetFilter assetFilter = await client.AssetFilters.CreateOrUpdateAsync(
resourceGroupName,
accountName,
assetName,
assetFilterName,
new AssetFilter(
presentationTimeRange : new PresentationTimeRange(
startTimestamp : 100000000L,
endTimestamp : 300000000L))
);
return(assetFilter);
}
internal static void ValidateAssetFilter(AssetFilter assetFilter, FirstQuality expectedFirstQuality, string expectedName, PresentationTimeRange expectedPresentationTimeRange, IList <FilterTrackSelection> expectedTracks)
{
Assert.Equal(expectedFirstQuality?.Bitrate, assetFilter.FirstQuality?.Bitrate);
Assert.Equal(expectedName, assetFilter.Name);
if (expectedPresentationTimeRange != null)
{
Assert.Equal(expectedPresentationTimeRange.StartTimestamp, assetFilter.PresentationTimeRange.StartTimestamp);
Assert.Equal(expectedPresentationTimeRange.EndTimestamp, assetFilter.PresentationTimeRange.EndTimestamp);
Assert.Equal(expectedPresentationTimeRange.PresentationWindowDuration, assetFilter.PresentationTimeRange.PresentationWindowDuration);
Assert.Equal(expectedPresentationTimeRange.LiveBackoffDuration, assetFilter.PresentationTimeRange.LiveBackoffDuration);
Assert.Equal(expectedPresentationTimeRange.Timescale ?? HNSTimescale, assetFilter.PresentationTimeRange.Timescale);
Assert.Equal(expectedPresentationTimeRange.ForceEndTimestamp, assetFilter.PresentationTimeRange.ForceEndTimestamp);
}
else
{
Assert.Null(assetFilter.PresentationTimeRange);
}
if (expectedTracks != null)
{
// A filter can include multiple track definitions
Assert.Equal(expectedTracks.Count, assetFilter.Tracks.Count);
for (int x = 0; x < expectedTracks.Count; x++)
{
// For each track included in the filter, there can be multiple selection criteria. The criteria have an AND relationship
Assert.Equal(expectedTracks[x].TrackSelections.Count, assetFilter.Tracks[x].TrackSelections.Count);
for (int y = 0; y < expectedTracks[x].TrackSelections.Count; y++)
{
Assert.Equal(expectedTracks[x].TrackSelections[y].Property, assetFilter.Tracks[x].TrackSelections[y].Property);
Assert.Equal(expectedTracks[x].TrackSelections[y].Operation, assetFilter.Tracks[x].TrackSelections[y].Operation);
Assert.Equal(expectedTracks[x].TrackSelections[y].Value, assetFilter.Tracks[x].TrackSelections[y].Value);
}
}
}
else
{
Assert.True(assetFilter.Tracks == null || assetFilter.Tracks.Count == 0);
}
}
/// <summary>
/// Creates a filter which includes all the tracks in the list.
/// </summary>
/// <param name="assetName">The asset name.</param>
/// <param name="filterName">The desired filter name.</param>
/// <param name="tracksToKeep">The list of tracks to keep.</param>
private async Task CreateTrackFilterAsync(string assetName, string filterName, List <TrackInfo> tracksToKeep)
{
List <FilterTrackSelection> includedTracks = new List <FilterTrackSelection>();
foreach (TrackInfo track in tracksToKeep)
{
var conditions = new List <FilterTrackPropertyCondition>()
{
new FilterTrackPropertyCondition(FilterTrackPropertyType.Type, track.TrackType, FilterTrackPropertyCompareOperation.Equal),
new FilterTrackPropertyCondition(FilterTrackPropertyType.Name, track.TrackName, FilterTrackPropertyCompareOperation.Equal)
};
includedTracks.Add(new FilterTrackSelection(conditions));
}
AssetFilter assetFilterParams = new AssetFilter(tracks: includedTracks);
try
{
AssetFilter newAssetFilter = await this.MediaServicesV3SdkWrapper.AssetFiltersCreateOrUpdateAsync(
assetName,
filterName,
assetFilterParams)
.ConfigureAwait(false);
}
catch (Exception ex)
{
var msg = "AMS v3 Publish. Error when creating asset filter.";
var exceptionToThrow = new GridwichPublicationAssetFilterCreateException(
assetName,
msg,
ex);
// Providing additional specific details:
exceptionToThrow.SafeAddToData("filterName", filterName);
throw exceptionToThrow;
}
}
