/// <summary>
/// Converts a Protobuf <see cref="ProtobufDuration"/> to a Noda Time <see cref="NodaDuration"/>.
/// </summary>
/// <remarks>
/// Every valid Protobuf duration can be represented in Noda Time without loss of information.
/// </remarks>
/// <param name="duration">The duration to convert. Must not be null.</param>
/// <exception cref="ArgumentException"><paramref name="duration"/> represents an invalid duration.</exception>
/// <exception cref="ArgumentNullException"><paramref name="duration"/> is null.</exception>
/// <returns>The Noda Time representation.</returns>
public static NodaDuration ToNodaDuration(this ProtobufDuration duration)
{
Preconditions.CheckNotNull(duration, nameof(duration));
long seconds = duration.Seconds;
long nanos = duration.Nanos;
Preconditions.CheckArgument(
seconds >= ProtobufDuration.MinSeconds &&
seconds <= ProtobufDuration.MaxSeconds,
nameof(duration),
"duration.Seconds out of range: {0}",
seconds);
Preconditions.CheckArgument(
nanos > -ProtobufDuration.NanosecondsPerSecond &&
nanos < ProtobufDuration.NanosecondsPerSecond,
nameof(duration),
"duration.Nanos out of range: {0}",
nanos);
// If either sign is 0, we're fine. Otherwise, they should be the same. Multiplying them
// together seems the easiest way to check that.
Preconditions.CheckArgument(Math.Sign(seconds) * Math.Sign(nanos) != -1,
nameof(duration),
"duration.Seconds and duration.Nanos have different signs: {0}s {1}ns",
seconds, nanos);
return(NodaDuration.FromSeconds(seconds) + NodaDuration.FromNanoseconds(nanos));
}
/// <inheritdoc />
/// <summary>Converts a value. </summary>
/// <param name="value">The value that is produced by the binding target.</param>
/// <param name="targetType">The type to convert to.</param>
/// <param name="parameter">The converter parameter to use.</param>
/// <param name="culture">The culture to use in the converter.</param>
/// <returns>A converted value. If the method returns <see langword="null" />, the valid null value is used.</returns>
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value is string str && TimeSpan.TryParse(str, out TimeSpan tSpan))
{
return(Duration.FromTimeSpan(tSpan));
}
return(default(Duration));
}
public void Init()
{
_campaignSalesAreaList.Add("TCN91");
_campaignSalesArea = _campaignSalesAreaList[0];
_targetStrikeWeightStartDate = new DateTime(2018, 1, 1, 0, 0, 0);
_targetStrikeWeightEndDate = new DateTime(2018, 1, 10, 0, 0, 0);
_recommendation1 = new Mock <Recommendation>();
_recommendation2 = new Mock <Recommendation>();
_rec1Rating = 10;
_rec2Rating = 5;
_rec1Action = "B"; //this is a booking and is to be added to the total
_rec2Action = "C"; //this is a cancellation and is to be subtracted from the total
_rec1Length = NodaTime.Duration.FromSeconds(15);
_rec2Length = NodaTime.Duration.FromSeconds(30);
_timeslice1From = "00:00";
_timeslice1To = "01:00";
_timeslice2From = "06:00";
_timeslice2To = "08:00";
_recommendationsTotalForDayPart = 0;
_dayPart = new DayPartModel()
{
DesiredPercentageSplit = 0,
CurrentPercentageSplit = 10,
Timeslices = new List <TimesliceModel>()
{
new TimesliceModel()
{
FromTime = _timeslice1From, ToTime = _timeslice1To, DowPattern = new List <string>()
{
"Mon", "Tues", "Wed"
},
},
new TimesliceModel()
{
FromTime = _timeslice2From, ToTime = _timeslice2To, DowPattern = new List <string>()
{
"Mon", "Tues", "Wed"
},
}
}
};
_ = _recommendation1.Setup(r => r.SpotRating).Returns(_rec1Rating);
_ = _recommendation1.Setup(r => r.Action).Returns(_rec1Action);
_ = _recommendation1.Setup(r => r.StartDateTime).Returns(_targetStrikeWeightStartDate);
_ = _recommendation1.Setup(r => r.SalesArea).Returns(_campaignSalesArea);
_ = _recommendation2.Setup(r => r.SpotRating).Returns(_rec2Rating);
_ = _recommendation2.Setup(r => r.Action).Returns(_rec2Action);
_ = _recommendation2.Setup(r => r.StartDateTime).Returns(_targetStrikeWeightStartDate);
_ = _recommendation2.Setup(r => r.SalesArea).Returns(_campaignSalesArea);
}
/// <summary>
/// Converts a Noda Time <see cref="NodaDuration"/> to a Protobuf <see cref="ProtobufDuration"/>.
/// </summary>
/// <remarks>
/// Noda Time has a wider range of valid durations than Protobuf; durations of more than around 10,000
/// years (positive or negative) cannot be represented.
/// </remarks>
/// <param name="duration">The duration to convert. Must not be null.</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="duration"/> represents a duration
/// which is invalid in <see cref="ProtobufDuration"/>.</exception>
/// <returns>The Protobuf representation.</returns>
public static ProtobufDuration ToProtobufDuration(this NodaDuration duration)
{
if (duration < minProtobufDuration || duration > maxProtobufDuration)
{
throw new ArgumentOutOfRangeException(nameof(duration), "Duration is outside the range of valid Protobuf durations.");
}
// Deliberately long to keep the later arithmetic in 64-bit.
long days = duration.Days;
long nanoOfDay = duration.NanosecondOfDay;
long secondOfDay = nanoOfDay / NodaConstants.NanosecondsPerSecond;
int nanos = duration.SubsecondNanoseconds;
return(new ProtobufDuration {
Seconds = days * NodaConstants.SecondsPerDay + secondOfDay, Nanos = nanos
});
}