public void WhenDeleteAssetIsCalledThenMediaServicesContextIsCreatedWithTheAccountProvided()
{
const string AccountName = "myAccount";
const string AccountKey = "myKey";
var client = new AzureMediaServicesClient(AccountName, AccountKey);
using (ShimsContext.Create())
{
string providedAccountName = null;
string providedAccountKey = null;
var sampleAssets = new List<IAsset>().AsQueryable();
var collection = new StubAssetBaseCollection { QueryableGet = () => sampleAssets };
ShimCloudMediaContext.ConstructorStringString = (context, accountName, accountKey) =>
{
providedAccountName = accountName;
providedAccountKey = accountKey;
};
ShimCloudMediaContext.AllInstances.AssetsGet = context => collection;
ShimQueryable.WhereOf1IQueryableOfM0ExpressionOfFuncOfM0Boolean<IAsset>((assets, predicate) => sampleAssets);
client.DeleteAsset("nb:cid:UUID:8131a85d-5999-555c-a30f-468cb087701c");
Assert.AreEqual(AccountName, providedAccountName);
Assert.AreEqual(AccountKey, providedAccountKey);
}
}
public void WhenCreateUploaderIsCalledThenUploaderIsReturned()
{
const string AssetName = "MyVideo";
const string Path = @"C:\videos\myvideo.mp4";
var client = new AzureMediaServicesClient("myAccountName", "myAccountKey");
var uploader = client.CreateUploader(AssetName, Path);
Assert.AreEqual(AssetName, uploader.AssetName);
Assert.AreEqual(Path, uploader.FilePath);
}
public void WhenCreateEncoderIsCalledThenEncoderIsReturnedAndConfigured()
{
const string JobName = "MyVideo";
IAsset asset = new StubIAsset();
const string OutputAssetName = "OutputAsset Name";
const string Configuration = "H264 Broadband 720p";
var client = new AzureMediaServicesClient("myAccountName", "myAccountKey");
var encoder = client.CreateEncoder(JobName, asset, Configuration, OutputAssetName);
Assert.AreEqual(JobName, encoder.JobName);
Assert.AreEqual(asset, encoder.InputAsset);
Assert.AreEqual(OutputAssetName, encoder.OutputAssetName);
Assert.AreEqual(Configuration, encoder.Configuration);
}
private async void buttonPickupAccount_Click(object sender, EventArgs e)
{
AddAMSAccount1 addaccount1 = new AddAMSAccount1();
if (addaccount1.ShowDialog() == DialogResult.OK)
{
if (addaccount1.SelectedMode == AddAccountMode.BrowseSubscriptions)
{
environment = addaccount1.GetEnvironment();
AuthenticationContext authContext = new AuthenticationContext(
// authority: environment.Authority,
authority: environment.AADSettings.AuthenticationEndpoint.ToString() + "common",
validateAuthority: true
);
AuthenticationResult accessToken;
try
{
accessToken = await authContext.AcquireTokenAsync(
resource : environment.AADSettings.TokenAudience.ToString(),
clientId : environment.ClientApplicationId,
redirectUri : new Uri("urn:ietf:wg:oauth:2.0:oob"),
parameters : new PlatformParameters(addaccount1.SelectUser ? PromptBehavior.SelectAccount : PromptBehavior.Auto)
);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
TokenCredentials credentials = new TokenCredentials(accessToken.AccessToken, "Bearer");
SubscriptionClient subscriptionClient = new SubscriptionClient(environment.ArmEndpoint, credentials);
Microsoft.Rest.Azure.IPage <Microsoft.Azure.Management.ResourceManager.Models.Subscription> subscriptions = subscriptionClient.Subscriptions.List();
// tenants browsing
myTenants tenants = new myTenants();
string URL = environment.ArmEndpoint + "tenants?api-version=2017-08-01";
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Remove("Authorization");
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + accessToken.AccessToken);
HttpResponseMessage response = await client.GetAsync(URL);
if (response.IsSuccessStatusCode)
{
string str = await response.Content.ReadAsStringAsync();
tenants = (myTenants)JsonConvert.DeserializeObject(str, typeof(myTenants));
}
AddAMSAccount2Browse addaccount2 = new AddAMSAccount2Browse(credentials, subscriptions, environment, tenants.value, new PlatformParameters(addaccount1.SelectUser ? PromptBehavior.SelectAccount : PromptBehavior.Auto));
if (addaccount2.ShowDialog() == DialogResult.OK)
{
// Getting Media Services accounts...
AzureMediaServicesClient mediaServicesClient = new AzureMediaServicesClient(environment.ArmEndpoint, credentials);
CredentialsEntryV3 entry = new CredentialsEntryV3(addaccount2.selectedAccount,
environment,
addaccount1.SelectUser ? PromptBehavior.SelectAccount : PromptBehavior.Auto,
false,
addaccount2.selectedTenantId,
false
);
CredentialList.MediaServicesAccounts.Add(entry);
AddItemToListviewAccounts(entry);
SaveCredentialsToSettings();
}
else
{
return;
}
}
// Get info from the Azure CLI JSON
else if (addaccount1.SelectedMode == AddAccountMode.FromAzureCliJson)
{
string example = @"{
""AadClientId"": ""00000000-0000-0000-0000-000000000000"",
""AadEndpoint"": ""https://login.microsoftonline.com"",
""AadSecret"": ""00000000-0000-0000-0000-000000000000"",
""AadTenantId"": ""00000000-0000-0000-0000-000000000000"",
""AccountName"": ""amsaccount"",
""ArmAadAudience"": ""https://management.core.windows.net/"",
""ArmEndpoint"": ""https://management.azure.com/"",
""Region"": ""West Europe"",
""ResourceGroup"": ""amsResourceGroup"",
""SubscriptionId"": ""00000000-0000-0000-0000-000000000000""
}";
EditorXMLJSON form = new EditorXMLJSON("Enter the JSON output of Azure Cli Service Principal creation (az ams account sp create)", example, true, false, true, "The Service Principal secret is stored encrypted in the application settings.");
if (form.ShowDialog() == DialogResult.OK)
{
JsonFromAzureCli json = null;
try
{
json = (JsonFromAzureCli)JsonConvert.DeserializeObject(form.TextData, typeof(JsonFromAzureCli));
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error reading the json", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
string resourceId = string.Format("/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Media/mediaservices/{2}", json.SubscriptionId, json.ResourceGroup, json.AccountName);
string AADtenantId = json.AadTenantId;
ActiveDirectoryServiceSettings aadSettings = new ActiveDirectoryServiceSettings()
{
AuthenticationEndpoint = json.AadEndpoint,
TokenAudience = json.ArmAadAudience,
ValidateAuthority = true
};
AzureEnvironment env = new AzureEnvironment(AzureEnvType.Custom)
{
AADSettings = aadSettings, ArmEndpoint = json.ArmEndpoint
};
CredentialsEntryV3 entry = new CredentialsEntryV3(
new SubscriptionMediaService(resourceId, json.AccountName, null, null, json.Region),
env,
PromptBehavior.Auto,
true,
AADtenantId,
false
)
{
ADSPClientId = json.AadClientId,
ClearADSPClientSecret = json.AadSecret
};
CredentialList.MediaServicesAccounts.Add(entry);
AddItemToListviewAccounts(entry);
SaveCredentialsToSettings();
}
else
{
return;
}
}
else if (addaccount1.SelectedMode == AddAccountMode.ManualEntry)
{
AddAMSAccount2Manual form = new AddAMSAccount2Manual();
if (form.ShowDialog() == DialogResult.OK)
{
string accountnamecc = form.textBoxAMSResourceId.Text.Split('/').Last();
CredentialsEntryV3 entry = new CredentialsEntryV3(
new SubscriptionMediaService(form.textBoxAMSResourceId.Text, accountnamecc, null, null, form.textBoxLocation.Text),
addaccount1.GetEnvironment(),
PromptBehavior.Auto,
form.radioButtonAADServicePrincipal.Checked,
form.textBoxAADtenantId.Text,
true
);
CredentialList.MediaServicesAccounts.Add(entry);
AddItemToListviewAccounts(entry);
SaveCredentialsToSettings();
}
else
{
return;
}
}
}
}
public void WhenGetMediaProcessorsIsCalledThenMediaServicesContextIsCreatedWithTheAccountProvided()
{
const string AccountName = "myAccount";
const string AccountKey = "myKey";
var client = new AzureMediaServicesClient(AccountName, AccountKey);
using (ShimsContext.Create())
{
string providedAccountName = null;
string providedAccountKey = null;
ShimCloudMediaContext.ConstructorStringString = (context, accountName, accountKey) =>
{
providedAccountName = accountName;
providedAccountKey = accountKey;
};
client.GetMediaProcessors();
Assert.AreEqual(AccountName, providedAccountName);
Assert.AreEqual(AccountKey, providedAccountKey);
}
}
public void WhenGetJobsByStateIsCalledThenMediaServicesContextIsCreatedWithTheAccountProvided()
{
const string AccountName = "myAccount";
const string AccountKey = "myKey";
var client = new AzureMediaServicesClient(AccountName, AccountKey);
using (ShimsContext.Create())
{
string providedAccountName = null;
string providedAccountKey = null;
var jobs = new List<IJob>().AsQueryable();
var collection = new ShimJobBaseCollection();
collection.Bind(jobs);
ShimCloudMediaContext.ConstructorStringString = (context, accountName, accountKey) =>
{
providedAccountName = accountName;
providedAccountKey = accountKey;
};
ShimCloudMediaContext.AllInstances.JobsGet = context => collection;
client.GetJobsByState(JobState.Finished);
Assert.AreEqual(AccountName, providedAccountName);
Assert.AreEqual(AccountKey, providedAccountKey);
}
}
public void WhenGetMediaProcessorsIsCalledThenAllMediaProcessorsAreReturned()
{
var client = new AzureMediaServicesClient("myAccountName", "myAccountKey");
using (ShimsContext.Create())
{
var mediaProcessor = new StubIMediaProcessor { NameGet = () => "My Media Processor" };
var mediaProcessors = new List<IMediaProcessor> { mediaProcessor };
var collection = new ShimMediaProcessorBaseCollection();
collection.Bind(mediaProcessors.AsQueryable());
ShimCloudMediaContext.ConstructorStringString = (context, accountName, accountKey) => { };
ShimCloudMediaContext.AllInstances.MediaProcessorsGet = context => collection;
var returnedMediaProcesors = client.GetMediaProcessors();
Assert.AreEqual(1, returnedMediaProcesors.Count());
Assert.AreEqual(mediaProcessor.NameGet(), returnedMediaProcesors.First().Name);
}
}
public void WhenGetJobIsCalledWithANonExistingIdThenNullIsReturned()
{
var client = new AzureMediaServicesClient("myAccountName", "myAccountKey");
using (ShimsContext.Create())
{
const string JobId = "nb:cid:UUID:8131a85d-5999-555c-a30f-468cb087701c";
var job = new StubIJob() { IdGet = () => "myId" };
var jobs = new List<IJob> { job };
var collection = new ShimJobBaseCollection();
collection.Bind(jobs.AsQueryable());
ShimCloudMediaContext.ConstructorStringString = (context, accountName, accountKey) => { };
ShimCloudMediaContext.AllInstances.JobsGet = context => collection;
var returnedJob = client.GetJob(JobId);
Assert.IsNull(returnedJob);
}
}
public void WhenGetJobsByStateIsCalledThenJobsInTheProvidedStateAreReturned()
{
var client = new AzureMediaServicesClient("myAccountName", "myAccountKey");
using (ShimsContext.Create())
{
var job1 = new StubIJob() { StateGet = () => JobState.Finished };
var job2 = new StubIJob() { StateGet = () => JobState.Canceled };
var jobs = new List<IJob> { job1, job2 };
var collection = new ShimJobBaseCollection();
collection.Bind(jobs.AsQueryable());
ShimCloudMediaContext.ConstructorStringString = (context, accountName, accountKey) => { };
ShimCloudMediaContext.AllInstances.JobsGet = context => collection;
var returnedJobs = client.GetJobsByState(JobState.Finished);
Assert.AreEqual(1, returnedJobs.Count());
}
}
public void WhenGetAssetsIsCalledWithAPredicateThenAssetsCollectionIsFiltered()
{
var client = new AzureMediaServicesClient("myAccountName", "myAccountKey");
using (ShimsContext.Create())
{
var asset1 = new StubIAsset { NameGet = () => "EZ" };
var asset2 = new StubIAsset { NameGet = () => "VOD" };
var sampleAssets = new List<IAsset> { asset1, asset2 };
var collection = new StubAssetBaseCollection { QueryableGet = sampleAssets.AsQueryable };
Expression<Func<IAsset, bool>> filter = asset => asset.Name == "EZ";
Expression<Func<IAsset, bool>> providedPredicate = null;
ShimCloudMediaContext.ConstructorStringString = (context, accountName, accountKey) => { };
ShimCloudMediaContext.AllInstances.AssetsGet = context => collection;
ShimQueryable.WhereOf1IQueryableOfM0ExpressionOfFuncOfM0Boolean<IAsset>((assets, predicate) =>
{
Assert.AreEqual(2, assets.Count());
providedPredicate = predicate;
return ShimsContext.ExecuteWithoutShims(() => assets.Where(predicate));
});
var returnedAssets = client.GetAssets(filter);
Assert.AreSame(filter, providedPredicate);
Assert.AreEqual(1, returnedAssets.Count());
Assert.AreEqual(asset1.NameGet(), returnedAssets.First().Name);
}
}
public void WhenGetAssetsIsCalledWithNoPredicateThenAllAssetsAreReturned()
{
var client = new AzureMediaServicesClient("myAccountName", "myAccountKey");
using (ShimsContext.Create())
{
var asset = new StubIAsset { NameGet = () => "EZ" };
var assets = new List<IAsset> { asset };
var collection = new StubAssetBaseCollection { QueryableGet = assets.AsQueryable };
ShimCloudMediaContext.ConstructorStringString = (context, accountName, accountKey) => { };
ShimCloudMediaContext.AllInstances.AssetsGet = context => collection;
var returnedAssets = client.GetAssets();
Assert.AreEqual(1, returnedAssets.Count());
Assert.AreSame(collection, returnedAssets);
}
}
public void WhenGetAssetsIsCalledThenMediaServicesContextIsCreatedWithTheAccountProvided()
{
const string AccountName = "myAccount";
const string AccountKey = "myKey";
var client = new AzureMediaServicesClient(AccountName, AccountKey);
using (ShimsContext.Create())
{
string providedAccountName = null;
string providedAccountKey = null;
ShimCloudMediaContext.ConstructorStringString = (context, accountName, accountKey) =>
{
providedAccountName = accountName;
providedAccountKey = accountKey;
};
ShimQueryable.WhereOf1IQueryableOfM0ExpressionOfFuncOfM0Boolean<IAsset>((assets, predicate) => null);
client.GetAssets(asset => asset.Name == "EZ");
Assert.AreEqual(AccountName, providedAccountName);
Assert.AreEqual(AccountKey, providedAccountKey);
}
}
public void WhenGetAssetIsCalledWithANonExistingIdThenNullIsReturned()
{
var client = new AzureMediaServicesClient("myAccountName", "myAccountKey");
using (ShimsContext.Create())
{
const string AssetId = "nb:cid:UUID:8131a85d-5999-555c-a30f-468cb087701c";
var asset = new StubIAsset { IdGet = () => "myId" };
var assets = new List<IAsset> { asset };
var collection = new StubAssetBaseCollection { QueryableGet = assets.AsQueryable };
ShimCloudMediaContext.ConstructorStringString = (context, accountName, accountKey) => { };
ShimCloudMediaContext.AllInstances.AssetsGet = context => collection;
var returnedAsset = client.GetAsset(AssetId);
Assert.IsNull(returnedAsset);
}
}
public void WhenDeleteAssetIsCalledWithAnExistingIdThenDeleteIsCalledOnAsset()
{
bool deleteCalled = false;
var client = new AzureMediaServicesClient("myAccountName", "myAccountKey");
using (ShimsContext.Create())
{
const string AssetId = "nb:cid:UUID:8131a85d-5999-555c-a30f-468cb087701c";
var asset1 = new StubIAsset { IdGet = () => AssetId };
var asset2 = new StubIAsset { IdGet = () => "myId" };
asset1.Delete = () => { deleteCalled = true; };
var assets = new List<IAsset> { asset1, asset2 };
var collection = new StubAssetBaseCollection { QueryableGet = assets.AsQueryable };
ShimCloudMediaContext.ConstructorStringString = (context, accountName, accountKey) => { };
ShimCloudMediaContext.AllInstances.AssetsGet = context => collection;
client.DeleteAsset(AssetId);
Assert.IsTrue(deleteCalled);
}
}
private async Task <AzureMediaServicesClient> Init(bool isDevelop)
{
var jsonFile = "appsettings.json";
if (isDevelop)
{
jsonFile = "appsettings-dev.json";
}
using (var stream = Assembly.GetExecutingAssembly()
.GetManifestResourceStream($"Cloudents.Infrastructure.Video.{jsonFile}"))
{
_config = stream.ToJsonReader <ConfigWrapper>();
}
var clientCredential = new ClientCredential(_config.AadClientId, _config.AadSecret);
var serviceClientCredentials = await ApplicationTokenProvider.LoginSilentAsync(_config.AadTenantId, clientCredential, ActiveDirectoryServiceSettings.Azure);
//TODO Maybe we should pass http client factory
var client = new AzureMediaServicesClient(_config.ArmEndpoint, serviceClientCredentials)
{
SubscriptionId = _config.SubscriptionId,
};
var t1 = client.Transforms.CreateOrUpdateAsync(
_config.ResourceGroup,
_config.AccountName,
ThumbnailTransformer,
new List <TransformOutput>()
{
new TransformOutput(
new StandardEncoderPreset(
new List <Codec>()
{
new JpgImage(start: "{Best}", layers: new List <JpgLayer>()
{
new JpgLayer("100%", "100%", quality: 80)
})
}
,
new List <Format>()
{
new JpgFormat(PrefixThumbnailBlobName + "{Index}{Extension}")
}),
onError: OnErrorType.ContinueJob
)
});
var t2 = client.Transforms.CreateOrUpdateAsync(
_config.ResourceGroup,
_config.AccountName,
StreamingTransformer,
new List <TransformOutput>()
{
new TransformOutput(new BuiltInStandardEncoderPreset()
{
PresetName = EncoderNamedPreset.AdaptiveStreaming
}),
});
var t3 = client.Transforms.CreateOrUpdateAsync(
_config.ResourceGroup,
_config.AccountName,
FullHdTransformer,
new List <TransformOutput>()
{
new TransformOutput(new BuiltInStandardEncoderPreset()
{
PresetName = EncoderNamedPreset.H264SingleBitrate1080p
}),
});
await Task.WhenAll(t1, t2, t3);
return(client);
//TODO: need to add event to queue
}
private async void listViewAccounts_SelectedIndexChanged(object sender, EventArgs e)
{
ErrorConnectingAMS = false;
ErrorConnectingStorage = false;
listBoxStorage.Items.Clear();
if (listViewAccounts.SelectedIndices.Count != 1)
{
return;
}
// code when used from pick-up
DestinationLoginInfo = CredentialList.MediaServicesAccounts[listViewAccounts.SelectedIndices[0]];
if (DestinationLoginInfo == null)
{
MessageBox.Show("Error", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
//MessageBox.Show(string.Format("The {0} cannot be empty.", labelE1.Text), "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
this.Cursor = Cursors.WaitCursor;
DestinationAmsClient = new AMSClientV3(DestinationLoginInfo.Environment, DestinationLoginInfo.AzureSubscriptionId, DestinationLoginInfo);
AzureMediaServicesClient response = null;
try
{
response = await DestinationAmsClient.ConnectAndGetNewClientV3Async();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Cursor = Cursors.Default;
ErrorConnectingAMS = true;
return;
}
if (response == null)
{
Cursor = Cursors.Default;
ErrorConnectingAMS = true;
return;
}
// let's save the credentials (SP) They may be updated by the user when connecting
CredentialList.MediaServicesAccounts[listViewAccounts.SelectedIndices[0]] = DestinationAmsClient.credentialsEntry;
//SaveCredentialsToSettings();
try
{ // let's refresh storage accounts
DestinationAmsClient.credentialsEntry.MediaService.StorageAccounts = (await DestinationAmsClient.AMSclient.Mediaservices.GetAsync(DestinationAmsClient.credentialsEntry.ResourceGroup, DestinationAmsClient.credentialsEntry.AccountName)).StorageAccounts;
foreach (var storage in DestinationAmsClient.credentialsEntry.MediaService.StorageAccounts)
{
string storageName = AMSClientV3.GetStorageName(storage.Id);
int index = listBoxStorage.Items.Add(new Item(storageName + ((storage.Type == StorageAccountType.Primary) ? AMSExplorer.Properties.Resources.CopyAsset_listBoxAcounts_SelectedIndexChanged_Default : string.Empty), storageName));
if (storage.Type == StorageAccountType.Primary)
{
listBoxStorage.SelectedIndex = index;
}
}
Cursor = Cursors.Default;
}
catch (Exception ex)
{
MessageBox.Show(Program.GetErrorMessage(ex), "Login error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Cursor = Cursors.Default;
ErrorConnectingAMS = true;
return;
}
// DialogResult = DialogResult.OK; // form will close with OK result
// else --> form won't close...
UpdateStatusButtonOk();
}