DateTimeHelper.pas

unit DateTimeHelper;

interface

uses
  DateTimeHelper.Exceptions,
  System.Types,
  System.SysUtils,
  System.DateUtils;

type
{$REGION 'TDateTimeHelper'}
  /// <summary> Ayudante para System.TDateTime </summary>
  /// <remarks> Como System.DateTime es un tipo primitivo (no una referencia) es tratado como si fuera inmutable,
  /// es decir que todos los metodos que modifican el estado de "Self" devuelven un nuevo valor TDateTime </remarks>
  TDateTimeHelper = record helper for TDateTime
  strict private const
    ZeroAM: TTime = 0;
  strict private
    function GetDate: TDate; inline;
    function GetTime: TTime; inline;
    function GetDay: Word; inline;
    function GetHours: Word; inline;
    function GetMilliseconds: Word; inline;
    function GetMinutes: Word; inline;
    function GetMonth: Word; inline;
    function GetSeconds: Word; inline;
    function GetYear: Word; inline;

    /// <summary> Chequea que se pueda crear una instancia valida de TDateTime con los valores indicados
    /// Se eleva una excepcion EIllegalDateTime si el TDateTime no se puede crear con los valores indicados </summary>
    class procedure CheckDateTime(const Day, Month, Year, Hours, Mins, Secs, MSecs: Word); static; inline;
  public
    /// <summary> Concatena el string Text con la representacion en string del TimeStamp </summary>
    /// <remarks> El formato es: %Text% YYYY-MM-DD HH:MM:SS.ZZZZ </remarks>
    class function AppendTimeStamp(const Text: string; const TimeStamp: TDateTime): string; static; inline;

    /// <summary> Crea un TDateTime a partir de los valores especificados </summary>
    /// <param name="Day"> El dia del TDateTime </param>
    /// <param name="Month"> El mes del TDateTime </param>
    /// <param name="Year"> El año del TDateTime </param>
    /// <remarks> La hora se setea a 00:00:00.000 </remarks>
    class function Create(const Day, Month, Year: Word): TDateTime; overload; static;
    /// <summary> Crea un TDateTime a partir de los valores especificados </summary>
    /// <param name="Day"> El dia del TDateTime </param>
    /// <param name="Month"> El mes del TDateTime </param>
    /// <param name="Year"> El año del TDateTime </param>
    /// <param name="Hours"> La hora del TDateTime </param>
    /// <param name="Mins"> Los minutos del TDateTime </param>
    /// <param name="Secs"> Los segundos del TDateTime </param>
    class function Create(const Day, Month, Year, Hours, Mins, Secs: Word): TDateTime; overload; static;
    /// <summary> Crea un TDateTime a partir de los valores especificados </summary>
    /// <param name="Day"> El dia del TDateTime </param>
    /// <param name="Month"> El mes del TDateTime </param>
    /// <param name="Year"> El año del TDateTime </param>
    /// <param name="Hours"> La hora del TDateTime </param>
    /// <param name="Mins"> Los minutos del TDateTime </param>
    /// <param name="Secs"> Los segundos del TDateTime </param>
    /// <param name="MSecs"> Los milisegunfos del TDateTime </param>
    class function Create(const Day, Month, Year, Hours, Mins, Secs, MSecs: Word): TDateTime; overload; static;
    /// <summary> Crea un TDateTime a partir de los valores especificados </summary>
    /// <param name="Day"> El dia del TDateTime </param>
    /// <param name="Month"> El mes del TDateTime </param>
    /// <param name="Year"> El año del TDateTime </param>
    /// <param name="Time"> Variable TTime de la cual se extraen la hora, minutos, segundos y milisegundos del TDateTime </param>
    class function Create(const Day, Month, Year: Word; const Time: TTime): TDateTime; overload; static;

    /// <summary> Devuelve la fecha y hora actuales </summary>
    class function Current: TDateTime; static; inline;
    /// <summary> Devuelve la fecha de hoy </summary>
    class function Today: TDateTime; static; inline;
    /// <summary> Devuelve la fecha de ayer </summary>
    class function Yesterday: TDateTime; static; inline;
    /// <summary> Devuelve la fecha de mañana </summary>
    class function Tomorrow: TDateTime; static; inline;

    /// <summary> Devuelve la fecha en la que inicia la semana actual (calculado a partir de Today) </summary>
    class function StartOfWeek: TDateTime; static; inline;
    /// <summary> Devuelve la fecha en la que termina la semana actual (calculado a partir de Today) </summary>
    class function EndOfWeek: TDateTime; static; inline;
    /// <summary> Devuelve la fecha en la que inicia la Fortnight actual (calculado a partir de Today) </summary>
    class function StartOfFortnight: TDateTime; static; inline;
    /// <summary> Devuelve la fecha en la que termina la Fortnight actual (calculado a partir de Today) </summary>
    class function EndOfFortnight: TDateTime; static; inline;
    /// <summary> Devuelve la fecha en la que inicia el mes actual (calculado a partir de Today) </summary>
    class function StartOfMonth: TDateTime; static; inline;
    /// <summary> Devuelve la fecha en la que termina el mes actual (calculado a partir de Today) </summary>
    class function EndOfMonth: TDateTime; static; inline;
    /// <summary> Devuelve la fecha en la que inicia el año actual (calculado a partir de Today) </summary>
    class function StartOfYear: TDateTime; static; inline;
    /// <summary> Devuelve la fecha en la que termina el año actual (calculado a partir de Today) </summary>
    class function EndOfYear: TDateTime; static; inline;

    /// <summary> Convierte el string en su representacion TDateTime </summary>
    /// <summary> El string es interpretado usando el TFormatSettings global (System.SysUtils.FormatSettings) </summary>
    /// <remarks> Eleva una excepcion EInvalidaa si Value no es un string valido </remarks>
    class function Parse(const Value: string): TDateTime; overload; static;
    /// <summary> Convierte el string en su representacion TDateTime </summary>
    /// <summary> El string es interpretado usando el formato especificado por el parametro FormatSettings </summary>
    /// <remarks> Puede elevar excepciones al convertir un string invalido </remarks>
    class function Parse(const Value: string; const FormatSettings: TFormatSettings): TDateTime; overload; static;
    /// <summary> Convierte el string en su representacion TDateTime </summary>
    /// <summary> El string es interpretado usando TFormatSettings.Invariant </summary>
    /// <remarks> Puede elevar excepciones al convertir un string invalido </remarks>
    class function ParseInvariant(const Value: string): TDateTime; static; inline;
    /// <summary> Convierte el string en su representacion TDateTime </summary>
    /// <summary> El string es interpretado usando TFormatSettings.Create (valores por defecto del sistema operativo) </summary>
    /// <remarks> Puede elevar excepciones al convertir un string invalido </remarks>
    class function ParseLocaleDefault(const Value: string): TDateTime; static; inline;

    /// <summary> Intenta convertir el string a TDateTime, y si ocurre alguna excepcion devuelve un valor por defecto </summary>
    /// <summary> El string es interpretado usando el TFormatSettings global (System.SysUtils.FormatSettings) </summary>
    /// <param name="Value"> El string a parsear </param>
    /// <param name="Default"> Un valor TDateTime que se devuelve si se eleva una excepcion </param>
    /// <remarks> Eleva una excepcion EInvalidaa si Value no es un string valido </remarks>
    class function ParseDefault(const Value: string; const DefaultValue: TDateTime): TDateTime; overload; static;
    /// <summary> Intenta convertir el string a TDateTime, y si ocurre alguna excepcion devuelve un valor por defecto </summary>
    /// <summary> El string es interpretado usando el formato especificado por el parametro FormatSettings </summary>
    /// <param name="Value"> El string a parsear </param>
    /// <param name="FormatSettings"> Registro TFormatSettings que determina como se interpreta el string </param>
    /// <param name="Default"> Un valor TDateTime que se devuelve si se eleva una excepcion </param>
    /// <remarks> Eleva una excepcion EInvalidaa si Value no es un string valido </remarks>
    class function ParseDefault(const Value: string; const FormatSettings: TFormatSettings; const DefaultValue: TDateTime): TDateTime; overload; static;

    /// <summary> Convierte el string en su representacion TDateTime, devolviendo True y el valor TDateTime si
    /// la conversion tuvo exito, False en caso contrario </summary>
    /// <summary> El string es interpretado usando el TFormatSettings global (System.SysUtils.FormatSettings) </summary>
    /// <remarks> Si se eleva alguna excepcion, se captura y se devuelve False </remarks>
    class function TryParse(const Value: string; out ResultValue: TDateTime): Boolean; overload; static;
    /// <summary> Convierte el string en su representacion TDateTime, devolviendo True y el valor TDateTime si
    /// la conversion tuvo exito, False en caso contrario </summary>
    /// <summary> El string es interpretado usando el formato especificado por el parametro FormatSettings </summary>
    /// <remarks> Si se eleva alguna excepcion, se captura y se devuelve False </remarks>
    class function TryParse(const Value: string; const FormatSettings: TFormatSettings; out ResultValue: TDateTime): Boolean; overload; static;
    /// <summary> Convierte el string en su representacion TDateTime, devolviendo True y el valor TDateTime si
    /// la conversion tuvo exito, False en caso contrario </summary>
    /// <summary> El string es interpretado usando TFormatSettings.Invariant </summary>
    /// <remarks> Si se eleva alguna excepcion, se captura y se devuelve False </remarks>
    class function TryParseInvariant(const Value: string; out ResultValue: TDateTime): Boolean; static; inline;
    /// <summary> Convierte el string en su representacion TDateTime, devolviendo True y el valor TDateTime si
    /// la conversion tuvo exito, False en caso contrario </summary>
    /// <summary> El string es interpretado usando TFormatSettings.Create (valores por defecto del sistema operativo) </summary>
    /// <remarks> Si se eleva alguna excepcion, se captura y se devuelve False </remarks>
    class function TryParseLocaleDefault(const Value: string; out ResultValue: TDateTime): Boolean; static; inline;

    /// <summary> Devuelve la representacion en string del TDateTime </summary>
    /// <summary> El formato del string es determinado por el TFormatSettings global (System.SysUtils.FormatSettings) </summary>
    function ToString: string; overload;
    /// <summary> Devuelve la representacion en string del TDateTime </summary>
    /// <summary> El formato del string es determinado por el parametro Format </summary>
    function ToString(const Format: string): string; overload;
    /// <summary> Devuelve la representacion en string del TDateTime </summary>
    /// <summary> El formato del string es determinado por el parametro FormatSettings </summary>
    function ToString(const FormatSettings: TFormatSettings): string; overload;

    /// <summary> Crea un TDateTime con los valores de Self cambiando el dia de la fecha </summary>
    function SetDay(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self cambiando el mes de la fecha  </summary>
    function SetMonth(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self cambiando el año de la fecha  </summary>
    function SetYear(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self cambiando las horas </summary>
    function SetHour(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self cambiando los minutos de la hora </summary>
    function SetMinute(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self cambiando los dia de la fecha hora </summary>
    function SetSecond(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self cambiando los milisegundos de la fecha hora </summary>
    function SetMillisecond(const Value: Word): TDateTime; inline;

    /// <summary> Crea un TDateTime con los valores de Self al cual suma una cantidad de dias </summary>
    function AddDays(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual suma una cantidad de meses </summary>
    function AddMonths(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual suma una cantidad de años </summary>
    function AddYears(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual suma una cantidad de horas </summary>
    function AddHours(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual suma una cantidad de minutos </summary>
    function AddMinutes(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual suma una cantidad de segundos </summary>
    function AddSeconds(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual suma una cantidad de milisegundos </summary>
    function AddMilliseconds(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual se le suma la hora determinada </summary>
    function AddTime(const Value: TTime): TDateTime; inline;

    /// <summary> Crea un TDateTime con los valores de Self al cual suma un dia </summary>
    function AddDay: TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual suma un mese </summary>
    function AddMonth: TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual suma un año </summary>
    function AddYear: TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual suma una hora </summary>
    function AddHour: TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual suma un minuto </summary>
    function AddMinute: TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual suma un segundo </summary>
    function AddSecond: TDateTime; inline;

    /// <summary> Crea un TDateTime con los valores de Self al cual resta una cantidad de dias </summary>
    function SubDays(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual resta una cantidad de meses </summary>
    function SubMonths(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual resta una cantidad de años </summary>
    function SubYears(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual resta una cantidad de horas </summary>
    function SubHours(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual resta una cantidad de minutos </summary>
    function SubMinutes(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual resta una cantidad de segundos </summary>
    function SubSeconds(const Value: Word): TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual resta una cantidad de milisegundos </summary>
    function SubMilliseconds(const Value: Word): TDateTime; inline;

    /// <summary> Crea un TDateTime con los valores de Self al cual resta un dia </summary>
    function SubDay: TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual resta un mese </summary>
    function SubMonth: TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual resta un año </summary>
    function SubYear: TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual resta una hora </summary>
    function SubHour: TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual resta un minuto </summary>
    function SubMinute: TDateTime; inline;
    /// <summary> Crea un TDateTime con los valores de Self al cual resta un segundo </summary>
    function SubSecond: TDateTime; inline;

    /// <summary> Devuelve True si el TDateTime es mayor que "Left" y menor que "Right" </summary>
    function IsContained(const Left, Right: TDateTime): Boolean; inline;
    /// <summary> Devuelve True si el TDateTime es mayor o igual que "Left" y menor o igual que "Right" </summary>
    function IsBetween(const Left, Right: TDateTime): Boolean; inline;
    /// <summary> Devuelve True si Self es igual a Another; es decir, todos sus componentes son iguales </summary>
    function AreEquals(const Another: TDateTime): Boolean; inline;
    /// <summary> Devuelve True si Self es igual a Another; en esta comparacion se descartan los segundos y milisegundos </summary>
    function AreSame(const Another: TDateTime): Boolean; inline;
    /// <summary> Compara Self con Another, para determinar cual es mayor o si son iguales </summary>
    /// <remarks>
    ///   Sigue las reglas de comparacion idiomaticas a Delphi:
    ///  Si Self > Another se devuelve System.Types.GreaterThanValue
    ///  Si Self = Another se devuelve System.Types.EqualsValue
    ///  Si Self < Another se devuelve System.Types.LessThanValue
    /// </remarks>
    function Compare(const Another: TDateTime): TValueRelationShip; inline;
    /// <summary> Devuelve True si el dia de Self es igual al de Another; False en caso contrario </summary>
    function AreSameDay(const Another: TDateTime): Boolean; inline;
    /// <summary> Devuelve True si el mes de Self es igual al de Another; False en caso contrario </summary>
    function AreSameMonth(const Another: TDateTime): Boolean; inline;
    /// <summary> Devuelve True si el año de Self es igual al de Another; False en caso contrario </summary>
    function AreSameYear(const Another: TDateTime): Boolean; inline;
    /// <summary> Devuelve True si las horas de Self son iguales a las de Another; False en caso contrario </summary>
    function AreSameHours(const Another: TDateTime): Boolean; inline;
    /// <summary> Devuelve True si los minutos de Self son iguales a los de Another; False en caso contrario </summary>
    function AreSameMinutes(const Another: TDateTime): Boolean; inline;
    /// <summary> Devuelve True si los segundos de Self son iguales a los de de Another; False en caso contrario </summary>
    function AreSameSeconds(const Another: TDateTime): Boolean; inline;
    /// <summary> Devuelve True si los milisegundos de Self son iguales a los de Another; False en caso contrario </summary>
    function AreSameMiliseconds(const Another: TDateTime): Boolean; inline;
    /// <summary> Devuelve True si el TDateTime es mayor a Another </summary>
    function IsGreaterThan(const Another: TDateTime): Boolean; inline;
    /// <summary> Devuelve True si el TDateTime es mayor o igual que Another </summary>
    function IsGreaterOrEquals(const Another: TDateTime): Boolean; inline;
    /// <summary> Devuelve True si el TDateTime es menor a Another </summary>
    function IsLessThan(const Another: TDateTime): Boolean; inline;
    /// <summary> Devuelve True si el TDateTime es menor o igual que Another </summary>
    function IsLessOrEquals(const Another: TDateTime): Boolean; inline;

    /// <summary> Devuelve la fecha del TDateTime </summary>
    property Date: TDate read GetDate;
    /// <summary> Devuelve la hora del TDateTime </summary>
    property Time: TTime read GetTime;
    /// <summary> Devuelve el dia del TDateTime </summary>
    property Day: Word read GetDay;
    /// <summary> Devuelve el mes del TDateTime </summary>
    property Month: Word read GetMonth;
    /// <summary> Devuelve el año del TDateTime </summary>
    property Year: Word read GetYear;
    /// <summary> Devuelve las horas del TDateTime </summary>
    property Hours: Word read GetHours;
    /// <summary> Devuelve los minutos del TDateTime </summary>
    property Minutes: Word read GetMinutes;
    /// <summary> Devuelve los segundos del TDateTime </summary>
    property Seconds: Word read GetSeconds;
    /// <summary> Devuelve los milisegundos del TDateTime </summary>
    property Milliseconds: Word read GetMilliseconds;
  end;
{$ENDREGION}

implementation

uses
  System.SysConst;

{$REGION 'TDateTimeHelper'}

{$REGION 'SetXXX'}

function TDateTimeHelper.SetDay(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.RecodeDay(Self, Value);
end;

function TDateTimeHelper.SetMonth(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.RecodeMonth(Self, Value);
end;

function TDateTimeHelper.SetYear(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.RecodeYear(Self, Value);
end;

function TDateTimeHelper.SetHour(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.RecodeHour(Self, Value);
end;

function TDateTimeHelper.SetMinute(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.RecodeMinute(Self, Value);
end;

function TDateTimeHelper.SetSecond(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.RecodeSecond(Self, Value);
end;

function TDateTimeHelper.SetMillisecond(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.RecodeMilliSecond(Self, Value);
end;

{$ENDREGION}

{$REGION 'Arithmetic'}

function TDateTimeHelper.AddDay: TDateTime;
begin
  Result := System.DateUtils.IncDay(Self);
end;

function TDateTimeHelper.AddDays(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.IncDay(Self, Value);
end;

function TDateTimeHelper.AddMonth: TDateTime;
begin
  Result := System.SysUtils.IncMonth(Self);
end;

function TDateTimeHelper.AddMonths(const Value: Word): TDateTime;
begin
  Result := System.SysUtils.IncMonth(Self, Value);
end;

function TDateTimeHelper.AddYear: TDateTime;
begin
  Result := System.DateUtils.IncYear(Self);
end;

function TDateTimeHelper.AddYears(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.IncYear(Self, Value);
end;

function TDateTimeHelper.AddHour: TDateTime;
begin
  Result := System.DateUtils.IncHour(Self);
end;

function TDateTimeHelper.AddHours(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.IncHour(Self, Value);
end;

function TDateTimeHelper.AddMinute: TDateTime;
begin
  Result := System.DateUtils.IncMinute(Self);
end;

function TDateTimeHelper.AddMinutes(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.IncMinute(Self, Value);
end;

function TDateTimeHelper.AddSecond: TDateTime;
begin
  Result := System.DateUtils.IncSecond(Self);
end;

function TDateTimeHelper.AddSeconds(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.IncSecond(Self, Value);
end;

function TDateTimeHelper.AddMilliseconds(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.IncMilliSecond(Self, Value);
end;

function TDateTimeHelper.AddTime(const Value: TTime): TDateTime;
var
  Time: TDateTime absolute Value;
begin
  Result := Self
    .AddHours(Time.Hours)
    .AddMinutes(Time.Minutes)
    .AddSeconds(Time.Seconds)
    .AddMilliseconds(Time.Milliseconds);
end;

function TDateTimeHelper.SubDay: TDateTime;
begin
  Result := System.DateUtils.IncDay(Self, -1);
end;

function TDateTimeHelper.SubDays(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.IncDay(Self, -Value);
end;

function TDateTimeHelper.SubMonth: TDateTime;
begin
  Result := System.SysUtils.IncMonth(Self, -1);
end;

function TDateTimeHelper.SubMonths(const Value: Word): TDateTime;
begin
  Result := System.SysUtils.IncMonth(Self, -Value);
end;

function TDateTimeHelper.SubYear: TDateTime;
begin
  Result := System.DateUtils.IncYear(Self, -1);
end;

function TDateTimeHelper.SubYears(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.IncYear(Self, -Value);
end;

function TDateTimeHelper.SubHour: TDateTime;
begin
  Result := System.DateUtils.IncHour(Self, -1);
end;

function TDateTimeHelper.SubHours(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.IncHour(Self, -Value);
end;

function TDateTimeHelper.SubMinute: TDateTime;
begin
  Result := System.DateUtils.IncMinute(Self, -1);
end;

function TDateTimeHelper.SubMinutes(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.IncMinute(Self, -Value);
end;

function TDateTimeHelper.SubSecond: TDateTime;
begin
  Result := System.DateUtils.IncSecond(Self, -1);
end;

function TDateTimeHelper.SubSeconds(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.IncSecond(Self, -Value);
end;

function TDateTimeHelper.SubMilliseconds(const Value: Word): TDateTime;
begin
  Result := System.DateUtils.IncMilliSecond(Self, -Value);
end;

{$ENDREGION}

{$REGION 'Comparison'}

function TDateTimeHelper.AreEquals(const Another: TDateTime): Boolean;
begin
  Result := System.DateUtils.SameDateTime(Self, Another);
end;

function TDateTimeHelper.AreSame(const Another: TDateTime): Boolean;
begin
  Result := AreSameDay(Another) and AreSameMonth(Another) and AreSameYear(Another) and
            AreSameHours(Another) and AreSameMinutes(Another);
end;

function TDateTimeHelper.AreSameDay(const Another: TDateTime): Boolean;
begin
  Result := Day = Another.Day;
end;

function TDateTimeHelper.AreSameHours(const Another: TDateTime): Boolean;
begin
  Result := Hours = Another.Hours;
end;

function TDateTimeHelper.AreSameMiliseconds(const Another: TDateTime): Boolean;
begin
  Result := Milliseconds = Another.Milliseconds;
end;

function TDateTimeHelper.AreSameMinutes(const Another: TDateTime): Boolean;
begin
  Result := Minutes = Another.Minutes;
end;

function TDateTimeHelper.AreSameMonth(const Another: TDateTime): Boolean;
begin
  Result := Month = Another.Month;
end;

function TDateTimeHelper.AreSameSeconds(const Another: TDateTime): Boolean;
begin
  Result := Seconds = Another.Seconds;
end;

function TDateTimeHelper.AreSameYear(const Another: TDateTime): Boolean;
begin
  Result := Year = Another.Year;
end;

function TDateTimeHelper.Compare(const Another: TDateTime): TValueRelationShip;
begin
  Result := System.DateUtils.CompareDateTime(Self, Another);
end;

function TDateTimeHelper.IsContained(const Left, Right: TDateTime): Boolean;
begin
  Result := System.DateUtils.DateTimeInRange(Self, Left, Right, False);
end;

function TDateTimeHelper.IsGreaterThan(const Another: TDateTime): Boolean;
begin
  Result := Compare(Another) = System.Types.GreaterThanValue;
end;

function TDateTimeHelper.IsGreaterOrEquals(const Another: TDateTime): Boolean;
begin
  Result := Compare(Another) >= System.Types.EqualsValue;
end;

function TDateTimeHelper.IsLessOrEquals(const Another: TDateTime): Boolean;
begin
  Result := Compare(Another) <= System.Types.EqualsValue;
end;

function TDateTimeHelper.IsLessThan(const Another: TDateTime): Boolean;
begin
  Result := Compare(Another) = System.Types.LessThanValue;
end;

function TDateTimeHelper.IsBetween(const Left, Right: TDateTime): Boolean;
begin
  Result := System.DateUtils.DateTimeInRange(Self, Left, Right, True);
end;

{$ENDREGION}

{$REGION 'Creating'}

class function TDateTimeHelper.Create(const Day, Month, Year: Word): TDateTime;
begin
  Result := TDateTime.Create(Day, Month, Year, ZeroAM);
end;

class function TDateTimeHelper.Create(const Day, Month, Year, Hours, Mins, Secs: Word): TDateTime;
begin
  Result := TDateTime.Create(Day, Month, Year, Hours, Mins, Secs, 0);
end;

class function TDateTimeHelper.Create(const Day, Month, Year: Word; const Time: TTime): TDateTime;
var
  Hours, Mins, Secs, MSecs: Word;
begin
  System.SysUtils.DecodeTime(Time, Hours, Mins, Secs, MSecs);
  Result := TDateTime.Create(Day, Month, Year, Hours, Mins, Secs, MSecs);
end;

class function TDateTimeHelper.Create(const Day, Month, Year, Hours, Mins, Secs, MSecs: Word): TDateTime;
begin
  CheckDateTime(Day, Month, Year, Hours, Mins, Secs, MSecs);
  Result := System.DateUtils.EncodeDateTime(Year, Month, Day, Hours, Mins, Secs, MSecs);
end;

class function TDateTimeHelper.StartOfYear: TDateTime;
begin
  Result := System.DateUtils.StartOfTheYear(TDateTime.Today);
end;

class function TDateTimeHelper.EndOfYear: TDateTime;
begin
  Result := System.DateUtils.EndOfTheYear(TDateTime.Today);
end;

class function TDateTimeHelper.StartOfMonth: TDateTime;
begin
  Result := System.DateUtils.StartOfTheMonth(TDateTime.Today);
end;

class function TDateTimeHelper.StartOfFortnight: TDateTime;
var
  DayFrom: Word;
begin
  if TDateTime.Today.Day > 15 then
    DayFrom := 15
  else
    DayFrom := 1;

  Result := TDateTime.Today.SetDay(DayFrom);
end;

class function TDateTimeHelper.EndOfFortnight: TDateTime;
var
  DayTo: Word;
begin
  if TDateTime.Today.Day <= 15 then
    DayTo := 15
  else
    DayTo := TDateTime.EndOfMonth.Day;

  Result := TDateTime.Today.SetDay(DayTo);
end;

class function TDateTimeHelper.EndOfMonth: TDateTime;
begin
  Result := System.DateUtils.EndOfTheMonth(TDateTime.Today);
end;

class function TDateTimeHelper.StartOfWeek: TDateTime;
begin
  Result := System.DateUtils.StartOfTheWeek(TDateTime.Today);
end;

class function TDateTimeHelper.EndOfWeek: TDateTime;
begin
  Result := System.DateUtils.EndOfTheWeek(TDateTime.Today);
end;

class function TDateTimeHelper.Current: TDateTime;
begin
  Result := System.SysUtils.Now;
end;

class function TDateTimeHelper.Today: TDateTime;
begin
  Result := System.SysUtils.Date;
end;

class function TDateTimeHelper.Tomorrow: TDateTime;
begin
  Result := TDateTime.Today.AddDay;
end;

class function TDateTimeHelper.Yesterday: TDateTime;
begin
  Result := TDateTime.Today.SubDay;
end;

{$ENDREGION}

{$REGION 'Properties'}

function TDateTimeHelper.GetDate: TDate;
begin
  Result := DateOf(Self);
end;

function TDateTimeHelper.GetTime: TTime;
begin
  Result := TimeOf(Self);
end;

function TDateTimeHelper.GetDay: Word;
begin
  Result := DayOf(Self);
end;

function TDateTimeHelper.GetHours: Word;
begin
  Result := HourOf(Self);
end;

function TDateTimeHelper.GetMilliseconds: Word;
begin
  Result := MilliSecondOf(Self);
end;

function TDateTimeHelper.GetMinutes: Word;
begin
  Result := MinuteOf(Self);
end;

function TDateTimeHelper.GetMonth: Word;
begin
  Result := MonthOf(Self);
end;

function TDateTimeHelper.GetSeconds: Word;
begin
  Result := SecondOf(Self);
end;

function TDateTimeHelper.GetYear: Word;
begin
  Result := YearOf(Self);
end;

{$ENDREGION}

{$REGION 'Conversion'}

class function TDateTimeHelper.Parse(const Value: string): TDateTime;
begin
  Result := Parse(Value, System.SysUtils.FormatSettings);
end;

class function TDateTimeHelper.ParseInvariant(const Value: string): TDateTime;
begin
  Result := Parse(Value, TFormatSettings.Invariant);
end;

class function TDateTimeHelper.ParseLocaleDefault(const Value: string): TDateTime;
begin
  Result := Parse(Value, TFormatSettings.Create);
end;

class function TDateTimeHelper.Parse(const Value: string; const FormatSettings: TFormatSettings): TDateTime;
begin
  if not TryParse(Value, FormatSettings, Result) then
    CannotParseDateTimeError(Value)
end;

class function TDateTimeHelper.TryParse(const Value: string; out ResultValue: TDateTime): Boolean;
begin
  Result := TryParse(Value, System.SysUtils.FormatSettings, ResultValue);
end;

class function TDateTimeHelper.TryParseInvariant(const Value: string; out ResultValue: TDateTime): Boolean;
begin
  Result := TryParse(Value, TFormatSettings.Invariant, ResultValue);
end;

class function TDateTimeHelper.TryParseLocaleDefault(const Value: string; out ResultValue: TDateTime): Boolean;
begin
  Result := TryParse(Value, TFormatSettings.Create, ResultValue);
end;

class function TDateTimeHelper.TryParse(const Value: string; const FormatSettings: TFormatSettings;
  out ResultValue: TDateTime): Boolean;
begin
  Result := TryStrToDateTime(Value, ResultValue, FormatSettings);
end;

class function TDateTimeHelper.ParseDefault(const Value: string; const DefaultValue: TDateTime): TDateTime;
begin
  Result := ParseDefault(Value, System.SysUtils.FormatSettings, DefaultValue);
end;

class function TDateTimeHelper.ParseDefault(const Value: string; const FormatSettings: TFormatSettings;
  const DefaultValue: TDateTime): TDateTime;
begin
  if not TryParse(Value, FormatSettings, Result) then
    Result := DefaultValue;
end;

function TDateTimeHelper.ToString(const FormatSettings: TFormatSettings): string;
begin
  Result := System.SysUtils.DateTimeToStr(Self, FormatSettings);
end;

function TDateTimeHelper.ToString(const Format: string): string;
begin
  System.SysUtils.DateTimeToString(Result, Format, Self);
end;

function TDateTimeHelper.ToString: string;
begin
  Result := ToString(System.SysUtils.FormatSettings);
end;

{$ENDREGION}

class function TDateTimeHelper.AppendTimeStamp(const Text: string; const TimeStamp: TDateTime): string;
var
  Year, Month, Day, Hour, Min, Sec, MSec: Word;
begin
  DecodeDateTime(TimeStamp, Year, Month, Day, Hour, Min, Sec, MSec);
  Result := Format('%s %d-%d-%d %d:%d:%d.%d', [Text, Year, Month, Day, Hour, Min, Sec, MSec]);
end;

class procedure TDateTimeHelper.CheckDateTime(const Day, Month, Year, Hours, Mins, Secs, MSecs: Word);
begin
  if not System.DateUtils.IsValidDateTime(Year, Month, Day, Hours, Mins, Secs, MSecs) then
    IllegalDateTimeError(Day, Month, Year, Hours, Mins, Secs, MSecs);
end;

{$ENDREGION}

end.