public void ParseTimeStringsWithoutMillisecsStyle()
{
var style = DbTimeStyle.WithoutMillisecond;
Assert.AreEqual(1000, DbDateTime.ParseTime("1", style: style).Ticks); // 1 sec
Assert.AreEqual(423000, DbDateTime.ParseTime("423", style: style).Ticks); // 4 min, 23 sec
Assert.AreEqual(423000, DbDateTime.ParseTime("0423", style: style).Ticks);
Assert.AreEqual(70423000, DbDateTime.ParseTime("70423", style: style).Ticks); // 7 h, 4 min, 23 secs
Assert.AreEqual(110423000, DbDateTime.ParseTime("110423", style: style).Ticks); // 11 h, 4 min, 23 secs
var dbTime = DbDateTime.ParseTime("110423", style: style);
Assert.AreEqual(11, dbTime.Hour);
Assert.AreEqual(4, dbTime.Minute);
Assert.AreEqual(23, dbTime.Second);
Assert.AreEqual(0, dbTime.Millisecond);
Assert.AreEqual(DateTimeKind.Utc, dbTime.Kind);
dbTime = DbDateTime.ParseTime("0", style: style, kind: DateTimeKind.Unspecified);
Assert.AreEqual(0, dbTime.Hour);
Assert.AreEqual(0, dbTime.Minute);
Assert.AreEqual(0, dbTime.Second);
Assert.AreEqual(0, dbTime.Millisecond);
Assert.AreEqual(DateTimeKind.Unspecified, dbTime.Kind);
}
protected override void OnItemAdded(ListViewItem item, Lfx.Data.Row row)
{
switch (row.Fields["vencimientos.estado"].ValueInt)
{
case 1:
item.SubItems["vencimientos.estado"].Text = "Activo";
DbDateTime Vencimiento = row.Fields["vencimientos.fecha_proxima"].ValueDateTime;
if (Vencimiento != null)
{
if (Vencimiento <= DateTime.Now)
{
item.ForeColor = System.Drawing.Color.Red;
}
else if (Vencimiento <= DateTime.Now.AddDays(5))
{
item.ForeColor = System.Drawing.Color.Orange;
}
}
break;
case 2:
item.SubItems["vencimientos.estado"].Text = "Inactivo";
break;
case 100:
item.SubItems["vencimientos.estado"].Text = "Terminado";
break;
}
}
private void EntradaHasta_TextChanged(object sender, EventArgs e)
{
DbDateTime Fecha = Lfx.Types.Parsing.ParseDate(EntradaHasta.Text);
if (Fecha != null)
{
m_Rango.To = Fecha.Value;
}
}
/// <summary>
/// Obtiene el valor de un campo del registro asociado.
/// </summary>
/// <typeparam name="T">El tipo de datos a utilizar para el valor devuelto.</typeparam>
/// <param name="fieldName">El nombre del campo.</param>
/// <returns>El valor del campo.</returns>
public T GetFieldValue <T>(string fieldName)
{
if (typeof(T).BaseType == typeof(Lbl.ElementoDeDatos) || typeof(T).GetInterface("Lbl.IElementoDeDatos") != null)
{
// Si intento obtener un ElementoDeDatos (por ejemplo, la propiedad Persona.Localidad)
// tengo que instanciar un elemento.
int ItemId = this.GetFieldValue <int>(fieldName);
if (ItemId == 0)
{
object Res = null;
return((T)Res);
}
else
{
object Res = Lbl.Instanciador.Instanciar(typeof(T), this.Connection, this.GetFieldValue <int>(fieldName));
return((T)Res);
}
}
else if (typeof(T) == typeof(DbDateTime))
{
if (this.Registro[fieldName] == null)
{
return(default(T));
}
else
{
object Res;
if (this.Registro[fieldName] is DbDateTime)
{
Res = (DbDateTime)(this.Registro[fieldName]);
}
else
{
Res = new DbDateTime(this.GetFieldValue <DateTime>(fieldName));
}
return((T)Res);
}
}
else
{
// De lo contrario, asumo que es un tipo intrínseco y lo convierto con System.Convert.
if (this.Registro[fieldName] == null)
{
return(default(T));
}
else
{
try {
return((T)(System.Convert.ChangeType(this.Registro[fieldName], typeof(T))));
} catch {
return(default(T));
}
}
}
}
/// <summary>
/// Gets a DateTime by combining the two database fields used to store
/// a database date and database time.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="dateFieldIndex">Index of the date field.</param>
/// <param name="timeFieldIndex">Name of the time field.</param>
/// <param name="defaultValueIfNull">The default value if null.</param>
/// <returns></returns>
public static DateTime GetSafe(this IDataReader reader, int dateFieldIndex, int timeFieldIndex, DateTime defaultValueIfNull)
{
// the database (should) always store a date/time in UTC. So the default should be of the same Kind:
var utcDefault = defaultValueIfNull.ToUniversalTime();
var dbDate = Db.Parse(reader, dateFieldIndex, (DbDate)utcDefault);
var dbTime = Db.Parse(reader, timeFieldIndex, (DbTime)utcDefault);
// re-combine the read field values:
return(DbDateTime.ToDateTime(dbDate, dbTime));
}
public bool WriteGlobalSetting(string settingName, DbDateTime dateTimeValue)
{
if (dateTimeValue == null)
{
return(WriteGlobalSetting(settingName, ""));
}
else
{
return(WriteGlobalSetting(settingName, Lfx.Types.Formatting.FormatDateTimeSql(dateTimeValue)));
}
}
public async Task <ActionResult <IEnumerable <BasketChangeEventDto> > > GetEvents([FromQuery] DateTime fromDate,
[FromQuery] int max)
{
var events = await _dbContext
.BasketChangeEvents
.Where(@event => DbDateTime.From(@event.InsertedAt) > fromDate)
.OrderBy(@event => @event.InsertedAt)
.Take(max)
.ToListAsync()
;
return(Ok(events.Select(BasketChangeEventDtoMapper.From)));
}
public T ReadGlobalSetting <T>(string settingName, T defaultValue, string terminalName, int sucursal)
{
string Val = ReadGlobalSettingString(settingName, null, terminalName, sucursal);
if (Val == null)
{
return(defaultValue);
}
object Res;
if (typeof(T) == typeof(string))
{
Res = Val;
}
else if (typeof(T) == typeof(int))
{
Res = Lfx.Types.Parsing.ParseInt(Val);
}
else if (typeof(T) == typeof(decimal))
{
Res = Lfx.Types.Parsing.ParseDecimal(Val);
}
else if (typeof(T) == typeof(DateTime))
{
Res = Lfx.Types.Parsing.ParseSqlDateTime(Val);
}
else if (typeof(T) == typeof(DbDateTime))
{
if (string.IsNullOrWhiteSpace(Val))
{
Res = null;
}
else
{
Res = new DbDateTime(Lfx.Types.Parsing.ParseSqlDateTime(Val));
}
}
else
{
Res = null;
}
return((T)Res);
}
public void ParseDateStrings()
{
Assert.AreEqual(DbDate.MinValue, DbDateTime.ParseDate("0")); // 0 - gets minimum value
Assert.AreEqual(DbDate.MinValue, DbDateTime.ParseDate("1")); // 1 - gets minimum value
Assert.AreEqual(DbDate.MinValue, DbDateTime.ParseDate("423")); // dito
Assert.AreEqual(DbDate.MinValue, DbDateTime.ParseDate("10101")); // dito
Assert.AreEqual(10102, DbDateTime.ParseDate("10102").Ticks);
Assert.AreEqual(19660630, DbDateTime.ParseDate("19660630").Ticks); //
Assert.AreEqual(770401, DbDateTime.ParseDate("770401").Ticks); // April fool at 77 a.D.
var dbTime = DbDateTime.ParseDate("19660630");
Assert.AreEqual(1966, dbTime.Year);
Assert.AreEqual(6, dbTime.Month);
Assert.AreEqual(30, dbTime.Day);
dbTime = DbDateTime.ParseDate("770401");
Assert.AreEqual(77, dbTime.Year);
Assert.AreEqual(4, dbTime.Month);
Assert.AreEqual(1, dbTime.Day);
}
public void ToDateTime()
{
var utcDt = DateTime.MinValue.ToUniversalTime();
Assert.AreEqual(utcDt, DbDateTime.ToDateTime(DbDate.MinValue, DbTime.MinValue));
utcDt = new DateTime(2013, 2, 20, 13, 24, 56, 0, DateTimeKind.Utc);
Assert.AreEqual(utcDt, DbDateTime.ToDateTime(new DbDate(2013, 2, 20), new DbTime(13, 24, 56, 0, DateTimeKind.Utc)));
// using DateTime.Now here get non-Equal results (internal datedata are different, but the ticks and kind are equal)
var localDt = new DateTime(2013, 2, 20, 14, 24, 56, 0, DateTimeKind.Local);
// provide a local datetime
var res = DbDateTime.ToDateTime(
new DbDate(localDt.Year, localDt.Month, localDt.Day),
new DbTime(localDt.Hour, localDt.Minute, localDt.Second, localDt.Millisecond, localDt.Kind));
Assert.AreEqual(localDt, res);
Assert.AreEqual(localDt, DbDateTime.ToDateTime((DbDate)localDt, (DbTime)localDt));
}
public void ParseTimeStringsFullStyle()
{
Assert.AreEqual(1, DbDateTime.ParseTime("1").Ticks); // 1 msec
Assert.AreEqual(423, DbDateTime.ParseTime("423").Ticks);
Assert.AreEqual(423, DbDateTime.ParseTime("0423").Ticks);
Assert.AreEqual(57423, DbDateTime.ParseTime("57423").Ticks); // 57 sec, 423 msecs
Assert.AreEqual(110423, DbDateTime.ParseTime("110423").Ticks); // 1 min, 10 sec, 423 msecs
var dbTime = DbDateTime.ParseTime("110423");
Assert.AreEqual(0, dbTime.Hour);
Assert.AreEqual(1, dbTime.Minute);
Assert.AreEqual(10, dbTime.Second);
Assert.AreEqual(423, dbTime.Millisecond);
Assert.AreEqual(DateTimeKind.Utc, dbTime.Kind);
dbTime = DbDateTime.ParseTime("50110423", kind: DateTimeKind.Local);
Assert.AreEqual(5, dbTime.Hour);
Assert.AreEqual(1, dbTime.Minute);
Assert.AreEqual(10, dbTime.Second);
Assert.AreEqual(423, dbTime.Millisecond);
Assert.AreEqual(DateTimeKind.Local, dbTime.Kind);
}
public Cheque(Lfx.Data.IConnection dataBase, decimal importe, int numero, string emisor, DbDateTime fechaEmision, DbDateTime fechaCobro, Bancos.Banco banco)
: this(dataBase)
{
this.Importe = importe;
this.Numero = numero;
this.Emisor = emisor;
this.FechaEmision = fechaEmision;
this.FechaCobro = fechaCobro;
this.Banco = banco;
}
public static DbInt DatePart(this DbFunctions dbFunctions, DatePart datePart, DbDateTime date)
{
return(new DbIntFunctionValue("datepart", new IDbFragment[] { new RawFragment(datePart.ToString()), date }));
}
public void ParseTimeStringsAlphaNumericInputShouldFail()
{
DbDateTime.ParseTime("hä?");
}
public void ParseTimeStringsSpacesShouldFail()
{
DbDateTime.ParseTime(" ");
}
public static DbDateTime Coalesce(this DbFunctions dbFunctions, DbDateTime value, params IDbFragment[] other)
{
return(new DbDateTimeFunctionValue("coalesce", new[] { value }.Concat(other)));
}
public static DbString Format(this DbFunctions dbFunctions, DbDateTime date, string format)
=> new DbStringFunctionValue("format", new IDbFragment[] { date, format.DbValue() });
public void ParseDateStringsNegativeNumberInputShouldFail()
{
DbDateTime.ParseDate("-123");
}
public static DbInt DateDiff(this DbFunctions dbFunctions, DatePart datePart, DbDateTime lhs, DbDateTime rhs)
{
return(new DbIntFunctionValue("datediff", new IDbFragment[] { new RawFragment(datePart.ToString()), lhs, rhs }));
}
public void ParseTimeStringsInvalidTimeNumberInputShouldFail()
{
DbDateTime.ParseTime("9739123"); // 00:97:39.123
}
public void ParseDateStringsInvalidDateLeapYearDayInputShouldFail()
{
DbDateTime.ParseDate("20010229"); // Feb., 29th 2001 ???
}
public void ParseDateStringsValidDateLeapYearDayInput()
{
Assert.AreEqual(new DbDate(2000, 2, 29), DbDateTime.ParseDate("20000229")); // Feb., 29th 2000 !!!
}
public void ParseDateStringsInvalidDateNumberInputShouldFail()
{
DbDateTime.ParseDate("19994523"); // 45 months
}
public static DbDateTime Max(this DbFunctions dbFunctions, DbDateTime value)
{
return(new DbDateTimeFunctionValue("max", new[] { value }));
}
