public void CompareToTest()
{
var my1 = new MonthYear(1, 2000);
var my2 = new MonthYear(2, 2000);
var actual = my1.CompareTo(my2);
Assert.Less(actual, 0);
my1 = new MonthYear(1, 2000);
my2 = new MonthYear(1, 2001);
actual = my1.CompareTo(my2);
Assert.Less(actual, 0);
my1 = new MonthYear(1, 2000);
my2 = new MonthYear(1, 2000);
actual = my1.CompareTo(my2);
Assert.AreEqual(actual, 0);
my1 = new MonthYear(3, 2000);
my2 = new MonthYear(2, 2000);
actual = my1.CompareTo(my2);
Assert.Greater(actual, 0);
my1 = new MonthYear(1, 2002);
my2 = new MonthYear(1, 2001);
actual = my1.CompareTo(my2);
Assert.Greater(actual, 0);
}
public void ArithmeticOperatorsTest()
{
var my1 = new MonthYear(12, 1999);
var my2 = new MonthYear(1, 2000);
Assert.AreEqual(1, my2.Month);
Assert.AreEqual(2, (my2 + 1).Month);
Assert.AreEqual(1, (my1 + 1).Month);
Assert.AreEqual(11, (my1 - 1).Month);
Assert.AreEqual(12, (my2 - 1).Month);
Assert.AreEqual(1, my2 - my1);
Assert.AreEqual(-1, my1 - my2);
Assert.AreEqual(0, my1 - my1);
}
public void AddMonthsTest()
{
var my = new MonthYear(1, 2000);
var actual = my.AddMonths(1);
var expected = new MonthYear(2, 2000);
Assert.AreEqual(expected.Month, actual.Month);
Assert.AreEqual(expected.Year, actual.Year);
actual = my.AddMonths(-1);
expected = new MonthYear(12, 1999);
Assert.AreEqual(expected.Month, actual.Month);
Assert.AreEqual(expected.Year, actual.Year);
}
public void ComparisonOperatorsTest()
{
var my1 = new MonthYear(12, 1999);
var my2 = new MonthYear(1, 2000);
var my3 = new MonthYear(1, 2000);
Assert.True(my1 != my2);
Assert.True(my2 != my1);
Assert.True(my1 < my2);
Assert.True(my2 > my1);
Assert.True(my1 <= my2);
Assert.True(my2 >= my1);
Assert.True(my2 == my3);
Assert.True(my3 == my2);
Assert.True(my3 <= my2);
Assert.True(my2 <= my3);
Assert.True(my2 >= my3);
Assert.True(my3 >= my2);
}
public CreditCardBill GetCurrentBill(MonthYear monthYear)
{
return(Bills
.Where(x => x.DueDate.Year == monthYear.Year && x.DueDate.Month == monthYear.Month)
.SingleOrDefault());
}
public static Income Load(Guid id, Title title, AmountRecordCollection amountRecords, MonthYear referenceDate)
{
Income income = new Income();
income.Id = id;
income.Title = title;
income.AmountRecords = amountRecords;
income.ReferenceDate = referenceDate;
return(income);
}
private MonthYearRange CreateRangeFromJanuaryToGivenMonth(
MonthYear monthYear)
{
return(new MonthYearRange(new MonthYear(monthYear.Year, 1), monthYear));
}
public static MonthlyReturn GetMonth(
this IEnumerable <MonthlyReturn> allReturns,
MonthYear monthYear)
{
return(allReturns.FirstOrDefault(r => r.MonthYear == monthYear));
}
public void Should_MonthYear_Now_Created()
{
MonthYear monthYear = MonthYear.Now;
Assert.NotNull(monthYear);
}
public void ToStringTest()
{
var my = new MonthYear(1, 2000);
var expected = my.GetDate(1).ToString("MM/yyyy");
var actual = my.ToString();
Assert.AreEqual(expected, actual);
}
public PortfolioListPageAdapterTests()
{
_monthYear = new MonthYear(2014, 5);
}
public void DateComparisonTests()
{
var my1 = new MonthYear(12, 1999);
var my2 = new MonthYear(1, 2000);
var dt1 = new DateTime(1999, 12, 1);
var dt2 = new DateTime(2000, 1, 1);
var dt3 = new DateTime(2000, 2, 1);
MonthYear my3 = dt3;
Assert.True(my1.Equals(dt1));
Assert.False(my1.Equals(dt2));
Assert.True(my1.CompareTo(dt1) == 0);
Assert.True(my2.CompareTo(dt1) > 0);
Assert.True(my1.Equals(dt1));
Assert.True(my1.Equals((object)my1));
Assert.True(my1.Equals(dt1));
Assert.False(my1.Equals(dt2));
my1++;
Assert.True(my1.Equals(dt2));
Assert.False(my1.Equals(dt1));
my1--;
Assert.False(my1.Equals(dt2));
Assert.True(my1.Equals(dt1));
}
public List <AsForTableDto> GetByPlanPosteReferences(List <PlanPosteReference> planPosteReferences, MonthYear monthYear)
{
DateTime minDate = monthYear.Month.Id == (int)EnumMonth.BalanceSheetYear
? Convert.ToDateTime($"01/01/{monthYear.Year}")
: Convert.ToDateTime($"01/{monthYear.Month.Id}/{monthYear.Year}");
DateTime maxDate = monthYear.Month.Id == (int)EnumMonth.BalanceSheetYear
? Convert.ToDateTime($"31/12/{monthYear.Year}")
: DateHelper.GetLastDayOfMonth(minDate);
var accountStatements = _accountStatementRepository.GetByDatePlanPosteReferenceList(planPosteReferences, minDate, maxDate);
return(_mapper.Map <List <AsForTableDto> >(accountStatements));
}
public async Task Adds_Key_To_Cache()
{
const string GENERATED_REQUEST_KEY = "1v9ESIpTOJ1czY9SZW5oWf2DiRWrNOB4kHdPFODIYjI=";
const int RETURNED_PAYMENT_ID = 1;
const string CARD_NUMBER = "4111111111111111";
const string CVV = "123";
const string CURRENCY = "GBP";
const string OWNER = "owner";
const decimal AMOUNT = .1m;
var EXPIRY = new MonthYear {
Year = 2021, Month = 01
};
var testNow = new DateTime(2021, 02, 01);
var nowProvider = new NowProvider(testNow);
var request = new ProcessPaymentRequest
{
CardNumber = CARD_NUMBER,
Amount = AMOUNT,
Currency = CURRENCY,
CVV = CVV,
Expiry = EXPIRY,
Owner = OWNER
};
var acqBankMock = new Mock <IAcquiringBank>();
acqBankMock
.Setup(mock => mock.SendPayment(It.IsAny <AcquiringBankRequest>()))
.ReturnsAsync(new AcquiringBankResponse
{
Status = AcquiringBankResponseStatus.Success,
PaymentId = RETURNED_PAYMENT_ID
});
var memoryCacheMock = new Mock <IMemoryCache>();
var cacheEntryMock = new Mock <ICacheEntry>();
memoryCacheMock
.Setup(mock => mock.TryGetValue(It.IsAny <string>(), out It.Ref <object> .IsAny))
.Returns(false);
memoryCacheMock
.Setup(mock => mock.CreateEntry(It.IsAny <object>()))
.Returns(cacheEntryMock.Object);
using var context = Setup.CreateContext();
var handler = new ProcessPaymentHandler(
acqBankMock.Object,
nowProvider,
memoryCacheMock.Object,
_logger,
_cachingOptions,
context);
var result = await handler.Handle(request, CancellationToken.None);
memoryCacheMock.Verify(
mock => mock.CreateEntry(GENERATED_REQUEST_KEY),
Times.Once);
}
public async Task Stores_Masked_Card_Details()
{
const int RETURNED_PAYMENT_ID = 1;
const string CARD_NUMBER = "4111111111111111";
const string CVV = "123";
const string CURRENCY = "GBP";
const string OWNER = "owner";
const decimal AMOUNT = .1m;
var EXPIRY = new MonthYear {
Year = 2021, Month = 01
};
var testNow = new DateTime(2021, 02, 01);
var nowProvider = new NowProvider(testNow);
var request = new ProcessPaymentRequest
{
CardNumber = CARD_NUMBER,
Amount = AMOUNT,
Currency = CURRENCY,
CVV = CVV,
Expiry = EXPIRY,
Owner = OWNER
};
var acqBankMock = new Mock <IAcquiringBank>();
acqBankMock
.Setup(mock => mock.SendPayment(It.IsAny <AcquiringBankRequest>()))
.ReturnsAsync(new AcquiringBankResponse
{
Status = AcquiringBankResponseStatus.Success,
PaymentId = RETURNED_PAYMENT_ID
});
var memoryCacheMock = new Mock <IMemoryCache>();
var cacheEntryMock = new Mock <ICacheEntry>();
memoryCacheMock
.Setup(mock => mock.TryGetValue(It.IsAny <string>(), out It.Ref <object> .IsAny))
.Returns(false);
memoryCacheMock
.Setup(mock => mock.CreateEntry(It.IsAny <object>()))
.Returns(cacheEntryMock.Object);
using var context = Setup.CreateContext();
var handler = new ProcessPaymentHandler(
acqBankMock.Object,
nowProvider,
memoryCacheMock.Object,
_logger,
_cachingOptions,
context);
var result = (await handler.Handle(request, CancellationToken.None)).SuccessOrDefault;
Assert.IsTrue(result.Success);
// assert that a record is in the db for this payment id,
var foundPayment = context.ProcessedPayments.Find(result.PaymentId);
// should be masked
Assert.AreEqual("************1111", foundPayment.CardNumber);
Assert.AreEqual("***", foundPayment.CVV);
Assert.AreEqual(AMOUNT, foundPayment.Amount);
Assert.AreEqual(CURRENCY, foundPayment.Currency);
Assert.AreEqual(OWNER, foundPayment.Owner);
Assert.AreEqual(EXPIRY.Year, foundPayment.Expiry.Year);
Assert.AreEqual(EXPIRY.Month, foundPayment.Expiry.Month);
}
public async Task Unsuccesful_Bank_Result_Does_Not_Throw()
{
const int RETURNED_PAYMENT_ID = 1;
const string CARD_NUMBER = "4111111111111111";
const string CVV = "123";
const string CURRENCY = "GBP";
const string OWNER = "owner";
const decimal AMOUNT = .1m;
var EXPIRY = new MonthYear {
Year = 2021, Month = 01
};
var testNow = new DateTime(2021, 02, 01);
var nowProvider = new NowProvider(testNow);
var request = new ProcessPaymentRequest
{
CardNumber = CARD_NUMBER,
Amount = AMOUNT,
Currency = CURRENCY,
CVV = CVV,
Expiry = EXPIRY,
Owner = OWNER
};
using var context = Setup.CreateContext();
var acqBankMock = new Mock <IAcquiringBank>();
acqBankMock
.Setup(mock => mock.SendPayment(It.IsAny <AcquiringBankRequest>()))
.ReturnsAsync(new AcquiringBankResponse
{
Status = AcquiringBankResponseStatus.Acquiring_Bank_Unreachable,
PaymentId = RETURNED_PAYMENT_ID
});
var memoryCacheMock = new Mock <IMemoryCache>();
var cacheEntryMock = new Mock <ICacheEntry>();
memoryCacheMock
.Setup(mock => mock.TryGetValue(It.IsAny <string>(), out It.Ref <object> .IsAny))
.Returns(false);
memoryCacheMock
.Setup(mock => mock.CreateEntry(It.IsAny <object>()))
.Returns(cacheEntryMock.Object);
// use mock of acqbank to ensure we get a failure here
var handler = new ProcessPaymentHandler(
acqBankMock.Object,
nowProvider,
memoryCacheMock.Object,
_logger,
_cachingOptions,
context);
var result = (await handler.Handle(request, CancellationToken.None)).SuccessOrDefault;
// ensure payment is still saved in failed state
var foundPayment = context.ProcessedPayments.Find(result.PaymentId);
Assert.AreEqual(RETURNED_PAYMENT_ID, result.PaymentId);
Assert.IsFalse(result.Success);
Assert.AreEqual("************1111", foundPayment.CardNumber);
Assert.AreEqual("***", foundPayment.CVV);
Assert.AreEqual(AMOUNT, foundPayment.Amount);
Assert.AreEqual(CURRENCY, foundPayment.Currency);
Assert.AreEqual(OWNER, foundPayment.Owner);
Assert.AreEqual(EXPIRY.Year, foundPayment.Expiry.Year);
Assert.AreEqual(EXPIRY.Month, foundPayment.Expiry.Month);
}
public AdvancedPageViewModel() : base()
{
Culture = CultureInfo.CreateSpecificCulture("en-GB");
// testing all kinds of adding events
// when initializing collection
Events = new EventCollection
{
[DateTime.Now.AddDays(-3)] = new List <AdvancedEventModel>(GenerateEvents(10, "Cool")),
[DateTime.Now.AddDays(-6)] = new DayEventCollection <AdvancedEventModel>(Color.Purple, Color.Purple)
{
new AdvancedEventModel {
Name = "Cool event1", Description = "This is Cool event1's description!", Starting = new DateTime()
},
new AdvancedEventModel {
Name = "Cool event2", Description = "This is Cool event2's description!", Starting = new DateTime()
}
}
};
//Adding a day with a different dot color
Events.Add(DateTime.Now.AddDays(-2), new DayEventCollection <AdvancedEventModel>(GenerateEvents(10, "Cool"))
{
EventIndicatorColor = Color.Blue, EventIndicatorSelectedColor = Color.Blue
});
Events.Add(DateTime.Now.AddDays(-4), new DayEventCollection <AdvancedEventModel>(GenerateEvents(10, "Cool"))
{
EventIndicatorColor = Color.Green, EventIndicatorSelectedColor = Color.White
});
Events.Add(DateTime.Now.AddDays(-5), new DayEventCollection <AdvancedEventModel>(GenerateEvents(10, "Cool"))
{
EventIndicatorColor = Color.Orange, EventIndicatorSelectedColor = Color.Orange
});
// with add method
Events.Add(DateTime.Now.AddDays(-1), new List <AdvancedEventModel>(GenerateEvents(5, "Cool")));
// with indexer
Events[DateTime.Now] = new List <AdvancedEventModel>(GenerateEvents(2, "Boring"));
MonthYear = MonthYear.AddMonths(1);
Task.Delay(5000).ContinueWith(_ =>
{
// indexer - update later
Events[DateTime.Now] = new ObservableCollection <AdvancedEventModel>(GenerateEvents(10, "Cool"));
// add later
Events.Add(DateTime.Now.AddDays(3), new List <AdvancedEventModel>(GenerateEvents(5, "Cool")));
// indexer later
Events[DateTime.Now.AddDays(10)] = new List <AdvancedEventModel>(GenerateEvents(10, "Boring"));
// add later
Events.Add(DateTime.Now.AddDays(15), new List <AdvancedEventModel>(GenerateEvents(10, "Cool")));
Task.Delay(3000).ContinueWith(t =>
{
MonthYear = MonthYear.AddMonths(-2);
// get observable collection later
var todayEvents = Events[DateTime.Now] as ObservableCollection <AdvancedEventModel>;
// insert/add items to observable collection
todayEvents.Insert(0, new AdvancedEventModel {
Name = "Cool event insert", Description = "This is Cool event's description!", Starting = new DateTime()
});
todayEvents.Add(new AdvancedEventModel {
Name = "Cool event add", Description = "This is Cool event's description!", Starting = new DateTime()
});
}, TaskScheduler.FromCurrentSynchronizationContext());
}, TaskScheduler.FromCurrentSynchronizationContext());
}
public static Expense Load(Guid id, Title title, AmountRecordCollection amountRecords, MonthYear referenceDate)
{
Expense expense = new Expense();
expense.Id = id;
expense.Title = title;
expense.AmountRecords = amountRecords;
expense.ReferenceDate = referenceDate;
return(expense);
}
public void EqualsReturnFalseIfIsNotAMonthYear()
{
var my1 = new MonthYear(1, 2000);
var my2 = 0;
var actual = my1.Equals(my2);
Assert.False(actual);
}
public static OverviewDto Create(MonthYear monthYear, MonthSummary summary, IReadOnlyList <Category> categories) => new OverviewDto(monthYear, summary, categories);
public InvestmentVehicleBuilderForTests AddGrossReturn(
MonthYear monthYear,
decimal returnValue)
{
return(AddReturn(monthYear, returnValue, FeeType.GrossOfFees));
}
public void EqualsTest()
{
var my1 = new MonthYear(1, 2000);
var my2 = new MonthYear(2, 2000);
var actual = my1.Equals(my2);
Assert.False(actual);
my1 = new MonthYear(1, 2000);
my2 = new MonthYear(1, 2000);
actual = my1.Equals(my2);
Assert.True(actual);
}
public static Investment Load(Guid id, Title title, AmountRecordCollection amountRecords, MonthYear referenceDate)
{
Investment investment = new Investment();
investment.Id = id;
investment.Title = title;
investment.AmountRecords = amountRecords;
investment.ReferenceDate = referenceDate;
return(investment);
}
public override string ToString() =>
$"Id={Id}, BranchId={BranchId}, MonthYear={MonthYear.ToString("Y")}, Value={Value}";
public void GetDateTest()
{
var date = new DateTime(2000, 1, 14);
var my = new MonthYear(1, 2000);
Assert.AreEqual(date, my.GetDate(14));
date = new DateTime(2000, 2, 29);
my = new MonthYear(2, 2000);
Assert.AreEqual(date, my.GetDate(29));
}
public static CalculateReturnRequest OneMonth(
MonthYear endMonth)
{
return(new CalculateReturnRequest(
endMonth, 1));
}
public void GetDateTestShouldFailIfDayIsInvalid()
{
var my = new MonthYear(2, 2001);
Assert.Throws<ArgumentOutOfRangeException>(() => my.GetDate(29));
}
public OmniDataFileLineModelFactory(
MonthYear endEndMonth)
{
_endMonth = endEndMonth;
_januaryToGivenMonth = CreateRangeFromJanuaryToGivenMonth(endEndMonth);
}
public void GetLastDayTest()
{
var my = new MonthYear(1, 2000);
var actual = my.GetLastDay();
var expected = new DateTime(2000, 1, 31);
Assert.AreEqual(expected, actual);
my = new MonthYear(2, 2000);
actual = my.GetLastDay();
expected = new DateTime(2000, 2, 29);
Assert.AreEqual(expected, actual);
}
public MonthYear GetCurrentMonthYear() => MonthYear.Create(DateTime.Today.Year, DateTime.Today.Month);
public void GetNthWorkDayShouldFailWithInvalidnthWorkday()
{
var my = new MonthYear(1, 2000);
Assert.Throws<ArgumentOutOfRangeException>(() => my.GetNthWorkDay(0, null));
}
/// <summary>
/// Combines multiple cleanup tags into {{multiple issues}} template, ensures parameters have correct case, removes date parameter where not needed
/// only for English-language wikis
/// </summary>
/// <param name="articleText">The wiki text of the article.</param>
/// <returns>The modified article text.</returns>
public string MultipleIssuesOld(string articleText)
{
if (!Variables.LangCode.Equals("en"))
{
return(articleText);
}
// convert title case parameters within {{Multiple issues}} to lower case
foreach (Match m in WikiRegexes.MultipleIssuesInTitleCase.Matches(articleText))
{
string firstPart = m.Groups[1].Value;
string parameterFirstChar = m.Groups[2].Value.ToLower();
string lastPart = m.Groups[3].Value;
articleText = articleText.Replace(m.Value, firstPart + parameterFirstChar + lastPart);
}
// remove any date field within {{Multiple issues}} if no 'expert=subject' field using it
string MICall = WikiRegexes.MultipleIssues.Match(articleText).Value;
if (MICall.Length > 10 && (Tools.GetTemplateParameterValue(MICall, "expert").Length == 0 ||
MonthYear.IsMatch(Tools.GetTemplateParameterValue(MICall, "expert"))))
{
articleText = articleText.Replace(MICall, Tools.RemoveTemplateParameter(MICall, "date"));
}
// get the zeroth section (text upto first heading)
string zerothSection = Tools.GetZerothSection(articleText);
// get the rest of the article including first heading (may be null if entire article falls in zeroth section)
string restOfArticle = articleText.Substring(zerothSection.Length);
string ESDate = "";
if (ExpertSubject.IsMatch(zerothSection))
{
ESDate = Tools.GetTemplateParameterValue(ExpertSubject.Match(zerothSection).Value, "date");
zerothSection = Tools.RemoveTemplateParameter(zerothSection, "expert-subject", "date");
}
int tagsToAdd = WikiRegexes.MultipleIssuesTemplates.Matches(zerothSection).Count;
// if currently no {{Multiple issues}} and less than the min number of cleanup templates, do nothing
if (!WikiRegexes.MultipleIssues.IsMatch(zerothSection) && WikiRegexes.MultipleIssuesTemplates.Matches(zerothSection).Count < MinCleanupTagsToCombine)
{
// article issues with one issue -> single issue tag (e.g. {{multiple issues|cleanup=January 2008}} to {{cleanup|date=January 2008}} etc.)
articleText = WikiRegexes.MultipleIssues.Replace(articleText, MultipleIssuesOldSingleTagME);
return(MultipleIssuesBLPUnreferenced(articleText));
}
// only add tags to multiple issues if new tags + existing >= MinCleanupTagsToCombine
MICall = Tools.RenameTemplateParameter(WikiRegexes.MultipleIssues.Match(zerothSection).Value, "OR", "original research");
if ((WikiRegexes.MultipleIssuesTemplateNameRegex.Matches(MICall).Count + tagsToAdd) < MinCleanupTagsToCombine || tagsToAdd == 0)
{
// article issues with one issue -> single issue tag (e.g. {{multiple issues|cleanup=January 2008}} to {{cleanup|date=January 2008}} etc.)
articleText = WikiRegexes.MultipleIssues.Replace(articleText, (MultipleIssuesOldSingleTagME));
return(MultipleIssuesBLPUnreferenced(articleText));
}
string newTags = "";
foreach (Match m in WikiRegexes.MultipleIssuesTemplates.Matches(zerothSection))
{
// all fields except COI, OR, POV and ones with BLP should be lower case
string singleTag = m.Groups[1].Value;
string tagValue = m.Groups[2].Value;
if (!WikiRegexes.CoiOrPovBlp.IsMatch(singleTag))
{
singleTag = singleTag.ToLower();
}
string singleTagLower = singleTag.ToLower();
// tag renaming
if (singleTagLower.Equals("cleanup-rewrite"))
{
singleTag = "rewrite";
}
else if (singleTagLower.Equals("cleanup-laundry"))
{
singleTag = "laundrylists";
}
else if (singleTagLower.Equals("cleanup-jargon"))
{
singleTag = "jargon";
}
else if (singleTagLower.Equals("primary sources"))
{
singleTag = "primarysources";
}
else if (singleTagLower.Equals("news release"))
{
singleTag = "newsrelease";
}
else if (singleTagLower.Equals("game guide"))
{
singleTag = "gameguide";
}
else if (singleTagLower.Equals("travel guide"))
{
singleTag = "travelguide";
}
else if (singleTagLower.Equals("very long"))
{
singleTag = "verylong";
}
else if (singleTagLower.Equals("cleanup-reorganise"))
{
singleTag = "restructure";
}
else if (singleTagLower.Equals("cleanup-reorganize"))
{
singleTag = "restructure";
}
else if (singleTagLower.Equals("cleanup-spam"))
{
singleTag = "spam";
}
else if (singleTagLower.Equals("criticism section"))
{
singleTag = "criticisms";
}
else if (singleTagLower.Equals("pov-check"))
{
singleTag = "pov-check";
}
else if (singleTagLower.Equals("expert-subject"))
{
singleTag = "expert";
}
// copy edit|for=grammar --> grammar
if (singleTag.Replace(" ", "").Equals("copyedit") && Tools.GetTemplateParameterValue(m.Value, "for").Equals("grammar"))
{
singleTag = "grammar";
tagValue = Regex.Replace(tagValue, @"for\s*=\s*grammar\s*\|?", "");
}
// expert must have a parameter
if (singleTag == "expert" && tagValue.Trim().Length == 0)
{
continue;
}
// for tags with a parameter, that parameter must be the date
if ((tagValue.Contains("=") && Regex.IsMatch(tagValue, @"(?i)date")) || tagValue.Length == 0 || singleTag == "expert")
{
tagValue = Regex.Replace(tagValue, @"^[Dd]ate\s*=\s*", "= ");
// every tag except expert needs a date
if (!singleTag.Equals("expert") && tagValue.Length == 0)
{
tagValue = @"= {{subst:CURRENTMONTHNAME}} {{subst:CURRENTYEAR}}";
}
else if (!tagValue.Contains(@"="))
{
tagValue = @"= " + tagValue;
}
// don't add duplicate tags
if (MICall.Length == 0 || Tools.GetTemplateParameterValue(MICall, singleTag).Length == 0)
{
newTags += @"|" + singleTag + @" " + tagValue;
}
}
else
{
continue;
}
newTags = newTags.Trim();
// remove the single template
zerothSection = zerothSection.Replace(m.Value, "");
}
if (ESDate.Length > 0)
{
newTags += ("|date = " + ESDate);
}
// if article currently has {{Multiple issues}}, add tags to it
string ai = WikiRegexes.MultipleIssues.Match(zerothSection).Value;
if (ai.Length > 0)
{
zerothSection = zerothSection.Replace(ai, ai.Substring(0, ai.Length - 2) + newTags + @"}}");
}
else // add {{Multiple issues}} to top of article, metaDataSorter will arrange correctly later
{
zerothSection = @"{{Multiple issues" + newTags + "}}\r\n" + zerothSection;
}
articleText = zerothSection + restOfArticle;
// Conversions() will add any missing dates and correct ...|wikify date=May 2008|...
return(MultipleIssuesBLPUnreferenced(articleText));
}
public void NextTest()
{
var my = new MonthYear(1, 2000);
var actual = my.Next();
var expected = new MonthYear(2, 2000);
Assert.AreEqual(expected.Month, actual.Month);
Assert.AreEqual(expected.Year, actual.Year);
my = new MonthYear(12, 2000);
actual = my.Next();
expected = new MonthYear(1, 2001);
Assert.AreEqual(expected.Month, actual.Month);
Assert.AreEqual(expected.Year, actual.Year);
}
public CreditCardBill CreateBill(MonthYear monthYear) => CreditCardBill.Create(this, monthYear);
public void ParseTest()
{
var my = MonthYear.Parse("1/2000");
var expected = new MonthYear(1, 2000);
Assert.AreEqual(expected.Month, my.Month);
Assert.AreEqual(expected.Year, my.Year);
}
public IEnumerable <IStatusPerBarangModel> GetByMonthYear(MonthYear startMonthYear, MonthYear endMonthYear)
{
using (var context = new DbContext())
{
var queryStr = _queryStr.Replace("{MonthYearPembelian}", "(MONTH(pb.tanggal) >= @startMonth AND YEAR(pb.tanggal) >= @startYear AND " +
"MONTH(pb.tanggal) <= @endMonth AND YEAR(pb.tanggal) <= @endYear)");
queryStr = queryStr.Replace("{MonthYearPenjualan}", "(MONTH(pj.tanggal) >= @startMonth AND YEAR(pj.tanggal) >= @startYear AND " +
"MONTH(pj.tanggal) <= @endMonth AND YEAR(pj.tanggal) <= @endYear)");
return(context.Conn.Query <StatusPerBarangModel>(queryStr, new { startMonth = startMonthYear.Month, startYear = startMonthYear.Year,
endMonth = endMonthYear.Month, endYear = endMonthYear.Year }));
}
}
public void ParseWithFormatTest()
{
var my = MonthYear.Parse("12.2000", "MM.YYYY");
var expected = new MonthYear(12, 2000);
Assert.AreEqual(expected.Month, my.Month);
Assert.AreEqual(expected.Year, my.Year);
}
public void ToMonthYearTest()
{
var date = new DateTime(2000, 1, 14);
var expected = new MonthYear(1, 2000);
var actual = date.ToMonthYear();
Assert.AreEqual(expected.Month, actual.Month);
Assert.AreEqual(expected.Year, actual.Year);
}
public void PreviousTest()
{
var my = new MonthYear(1, 2000);
var actual = my.Previous();
var expected = new MonthYear(12, 1999);
Assert.AreEqual(expected.Month, actual.Month);
Assert.AreEqual(expected.Year, actual.Year);
my = new MonthYear(2, 2000);
actual = my.Previous();
expected = new MonthYear(1, 2000);
Assert.AreEqual(expected.Month, actual.Month);
Assert.AreEqual(expected.Year, actual.Year);
}
public async Task GetPastPendingStatement()
{
// Arrange
testsUtils.CleanAll();
int categoryId = testsUtils.AddSingleCategory();
dbUtils.Insert(new DbStatementDto()
{
Amount = 104,
CategoryId = categoryId,
Direction = 0,
DueDate = DateTime.Parse("2018-04-15")
});
dbUtils.Insert(new DbStatementDto()
{
Amount = 204,
CategoryId = categoryId,
Direction = 0,
DueDate = DateTime.Parse("2018-04-20"),
Paid = true,
PaymentDate = DateTime.Parse("2018-04-20")
});
dbUtils.Insert(new DbStatementDto()
{
Amount = 105,
CategoryId = categoryId,
Direction = 0,
DueDate = DateTime.Parse("2018-05-15")
});
dbUtils.Insert(new DbStatementDto()
{
Amount = 205,
CategoryId = categoryId,
Direction = 0,
DueDate = DateTime.Parse("2018-05-20"),
Paid = true,
PaymentDate = DateTime.Parse("2018-05-20")
});
dbUtils.Insert(new DbStatementDto()
{
Amount = 106,
CategoryId = categoryId,
Direction = 0,
DueDate = DateTime.Parse("2018-06-15")
});
dbUtils.Insert(new DbStatementDto()
{
Amount = 206,
CategoryId = categoryId,
Direction = 0,
DueDate = DateTime.Parse("2018-06-20"),
Paid = true,
PaymentDate = DateTime.Parse("2018-06-20")
});
var sut = new StatementRepository(dbUtils.DbContext);
// Act
var statementList = await sut.GetList(MonthYear.Create(2018, 5));
// Assert
Assert.Equal(3, statementList.Count);
Assert.Contains(statementList, x => x.Amount == 104);
Assert.Contains(statementList, x => x.Amount == 105);
Assert.Contains(statementList, x => x.Amount == 205);
}
public InvestmentVehicleSetupForTests AddNetReturn(
MonthYear monthYear,
decimal returnValue)
{
return(AddReturn(monthYear, returnValue, FeeType.NetOfFees));
}
