public async Task ShouldAddResumedSubcriptionDate_WhenLastSubscriptionDateWasTypeOfStartedAndViceVersa
(SubscriptionDateType type)
{
var today = DateTime.Today;
var subscriptionId = 1;
var subscriptionDateId = 1;
SubscriptionDate lastSubscriptionDate = new SubscriptionDate
{
Id = subscriptionDateId,
SubscriptionId = subscriptionId,
Type = type
};
SetupMocks(subscriptionId, lastSubscriptionDate);
var commandContext = new SuspendResumeSubscriptionContext(today);
var command = new SuspendResumeSubscriptionCommand(_queryBuilderMock.Object, _commandBuilderMock.Object);
await command.ExecuteAsync(commandContext);
var newSubscriptionDateType = lastSubscriptionDate.Type == SubscriptionDateType.Start
? SubscriptionDateType.Suspend
: SubscriptionDateType.Start;
_commandBuilderMock.Verify(x => x.ExecuteAsync(It.Is <AddSubcriptionDateRepositoryContext>
(y => y.SubscriptionDate.SubscriptionId == subscriptionId &&
y.SubscriptionDate.Type == newSubscriptionDateType))
, Times.Once);
}
private void SetupMocks(long subscriptionId, SubscriptionDate lastSubscriptionDate)
{
_queryBuilderMock.Setup(x => x.For <long>()
.WithAsync(It.IsAny <SubscriptionIdCriterion>()))
.ReturnsAsync(subscriptionId);
_queryBuilderMock.Setup(x => x.For <SubscriptionDate>()
.WithAsync(It.IsAny <LastSubscriptionDateForSubscriptionRepositoryCriterion>()))
.ReturnsAsync(lastSubscriptionDate);
}
private bool IsPackageValid()
{
if (Package.Type == Package.PackageType.Monthly)
{
return(SubscriptionDate.AddDays(30) >= DateTime.Now);
}
else //for Package.Type.Yearly
{
return(SubscriptionDate.AddDays(365) >= DateTime.Now);
}
}
public long SubscriptionTime()
{
var time = SubscriptionDate.Subtract(DateTime.Now).TotalMilliseconds;
if (SubscriptionDate.Subtract(DateTime.Now).TotalMilliseconds <= 1)
{
return(0);
}
return((long)time);
}
public async Task ShouldAddSubcriptionDate_WhenSubscripingFirstTime()
{
var today = DateTime.Today;
var subscriptionId = 1;
SubscriptionDate subscriptionDate = null;
SetupMocks(subscriptionId, subscriptionDate);
var commandContext = new SuspendResumeSubscriptionContext(today);
var command = new SuspendResumeSubscriptionCommand(_queryBuilderMock.Object, _commandBuilderMock.Object);
await command.ExecuteAsync(commandContext);
_commandBuilderMock.Verify(x => x.ExecuteAsync(It.Is <AddSubcriptionDateRepositoryContext>
(y => y.SubscriptionDate.SubscriptionId == subscriptionId &&
y.SubscriptionDate.Type == SubscriptionDateType.Start))
, Times.Once);
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
int hashCode = 41;
if (PassportId != null)
{
hashCode = hashCode * 59 + PassportId.GetHashCode();
}
hashCode = hashCode * 59 + PlanId.GetHashCode();
if (OptionalLinkedSubscriptionId != null)
{
hashCode = hashCode * 59 + OptionalLinkedSubscriptionId.GetHashCode();
}
if (SubscriptionDate != null)
{
hashCode = hashCode * 59 + SubscriptionDate.GetHashCode();
}
if (ExpirationDate != null)
{
hashCode = hashCode * 59 + ExpirationDate.GetHashCode();
}
hashCode = hashCode * 59 + CurrentTokensUsed.GetHashCode();
hashCode = hashCode * 59 + ExtraTokens.GetHashCode();
if (ExtraTokensEndDate != null)
{
hashCode = hashCode * 59 + ExtraTokensEndDate.GetHashCode();
}
hashCode = hashCode * 59 + IsYearlyPaid.GetHashCode();
hashCode = hashCode * 59 + IsActive.GetHashCode();
hashCode = hashCode * 59 + TokensPercentUsageAlert.GetHashCode();
hashCode = hashCode * 59 + TokensPercentUsageAlertSent.GetHashCode();
hashCode = hashCode * 59 + IsManaged.GetHashCode();
if (NextMonthlyTerm != null)
{
hashCode = hashCode * 59 + NextMonthlyTerm.GetHashCode();
}
hashCode = hashCode * 59 + RemainingTokens.GetHashCode();
return(hashCode);
}
}
public async Task <CommandResult> ExecuteAsync(SuspendResumeSubscriptionContext commandContext)
{
var today = commandContext.Today;
var subscriptionIdCriterion = new SubscriptionIdCriterion();
var subscriptionId = await _queryBuilder.For <long>().WithAsync(subscriptionIdCriterion);
var lastSubscriptionDateCriterion = new LastSubscriptionDateForSubscriptionRepositoryCriterion(subscriptionId);
var lastSubscriptionDate = await _queryBuilder.For <SubscriptionDate>().WithAsync(lastSubscriptionDateCriterion);
var newSubscriptionDate = new SubscriptionDate
{
Date = today,
SubscriptionId = subscriptionId,
};
if (lastSubscriptionDate != null)
{
var lastSubscriptionDateIsToday = lastSubscriptionDate.Date.Date == today.Date;
if (lastSubscriptionDateIsToday)
{
var removeSubscriptionDateContext = new RemoveSubcriptionDateRepositoryContext(lastSubscriptionDate);
return(await _commandBuilder.ExecuteAsync(removeSubscriptionDateContext));
}
newSubscriptionDate.Type = lastSubscriptionDate.Type == SubscriptionDateType.Start
? SubscriptionDateType.Suspend
: SubscriptionDateType.Start;
}
else
{
newSubscriptionDate.Type = SubscriptionDateType.Start;
}
var addSubscriptionDateContext = new AddSubcriptionDateRepositoryContext(newSubscriptionDate);
return(await _commandBuilder.ExecuteAsync(addSubscriptionDateContext));
}
public async Task ShouldRemoveLastSubcriptionDate_WhenSubscriptionHasBeenAlreadyStartedOrSuspendedToday()
{
var today = DateTime.Today;
var subscriptionId = 1;
var subscriptionDateId = 1;
SubscriptionDate lastSubscriptionDate = new SubscriptionDate
{
Id = subscriptionDateId,
SubscriptionId = subscriptionId,
Date = DateTime.UtcNow
};
SetupMocks(subscriptionId, lastSubscriptionDate);
var commandContext = new SuspendResumeSubscriptionContext(today);
var command = new SuspendResumeSubscriptionCommand(_queryBuilderMock.Object, _commandBuilderMock.Object);
await command.ExecuteAsync(commandContext);
_commandBuilderMock.Verify(x => x.ExecuteAsync(It.Is <RemoveSubcriptionDateRepositoryContext>
(y => y.SubscriptionDate.SubscriptionId == subscriptionId &&
y.SubscriptionDate.Id == subscriptionDateId))
, Times.Once);
}
public AddSubcriptionDateRepositoryContext(SubscriptionDate subscriptionDate)
{
SubscriptionDate = subscriptionDate;
}
/// <summary>
/// Returns true if PassportPDFPassport instances are equal
/// </summary>
/// <param name="input">Instance of PassportPDFPassport to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(PassportPDFPassport input)
{
if (input == null)
{
return(false);
}
return
((
PassportId == input.PassportId ||
(PassportId != null &&
PassportId.Equals(input.PassportId))
) &&
(
PlanId == input.PlanId ||
PlanId.Equals(input.PlanId)
) &&
(
OptionalLinkedSubscriptionId == input.OptionalLinkedSubscriptionId ||
(OptionalLinkedSubscriptionId != null &&
OptionalLinkedSubscriptionId.Equals(input.OptionalLinkedSubscriptionId))
) &&
(
SubscriptionDate == input.SubscriptionDate ||
(SubscriptionDate != null &&
SubscriptionDate.Equals(input.SubscriptionDate))
) &&
(
ExpirationDate == input.ExpirationDate ||
(ExpirationDate != null &&
ExpirationDate.Equals(input.ExpirationDate))
) &&
(
CurrentTokensUsed == input.CurrentTokensUsed ||
CurrentTokensUsed.Equals(input.CurrentTokensUsed)
) &&
(
ExtraTokens == input.ExtraTokens ||
ExtraTokens.Equals(input.ExtraTokens)
) &&
(
ExtraTokensEndDate == input.ExtraTokensEndDate ||
(ExtraTokensEndDate != null &&
ExtraTokensEndDate.Equals(input.ExtraTokensEndDate))
) &&
(
IsYearlyPaid == input.IsYearlyPaid ||
IsYearlyPaid.Equals(input.IsYearlyPaid)
) &&
(
IsActive == input.IsActive ||
IsActive.Equals(input.IsActive)
) &&
(
TokensPercentUsageAlert == input.TokensPercentUsageAlert ||
TokensPercentUsageAlert.Equals(input.TokensPercentUsageAlert)
) &&
(
TokensPercentUsageAlertSent == input.TokensPercentUsageAlertSent ||
TokensPercentUsageAlertSent.Equals(input.TokensPercentUsageAlertSent)
) &&
(
IsManaged == input.IsManaged ||
IsManaged.Equals(input.IsManaged)
) &&
(
NextMonthlyTerm == input.NextMonthlyTerm ||
(NextMonthlyTerm != null &&
NextMonthlyTerm.Equals(input.NextMonthlyTerm))
) &&
(
RemainingTokens == input.RemainingTokens ||
RemainingTokens.Equals(input.RemainingTokens)
));
}
