/// <summary>
/// Converts provided value into its string representation.
/// </summary>
/// <remarks>
/// This method converts provided value into its string representation
/// by finding the best fitting capacity entity and using it to format
/// provided value afterwards.
/// </remarks>
/// <param name="value">
/// The value to be converted.
/// </param>
/// <param name="unit">
/// The unit to get a capacity entity for.
/// </param>
/// <param name="decimals">
/// The number of decimal digits used for calculation.
/// </param>
/// <param name="calculate">
/// True to force a result calculation, otherwise false.
/// </param>
/// <param name="intercept">
/// True to force intercept mode, otherwise false.
/// </param>
/// <param name="culture">
/// The culture to be used for conversion.
/// </param>
/// <returns>
/// The string representation of converted value.
/// </returns>
/// <seealso cref="Find(String)"/>
/// <seealso cref="Find(Decimal)"/>
/// <seealso cref="CapacityEntity.Format(Decimal, Boolean, Boolean, CultureInfo)"/>
/// <seealso cref="CapacityEntity.Format(Decimal, Int32, Boolean, Boolean, CultureInfo)"/>
/// <seealso cref="CapacityEntity.Format(Decimal, String, Int32, Boolean, Boolean, CultureInfo)"/>
public static String Convert(Decimal value, String unit, Int32 decimals, Boolean calculate, Boolean intercept, CultureInfo culture)
{
if (!String.IsNullOrWhiteSpace(unit))
{
// Special case: Prefere unit one.
if (unit.Equals("one", StringComparison.InvariantCultureIgnoreCase))
{
CapacityEntity entity = CapacityConverter.Find(value);
return(entity.Format(value, entity.Unit1, decimals, calculate, intercept, culture));
}
// Special case: Prefere unit two.
if (unit.Equals("two", StringComparison.InvariantCultureIgnoreCase))
{
CapacityEntity entity = CapacityConverter.Find(value);
return(entity.Format(value, entity.Unit2, decimals, calculate, intercept, culture));
}
return(CapacityConverter.Find(unit).Format(value, unit, decimals, calculate, intercept, culture));
}
if (decimals > 0)
{
return(CapacityConverter.Find(value).Format(value, decimals, calculate, intercept, culture));
}
return(CapacityConverter.Find(value).Format(value, calculate, intercept, culture));
}
public void CapacityEntity_UnitsWithSpaces_UnitsAreTrimmed(String unitOne, String unitTwo)
{
CapacityEntity instance = new CapacityEntity(42, unitOne, unitTwo);
Assert.That(instance.Unit1, Is.EqualTo(unitOne.Trim()));
Assert.That(instance.Unit2, Is.EqualTo(unitTwo.Trim()));
}
private static string GetCapacityUsed(string authToken, string accountName)
{
string capacityUsed = string.Empty;
CloudStorageAccount storageAccount = GetUserAccount(authToken, accountName);
if (storageAccount != null)
{
CloudAnalyticsClient storageAnalytics = storageAccount.CreateCloudAnalyticsClient();
TableQuery <CapacityEntity> tableQuery = storageAnalytics.CreateCapacityQuery();
IQueryable <CapacityEntity> capacityQuery = tableQuery.Where(x => x.RowKey == "data");
try
{
List <CapacityEntity> capacityEntities = capacityQuery.ToList();
if (capacityEntities.Count == 0)
{
capacityUsed = Storage.MapByteCount(0);
}
else
{
capacityEntities.Sort(OrderByLatest);
CapacityEntity latestAnalytics = capacityEntities.First();
capacityUsed = Storage.MapByteCount(latestAnalytics.Capacity);
}
}
catch
{
capacityUsed = Constants.NotAvailable;
}
}
return(capacityUsed);
}
/// <summary>
/// Finds a capacity entity by value.
/// </summary>
/// <remarks>
/// This method finds the best fitting capacity entity by value. Best fitting
/// means the capacity entity where the <paramref name="value"/> divided by a
/// capacity entity's value is greater than or equal to one.
/// </remarks>
/// <param name="value">
/// The value to get a capacity entity for.
/// </param>
/// <returns>
/// One of the items in the list of used capacity entities or the default
/// capacity entity.
/// </returns>
/// <seealso cref="Default"/>
/// <seealso cref="Capacities"/>
public static CapacityEntity Find(Decimal value)
{
CapacityEntity result = null;
if (value != 0)
{
result = CapacityConverter.Capacities.FirstOrDefault(x => value / x.Value >= 1);
}
return(result ?? CapacityConverter.Default);
}
private static int OrderByLatest(CapacityEntity leftItem, CapacityEntity rightItem)
{
return(DateTimeOffset.Compare(rightItem.Time, leftItem.Time));
}
/// <summary>
/// Finds a capacity entity by unit.
/// </summary>
/// <remarks>
/// This method finds the first capacity entity for provided <paramref name="unit"/>.
/// The last capacity entity is returned if none of the supported capacity entities
/// fits.
/// </remarks>
/// <param name="unit">
/// The unit to get a capacity entity for.
/// </param>
/// <returns>
/// One of the items in the list of used capacity entities.
/// </returns>
/// <seealso cref="Capacities"/>
public static CapacityEntity Find(String unit)
{
CapacityEntity result = CapacityConverter.Capacities.FirstOrDefault(x => x.IsEqual(unit));
return(result ?? CapacityConverter.Default);
}
private static int OrderByLatest(CapacityEntity leftSide, CapacityEntity rightSide)
{
return(DateTimeOffset.Compare(rightSide.Time, leftSide.Time));
}
