/// <summary>
/// Verifies that two doubles are not equal within a tolerance range.
/// </summary>
/// <param name="expected">The expected value</param>
/// <param name="actual">The value to compare against</param>
/// <param name="precision">The level of precision to use when making the comparison</param>
public static void NotEqual(DateTime expected, DateTime actual, DatePrecision precision)
{
if (precision.Truncate(expected) == precision.Truncate(actual))
{
throw new NotEqualException(precision.Truncate(actual), precision.Truncate(actual));
}
}
public DateTime Equal(DateTime expected, DatePrecision precision)
{
if (Negate)
{
assertProvider.AreNotEqual(expected, Target, precision);
}
else
{
assertProvider.AreEqual(expected, Target, precision);
}
return(Target);
}
public static bool IsCalculable( DatePrecision thisPrecision )
{
switch ( thisPrecision ) {
case DatePrecision.Day:
case DatePrecision.Decade:
case DatePrecision.Month:
case DatePrecision.Year:
return true;
default:
return false;
}
}
private string GetLocalLaunchDateTime(ulong guildId, DateTime utc, DatePrecision precision)
{
var convertedToLocal = precision == DatePrecision.Hour
? _timeZoneService.ConvertUtcToLocalTime(guildId, utc)
: utc;
if (convertedToLocal == null)
{
return(null);
}
return(DateFormatter.GetDateStringWithPrecision(convertedToLocal.Value, precision, false, true, true));
}
public static bool isCalculable(DatePrecision thisPrecision)
{
switch (thisPrecision)
{
case DatePrecision.Day:
case DatePrecision.Decade:
case DatePrecision.Month:
case DatePrecision.Year:
return(true);
default:
return(false);
}
}
/// <summary>
/// Returns true if date precision has a timezone
/// </summary>
public static bool HasTimeZone(this DatePrecision a)
{
switch (a)
{
case DatePrecision.FullNoTimezone:
case DatePrecision.HourNoTimezone:
case DatePrecision.MinuteNoTimezone:
case DatePrecision.SecondNoTimezone:
return(false);
default:
return(true);
}
}
/// <summary>
/// Create a timestamp
/// </summary>
public TS CreateTS(TimestampPart part)
{
if (part == null)
{
return(null);
}
DatePrecision prec = default(DatePrecision);
foreach (var kv in m_precisionMap)
{
if (kv.Value.Equals(part.Precision))
{
prec = kv.Key;
}
}
return(new TS(part.Value, prec));
}
/// <summary>
/// Create a timestamp
/// </summary>
public TS CreateTS(TimestampPart part, List <IResultDetail> dtls)
{
if (part == null)
{
return(null);
}
DatePrecision prec = default(DatePrecision);
foreach (var kv in ComponentUtil.m_precisionMap)
{
if (kv.Value.Equals(part.Precision))
{
prec = kv.Key;
}
}
return(new TS(part.Value, prec));
}
public static string GetDateStringWithPrecision(DateTime date, DatePrecision precision, bool includeUtc, bool displayPrecision, bool longDate)
{
string format;
switch (precision)
{
case DatePrecision.Year:
case DatePrecision.Half:
case DatePrecision.Quarter:
format = "yyyy";
break;
case DatePrecision.Month:
format = longDate ? "MMMM yyyy" : "MM-yyyy";
break;
case DatePrecision.Day:
format = longDate ? "dddd, dd MMMM yyyy" : "dd-MM-yyyy";
break;
case DatePrecision.Hour:
format = longDate ? "dddd, dd MMMM yyyy HH:mm" : "dd-MM-yyyy HH:mm";
break;
default:
format = longDate ? "dddd, dd MMMM yyyy HH:mm" : "dd-MM-yyyy HH:mm";
break;
}
var output = date.ToString(format, CultureInfo.InvariantCulture);
if (includeUtc && precision == DatePrecision.Hour)
{
output += " UTC";
}
if (displayPrecision && precision != DatePrecision.Hour)
{
output += $" ({precision.ToString().ToLower(CultureInfo.InvariantCulture)} precision)";
}
return(output);
}
/// <summary>
/// Verifies that two values are equal within a given tolerance.
/// </summary>
/// <param name="actual">The value to be compared against</param>
/// <param name="expected">The expected value</param>
/// <param name="precision">The level of precision to use when making the comparison</param>
/// <exception cref="EqualException">Thrown when the objects are not equal</exception>
public static void ShouldEqual(this DateTime actual, DateTime expected, DatePrecision precision)
{
CustomizeAssert.Equal(expected, actual, precision);
}
public static DateTime Equal(this IShould <DateTime> should, DateTime expected, DatePrecision precision)
{
return(should.Apply(
(t, a) => a.AreEqual(expected, t, precision),
(t, a) => a.AreNotEqual(expected, t, precision)
));
}
public static void RenderLocalizedDate(Interpreter interpreter, IFormatting?element, IVariable?value, string?delimiter, DateFormat dateFormat, DatePrecision precision, IEnumerable <DatePartElement> dateParts)
{
var parts = new List <DatePartElement>();
var locale = interpreter.LocaleFile;
var localeDate = locale.Dates !.FirstOrDefault(e => e.Format == dateFormat);
parts.AddRange(localeDate.DateParts);
if (dateParts != null)
{
foreach (var part in dateParts)
{
Replace(parts, part.Name, part);
}
}
RenderDate(interpreter, element, value, delimiter, precision, parts.ToArray());
}
/// <summary>
/// Create a new instance of TS with the specified datetime value and the precision specified
/// </summary>
/// <param name="value">The value of the timestamp</param>
/// <param name="precision">The precision of the timestamp</param>
public TS(DateTime value, DatePrecision precision) : this(value) { this.DateValuePrecision = precision; }
public static void RenderDate(Interpreter interpreter, IFormatting?element, IVariable?value, string?delimiter, DatePrecision precision, DatePartElement[] dateParts)
{
if (!(value is IDateVariable date) || dateParts == null)
{
return;
}
int precisionValue = (int)precision;
var available = new List <DatePartName>()
{
DatePartName.Year
};
if (date.MonthFrom.HasValue && date.MonthTo.HasValue && dateParts.Any(x => x.Name == DatePartName.Month) && precisionValue < 2)
{
// add month
available.Add(DatePartName.Month);
// day?
if (date.DayFrom.HasValue && date.DayTo.HasValue && dateParts.Any(x => x.Name == DatePartName.Day) && precisionValue == 0)
{
available.Add(DatePartName.Day);
}
}
// find differing date parts
DatePartName[] differing = Array.Empty <DatePartName>();
if (date.YearFrom != date.YearTo)
{
// year, month, day
differing = available.ToArray();
}
else if (date.MonthFrom.HasValue && date.MonthTo.HasValue && date.MonthFrom.Value != date.MonthTo.Value)
{
// month, day
differing = available
.Where(x => x != DatePartName.Year)
.ToArray();
}
else if (date.DayFrom.HasValue && date.DayTo.HasValue && date.DayFrom.Value != date.DayTo.Value)
{
// day
differing = available
.Where(x => x == DatePartName.Day)
.ToArray();
}
// range?
if (differing.Length == 0)
{
// render single date
RenderDateParts(interpreter, dateParts, date.YearFrom, date.SeasonFrom, date.MonthFrom, date.DayFrom, delimiter, true, true);
}
else
{
// render from
var delimiterIndex = Enumerable.Range(1, dateParts.Length)
.Select(i => dateParts.Take(i).Select(x => x.Name).ToArray())
.First(a => differing.All(x => a.Contains(x)))
.Length;
var fromParts = dateParts
.Take(delimiterIndex)
.ToArray();
RenderDateParts(interpreter, fromParts, date.YearFrom, date.SeasonFrom, date.MonthFrom, date.DayFrom, delimiter, true, false);
var lastFromPart = fromParts[^ 1];
public void AreNotEqual(DateTime expected, DateTime actual, DatePrecision precision)
{
Assert.NotEqual(expected, actual, precision);
}
public static void RenderNonLocalizedDate(Interpreter interpreter, IFormatting?element, IVariable?value, string?delimiter, DatePrecision precision, IEnumerable <DatePartElement> dateParts)
{
if (dateParts == null)
{
return;
}
RenderDate(interpreter, element, value, delimiter, precision, dateParts.ToArray());
}
/// <summary>
/// Verifies that two values are not equal within a given tolerance.
/// </summary>
/// <param name="actual">The value to be compared against</param>
/// <param name="expected">The expected value</param>
/// <param name="precision">The level of precision to use when making the comparison</param>
/// <exception cref="EqualException">Thrown when the objects are equal</exception>
public static void ShouldNotEqual(this DateTime actual, DateTime expected, DatePrecision precision)
{
Assert.NotEqual(expected, actual, precision);
}
/// <summary>
/// Note: This method requires Newtonsoft Json to be installed
/// </summary>
/// <returns></returns>
private bool ExtractJSON()
{
//Interpret the JSON - Basically read in a level at a time.
var DataFromWiki = JObject.Parse(Content);
var Entities = (JObject)DataFromWiki["entities"];
var Entity = Entities.Properties().First(); // Name is variable, so grab data by using first method
string EntityKey = Entity.Name;
var EntityData = (JObject)Entity.Value;
if (EntityKey == "-1")
{
WikidataExtractErrors.NotWikidata();
return(false);
}
string Qcode = (string)EntityData["id"];
Fields.Id = Convert.ToInt32(Qcode.Substring(1));
string EntityType = (string)EntityData["type"];
if (EntityType == null)
{
WikidataExtractErrors.QcodeNotExist(EntityKey);
return(false);
}
var Descriptions = (JObject)EntityData["descriptions"];
var Labels = (JObject)EntityData["labels"];
var WikipediaLinks = (JObject)EntityData["sitelinks"];
if (Labels != null)
{
foreach (var Label in Labels.Properties())
{
var LabelData = (JObject)Label.Value;
Fields.Labels.Add((string)LabelData["language"], (string)LabelData["value"]);
}
}
if (Descriptions != null)
{
foreach (var Description in Descriptions.Properties())
{
var DescriptionData = (JObject)Description.Value;
string l = (string)DescriptionData["language"];
Fields.Description.Add((string)DescriptionData["language"], (string)DescriptionData["value"]);
}
}
if (WikipediaLinks != null)
{
foreach (var WikipediaLink in WikipediaLinks.Properties())
{
var WikipediaLinkData = (JObject)WikipediaLink.Value;
Fields.WikipediaLinks.Add((string)WikipediaLinkData["site"], (string)WikipediaLinkData["title"]);
}
}
var Claims = (JObject)EntityData["claims"];
if (Claims != null)
{
//Now we get to loop through each claim property for that article
foreach (var Claim in Claims.Properties())
{
string ClaimKey = Claim.Name;
if (ClaimsRequired != null && Array.IndexOf(ClaimsRequired, ClaimKey) == -1)
{
continue;
}
var ClaimData = (JArray)Claim.Value;
for (int ThisClaim = 0; ThisClaim < ClaimData.Count(); ThisClaim++)
{
//claimData is an array - another loop
WikidataClaim ThisClaimData = new WikidataClaim();
var MainSnak = (JObject)ClaimData[ThisClaim]["mainsnak"];
string SnakType = (string)MainSnak["snaktype"];
string SnakDataType = (string)MainSnak["datatype"];
var SnakDataValue = (JObject)MainSnak["datavalue"];
if (SnakType == "novalue" || SnakType == "somevalue")
{
ThisClaimData.ValueAsString = SnakType;
}
else
{
if (SnakDataType == "string" || SnakDataType == "commonsMedia" || SnakDataType == "url")
{
ThisClaimData.ValueAsString = (string)SnakDataValue["value"];
}
else if (SnakDataType == "wikibase-item")
{
var ObjectValue = (JObject)SnakDataValue["value"];
ThisClaimData.Qcode = (int)ObjectValue["numeric-id"];
ThisClaimData.ValueAsString = Cache.RetrieveLabel(ThisClaimData.Qcode);
}
else if (SnakDataType == "time")
{
var ObjectValue = (JObject)SnakDataValue["value"];
string ValueTime = (string)ObjectValue["time"];
string ValueTimePrecision = (string)ObjectValue["precision"];
string ValueTimeCalendarModel = (string)ObjectValue["calendarmodel"];
bool Julian = false;
bool Gregorian = false;
if (ValueTimeCalendarModel != "http://www.Wikidata.org/entity/Q1985727")
{
Gregorian = true;
}
if (ValueTimeCalendarModel == "http://www.Wikidata.org/entity/Q1985786")
{
Julian = true;
}
if (ValueTimePrecision == "11" || ValueTimePrecision == "10" || ValueTimePrecision == "9" ||
ValueTimePrecision == "8" || ValueTimePrecision == "7" || ValueTimePrecision == "6")
{
int DateStart = ValueTime.IndexOf("-", 2) - 4;
string ThisDateString = (ValueTime.Substring(DateStart, 10));
ThisDateString = ThisDateString.Replace("-00", "-01"); // Occasionally get 1901-00-00 ?
bool ValidDate = true;
DateTime thisDate;
try
{
thisDate = DateTime.Parse(ThisDateString, null, DateTimeStyles.RoundtripKind);
}
catch
{
thisDate = DateTime.MinValue;
ValidDate = false;
}
if (Julian == true && ValueTimePrecision == "11")
{
// All dates will be Gregorian
// Julian flag tells us to display Julian date.
// JulianCalendar JulCal = new JulianCalendar();
// DateTime dta = JulCal.ToDateTime(thisDate.Year, thisDate.Month, thisDate.Day, 0, 0, 0, 0);
// thisDate = dta;
}
DatePrecision Precision = DatePrecision.Null;
if (ValidDate == false)
{
Precision = DatePrecision.Invalid;
}
else if (ValueTime.Substring(0, 1) == "+")
{
switch (ValueTimePrecision)
{
case "11":
Precision = DatePrecision.Day;
break;
case "10":
Precision = DatePrecision.Month;
break;
case "9":
Precision = DatePrecision.Year;
break;
case "8":
Precision = DatePrecision.Decade;
break;
case "7":
Precision = DatePrecision.Century;
break;
case "6":
Precision = DatePrecision.Millenium;
break;
}
}
else
{
Precision = DatePrecision.BCE;
}
ThisClaimData.ValueAsDateTime.thisDate = thisDate;
ThisClaimData.ValueAsDateTime.thisPrecision = Precision;
}
}
else if (SnakDataType == "monolingualtext")
{
var ObjectValue = (JObject)SnakDataValue["value"];
string ValueText = (string)ObjectValue["text"];
string ValueLanguage = (string)ObjectValue["language"];
// TODO Multi language handling
ThisClaimData.ValueAsString = ValueText + "(" + ValueLanguage + ")";
}
else if (SnakDataType == "quantity")
{
var ObjectValue = (JObject)SnakDataValue["value"];
string ValueAmount = (string)ObjectValue["amount"];
string ValueUnit = (string)ObjectValue["unit"];
string ValueUpper = (string)ObjectValue["upperBound"];
string ValueLower = (string)ObjectValue["lowerBound"];
ThisClaimData.ValueAsString = "(" + ValueLower + " to " + ValueUpper + ") Unit " + ValueUnit;
}
}
Fields.Claims.Add(new KeyValuePair <int, WikidataClaim>(Convert.ToInt32(ClaimKey.Substring(1)), ThisClaimData));
}
}
}
return(true);
}
