public void ShouldGiveSameDayWhenWeekdayMatches()
{
DateTime saturday = new DateTime(2012, 04, 21);
DateTime nextSaturday = saturday.Next(DayOfWeek.Saturday);
Assert.That(nextSaturday, Is.EqualTo(saturday));
}
public GroupNotes()
{
InitializeComponent();
admin = false;
String query = "select ClientNum, ClientName from ClientInfo where IntakeDate not like '0001-01-01%' and ExitDate like '0001-01-01%'";
clients = database.GetTable(query);
editingDay = DateTime.Now;
lastDayOfWeek = editingDay.Next(DayOfWeek.Sunday);
firstDayOfWeek = editingDay.StartOfWeek(DayOfWeek.Monday);
dayOfWeek = editingDay.DayOfWeek.ToString();
WeekOf_Label.Text = "Week of " + firstDayOfWeek.ToString("MM/dd") + " through " + lastDayOfWeek.ToString("MM/dd");
updateClientList();
clientList.SetSelected(0, true);
newPDFPath = "/clientfiles/groupnotes/" + loadClientID + "/"; // C:\\Users/Darryl/SparkleShare/WestSlopeSecure
newFile = newPDFPath + firstDayOfWeek.ToString("MM-dd-yyyy") + ".pdf";
templatePathFromOld = newPDFPath + firstDayOfWeek.ToString("MM-dd-yyyy") + "-old.pdf";
// Wipe out shit files.
if (Directory.Exists(newPDFPath))
{
foreach (var file in Directory.EnumerateFiles(newPDFPath, "*-old.pdf", SearchOption.TopDirectoryOnly))
File.Delete(file);
}
processPdfGen();
DaySelection.SelectedIndex = ((int)(editingDay.DayOfWeek) + 6) % 7;
}
public IEnumerable<DateTime> ScheduleRoundDates(DateTime startDate, DateTime endDate, DayOfWeek dayOfWeek, int frequency, params int[] stageRoundCounts)
{
int roundCount = stageRoundCounts.Sum();
int stageCount = stageRoundCounts.Length;
var dates = new List<DateTime>();
DateTime date = startDate.Next(dayOfWeek);
int weeks = (endDate - date).Days / 7 + 1;
int breakLength = weeks - frequency * roundCount;
int halfStageIndex = CalculateHalfStageIndex(stageRoundCounts, roundCount, stageCount);
for (int i = 0; i < stageCount; i++)
{
var roundDates = new DateTime[stageRoundCounts[i]];
for (int j = 0; j < roundDates.Length; j++)
{
roundDates[j] = date;
date = date.AddDays(checked(7 * frequency)).Date;
}
dates.AddRange(roundDates);
if (i == halfStageIndex)
{
date = date.AddDays(7 * breakLength).Date;
}
}
return dates;
}
public void ShouldGiveNextWeekday()
{
DateTime saturday = new DateTime(2012, 04, 21);
DateTime nextMonday = saturday.Next(DayOfWeek.Monday);
Assert.That(nextMonday, Is.EqualTo(saturday.AddDays(2)));
}
private static DateTime UTCDateFromYearMonthWeekDay(int year, int month, int week, int day)
{
var date = new DateTime (year, month, 1).ToUniversalTime ();
var dayOfWeekWanted = (DayOfWeek)Enum.ToObject (typeof(DayOfWeek), day);
var beginningDay = (int) date.DayOfWeek;
if (beginningDay < day)
date = date.Next (dayOfWeekWanted);
else if (beginningDay > day) {
var previous = date.Previous (dayOfWeekWanted);
if (previous.Month == month)
date = previous;
else
date = date.Next (dayOfWeekWanted);
}
var daysToAdd = (week - 1) * 7;
return date.AddDays (daysToAdd);
}
public LeaguePlayOffsSeason(LeaguePlayOffs playOffs, DateTime startDate, DateTime endDate, IEnumerable<TeamPair> teamPairs)
: base(playOffs, startDate, endDate)
{
DateTime firstLegDate = startDate.Next(playOffs.DayOfWeek);
DateTime secondLegDate = firstLegDate.AddDays(7);
Ties = teamPairs.Select(p => new Tie(firstLegDate, secondLegDate, p.Team1, p.Team2)).ToList();
var teams = Enumerable.Union(teamPairs.Select(p => p.Team1).ToArray(), teamPairs.Select(p => p.Team2).ToArray()).ToList();
AddTeams(teams);
}
/// <summary>
/// Gets a DateTime representing the first specified day in the current month
/// </summary>
/// <param name="current">The current day</param>
/// <param name="dayOfWeek">The current day of week</param>
/// <returns></returns>
public static DateTime First(this DateTime current, DayOfWeek dayOfWeek)
{
DateTime first = current.First();
if (first.DayOfWeek != dayOfWeek)
{
first = first.Next(dayOfWeek);
}
return(first);
}
private DateObject ComputeDate(int cadinal, int weekday, int month, int year)
{
var firstDay = new DateObject(year, month, 1);
var firstWeekday = firstDay.This((DayOfWeek)weekday);
if (weekday == 0)
{
weekday = 7;
}
if (weekday < (int)firstDay.DayOfWeek)
{
firstWeekday = firstDay.Next((DayOfWeek)weekday);
}
return(firstWeekday.AddDays(7 * (cadinal - 1)));
}
public void NextDate_Tests()
{
DateTime thursdayFourteenthFebruary2008 = new DateTime(2008, 2, 14);
Assert.AreEqual(new DateTime(2008, 2, 18), thursdayFourteenthFebruary2008.Next(DayOfWeek.Monday));
Assert.AreEqual(new DateTime(2008, 2, 21), thursdayFourteenthFebruary2008.Next(DayOfWeek.Thursday));
Assert.AreEqual(new DateTime(2008, 2, 15), thursdayFourteenthFebruary2008.Next(DayOfWeek.Friday));
Assert.AreEqual(new DateTime(2008, 2, 18), thursdayFourteenthFebruary2008.Next(DayOfWeek.Monday, true));
Assert.AreEqual(new DateTime(2008, 2, 15), thursdayFourteenthFebruary2008.Next(DayOfWeek.Friday, true));
Assert.AreEqual(new DateTime(2008, 2, 14), thursdayFourteenthFebruary2008.Next(DayOfWeek.Thursday, true));
}
protected DateTimeResolutionResult MatchNextWeekday(string text, DateObject reference)
{
var result = new DateTimeResolutionResult();
var match = this.config.NextRegex.Match(text);
if (match.Success && match.Index == 0 && match.Length == text.Length)
{
var weekdayKey = match.Groups["weekday"].Value.ToLowerInvariant();
var value = reference.Next((DayOfWeek)this.config.DayOfWeek[weekdayKey]);
result.Timex = FormatUtil.LuisDate(value);
result.FutureValue = result.PastValue = value;
result.Success = true;
}
return(result);
}
protected DateTimeResolutionResult MatchNextWeekday(string text, DateObject reference)
{
var result = new DateTimeResolutionResult();
var match = this.config.NextRegex.MatchExact(text, trim: true);
if (match.Success)
{
var weekdayKey = match.Groups["weekday"].Value;
var value = reference.Next((DayOfWeek)this.config.DayOfWeek[weekdayKey]);
result.Timex = DateTimeFormatUtil.LuisDate(value);
result.FutureValue = result.PastValue = value;
result.Success = true;
}
return(result);
}
protected DateTimeResolutionResult MatchWeekdayAlone(string text, DateObject reference)
{
var result = new DateTimeResolutionResult();
var match = this.config.StrictWeekDayRegex.MatchExact(text, trim: true);
if (match.Success)
{
var weekdayKey = match.Groups["weekday"].Value.ToLower();
var weekday = this.config.DayOfWeek[weekdayKey];
var value = reference.This((DayOfWeek)weekday);
if (weekday == 0)
{
weekday = 7;
}
if (weekday < (int)reference.DayOfWeek)
{
value = reference.Next((DayOfWeek)weekday);
}
result.Timex = "XXXX-WXX-" + weekday;
var futureDate = value;
var pastDate = value;
if (futureDate < reference)
{
futureDate = futureDate.AddDays(7);
}
if (pastDate >= reference)
{
pastDate = pastDate.AddDays(-7);
}
result.FutureValue = futureDate;
result.PastValue = pastDate;
result.Success = true;
}
return(result);
}
/// <summary>
/// next week
/// last month
/// next june
/// last monday
/// </summary>
/// <param name="dateString"></param>
/// <param name="dateBase"></param>
/// <returns></returns>
private DateTime? CheckNextLastIndicator(string dateString, DateTime dateBase)
{
Match match = nextLastUnit.Match(dateString);
if (match.Success)
{
bool isNext = match.Groups[1].Value.Equals("next");
string unit = match.Groups[2].Value;
if (StringIsDayOfTheWeek(unit))
{
return ParseRelative(dateBase, dateString.Substring(5)).AddWeeks(isNext ? 1 : -1);
}
if (unit.Equals("month"))
{
return isNext ? dateBase.Next(DateUnit.Month) : dateBase.Last(DateUnit.Month);
}
if (allMonthNames.Contains(unit, StringComparer.CurrentCultureIgnoreCase))
{
return ParseRelative(dateBase, unit).AddYears(1);
}
}
return null;
}
/// <summary>
/// friday
/// </summary>
/// <param name="dateString"></param>
/// <param name="dateBase"></param>
/// <returns></returns>
private DateTime? CheckEntireStringIsDay(string dateString, DateTime dateBase)
{
if (StringIsDayOfTheWeek(dateString))
{
return dateBase.Next(StringToDayOfWeek(dateString));
}
return null;
}
/// <summary>
/// Get a DateTime that represents the provided day of the week in the provided numerical week of the provided date. Example: 2nd Thursday.
/// </summary>
/// <param name="date">The date</param>
/// <param name="nthWeek">The numerical week to get the DateTime in</param>
/// <param name="dayOfWeek">The day of the week you want the DateTime to be in</param>
/// <returns></returns>
public static DateTime GetNthWeekofMonth(DateTime date, int nthWeek, DayOfWeek dayOfWeek)
{
return date.Next(dayOfWeek).AddDays((nthWeek - 1) * 7);
}
// match several other cases
// including 'today', 'the day after tomorrow', 'on 13'
private DateTimeResolutionResult ParseImplicitDate(string text, DateObject referenceDate)
{
var trimedText = text.Trim();
var ret = new DateTimeResolutionResult();
// handle "on 12"
var match = this.config.OnRegex.Match(this.config.DateTokenPrefix + trimedText);
if (match.Success && match.Index == 3 && match.Length == trimedText.Length)
{
int day = 0, month = referenceDate.Month, year = referenceDate.Year;
var dayStr = match.Groups["day"].Value.ToLower();
day = this.config.DayOfMonth[dayStr];
ret.Timex = FormatUtil.LuisDate(-1, -1, day);
DateObject futureDate, pastDate, temp;
var tryStr = FormatUtil.LuisDate(year, month, day);
if (DateObject.TryParse(tryStr, out temp))
{
futureDate = new DateObject(year, month, day);
pastDate = new DateObject(year, month, day);
if (futureDate < referenceDate)
{
futureDate = futureDate.AddMonths(+1);
}
if (pastDate >= referenceDate)
{
pastDate = pastDate.AddMonths(-1);
}
}
else
{
futureDate = new DateObject(year, month + 1, day);
pastDate = new DateObject(year, month - 1, day);
}
ret.FutureValue = futureDate;
ret.PastValue = pastDate;
ret.Success = true;
return(ret);
}
// handle "today", "the day before yesterday"
match = this.config.SpecialDayRegex.Match(trimedText);
if (match.Success && match.Index == 0 && match.Length == trimedText.Length)
{
var swift = this.config.GetSwiftDay(match.Value);
var value = referenceDate.AddDays(swift);
ret.Timex = FormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "next Sunday"
match = this.config.NextRegex.Match(trimedText);
if (match.Success && match.Index == 0 && match.Length == trimedText.Length)
{
var weekdayStr = match.Groups["weekday"].Value.ToLower();
var value = referenceDate.Next((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
ret.Timex = FormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "this Friday"
match = this.config.ThisRegex.Match(trimedText);
if (match.Success && match.Index == 0 && match.Length == trimedText.Length)
{
var weekdayStr = match.Groups["weekday"].Value.ToLower();
var value = referenceDate.This((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
ret.Timex = FormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "last Friday", "last mon"
match = this.config.LastRegex.Match(trimedText);
if (match.Success && match.Index == 0 && match.Length == trimedText.Length)
{
var weekdayStr = match.Groups["weekday"].Value.ToLower();
var value = referenceDate.Last((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
ret.Timex = FormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "Friday"
match = this.config.StrictWeekDay.Match(trimedText);
if (match.Success && match.Index == 0 && match.Length == trimedText.Length)
{
var weekdayStr = match.Groups["weekday"].Value.ToLower();
var weekDay = this.config.DayOfWeek[weekdayStr];
var value = referenceDate.This((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
if (weekDay == 0)
{
weekDay = 7;
}
if (weekDay < (int)referenceDate.DayOfWeek)
{
value = referenceDate.Next((DayOfWeek)weekDay);
}
ret.Timex = "XXXX-WXX-" + weekDay;
var futureDate = value;
var pastDate = value;
if (futureDate < referenceDate)
{
futureDate = futureDate.AddDays(7);
}
if (pastDate >= referenceDate)
{
pastDate = pastDate.AddDays(-7);
}
ret.FutureValue = futureDate;
ret.PastValue = pastDate;
ret.Success = true;
return(ret);
}
return(ret);
}
public void Next_ReturnsNextFridayProperly()
{
var friday = new DateTime(2009, 7, 10, 1, 0, 0, 0, DateTimeKind.Local);
var reallyNextFriday = new DateTime(2009, 7, 17, 1, 0, 0, 0, DateTimeKind.Local);
var nextFriday = friday.Next(DayOfWeek.Friday);
DateAssert.AreEqual(reallyNextFriday, nextFriday);
}
public void BasicTests()
{
var now = DateTime.Now;
DateAssert.AreEqual(new DateTime(now.Year, now.Month, now.Day, 23, 59, 59, 999, DateTimeKind.Local), DateTime.Now.EndOfDay(), " End of the day wrong");
DateAssert.AreEqual(new DateTime(now.Year, now.Month, now.Day, 0, 0, 0, 0, DateTimeKind.Local), DateTime.Now.BeginningOfDay(), "Start of the day wrong");
var firstBirthDay = new DateTime(1977, 12, 31, 17, 0, 0, 0, DateTimeKind.Local);
DateAssert.AreEqual(firstBirthDay + new TimeSpan(1, 0, 5, 0, 0), firstBirthDay + 1.Days() + 5.Minutes());
DateAssert.AreEqual(now + TimeSpan.FromDays(1), now.NextDay());
DateAssert.AreEqual(now - TimeSpan.FromDays(1), now.PreviousDay());
DateAssert.AreEqual(now + TimeSpan.FromDays(7), now.WeekAfter());
DateAssert.AreEqual(now - TimeSpan.FromDays(7), now.WeekEarlier());
Assert.AreEqual(new DateTime(2009, 1, 1, 0, 0, 0, 0, DateTimeKind.Local), new DateTime(2008, 12, 31, 0, 0, 0, DateTimeKind.Local).Add(1.Days()));
Assert.AreEqual(new DateTime(2009, 1, 2, 0, 0, 0, 0, DateTimeKind.Local), new DateTime(2009, 1, 1, 0, 0, 0, 0, DateTimeKind.Local).Add(1.Days()));
var sampleDate = new DateTime(2009, 1, 1, 13, 0, 0, 0, DateTimeKind.Local);
DateAssert.AreEqual(new DateTime(2009, 1, 1, 12, 0, 0, 0, DateTimeKind.Local), sampleDate.Noon());
DateAssert.AreEqual(new DateTime(2009, 1, 1, 0, 0, 0, 0, DateTimeKind.Local), sampleDate.Midnight());
Assert.AreEqual(3.Days() + 3.Days(), 6.Days());
Assert.AreEqual(102.Days() - 3.Days(), 99.Days());
Assert.AreEqual(24.Hours(), 1.Days());
sampleDate = new DateTime(2008, 1, 1, 0, 0, 0, 0, DateTimeKind.Local);
DateAssert.AreEqual(3.Days().Since(sampleDate), sampleDate + 3.Days());
var saturday = new DateTime(2008, 10, 25, 12, 0, 0, DateTimeKind.Local);
DateAssert.AreEqual(new DateTime(2008, 11, 1, 12, 0, 0, DateTimeKind.Local), saturday.Next(DayOfWeek.Saturday));
DateAssert.AreEqual(new DateTime(2008, 10, 18, 12, 0, 0, DateTimeKind.Local), saturday.Previous(DayOfWeek.Saturday));
// ReSharper disable UnusedVariable
var nextWeek = DateTime.Now + 1.Weeks();
var tomorrow = DateTime.Now + 1.Days();
var yesterday = DateTime.Now - 1.Days();
var changedHourTo14H = DateTime.Now.SetHour(14);
var todayNoon = DateTime.Now.Noon();
var tomorrowNoon = DateTime.Now.NextDay().Noon();
var fiveDaysAgo = 5.Days().Ago();
var twoDaysFromNow = 2.Days().FromNow();
var nextYearSameDateAsTodayNoon = 1.Years().FromNow().Noon();
var twoWeeksFromNow = 2.Weeks().FromNow();
// ReSharper restore UnusedVariable
}
public static DateTime Last(this DateTime input, Predicate <DateTime> predicate) => input.Next(predicate, true);
public static DateTime Last(this DateTime input, DayOfWeek dayOfWeek) => input.Next(d => d.DayOfWeek == dayOfWeek, true);
// match several other cases
// including 'today', 'the day after tomorrow', 'on 13'
private DateTimeResolutionResult ParseImplicitDate(string text, DateObject referenceDate)
{
var trimmedText = text.Trim();
var ret = new DateTimeResolutionResult();
// handle "on 12"
var match = this.config.OnRegex.Match(this.config.DateTokenPrefix + trimmedText);
if (match.Success && match.Index == 3 && match.Length == trimmedText.Length)
{
int month = referenceDate.Month, year = referenceDate.Year;
var dayStr = match.Groups["day"].Value.ToLower();
var day = this.config.DayOfMonth[dayStr];
ret.Timex = DateTimeFormatUtil.LuisDate(-1, -1, day);
DateObject futureDate, pastDate;
var tryStr = DateTimeFormatUtil.LuisDate(year, month, day);
if (DateObject.TryParse(tryStr, out DateObject _))
{
futureDate = DateObject.MinValue.SafeCreateFromValue(year, month, day);
pastDate = DateObject.MinValue.SafeCreateFromValue(year, month, day);
if (futureDate < referenceDate)
{
futureDate = futureDate.AddMonths(+1);
}
if (pastDate >= referenceDate)
{
pastDate = pastDate.AddMonths(-1);
}
}
else
{
futureDate = DateObject.MinValue.SafeCreateFromValue(year, month + 1, day);
pastDate = DateObject.MinValue.SafeCreateFromValue(year, month - 1, day);
}
ret.FutureValue = futureDate;
ret.PastValue = pastDate;
ret.Success = true;
return(ret);
}
// handle "today", "the day before yesterday"
var exactMatch = this.config.SpecialDayRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var swift = GetSwiftDay(exactMatch.Value);
var value = referenceDate.AddDays(swift);
ret.Timex = DateTimeFormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "two days from tomorrow"
exactMatch = this.config.SpecialDayWithNumRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var swift = GetSwiftDay(exactMatch.Groups["day"].Value);
var numErs = this.config.IntegerExtractor.Extract(trimmedText);
var numOfDays = Convert.ToInt32((double)(this.config.NumberParser.Parse(numErs[0]).Value ?? 0));
var value = referenceDate.AddDays(numOfDays + swift);
ret.Timex = DateTimeFormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "two sundays from now"
exactMatch = this.config.RelativeWeekDayRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var numErs = this.config.IntegerExtractor.Extract(trimmedText);
var num = Convert.ToInt32((double)(this.config.NumberParser.Parse(numErs[0]).Value ?? 0));
var weekdayStr = exactMatch.Groups["weekday"].Value.ToLower();
var value = referenceDate;
// Check whether the determined day of this week has passed.
if (value.DayOfWeek > (DayOfWeek)this.config.DayOfWeek[weekdayStr])
{
num--;
}
while (num-- > 0)
{
value = value.Next((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
}
ret.Timex = DateTimeFormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "next Sunday"
exactMatch = this.config.NextRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var weekdayStr = exactMatch.Groups["weekday"].Value.ToLower();
var value = referenceDate.Next((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
ret.Timex = DateTimeFormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "this Friday"
exactMatch = this.config.ThisRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var weekdayStr = exactMatch.Groups["weekday"].Value.ToLower();
var value = referenceDate.This((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
ret.Timex = DateTimeFormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "last Friday", "last mon"
exactMatch = this.config.LastRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var weekdayStr = exactMatch.Groups["weekday"].Value.ToLower();
var value = referenceDate.Last((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
ret.Timex = DateTimeFormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "Friday"
exactMatch = this.config.WeekDayRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var weekdayStr = exactMatch.Groups["weekday"].Value.ToLower();
var weekDay = this.config.DayOfWeek[weekdayStr];
var value = referenceDate.This((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
if (weekDay == 0)
{
weekDay = 7;
}
if (weekDay < (int)referenceDate.DayOfWeek)
{
value = referenceDate.Next((DayOfWeek)weekDay);
}
ret.Timex = "XXXX-WXX-" + weekDay;
var futureDate = value;
var pastDate = value;
if (futureDate < referenceDate)
{
futureDate = futureDate.AddDays(7);
}
if (pastDate >= referenceDate)
{
pastDate = pastDate.AddDays(-7);
}
ret.FutureValue = futureDate;
ret.PastValue = pastDate;
ret.Success = true;
return(ret);
}
// handle "for the 27th."
match = this.config.ForTheRegex.Match(text);
if (match.Success)
{
int day = 0, month = referenceDate.Month, year = referenceDate.Year;
var dayStr = match.Groups["DayOfMonth"].Value.ToLower();
// create a extract result which content ordinal string of text
ExtractResult er = new ExtractResult
{
Text = dayStr,
Start = match.Groups["DayOfMonth"].Index,
Length = match.Groups["DayOfMonth"].Length,
};
day = Convert.ToInt32((double)(this.config.NumberParser.Parse(er).Value ?? 0));
ret.Timex = DateTimeFormatUtil.LuisDate(-1, -1, day);
DateObject futureDate;
var tryStr = DateTimeFormatUtil.LuisDate(year, month, day);
if (DateObject.TryParse(tryStr, out DateObject _))
{
futureDate = DateObject.MinValue.SafeCreateFromValue(year, month, day);
}
else
{
futureDate = DateObject.MinValue.SafeCreateFromValue(year, month + 1, day);
}
ret.FutureValue = futureDate;
ret.PastValue = ret.FutureValue;
ret.Success = true;
return(ret);
}
// handling cases like 'Thursday the 21st', which both 'Thursday' and '21st' refer to a same date
match = this.config.WeekDayAndDayOfMothRegex.Match(text);
if (match.Success)
{
int month = referenceDate.Month, year = referenceDate.Year;
// create a extract result which content ordinal string of text
ExtractResult ertmp = new ExtractResult
{
Text = match.Groups["DayOfMonth"].Value,
Start = match.Groups["DayOfMonth"].Index,
Length = match.Groups["DayOfMonth"].Length,
};
// parse the day in text into number
var day = Convert.ToInt32((double)(this.config.NumberParser.Parse(ertmp).Value ?? 0));
// the validity of the phrase is guaranteed in the Date Extractor
ret.Timex = DateTimeFormatUtil.LuisDate(year, month, day);
ret.FutureValue = new DateObject(year, month, day);
ret.PastValue = new DateObject(year, month, day);
ret.Success = true;
return(ret);
}
return(ret);
}
// match several other cases
// including 'today', 'the day after tomorrow', 'on 13'
private DateTimeResolutionResult ParseImplicitDate(string text, DateObject referenceDate)
{
var trimedText = text.Trim();
var ret = new DateTimeResolutionResult();
// handle "on 12"
var match = this.config.OnRegex.Match(this.config.DateTokenPrefix + trimedText);
if (match.Success && match.Index == 3 && match.Length == trimedText.Length)
{
int day = 0, month = referenceDate.Month, year = referenceDate.Year;
var dayStr = match.Groups["day"].Value.ToLower();
day = this.config.DayOfMonth[dayStr];
ret.Timex = FormatUtil.LuisDate(-1, -1, day);
DateObject futureDate, pastDate;
var tryStr = FormatUtil.LuisDate(year, month, day);
if (DateObject.TryParse(tryStr, out DateObject temp))
{
futureDate = DateObject.MinValue.SafeCreateFromValue(year, month, day);
pastDate = DateObject.MinValue.SafeCreateFromValue(year, month, day);
if (futureDate < referenceDate)
{
futureDate = futureDate.AddMonths(+1);
}
if (pastDate >= referenceDate)
{
pastDate = pastDate.AddMonths(-1);
}
}
else
{
futureDate = DateObject.MinValue.SafeCreateFromValue(year, month + 1, day);
pastDate = DateObject.MinValue.SafeCreateFromValue(year, month - 1, day);
}
ret.FutureValue = futureDate;
ret.PastValue = pastDate;
ret.Success = true;
return(ret);
}
// handle "today", "the day before yesterday"
match = this.config.SpecialDayRegex.Match(trimedText);
if (match.Success && match.Index == 0 && match.Length == trimedText.Length)
{
var swift = this.config.GetSwiftDay(match.Value);
var value = referenceDate.AddDays(swift);
ret.Timex = FormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "next Sunday"
match = this.config.NextRegex.Match(trimedText);
if (match.Success && match.Index == 0 && match.Length == trimedText.Length)
{
var weekdayStr = match.Groups["weekday"].Value.ToLower();
var value = referenceDate.Next((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
ret.Timex = FormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "this Friday"
match = this.config.ThisRegex.Match(trimedText);
if (match.Success && match.Index == 0 && match.Length == trimedText.Length)
{
var weekdayStr = match.Groups["weekday"].Value.ToLower();
var value = referenceDate.This((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
ret.Timex = FormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "last Friday", "last mon"
match = this.config.LastRegex.Match(trimedText);
if (match.Success && match.Index == 0 && match.Length == trimedText.Length)
{
var weekdayStr = match.Groups["weekday"].Value.ToLower();
var value = referenceDate.Last((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
ret.Timex = FormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// handle "Friday"
match = this.config.WeekDayRegex.Match(trimedText);
if (match.Success && match.Index == 0 && match.Length == trimedText.Length)
{
var weekdayStr = match.Groups["weekday"].Value.ToLower();
var weekDay = this.config.DayOfWeek[weekdayStr];
var value = referenceDate.This((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
if (weekDay == 0)
{
weekDay = 7;
}
if (weekDay < (int)referenceDate.DayOfWeek)
{
value = referenceDate.Next((DayOfWeek)weekDay);
}
ret.Timex = "XXXX-WXX-" + weekDay;
var futureDate = value;
var pastDate = value;
if (futureDate < referenceDate)
{
futureDate = futureDate.AddDays(7);
}
if (pastDate >= referenceDate)
{
pastDate = pastDate.AddDays(-7);
}
ret.FutureValue = futureDate;
ret.PastValue = pastDate;
ret.Success = true;
return(ret);
}
// handle "for the 27th."
match = this.config.ForTheRegex.Match(text);
if (match.Success)
{
int day = 0, month = referenceDate.Month, year = referenceDate.Year;
var dayStr = match.Groups["DayOfMonth"].Value.ToLower();
// create a extract result which content ordinal string of text
ExtractResult er = new ExtractResult();
er.Text = dayStr;
er.Start = match.Groups["DayOfMonth"].Index;
er.Length = match.Groups["DayOfMonth"].Length;
day = Convert.ToInt32((double)(this.config.NumberParser.Parse(er).Value ?? 0));
ret.Timex = FormatUtil.LuisDate(-1, -1, day);
DateObject futureDate;
var tryStr = FormatUtil.LuisDate(year, month, day);
if (DateObject.TryParse(tryStr, out DateObject temp))
{
futureDate = DateObject.MinValue.SafeCreateFromValue(year, month, day);
}
else
{
futureDate = DateObject.MinValue.SafeCreateFromValue(year, month + 1, day);
}
ret.FutureValue = futureDate;
ret.PastValue = ret.FutureValue;
ret.Success = true;
return(ret);
}
// handling cases like 'Thursday the 21st', which both 'Thursday' and '21st' refer to a same date
match = this.config.WeekDayAndDayOfMothRegex.Match(text);
if (match.Success)
{
int month = referenceDate.Month, year = referenceDate.Year;
// create a extract result which content ordinal string of text
ExtractResult erTmp = new ExtractResult();
erTmp.Text = match.Groups["DayOfMonth"].Value.ToString();
erTmp.Start = match.Groups["DayOfMonth"].Index;
erTmp.Length = match.Groups["DayOfMonth"].Length;
// parse the day in text into number
var day = Convert.ToInt32((double)(this.config.NumberParser.Parse(erTmp).Value ?? 0));
// the validity of the phrase is guaranteed in the Date Extractor
ret.Timex = FormatUtil.LuisDate(year, month, day);
ret.FutureValue = new DateObject(year, month, day);;
ret.PastValue = new DateObject(year, month, day);;
ret.Success = true;
return(ret);
}
return(ret);
}
public void NextLast()
{
var date = new DateTime(2015, 8, 7).Date;
Assert.AreEqual(new DateTime(2015, 8, 10), date.Next(DayOfWeek.Monday));
Assert.AreEqual(new DateTime(2015, 8, 14), date.Next(DayOfWeek.Friday));
Assert.AreEqual(new DateTime(2015, 8, 9), date.Next(DayOfWeek.Sunday));
Assert.AreEqual(new DateTime(2015, 8, 15), date.Next(DayOfWeek.Saturday));
Assert.AreEqual(new DateTime(2015, 8, 3), date.Last(DayOfWeek.Monday));
Assert.AreEqual(new DateTime(2015, 7, 31), date.Last(DayOfWeek.Friday));
Assert.AreEqual(new DateTime(2015, 8, 2), date.Last(DayOfWeek.Sunday));
Assert.AreEqual(new DateTime(2015, 8, 1), date.Last(DayOfWeek.Saturday));
}
// Match several other cases
// Including 'today', 'the day after tomorrow', 'on 13'
private DateTimeResolutionResult ParseImplicitDate(string text, DateObject referenceDate)
{
var trimmedText = text.Trim();
var ret = new DateTimeResolutionResult();
// Handle "on 12"
var match = this.config.OnRegex.Match(this.config.DateTokenPrefix + trimmedText);
if (match.Success && match.Index == 3 && match.Length == trimmedText.Length)
{
int month = referenceDate.Month, year = referenceDate.Year;
var dayStr = match.Groups["day"].Value;
var day = this.config.DayOfMonth[dayStr];
ret.Timex = DateTimeFormatUtil.LuisDate(-1, -1, day);
DateObject futureDate, pastDate;
var tryStr = DateTimeFormatUtil.LuisDate(year, month, day);
if (DateObject.TryParse(tryStr, out DateObject _))
{
futureDate = DateObject.MinValue.SafeCreateFromValue(year, month, day);
pastDate = DateObject.MinValue.SafeCreateFromValue(year, month, day);
if (futureDate < referenceDate)
{
futureDate = futureDate.AddMonths(+1);
}
if (pastDate >= referenceDate)
{
pastDate = pastDate.AddMonths(-1);
}
}
else
{
futureDate = DateObject.MinValue.SafeCreateFromValue(year, month + 1, day);
pastDate = DateObject.MinValue.SafeCreateFromValue(year, month - 1, day);
}
ret.FutureValue = futureDate;
ret.PastValue = pastDate;
ret.Success = true;
return(ret);
}
// Handle "today", "the day before yesterday"
var exactMatch = this.config.SpecialDayRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var swift = GetSwiftDay(exactMatch.Value);
var value = referenceDate.Date.AddDays(swift);
ret.Timex = DateTimeFormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = value;
ret.Success = true;
return(ret);
}
// Handle "two days from tomorrow"
exactMatch = this.config.SpecialDayWithNumRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var swift = GetSwiftDay(exactMatch.Groups["day"].Value);
var numErs = this.config.IntegerExtractor.Extract(trimmedText);
var numOfDays = Convert.ToInt32((double)(this.config.NumberParser.Parse(numErs[0]).Value ?? 0));
var value = referenceDate.AddDays(numOfDays + swift);
ret.Timex = DateTimeFormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = DateObject.MinValue.SafeCreateFromValue(value.Year, value.Month, value.Day);
ret.Success = true;
return(ret);
}
// Handle "two sundays from now"
exactMatch = this.config.RelativeWeekDayRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var numErs = this.config.IntegerExtractor.Extract(trimmedText);
var num = Convert.ToInt32((double)(this.config.NumberParser.Parse(numErs[0]).Value ?? 0));
var weekdayStr = exactMatch.Groups["weekday"].Value;
var value = referenceDate;
// Check whether the determined day of this week has passed.
if (value.DayOfWeek > (DayOfWeek)this.config.DayOfWeek[weekdayStr])
{
num--;
}
while (num-- > 0)
{
value = value.Next((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
}
ret.Timex = DateTimeFormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = DateObject.MinValue.SafeCreateFromValue(value.Year, value.Month, value.Day);
ret.Success = true;
return(ret);
}
// Handle "next Sunday", "upcoming Sunday"
// We define "upcoming Sunday" as the nearest Sunday to come (not include today)
// We define "next Sunday" as Sunday of next week
exactMatch = this.config.NextRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var weekdayStr = exactMatch.Groups["weekday"].Value;
var value = referenceDate.Next((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
if (this.config.UpcomingPrefixRegex.MatchBegin(trimmedText, trim: true).Success)
{
value = referenceDate.Upcoming((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
}
ret.Timex = DateTimeFormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = DateObject.MinValue.SafeCreateFromValue(value.Year, value.Month, value.Day);
ret.Success = true;
return(ret);
}
// Handle "this Friday"
exactMatch = this.config.ThisRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var weekdayStr = exactMatch.Groups["weekday"].Value;
var value = referenceDate.This((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
ret.Timex = DateTimeFormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = DateObject.MinValue.SafeCreateFromValue(value.Year, value.Month, value.Day);
ret.Success = true;
return(ret);
}
// Handle "last Friday", "last mon"
// We define "past Sunday" as the nearest Sunday that has already passed (not include today)
// We define "previous Sunday" as Sunday of previous week
exactMatch = this.config.LastRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var weekdayStr = exactMatch.Groups["weekday"].Value;
var value = referenceDate.Last((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
if (this.config.PastPrefixRegex.MatchBegin(trimmedText, trim: true).Success)
{
value = referenceDate.Past((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
}
ret.Timex = DateTimeFormatUtil.LuisDate(value);
ret.FutureValue = ret.PastValue = DateObject.MinValue.SafeCreateFromValue(value.Year, value.Month, value.Day);
ret.Success = true;
return(ret);
}
// Handle "Friday"
exactMatch = this.config.WeekDayRegex.MatchExact(trimmedText, trim: true);
if (exactMatch.Success)
{
var weekdayStr = exactMatch.Groups["weekday"].Value;
var weekDay = this.config.DayOfWeek[weekdayStr];
var value = referenceDate.This((DayOfWeek)this.config.DayOfWeek[weekdayStr]);
if (weekDay == 0)
{
weekDay = 7;
}
if (weekDay < (int)referenceDate.DayOfWeek)
{
value = referenceDate.Next((DayOfWeek)weekDay);
}
ret.Timex = "XXXX-WXX-" + weekDay;
var futureDate = value;
var pastDate = value;
if (futureDate < referenceDate)
{
futureDate = futureDate.AddDays(7);
}
if (pastDate >= referenceDate)
{
pastDate = pastDate.AddDays(-7);
}
ret.FutureValue = DateObject.MinValue.SafeCreateFromValue(futureDate.Year, futureDate.Month, futureDate.Day);
ret.PastValue = DateObject.MinValue.SafeCreateFromValue(pastDate.Year, pastDate.Month, pastDate.Day);
ret.Success = true;
return(ret);
}
// Handle "for the 27th."
match = this.config.ForTheRegex.Match(text);
if (match.Success)
{
int day = 0, month = referenceDate.Month, year = referenceDate.Year;
var dayStr = match.Groups["DayOfMonth"].Value;
// Create a extract result which content ordinal string of text
ExtractResult er = new ExtractResult
{
Text = dayStr,
Start = match.Groups["DayOfMonth"].Index,
Length = match.Groups["DayOfMonth"].Length,
};
day = Convert.ToInt32((double)(this.config.NumberParser.Parse(er).Value ?? 0));
ret.Timex = DateTimeFormatUtil.LuisDate(-1, -1, day);
DateObject futureDate;
var tryStr = DateTimeFormatUtil.LuisDate(year, month, day);
if (DateObject.TryParse(tryStr, out DateObject _))
{
futureDate = DateObject.MinValue.SafeCreateFromValue(year, month, day);
}
else
{
futureDate = DateObject.MinValue.SafeCreateFromValue(year, month + 1, day);
}
ret.FutureValue = futureDate;
ret.PastValue = ret.FutureValue;
ret.Success = true;
return(ret);
}
// Handling cases like 'Thursday the 21st', which both 'Thursday' and '21st' refer to a same date
match = this.config.WeekDayAndDayOfMothRegex.Match(text);
if (match.Success)
{
int month = referenceDate.Month, year = referenceDate.Year;
// create a extract result which content ordinal string of text
ExtractResult extractResultTmp = new ExtractResult
{
Text = match.Groups["DayOfMonth"].Value,
Start = match.Groups["DayOfMonth"].Index,
Length = match.Groups["DayOfMonth"].Length,
};
// parse the day in text into number
var day = Convert.ToInt32((double)(this.config.NumberParser.Parse(extractResultTmp).Value ?? 0));
// The validity of the phrase is guaranteed in the Date Extractor
ret.Timex = DateTimeFormatUtil.LuisDate(year, month, day);
ret.FutureValue = new DateObject(year, month, day);
ret.PastValue = new DateObject(year, month, day);
ret.Success = true;
return(ret);
}
// Handling cases like 'Monday 21', which both 'Monday' and '21' refer to the same date.
// The year of expected date can be different to the year of referenceDate.
match = this.config.WeekDayAndDayRegex.Match(text);
if (match.Success)
{
int month = referenceDate.Month, year = referenceDate.Year;
// Create a extract result which content ordinal string of text
ExtractResult ertmp = new ExtractResult
{
Text = match.Groups["day"].Value,
Start = match.Groups["day"].Index,
Length = match.Groups["day"].Length,
};
// Parse the day in text into number
var day = Convert.ToInt32((double)(this.config.NumberParser.Parse(ertmp).Value ?? 0));
// Firstly, find a latest date with the "day" as pivotDate.
// Secondly, if the pivotDate equals the referenced date, in other word, the day of the referenced date is exactly the "day".
// In this way, check if the pivotDate is the weekday. If so, then the futureDate and the previousDate are the same date (referenced date).
// Otherwise, increase the pivotDate month by month to find the latest futureDate and decrease the pivotDate month
// by month to the latest previousDate.
// Notice: if the "day" is larger than 28, some months should be ignored in the increase or decrease procedure.
var pivotDate = new DateObject(year, month, 1);
var daysInMonth = DateObject.DaysInMonth(year, month);
if (daysInMonth >= day)
{
pivotDate = DateObject.MinValue.SafeCreateFromValue(year, month, day);
}
else
{
// Add 1 month is enough, since 1, 3, 5, 7, 8, 10, 12 months has 31 days
pivotDate = pivotDate.AddMonths(1);
pivotDate = DateObject.MinValue.SafeCreateFromValue(pivotDate.Year, pivotDate.Month, day);
}
var numWeekDayInt = (int)pivotDate.DayOfWeek;
var extractedWeekDayStr = match.Groups["weekday"].Value;
var weekDay = this.config.DayOfWeek[extractedWeekDayStr];
if (!pivotDate.Equals(DateObject.MinValue))
{
if (day == referenceDate.Day && numWeekDayInt == weekDay)
{
// The referenceDate is the weekday and with the "day".
ret.FutureValue = new DateObject(year, month, day);
ret.PastValue = new DateObject(year, month, day);
ret.Timex = DateTimeFormatUtil.LuisDate(year, month, day);
}
else
{
var futureDate = pivotDate;
var pastDate = pivotDate;
while ((int)futureDate.DayOfWeek != weekDay || futureDate.Day != day || futureDate < referenceDate)
{
// Increase the futureDate month by month to find the expected date (the "day" is the weekday) and
// make sure the futureDate not less than the referenceDate.
futureDate = futureDate.AddMonths(1);
var tmp = DateObject.DaysInMonth(futureDate.Year, futureDate.Month);
if (tmp >= day)
{
// For months like January 31, after add 1 month, February 31 won't be returned, so the day should be revised ASAP.
futureDate = futureDate.SafeCreateFromValue(futureDate.Year, futureDate.Month, day);
}
}
ret.FutureValue = futureDate;
while ((int)pastDate.DayOfWeek != weekDay || pastDate.Day != day || pastDate > referenceDate)
{
// Decrease the pastDate month by month to find the expected date (the "day" is the weekday) and
// make sure the pastDate not larger than the referenceDate.
pastDate = pastDate.AddMonths(-1);
var tmp = DateObject.DaysInMonth(pastDate.Year, pastDate.Month);
if (tmp >= day)
{
// For months like March 31, after minus 1 month, February 31 won't be returned, so the day should be revised ASAP.
pastDate = pastDate.SafeCreateFromValue(pastDate.Year, pastDate.Month, day);
}
}
ret.PastValue = pastDate;
if (weekDay == 0)
{
weekDay = 7;
}
ret.Timex = "XXXX-WXX-" + weekDay;
}
}
ret.Success = true;
return(ret);
}
return(ret);
}
protected void Page_Load(object sender, EventArgs e)
{
StringBuilder sb = new StringBuilder();
// if (Vars.DevEnv)
// System.Threading.Thread.Sleep(new Random().Next(2000));
if (Request.QueryString["type"] == "calendar")
{
bool freeGuestlist = Request.QueryString["freeGuestlist"] == null || Request.QueryString["freeGuestlist"].Length == 0 || Request.QueryString["freeGuestlist"] == "0" ? false : true;
Brand brand = Request.QueryString["brandk"] == null || Request.QueryString["brandk"].Length == 0 || Request.QueryString["brandk"] == "0" ? null : new Brand(int.Parse(Request.QueryString["brandk"]));
Place place = Request.QueryString["placek"] == null || Request.QueryString["placek"].Length == 0 || Request.QueryString["placek"] == "0" ? null : new Place(int.Parse(Request.QueryString["placek"]));
Venue venue = Request.QueryString["venuek"] == null || Request.QueryString["venuek"].Length == 0 || Request.QueryString["venuek"] == "0" || Request.QueryString["venuek"] == "1" ? null : new Venue(int.Parse(Request.QueryString["venuek"]));
int key = Request.QueryString["key"] == null || Request.QueryString["key"].Length == 0 || Request.QueryString["key"] == "0" ? 0 : int.Parse(Request.QueryString["key"]);
MusicType music = Request.QueryString["musictypek"] == null || Request.QueryString["musictypek"].Length == 0 || Request.QueryString["musictypek"] == "0" ? null : new MusicType(int.Parse(Request.QueryString["musictypek"]));
bool me = Request.QueryString["me"] != null && Request.QueryString["me"] == "1";
bool addGalleryButton = Request.QueryString["addgallery"] != null && Request.QueryString["addgallery"] == "1";
bool allVenues = Request.QueryString["venuek"] != null && Request.QueryString["venuek"] == "1";
DateTime date = new DateTime(
int.Parse(Request.QueryString["date"].Substring(0, 4)),
int.Parse(Request.QueryString["date"].Substring(4, 2)),
int.Parse(Request.QueryString["date"].Substring(6, 2)) > 0 ? int.Parse(Request.QueryString["date"].Substring(6, 2)) : 1 );
//if (date == DateTime.Today)
// System.Threading.Thread.Sleep(1000);
DateTime from = date.Previous(DayOfWeek.Monday, true);
DateTime to = date.Next(DayOfWeek.Sunday, true);
Event.EventsForDisplay events = new Event.EventsForDisplay();
events.IgnoreMusicType = true;
if (me)
{
events.AttendedUsrK = Usr.Current.K;
}
else if (brand != null)
{
events.BrandK = brand.K;
}
else if (venue != null)
{
events.VenueK = venue.K;
}
else if (place != null && music != null)
{
events.PlaceK = place.K;
events.MusicTypeK = music.K;
}
else if (place != null && freeGuestlist)
{
events.PlaceK = place.K;
events.FreeGuestlist = freeGuestlist;
}
else if (key > 0)
{
}
else
throw new Exception();
EventSet es;
if (key == 0)
es = events.GetEventsBetweenDates(from, to);
else
es = new EventSet(new Query(new Q(Event.Columns.K, key)));
CustomControls.DsiCalendar calendar = new Spotted.CustomControls.DsiCalendar();
calendar.AllEvents = es;
calendar.Month = date.Month;
calendar.ShowCountryFriendlyName = !(events.FilterByCountry || events.FilterByPlace || events.FilterByVenue);
calendar.ShowPlace = !(events.FilterByPlace || events.FilterByVenue);
calendar.ShowVenue = !events.FilterByVenue;
calendar.ShowAddGalleryButton = addGalleryButton;
calendar.Tickets = true;
calendar.StartDate = from;
calendar.EndDate = to;
Out.Controls.Add(calendar);
}
else
{
sb.AppendLine("{");
if (Request.QueryString["type"] == "music")
{
#region Music types
Query q = new Query();
q.QueryCondition = new Q(MusicType.Columns.K, QueryOperator.NotEqualTo, 1);
q.Columns = new ColumnSet(MusicType.Columns.Name, MusicType.Columns.ParentK, MusicType.Columns.K);
q.OrderBy = new OrderBy(MusicType.Columns.Order, OrderBy.OrderDirection.Ascending);
q.CacheDuration = TimeSpan.FromDays(1);
MusicTypeSet mts = new MusicTypeSet(q);
append(sb, "Select your music...", "0");
append(sb, "", "");
foreach (MusicType mt in mts)
{
append(sb, (mt.ParentK == 1 ? "" : "... ") + mt.Name, mt.K.ToString());
}
#endregion
}
else if (Request.QueryString["type"] == "country")
{
#region Countries
append(sb, "Select a country...", "0");
Query qTop = new Query();
qTop.Columns = new ColumnSet(Country.Columns.FriendlyName, Country.Columns.K);
qTop.OrderBy = new OrderBy(Country.Columns.TotalEvents, OrderBy.OrderDirection.Descending);
qTop.QueryCondition = new Q(Country.Columns.Enabled, true);
qTop.TopRecords = 10;
qTop.CacheDuration = TimeSpan.FromDays(1);
CountrySet csTop = new CountrySet(qTop);
append(sb, "", "");
append(sb, "--- TOP COUNTRIES ---", "0");
foreach (Country c in csTop)
{
append(sb, c.FriendlyName.TruncateWithDots(maxLength), c.K.ToString());
}
Query qAll = new Query();
qAll.Columns = new ColumnSet(Country.Columns.FriendlyName, Country.Columns.K);
qAll.OrderBy = new OrderBy(Country.Columns.FriendlyName);
qAll.QueryCondition = new And(new Q(Country.Columns.Enabled, true), new StringQueryCondition("(SELECT COUNT(*) FROM [Place] WHERE [Place].[Enabled] = 1 AND [Place].[CountryK] = [Country].[K]) > 0"));
qAll.CacheDuration = TimeSpan.FromDays(1);
CountrySet csAll = new CountrySet(qAll);
append(sb, "", "");
append(sb, "--- ALL COUNTRIES ---", "0");
foreach (Country c in csAll)
{
append(sb, c.FriendlyName.TruncateWithDots(maxLength), c.K.ToString());
}
#endregion
}
else if (Request.QueryString["type"] == "place")
{
#region Places
int countryK = int.Parse(Request.QueryString["countryk"]);
Country country = new Country(countryK);
Query qTop = new Query();
qTop.Columns = new ColumnSet(Place.Columns.Name, Place.Columns.K, Place.LinkColumns);
qTop.TopRecords = 10;
qTop.QueryCondition = new And(new Q(Place.Columns.CountryK, country.K), new Q(Place.Columns.Enabled, true));
qTop.OrderBy = new OrderBy(Place.Columns.TotalEvents, OrderBy.OrderDirection.Descending);
PlaceSet psTop = new PlaceSet(qTop);
if (psTop.Count == 0)
{
append(sb, "No towns in our database for this country", "");
}
else
{
append(sb, "Towns in " + country.FriendlyName.Truncate(maxLength) + "...", "");
append(sb, "", "");
if (psTop.Count < 10)
{
foreach (Place p in psTop)
append(sb, p.NamePlainRegion.TruncateWithDots(maxLength), Request.QueryString["return"] == "k" ? p.K.ToString() : p.Url());
}
else
{
append(sb, "--- TOP TOWNS ---", "");
foreach (Place p in psTop)
append(sb, p.NamePlainRegion.TruncateWithDots(maxLength), Request.QueryString["return"] == "k" ? p.K.ToString() : p.Url());
Query qAll = new Query();
qAll.Columns = new ColumnSet(Place.Columns.Name, Place.Columns.K, Place.LinkColumns);
qAll.OrderBy = new OrderBy(Place.Columns.UrlName);
qAll.QueryCondition = new And(new Q(Place.Columns.CountryK, countryK), new Q(Place.Columns.Enabled, true));
PlaceSet psAll = new PlaceSet(qAll);
append(sb, "", "");
append(sb, "--- ALL TOWNS ---", "");
foreach (Place p in psAll)
append(sb, p.NamePlainRegion.TruncateWithDots(maxLength), Request.QueryString["return"] == "k" ? p.K.ToString() : p.Url());
}
}
#endregion
}
else if (Request.QueryString["type"] == "venue")
{
#region Venues
int placeK = int.Parse(Request.QueryString["placek"]);
Place place = new Place(placeK);
Query qTop = new Query();
qTop.Columns = new ColumnSet(Venue.Columns.Name, Venue.Columns.K, Venue.LinkColumns);
qTop.TopRecords = 10;
qTop.QueryCondition = new Q(Venue.Columns.PlaceK, place.K);
qTop.OrderBy = new OrderBy(Venue.Columns.TotalEvents, OrderBy.OrderDirection.Descending);
VenueSet vsTop = new VenueSet(qTop);
if (vsTop.Count == 0)
{
append(sb, "No venues in our database for this town", "");
}
else
{
append(sb, "Venues in " + place.NamePlainRegion.Truncate(maxLength) + "...", "");
append(sb, "", "");
if (Request.QueryString["all"] == "1")
{
append(sb, "All venues", "1");
append(sb, "", "");
}
if (vsTop.Count < 10)
{
appendVenues(sb, vsTop);
}
else
{
append(sb, "--- TOP VENUES ---", "");
appendVenues(sb, vsTop);
Query qAll = new Query();
qAll.Columns = new ColumnSet(Venue.Columns.Name, Venue.Columns.K, Venue.LinkColumns);
qAll.OrderBy = new OrderBy("( CASE WHEN [Venue].[UrlName] LIKE 'the-%' THEN SUBSTRING([Venue].[UrlName], 4, LEN([Venue].[UrlName]) - 4) ELSE [Venue].[UrlName] END )");
qAll.QueryCondition = new Q(Venue.Columns.PlaceK, placeK);
VenueSet vsAll = new VenueSet(qAll);
append(sb, "", "");
append(sb, "--- ALL VENUES ---", "");
if (vsAll.Count <= 300)
{
appendVenues(sb, vsAll);
}
else
{
append(sb, "Select the first letter:", "");
append(sb, "", "");
append(sb, "0-9", "*0");
string ch;
for (int i = 65; i <= 90; i++)
{
ch = char.ConvertFromUtf32(i);
append(sb, ch.ToUpper() + "...", "*" + ch.ToLower());
}
}
}
}
#endregion
}
else if (Request.QueryString["type"] == "venuebyletter")
{
#region Venues
int placeK = int.Parse(Request.QueryString["placek"]);
string letter = Request.QueryString["letter"];
if (letter.Length > 1)
throw new Exception();
Place place = new Place(placeK);
string qu = "";
if (letter.ToLower() == "0")
{
qu = "([Venue].[UrlName] LIKE '[0-9]%' OR [Venue].[UrlName] LIKE 'the-[0-9]%')";
}
else if (letter.ToLower() == "t")
{
qu = "(([Venue].[UrlName] LIKE 't%' AND [Venue].[UrlName] NOT LIKE 'the-%' ) OR [Venue].[UrlName] LIKE 'the-t%')";
}
else
{
qu = "([Venue].[UrlName] LIKE '" + letter.ToLower() + "%' OR [Venue].[UrlName] LIKE 'the-" + letter.ToLower() + "%')";
}
Query q = new Query();
q.Columns = new ColumnSet(Venue.Columns.Name, Venue.Columns.K, Venue.LinkColumns);
//q.OrderBy = new OrderBy(Venue.Columns.UrlName);
q.OrderBy = new OrderBy("( CASE WHEN [Venue].[UrlName] LIKE 'the-%' THEN SUBSTRING([Venue].[UrlName], 4, LEN([Venue].[UrlName]) - 4) ELSE [Venue].[UrlName] END )");
q.QueryCondition = new And(
new Q(Venue.Columns.PlaceK, placeK),
new StringQueryCondition(qu));
VenueSet vs = new VenueSet(q);
if (vs.Count == 0)
{
append(sb, "No venues starting with " + letter.ToUpper(), "");
}
else
{
append(sb, "Venues starting with " + letter.ToUpper() + "...", "");
append(sb, "", "");
appendVenues(sb, vs);
}
#endregion
}
else if (Request.QueryString["type"] == "event")
{
#region Events
int venueK = int.Parse(Request.QueryString["venuek"]);
int brandK = int.Parse(Request.QueryString["brandk"]);
int key = int.Parse(Request.QueryString["key"]);
int year = int.Parse(Request.QueryString["date"].Substring(0, 4));
int month = int.Parse(Request.QueryString["date"].Substring(4, 2));
DateTime dateFrom = new DateTime(year, month, 1);
DateTime dateTo = dateFrom.AddMonths(1);
Venue venue = venueK > 1 ? new Venue(venueK) : null;
Brand brand = brandK > 0 ? new Brand(brandK) : null;
EventSet es;
if (key == 0)
{
Query q = new Query();
if (brand == null)
q.Columns = new ColumnSet(Event.Columns.DateTime, Event.Columns.Name, Event.Columns.K);
else
q.Columns = new ColumnSet(Event.Columns.DateTime, Event.Columns.Name, Event.Columns.K, Event.FriendlyLinkColumns);
q.QueryCondition = new And(
new Q(Event.Columns.DateTime, QueryOperator.GreaterThanOrEqualTo, dateFrom),
new Q(Event.Columns.DateTime, QueryOperator.LessThan, dateTo),
venue != null ? new Q(Event.Columns.VenueK, venue.K) : new Q(true),
brand != null ? new Q(EventBrand.Columns.BrandK, brand.K) : new Q(true));
q.OrderBy = Event.FutureEventOrder;
if (brandK > 0)
{
q.TableElement = new Join(
Event.CountryAllJoin,
new TableElement(TablesEnum.EventBrand),
QueryJoinType.Inner,
Event.Columns.K,
EventBrand.Columns.EventK);
}
es = new EventSet(q);
}
else
es = new EventSet(new Query(new Q(Event.Columns.K, key)));
if (es.Count == 0)
{
append(sb, "No events in our database for this selection", "");
}
else
{
//append(sb, "Events at " + venue.FriendlyName.Truncate(maxLength) + ", " + dateFrom.ToString("MMM yyyy") + "...", "");
//append(sb, "", "");
Dictionary<string, int> counter = new Dictionary<string, int>();
foreach (Event ev in es)
{
string key1 = eventString(ev, brand != null);
if (counter.ContainsKey(key1.ToLower()))
counter[key1.ToLower()]++;
else
counter[key1.ToLower()] = 1;
}
foreach (Event ev in es)
{
string key1 = eventString(ev, brand != null);
if (counter[key1.ToLower()] > 1)
key1 = key1.Substring(0, 8) + " - #" + ev.K.ToString() + key1.Substring(8);
append(sb, key1, ev.K.ToString());
}
}
#endregion
}
sb.AppendLine("");
sb.Append("}");
}
Out.Controls.Add(new LiteralControl(sb.ToString()));
}
