/// <summary>
/// Lists protection containers according to the provider data
/// </summary>
/// <returns>List of protection containers</returns>
public List <ContainerBase> ListProtectionContainers()
{
string vaultName = (string)ProviderData[VaultParams.VaultName];
string resourceGroupName = (string)ProviderData[VaultParams.ResourceGroupName];
string name = (string)ProviderData[ContainerParams.FriendlyName];
ODataQuery <BMSContainerQueryObject> queryParams =
new ODataQuery <BMSContainerQueryObject>(
q => q.BackupManagementType
== ServiceClientModel.BackupManagementType.AzureSql);
var listResponse = ServiceClientAdapter.ListContainers(
queryParams,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
List <ContainerBase> containerModels =
ConversionHelpers.GetContainerModelList(listResponse);
if (!string.IsNullOrEmpty(name))
{
if (containerModels != null)
{
containerModels = containerModels.Where(x => x.Name == name).ToList();
}
}
return(containerModels);
}
public async Task RunAsync(GuidToAccountNumberOptions o)
{
var number = ConversionHelpers.GuidToAccountNumber(o.Guid);
_logger.LogInformation(number);
await Task.CompletedTask;
}
public ClientAudioProvider()
{
_filters = new OnlineFilter[2];
_filters[0] =
OnlineFilter.CreateBandpass(ImpulseResponse.Finite, AudioManager.INPUT_SAMPLE_RATE, 560, 3900);
_filters[1] =
OnlineFilter.CreateBandpass(ImpulseResponse.Finite, AudioManager.INPUT_SAMPLE_RATE, 100, 4500);
JitterBufferProviderInterface =
new JitterBufferProviderInterface(new WaveFormat(AudioManager.INPUT_SAMPLE_RATE, 2));
SampleProvider = new Pcm16BitToSampleProvider(JitterBufferProviderInterface);
_decoder = OpusDecoder.Create(AudioManager.INPUT_SAMPLE_RATE, 1);
_decoder.ForwardErrorCorrection = false;
_highPassFilter = BiQuadFilter.HighPassFilter(AudioManager.INPUT_SAMPLE_RATE, 520, 0.97f);
_lowPassFilter = BiQuadFilter.LowPassFilter(AudioManager.INPUT_SAMPLE_RATE, 4130, 2.0f);
var effect = new CachedAudioEffect(CachedAudioEffect.AudioEffectTypes.NATO_TONE);
if (effect.AudioEffectBytes.Length > 0)
{
natoTone = ConversionHelpers.ByteArrayToShortArray(effect.AudioEffectBytes);
var vol = Settings.GlobalSettingsStore.Instance.GetClientSetting(GlobalSettingsKeys.NATOToneVolume)
.FloatValue;
for (int i = 0; i < natoTone.Length; i++)
{
natoTone[i] = (short)(natoTone[i] * vol);
}
}
}
/// <summary>
/// Lists protection containers according to the provider data
/// </summary>
/// <returns>List of protection containers</returns>
public List <Models.ContainerBase> ListProtectionContainers()
{
string name = (string)this.ProviderData[ContainerParams.Name];
ProtectionContainerListQueryParams queryParams =
new ProtectionContainerListQueryParams();
queryParams.BackupManagementType =
ServiceClientModel.BackupManagementType.AzureSql.ToString();
var listResponse = ServiceClientAdapter.ListContainers(queryParams);
List <ContainerBase> containerModels =
ConversionHelpers.GetContainerModelList(listResponse);
if (!string.IsNullOrEmpty(name))
{
if (containerModels != null)
{
containerModels = containerModels.Where(x => x.Name == name).ToList();
}
}
return(containerModels);
}
public void EnumParse_null_ArgumentException_ignoreCaseTrue()
{
//even with null, first ArgumentException
double result;
Assert.Throws <ArgumentException>(() => ConversionHelpers.TryParse(null, true, out result));
}
public RadioMixDown[] MixDown()
{
// long start = Environment.TickCount;
lock (_lock)
{
var radioMix = new RadioMixDown[_clientRadioBuffers.Length];
bool _addEffect = _settings.UserSettings[(int)SettingType.RadioEffects] == "ON";
for (var i = 0; i < _clientRadioBuffers.Length; i++)
{
var radioBytes = ConversionHelpers.ShortArrayToByteArray(
AddRadioEffect(RadioMixDown(_clientRadioBuffers[i], i), _addEffect)
);
radioMix[i] = new RadioMixDown
{
RadioAudioPCM = (radioBytes),
HasDecryptedAudio = _hasDecryptedAudio[i]
//mark if this contains encrypted audio for effects
};
}
Clear();
// Logger.Debug("Mixdown took: "+(Environment.TickCount - start));
return(radioMix);
}
}
public async void LoadCharacteristics()
{
IEnumerable <ICharacteristic> characteristics = await ServiceInstance.GetCharacteristicsAsync();
foreach (ICharacteristic characteristic in characteristics)
{
if (characteristic.Id == TemperatureCharacteristicId)
{
characteristic.ValueUpdated += (sender, e) =>
{
byte[] tempBytes = e.Characteristic.Value;
Temperature = (sbyte)(tempBytes.First());
System.Diagnostics.Debug.WriteLine("Temperature: " + " " + Temperature);
};
MarkCharacteristicForUpdate(characteristic);
}
else if (characteristic.Id == TemperaturePeriodCharacteristicId)
{
byte[] val = await characteristic.ReadAsync();
int period = ConversionHelpers.ByteArrayToShort16BitLittleEndian(val);
TemperaturePeriod = period;
System.Diagnostics.Debug.WriteLine("Temperature period: " + " " + Temperature);
}
}
StartUpdates();
}
internal static string FormatWeatherResponse(CurrentWeatherModel.CurrentCondition currentWeather, CurrentWeatherModel.Location location, bool shortWeather = false)
{
var b = IrcConstants.IrcBold;
var n = IrcConstants.IrcNormal; // Gets a bit repetitive (also I'm illiterate)
if (shortWeather)
{
return
($"{b}{location.Name}, {location.Country}{n}: " +
$"{b}Temp:{n} {FormatTemperatureCelsius(currentWeather.Temperature)}°C " +
$"(feels like {FormatTemperatureCelsius(currentWeather.FeelsLike)}°C); " +
$"{b}Cond:{n} {currentWeather.WeatherDescriptions[0]}; " +
$"{b}Precip:{n} {currentWeather.Precipitation} mm; " +
$"{b}Humidity:{n} {currentWeather.Humidity}%; " +
$"at {currentWeather.ObservationTime} UTC");
}
return
($"Weather at {b}{location.Name}, {location.Region}, {location.Country}{n}: " +
$"{b}Temp:{n} {FormatTemperatureCelsius(currentWeather.Temperature)}°C / {FormatTemperatureFahrenheit(ConversionHelpers.CelsiusToFahrenheit(currentWeather.Temperature))}°F " +
$"(feels like {FormatTemperatureCelsius(currentWeather.FeelsLike)}°C / {FormatTemperatureFahrenheit(ConversionHelpers.CelsiusToFahrenheit(currentWeather.FeelsLike))}°F); " +
$"{b}Condition:{n} {currentWeather.WeatherDescriptions[0]}; " +
$"{b}Wind:{n} {currentWeather.WindSpeed} Kph / {ConversionHelpers.KilometresToMiles(currentWeather.WindSpeed)} Mph {currentWeather.WindDirection}; " +
$"{b}Precipitation:{n} {currentWeather.Precipitation} mm / {ConversionHelpers.MmToInch(currentWeather.Precipitation)} in; " +
$"{b}Humidity:{n} {currentWeather.Humidity}%; " +
$"{b}Pressure:{n} {currentWeather.Pressure} mbars; " +
$"{b}Visibility:{n} {currentWeather.Visibility} km / {ConversionHelpers.KilometresToMiles( currentWeather.Visibility)} mi; " +
$"Observed at {currentWeather.ObservationTime} UTC");
}
private static void TestEnumParseCaseIgnoreCaseParam(string value, bool ignoreCase, TestEnum expected, bool expectedReturn)
{
{
var returnResult = ConversionHelpers.TryParseEnum(value, ignoreCase, out TestEnum result);
Assert.Equal(expected, result);
Assert.Equal(expectedReturn, returnResult);
}
// if true, test also other TryParseEnum
if (ignoreCase)
{
{
var returnResult = ConversionHelpers.TryParseEnum <TestEnum>(value, out var result);
Assert.Equal(expected, result);
Assert.Equal(expectedReturn, returnResult);
}
{
var returnResult = ConversionHelpers.TryParseEnum(value, typeof(TestEnum), out var result);
Assert.Equal(expectedReturn, returnResult);
if (expectedReturn)
{
Assert.Equal(expected, result);
}
else
{
Assert.Null(result);
}
}
}
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
string backupManagementType = "";
string workloadType = "";
string containerName = "";
if (ParameterSetName == IdParamSet)
{
Dictionary <UriEnums, string> keyValueDict = HelperUtils.ParseUri(ParentID);
containerName = HelperUtils.GetContainerUri(keyValueDict, ParentID);
if (containerName.Split(new string[] { ";" }, System.StringSplitOptions.None)[0].ToLower() == "vmappcontainer")
{
backupManagementType = ServiceClientModel.BackupManagementType.AzureWorkload;
}
string protectableItem = HelperUtils.GetProtectableItemUri(keyValueDict, ParentID);
if (protectableItem.Split(new string[] { ";" }, System.StringSplitOptions.None)[0].ToLower() == "sqlinstance" ||
protectableItem.Split(new string[] { ";" }, System.StringSplitOptions.None)[0].ToLower() == "sqlavailabilitygroupcontainer")
{
workloadType = ServiceClientModel.WorkloadType.SQLDataBase;
}
}
else
{
backupManagementType = Container.BackupManagementType.ToString();
workloadType = ConversionUtils.GetServiceClientWorkloadType(WorkloadType.ToString());
containerName = Container.Name;
}
ODataQuery <BMSPOQueryObject> queryParam = new ODataQuery <BMSPOQueryObject>(
q => q.BackupManagementType
== backupManagementType &&
q.WorkloadType == workloadType &&
q.ContainerName == containerName);
WriteDebug("going to query service to get list of protectable items");
List <WorkloadProtectableItemResource> protectableItems =
ServiceClientAdapter.ListProtectableItem(
queryParam,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
WriteDebug("Successfully got response from service");
List <ProtectableItemBase> itemModels = ConversionHelpers.GetProtectableItemModelList(protectableItems);
if (ParameterSetName == FilterParamSet)
{
string protectableItemType = ItemType.ToString();
itemModels = itemModels.Where(itemModel =>
{
return(((AzureWorkloadProtectableItem)itemModel).ProtectableItemType == protectableItemType);
}).ToList();
}
WriteObject(itemModels, enumerateCollection: true);
});
}
public List <ItemBase> GetMABProtectedItems(string vaultName, string resourceGroupName, ContainerBase container = null)
{
ODataQuery <ProtectedItemQueryObject> queryParams =
new ODataQuery <ProtectedItemQueryObject>(
q => q.BackupManagementType == ServiceClientModel.BackupManagementType.MAB);
List <ProtectedItemResource> protectedItems = ServiceClientAdapter.ListProtectedItem(
queryParams,
null,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
// filter by Container Name if given
if (container != null)
{
protectedItems = protectedItems.Where(protectedItem =>
{
Dictionary <CmdletModel.UriEnums, string> dictionary = HelperUtils.ParseUri(protectedItem.Id);
string containerUri = HelperUtils.GetContainerUri(dictionary, protectedItem.Id);
var delimIndex = containerUri.IndexOf(';');
string containerName = containerUri.Substring(delimIndex + 1);
return(containerName.ToLower().Equals(container.Name.ToLower()));
}).ToList();
}
return(ConversionHelpers.GetItemModelList(protectedItems));
}
public int Read(byte[] buffer, int offset, int count)
{
int read = source.Read(buffer, offset, count);
if (Settings.GlobalSettingsStore.Instance.ProfileSettingsStore.GetClientSettingBool(ProfileSettingsKeys.NATOTone))
{
var effectBytes = GetEffect(read / 2);
//mix together
for (int i = 0; i < read / 2; i++)
{
short audio = ConversionHelpers.ToShort(buffer[(offset + i) * 2], buffer[((i + offset) * 2) + 1]);
audio = (short)(audio + _audioEffectShort[i]);
//buffer[i + offset] = effectBytes[i]+buffer[i + offset];
byte byte1;
byte byte2;
ConversionHelpers.FromShort(audio, out byte1, out byte2);
buffer[(offset + i) * 2] = byte1;
buffer[((i + offset) * 2) + 1] = byte2;
}
}
return(read);
}
public static byte[] CreateStereoMix(byte[] pcmAudio)
{
var stereoMix = new byte[pcmAudio.Length * 2];
for (var i = 0; i < pcmAudio.Length / 2; i++)
{
short audio = ConversionHelpers.ToShort(pcmAudio[i * 2], pcmAudio[i * 2 + 1]);
//half audio to keep loudness the same
if (audio != 0)
{
audio = (short)(audio / 2);
}
byte byte1;
byte byte2;
ConversionHelpers.FromShort(audio, out byte1, out byte2);
stereoMix[i * 4] = byte1;
stereoMix[i * 4 + 1] = byte2;
stereoMix[i * 4 + 2] = byte1;
stereoMix[i * 4 + 3] = byte2;
}
return(stereoMix);
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
WriteDebug(string.Format("Input params - Name:{0}, WorkloadType:{1}, " +
"BackupManagementType: {2}, " +
"RetentionPolicy:{3}, SchedulePolicy:{4}",
Name, WorkloadType.ToString(),
BackupManagementType.HasValue ? BackupManagementType.ToString() : "NULL",
RetentionPolicy == null ? "NULL" : RetentionPolicy.ToString(),
SchedulePolicy == null ? "NULL" : SchedulePolicy.ToString()));
// validate policy name
PolicyCmdletHelpers.ValidateProtectionPolicyName(Name);
// Validate if policy already exists
if (PolicyCmdletHelpers.GetProtectionPolicyByName(
Name,
ServiceClientAdapter,
vaultName: vaultName,
resourceGroupName: resourceGroupName) != null)
{
throw new ArgumentException(string.Format(Resources.PolicyAlreadyExistException, Name));
}
Dictionary <Enum, object> providerParameters = new Dictionary <Enum, object>();
providerParameters.Add(VaultParams.VaultName, vaultName);
providerParameters.Add(VaultParams.ResourceGroupName, resourceGroupName);
providerParameters.Add(PolicyParams.PolicyName, Name);
providerParameters.Add(PolicyParams.WorkloadType, WorkloadType);
providerParameters.Add(PolicyParams.RetentionPolicy, RetentionPolicy);
providerParameters.Add(PolicyParams.SchedulePolicy, SchedulePolicy);
PsBackupProviderManager providerManager = new PsBackupProviderManager(providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(WorkloadType, BackupManagementType);
psBackupProvider.CreatePolicy();
WriteDebug("Successfully created policy, now fetching it from service: " + Name);
// now get the created policy and return
ServiceClientModel.ProtectionPolicyResource policy = PolicyCmdletHelpers.GetProtectionPolicyByName(
Name,
ServiceClientAdapter,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
// now convert service Policy to PSObject
WriteObject(ConversionHelpers.GetPolicyModel(policy));
}, ShouldProcess(Name, VerbsCommon.New));
}
public void AddClientAudioSamples(ClientAudio audio)
{
//sort out volume
var timer = new Stopwatch();
timer.Start();
var decrytable = audio.Decryptable || (audio.Encryption == 0);
if (decrytable)
{
//adjust for LOS + Distance + Volume
AdjustVolume(audio);
////no radio effect for intercom
if (audio.ReceivedRadio != 0)
{
if (_settings.UserSettings[(int)SettingType.RadioEffects] != "OFF")
{
AddRadioEffect(audio);
}
}
}
else
{
AddEncryptionFailureEffect(audio);
if (_settings.UserSettings[(int)SettingType.RadioEffects] != "OFF")
{
AddRadioEffect(audio);
}
}
long now = Environment.TickCount;
if ((now - LastUpdate) > 400) //400 ms since last update
{
// System.Diagnostics.Debug.WriteLine(audio.ClientGuid+"ADDED");
//append ms of silence - this functions as our jitter buffer??
var silencePad = (AudioManager.INPUT_SAMPLE_RATE / 1000) * SILENCE_PAD;
var newAudio = new short[audio.PcmAudioShort.Length + silencePad];
Buffer.BlockCopy(audio.PcmAudioShort, 0, newAudio, silencePad, audio.PcmAudioShort.Length);
audio.PcmAudioShort = newAudio;
}
_lastReceivedOn = audio.ReceivedRadio;
LastUpdate = now;
JitterBufferProviderInterface.AddSamples(new JitterBufferAudio
{
Audio = SeperateAudio(ConversionHelpers.ShortArrayToByteArray(audio.PcmAudioShort), audio.ReceivedRadio),
PacketNumber = audio.PacketNumber
});
timer.Stop();
}
public override string ToString()
{
string bigStr = mIntegerValue.ToString();
if (mScale == 0)
{
return(bigStr);
}
bool negative = (bigStr[0] == '-');
int point = bigStr.Length - mScale - (negative ? 1 : 0);
StringBuilder val = new StringBuilder();
if (mScale >= 0 && (point - 1) > -6)
{
if (point <= 0)
{
if (negative)
{
val.Append('-');
}
val.Append('0').Append('.');
while (point < 0)
{
val.Append('0');
point++;
}
val.Append(bigStr.Substring(negative ? 1 : 0));
}
else
{
val.Append(bigStr);
val.Insert(point + (negative ? 1 : 0), '.');
}
}
else
{
val.Append(bigStr);
if (bigStr.Length > 1)
{
val.Insert((negative ? 2 : 1), '.');
}
val.Append('E');
if (point - 1 >= 0)
{
val.Append('+');
}
val.Append(point - 1);
}
var stringVal = val.ToString();
stringVal = ConversionHelpers.RemoveTrailingZeros(stringVal);
return(stringVal);
}
public static byte[] Hash(byte[] message)
{
uint[] hash = { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 };
byte[] beginState = MdPadding(message);
MainLoop(beginState, hash);
return(ConversionHelpers.ToBigEndianByteArray(hash));
}
public CachedLoopingAudioProvider(IWaveProvider source, WaveFormat waveFormat, CachedAudioEffect.AudioEffectTypes effectType)
{
this.WaveFormat = waveFormat;
var effect = new CachedAudioEffect(effectType);
_audioEffectShort = ConversionHelpers.ByteArrayToShortArray(effect.AudioEffectBytes);
this.source = source;
}
private static void TestEnumParseCaseIgnoreCaseParam(string value, bool ignoreCase, TestEnum expected, bool expectedReturn)
{
TestEnum result;
var returnResult = ConversionHelpers.TryParse(value, ignoreCase, out result);
Assert.Equal(expected, result);
Assert.Equal(expectedReturn, returnResult);
}
public void RepresentationStringToListOfStringsTest_Sub36RadixInput_Pass()
{
var input = "7543";
var radix = 8;
var expectedList = new List <string>(new string[] { "7", "5", "4", "3" });
var actualList = ConversionHelpers.RepresentationStringToListOfStrings(input, radix);
var actual = actualList.SequenceEqual(expectedList);
Assert.AreEqual(true, actual);
}
public void RepresentationStringToListOfStringsTest_MoreThan36RadixInput_Pass()
{
var input = "12 24 26 76";
var radix = 64;
var expectedList = new List <string>(new string[] { "12", "24", "26", "76" });
var actualList = ConversionHelpers.RepresentationStringToListOfStrings(input, radix);
var actual = actualList.SequenceEqual(expectedList);
Assert.AreEqual(true, actual);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TValue"></typeparam>
/// <param name="defaultValue"></param>
/// <returns></returns>
public TValue GetValue <TValue>(TValue defaultValue)
{
TValue value;
if (ConversionHelpers.TryConvert(Value, out value))
{
return(value);
}
return(defaultValue);
}
public void isCurrencyType_WhenTypeIsCents_ReturnsCentsString()
{
// Arrange
int typeTest = 0;
string typeExpected = "Cents";
// Act
var result = ConversionHelpers.isCurrencyType(typeTest);
// Assert
Assert.AreEqual(typeExpected, result);
}
public void ConvertWholeNumber_PositiveIntNumberStringTest_ReturnsNumericIntString()
{
// Arrange
var helpers = this.CreateHelpers();
string Number = "101.25";
string stringExpected = "One Hundred One Thousand Hundred Twenty Five";
// Act
var result = ConversionHelpers.ConvertWholeNumber(Number);
// Assert
Assert.AreEqual(stringExpected, result);
}
public void ConvertWholeNumber_EmptyStringTest_ReturnsEmptyString()
{
// Arrange
var helpers = this.CreateHelpers();
string Number = "";
string stringExpected = "";
// Act
var result = ConversionHelpers.ConvertWholeNumber(Number);
// Assert
Assert.AreEqual(stringExpected, result);
}
/// <summary>
/// Lists backup management servers registered with the recovery services vault
/// </summary>
/// <returns></returns>
public List <Models.BackupEngineBase> ListBackupManagementServers()
{
string name = (string)this.ProviderData[ContainerParams.Name];
ServiceClientModel.BackupEngineListQueryParams queryParams = new ServiceClientModel.BackupEngineListQueryParams();
var listResponse = ServiceClientAdapter.ListBackupEngines(queryParams);
List <BackupEngineBase> backupEngineModels = ConversionHelpers.GetBackupEngineModelList(listResponse);
return(backupEngineModels);
}
public void Test_Pound_Conversion()
{
// arrange - setup
var kgs = 20.0;
var expectedPounds = 44.092;
// act - test
var result = ConversionHelpers.ToPounds(kgs);
// assert - check
Assert.AreEqual(expectedPounds, Math.Round(result, 3));
}
public void Test_Kgs_Conversion()
{
// arrange - setup
var pounds = 20.0;
var expectedKgs = 9.072;
// act - test
var result = ConversionHelpers.ToKgs(pounds);
// assert - check
Assert.AreEqual(expectedKgs, Math.Round(result, 3));
}
public void ConversionTestByteShortArray()
{
byte[] bytes = new byte[] { 255, 253, 102, 0, 5, 0, 0, 0 };
var shorts = ConversionHelpers.ByteArrayToShortArray(bytes);
var result = ConversionHelpers.ShortArrayToByteArray(shorts);
var query = bytes.Where((b, i) => b == result[i]);
Assert.AreEqual(bytes.Length, query.Count());
}
public void ConversionTestShortByteArray()
{
short[] shorts = new short[] { 1, short.MaxValue, short.MinValue, 0 };
var bytes = ConversionHelpers.ShortArrayToByteArray(shorts);
var result = ConversionHelpers.ByteArrayToShortArray(bytes);
var query = shorts.Where((b, i) => b == result[i]);
Assert.AreEqual(shorts.Length, query.Count());
}
