public Func <object, object, bool> GetCompareAction(AssertObject subject, object compareTo)
{
//if (subject.Subject.GetType().IsPrimitive)
// return new SimpleTypeComparer().CompareEqual;
//else if (!subject.Subject.GetType().IsPrimitive && subject.CheckProperties)
// return new ComplexTypeComparer().CompareEqualProperties(subject, compareTo);
//if (!(obj.Subject.Equals(compareTo) && obj.ExpectedResult))
// throw new ExpectationFailedExceptin("Objects are not equal");
throw new ArgumentException("No action for that type of objects");
}
public override Task <CreateResult <TrackBillBO> > RunAsync(CreateTrackBillCmd request, CancellationToken cancellationToken = default)
{
Task <CreateResult <TrackBillBO> > retVal = null;
if (request.Entry == null)
{
return(Task.FromResult(new CreateResult <TrackBillBO>
{
IsCreated = false,
Error = new LynxObjectNotFoundException <TrackBillBO>("Parameter is null")
}));
}
var bill = DbContext.Bills.SingleOrDefault(a => a.ID == request.Entry.Bill.ID);
var billProvider = DbContext.BillProviders
.Include(a => a.N_ProviderType)
.SingleOrDefault(a => a.BillID == request.Entry.Bill.ID &&
a.ProviderTypeID == request.Entry.BillProvider.ProviderTypeID);
AssertObject.IsNotNull(bill);
AssertObject.IsNotNull(billProvider);
var newEntry = new TrackBill
{
BillID = request.Entry.Bill.ID,
AccountNumber = request.Entry.AccountNumber,
IsEnabled = true,
LongDesc = request.Entry.LongDesc,
ShortDesc = request.Entry.ShortDesc,
ProviderTypeID = request.Entry.BillProvider.ProviderTypeID,
UserID = AppUser.UserID
};
var entityEntry = TrackBillDbSet.Add(newEntry);
if (newEntry.ProviderTypeID == ProviderTypeConstants.Scheduled)
{
newEntry.N_ProviderTypeConfigScheduler = new ProviderTypeConfigScheduler
{
LongDesc = request.Entry.ProviderTypeConfigScheduler.LongDesc,
Amount = request.Entry.ProviderTypeConfigScheduler.Amount,
DayFrequency = request.Entry.ProviderTypeConfigScheduler.DayFrequency,
StartDate = request.Entry.ProviderTypeConfigScheduler.StartDate,
EndDate = request.Entry.ProviderTypeConfigScheduler.EndDate,
Frequency = request.Entry.ProviderTypeConfigScheduler.Frequency,
ShortDesc = request.Entry.ProviderTypeConfigScheduler.ShortDesc,
SkipTimes = request.Entry.ProviderTypeConfigScheduler.SkipTimes
};
if (newEntry.N_ProviderTypeConfigScheduler.DayFrequency != null &&
newEntry.N_ProviderTypeConfigScheduler.DayFrequency > 0)
{
var dates = GetDates
(
newEntry.N_ProviderTypeConfigScheduler.DayFrequency.Value,
newEntry.N_ProviderTypeConfigScheduler.StartDate,
newEntry.N_ProviderTypeConfigScheduler.EndDate
);
foreach (var date in dates)
{
newEntry.N_ProviderTypeConfigScheduler.N_ScheduleEntries.Add(new SchedulerEntry
{
Amount = request.Entry.ProviderTypeConfigScheduler.Amount,
DueDate = date
});
newEntry.N_UserBills.Add(new UserBill
{
Amount = request.Entry.ProviderTypeConfigScheduler.Amount,
DueDate = date,
Status = BillPaymentStatus.Pending
});
}
}
}
if (request.AutoSave)
{
return(BaseDbContext.SaveChangesAsync(cancellationToken)
.ContinueWith(result =>
{
if (result.IsFaulted)
{
return new CreateResult <TrackBillBO>
{
IsCreated = false,
NewEntry = request.Entry,
Error = new LynxException(result.Exception)
};
}
return new CreateResult <TrackBillBO>
{
IsCreated = true,
NewEntry = Mapper.Map <TrackBillBO>(entityEntry.Entity)
};
}));
}
else
{
var entry = Mapper.Map <TrackBillBO>(newEntry);
entry.Bill = Mapper.Map <BillBO>(bill);
entry.BillProvider = Mapper.Map <BillProviderBO>(billProvider);
retVal = Task.FromResult(new CreateResult <TrackBillBO>
{
NewEntry = entry
});
}
return(retVal);
}
public ValidationScope(AssertObject <T, TProperty> assertObject)
{
AssertObject = assertObject;
}
/// <param name="asserter">Asserter testing a method call using fakes.</param>
/// <param name="fake">Fake instance with behavior set.</param>
/// <param name="total">Expected total number of calls to test as well.</param>
/// <inheritdoc cref="VerifyAllCalls"/>
public static AssertChainer <AssertObject> Called(this AssertObject asserter, object fake, Times total = null)
{
VerifyAllCalls(fake, total);
return(asserter?.ToChainer());
}
/// <summary>Verifies two objects are unequal by value.</summary>
/// <param name="expected">Object to compare against.</param>
/// <param name="actual">Object to compare with.</param>
/// <param name="details">Optional failure details.</param>
/// <exception cref="AssertException">If the expected behavior doesn't happen.</exception>
public void IsNot(object expected, object actual, string details = null)
{
_ = new AssertObject(Gen, Valuer, actual).IsNot(expected, details);
}
/// <summary>Verifies two objects are unequal by value.</summary>
/// <param name="expected">Object to compare against.</param>
/// <param name="actual">Object to compare with.</param>
/// <param name="details">Optional failure details.</param>
/// <exception cref="AssertException">If the expected behavior doesn't happen.</exception>
public virtual void ValuesNotEqual(object expected, object actual, string details = null)
{
_ = new AssertObject(Gen, Valuer, actual).ValuesNotEqual(expected, details);
}
