my.functions.datum.html

PMS³² Online- Hilfereferenz

MY.FUNCTIONS.DATUM

Datum - Datumsfunktionen

Hilfe: Datumsfunktionen

Datumsfunktionen

Code: Datumsfunktionen

*/ Die unten angegebene Struktur verzweigt auf die Datumsfunktionen von PMS32
*/ Wenn in einem REPLACE mehrere Berechnungen durchgeführt werden, sollte eine Zwischenvariable genommen werden
loDatum = My.Functions.Datum
*/ weiterer Code ...
REPLACE Feldname1 WITH loDatum.function,Feldname2 WITH loDatum.function,...

Liste der Methoden von Datum

ATTOT() - BDESekunden in Sekunden

Rückgabe: [Integer], Wandelt eine 100 Sekundenangabe in eine 60 Sekundenangabe um.

Hilfeinformation

Rückgabe: [Integer], Wandelt eine 100 Sekundenangabe in eine 60 Sekundenangabe um.

Aufrufinformation

Integer = My.Functions.Datum.ATTOT(tnATime AS NUMBER)
Integer = My.Functions.Datum.ATTOT(tnATime)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,liTime AS Integer,lnTime AS Number
*/ So gehts schneller, wenn ein REPLACE benutzt wird
loDatum = My.Functions.Datum
*/ Umwandlung von 100Minuten.100Sekunden in 60Minuten.60Sekunden
lnTime = loDatum.ATTOT(5.50)		&& 3,30

CalcTime() - Berechnungen

Rückgabe:[Variant], Zeitberechnung verschiedener Werte. HH:MM und nZeiten sowie Stunden. Siehe auch Q01Tbl

Hilfeinformation

Rückgabe:[Variant], Zeitberechnung verschiedener Werte. HH:MM und nZeiten sowie Stunden. Siehe auch Q01Tbl.
Hier gibt es verschiedene Berechnungsvarianten, die je nach Übergabe von tcWhat gewählt werden.

Aufrufinformation

Variant = My.Functions.Datum.CalcTime(tcTime AS Variant,tvTime AS Variant,tcWhat AS STRING)
Variant = My.Functions.Datum.CalcTime(tcTime,tvTime,tcWhat)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,lnTime AS Number,lcTime AS String,lnHours AS Number
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Umwandlung einer C-Zeit in eine N-Zeit (Stunden gerechnet seit Mitternacht)
lnTime = loDatum.CalcTime("14:35",0,"CN")
*/ Umkehrfunktion
lcTime = loDatum.CalcTime(m.lnTime,0,"NC")

*/ Zu- bzw. Abziehen von Stunden zu einer C-Time
lcTime = loDatum.CalcTime("14:35",1.5,"+C")			&& "16:05"
lcTime = loDatum.CalcTime("14:35",1.5,"-C")			&& "13:05"

*/ Stunden zwischen zwei Zeiten
lnHours = loDatum.CalcTime("12:05","14:35","-N")	&& 14:35 - 12:05 = 02:30 = 2,5 Stunden

CalculateWd() - Arbeitstag nach Firmenkalender

Returnwert: [Date], Interne Methode für die Berechnung eines Datums anhand eines Startdatums und den Arbeitstagen!

Hilfeinformation

Returnwert: [Date], Interne Methode für die Berechnung eines Datums anhand eines Startdatums und den Arbeitstagen!

Aufrufinformation

Date = My.Functions.Datum.CalculateWd(tcIdc14 AS STRING,tdDate AS DATE,tiDays AS INTEGER)
Date = My.Functions.Datum.CalculateWd(tcIdc14,tdDate,tiDays)

Codeinformation

*/ Beispiel:
LOCAL ldDatum AS Date
*/ Erster Arbeitstag nach deutschem Kalender wenn 10 Tage von Heute in die Vergangenheit gesehen wird
ldDatum = My.Functions.Datum.CalculateWd("DE",DATE(),-10)
*/ Erster Arbeitstag nach deutschem Kalender wenn 10 Tage von Heute in die Zukunft gesehen wird
ldDatum = My.Functions.Datum.CalculateWd("DE",DATE(),10)

DTOChar() - Datum nach String

Rückgabe:[String], Wandelt einen Datumswert in einen definierten Charakter Wert um. tcDefine = "JJ.MM.TT" oder auch "JJJJ/TT/MM"... Erstes Trennzeichen Zählt!

Hilfeinformation

Rückgabe:[String], Wandelt einen Datumswert in einen definierten Charakter Wert um. tcDefine = "JJ.MM.TT" oder auch "JJJJ/TT/MM"... Erstes Trennzeichen Zählt!

Aufrufinformation

String = My.Functions.Datum.DTOChar(tdDatum AS DATE,tcDefine AS STRING)
String = My.Functions.Datum.DTOChar(tdDatum,tcDefine)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,liTime AS Integer,lnTime AS Number,lcDate AS String
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Umwandlung eines Datums in einen definierten String
lcDate = loDatum.DTOChar({^2012-03-15},"JJ-MM-TT")		&& 12-03-15

DTOCint() - Datum nach C-Datum-International

Rückgabe: [Strig], Wandelt einen Date() Wert in einen internationalen String um. Ohne Stringbegrenzung!

Hilfeinformation

Rückgabe: [Strig], Wandelt einen Date() Wert in einen internationalen String um. Ohne Stringbegrenzung!

Aufrufinformation

String = My.Functions.Datum.DTOCint(tdDate AS DATE)
String = My.Functions.Datum.DTOCint(tdDate)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,liTime AS Integer,lnTime AS Number,lcDate AS String
*/ So gehts schneller
loDatum = My.Functions.Datum

lcDate = loDatum.DTOCint(DATE())		&& Datum in der Form von {^YYYY-MM-DD}

DZ2T() - Umwandlung von Date+Time nach DateTime

Rückgabe:[Datetime], Wandelt getrennte Datum und Zeit Werte in einen DateTime Wert um

Hilfeinformation

Aufrufinformation

Datetime = My.Functions.Datum.DZ2T(tdDatum AS Date,tcZeit AS String)
Datetime = My.Functions.Datum.DZ2T(tdDatum,tcZeit)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ltDateTime AS DateTime
*/ So gehts schneller, wenn ein REPLACE benutzt wird
loDatum = My.Functions.Datum
ltDateTime = loDatum.DZ2T({^2013-05-12},'15:25:30')		&& 12.05.2013 15:25:30

DaS2cDT() - Sekunden und Datum nach DateTime

Rückgabe:[Datetime], Wandelt einen getrennten Datums und Zeitwert (Sekunden nach Mitternacht) in einen cDateTime Wert um.

Hilfeinformation

Rückgabe:[Datetime], Wandelt einen getrennten Datums und Zeitwert (Sekunden nach Mitternacht) in einen cDateTime Wert um.

Aufrufinformation

Datetime = My.Functions.Datum.DaS2cDT(tnSeconds AS INTEGER, tdDatum AS DATE, tlDTFormat AS Boolean)
Datetime = My.Functions.Datum.DaS2cDT(tnSeconds,tdDatum,tlDTFormat)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,lcDate AS String,ltDate AS Datetime
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Wandelt einen getrennten Datums und Zeitwert (Sekunden nach Mitternacht) in einen cDateTime Wert um.
lcDate= loDatum.DaS2cDT(25000,DATE(),.F.)		&& Datum und Uhrzeit in String
ltDate= loDatum.DaS2cDT(25000,DATE(),.T.)		&& Datum und Uhrzeit in DateTime

Date_Minus() - Schleife Datum-1

Zählt solange einen Tag vom Datum ab, bis DOW() davon in Arbeitstagen enthalten ist. Je nach erweiterter Klasse sind diese Methoden unterschiedlich.

Hilfeinformation

Zählt solange einen Tag vom Datum ab, bis DOW() davon in Arbeitstagen enthalten ist. Je nach erweiterter Klasse sind diese Methoden unterschiedlich.

Aufrufinformation

Variant = My.Functions.Datum.Date_Minus(tcIdc14 AS STRING,tpDate AS DATE)
Variant = My.Functions.Datum.Date_Minus(tcIdc14,tpDate)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate AS Date,tcIdc14 AS String,tdDate AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

tcIdc14 = "DE"				&& Betriebskalender der Tabelle C14/C15
tdDate  = {^2012-05-01}		&& 01. Mai 2012, Feiertag lt. deutschem Kalender
ldDate = loDatum.Date_Minus(m.tcIdc14,m.tdDate)		&& Gibt 30.04.2012 zurück

Date_Plus() - Schleife Datum+1

Zählt solange einen Tag zu Datum dazu, bis DOW() davon in Arbeitstagen enthalten ist. Je nach erweiterter Klasse sind diese Methoden unterschiedlich.

Hilfeinformation

Zählt solange einen Tag zu Datum dazu, bis DOW() davon in Arbeitstagen enthalten ist. Je nach erweiterter Klasse sind diese Methoden unterschiedlich.

Aufrufinformation

Variant = My.Functions.Datum.Date_Plus(tcIdc14 AS STRING,tpDate AS DATE)
Variant = My.Functions.Datum.Date_Plus(tcIdc14,tpDate)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate AS Date,tcIdc14 AS String,tdDate AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

tcIdc14 = "DE"				&& Betriebskalender der Tabelle C14/C15
tdDate  = {^2012-05-01}		&& 01. Mai 2012, Feiertag lt. deutschem Kalender
ldDate = loDatum.Date_Plus(m.tcIdc14,m.tdDate)		&& Gibt 02.05.2012 zurück

DaysBetweenDatesWd() - Arbeitstage zwischen zwei Datumsangaben

Returnwert: [Integer], Berechnet die Anzahl der Arbeitstage zwischen zwei Datumsangaben.

Hilfeinformation

Returnwert: [Integer], Berechnet die Anzahl der Arbeitstage zwischen zwei Datumsangaben.

Aufrufinformation

Integer = My.Functions.Datum.DaysBetweenDatesWd(tcIdc14 AS STRING,tdDate1 AS DATE,tdDate2 AS DATE)
Integer = My.Functions.Datum.DaysBetweenDatesWd(tcIdc14,tdDate1,tdDate2)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,liDays AS Integer,liDaysN AS Integer
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Berechnen der Arbeitstage zwischen zwei Datumsangaben
liDays  = loDatum.DaysBetweenDatesWd("DE",{^2012-04-25},{^2012-05-05})	&& Rückgabe: 6
liDaysN = {^2012-05-05} - {^2012-04-25}									&& Rückgabe: 10

DaysFromDateWd() - Arbeitstag nach Firmenkalender

Rückgabe: [Date], Berechnung des BETR_KAL des angegebenen Kalenders. tiDays>=0, tiArt=1 - Zukunft sonst Vergangenheit

Hilfeinformation

Rückgabe: [Date], Berechnung des BETR_KAL des angegebenen Kalenders. tiDays>=0, tiArt=1 - Zukunft sonst Vergangenheit

Aufrufinformation

Date = My.Functions.Datum.DaysFromDateWd(tcIdc14 AS STRING,tdDate AS DATE,tiDays AS INTEGER,tiArt AS INTEGER)
Date = My.Functions.Datum.DaysFromDateWd(tcIdc14,tdDate,tiDays,tiArt)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Berechnen eines Enddatums bei Vorgabe eines Startdatums und der Arbeitstage(n)
*/ 	DaysFromDateWd([cKalender],[dStartdatum],[nTage],[nArt,1=Zukunft])
ldDate = loDatum.DaysFromDateWd("DE",{^2012-04-25},6,1)		&& Rückgabe: 04.05.2012

DtoSC() - Date to Short

Rückgabe:[String], Wandelt ein Datum in einen SHORT - String um: YYMMDD

Hilfeinformation

Aufrufinformation

String = My.Functions.Datum.DtoSC(tdDatum AS Date)
String = My.Functions.Datum.DtoSC(tdDatum)

Codeinformation

FoGY() - Erster Tag des Geschäftsjahres

Rückgabe:[Date], Erster Tag des Geschäftsjahres. Siehe auch Firmenparameter...

Hilfeinformation

Rückgabe:[Date], Erster Tag des Geschäftsjahres. Siehe auch Firmenparameter...

Aufrufinformation

Date = My.Functions.Datum.FoGY(tpDate AS Variant)
Date = My.Functions.Datum.FoGY(tpDate)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

ldDate1 = loDatum.FoGY(2012)				&& Gibt den Ersten Tag im Geschäftsjahr zurück. Siehe Firmenparameter!
ldDate2 = loDatum.FoGY({^2012-05-01})		&& Gibt den Ersten Tag im Geschäftsjahr zurück. Siehe Firmenparameter!

FoGYwd() - Erster Arbeitstag des Geschäftsjahres

Rückgabe:[Date], Erster Arbeitstag des Geschäftsjahres. Siehe auch Firmenparameter...

Hilfeinformation

Rückgabe:[Date], Erster Arbeitstag des Geschäftsjahres. Siehe auch Firmenparameter...

Aufrufinformation

Date = My.Functions.Datum.FoGYwd(tcIdc14 AS STRING,tpDate AS Variant)
Date = My.Functions.Datum.FoGYwd(tcIdc14,tpDate)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

ldDate1 = loDatum.FoGYwd("DE",2012)				&& Gibt den Ersten Tag im Geschäftsjahr zurück. Siehe Firmenparameter!
ldDate2 = loDatum.FoGYwd("DE",{^2012-05-01})	&& Gibt den Ersten Tag im Geschäftsjahr zurück. Siehe Firmenparameter!

*/ Gleiche Funktion wie FoGY, jedoch wird der Betriebskalender abgefragt.
*/ Fällt der erste Tag auf einen Feiertag, so wird mit Date_Plus() gearbeitet.

Foh() - Erster Tag im Halbjahr

Returnwert: [Date], Berechnet den ersten Tag im Halbjahr tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den ersten Tag im Halbjahr tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.Foh(tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.Foh(tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "ersten" Tags des angegebenen Halbjahres
ldDate1 = loDatum.Foh(1,2012)					&& Foh([nHalbjahr,1|2],nJahr)
ldDate2 = loDatum.Foh({^2012-04-20})			&& Foh([dDate])

*/ Rückgabe des "ersten" Arbeitstags des angegebenen Halbjahres incl. Betriebskalender
ldDate1WD = loDatum.FohWd("DE",1,2012)			&& FohWd([cKalender],[nHalbjahr,1|2],nJahr)
ldDate2WD = loDatum.FohWd("DE",{^2012-04-20})	&& FohWd([cKalender],[dDate])

FohWd() - Erster Arbeitstag im Halbjahr

Returnwert: [Date], Berechnet den ersten Arbeitstag im Halbjahr tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den ersten Arbeitstag im Halbjahr tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.FohWd(tcIdc14 AS STRING,tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.FohWd(tcIdc14,tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "ersten" Tags des angegebenen Halbjahres
ldDate1 = loDatum.Foh(1,2012)					&& Foh([nHalbjahr,1|2],nJahr)
ldDate2 = loDatum.Foh({^2012-04-20})			&& Foh([dDate])

*/ Rückgabe des "ersten" Arbeitstags des angegebenen Halbjahres incl. Betriebskalender
ldDate1WD = loDatum.FohWd("DE",1,2012)			&& FohWd([cKalender],[nHalbjahr,1|2],nJahr)
ldDate2WD = loDatum.FohWd("DE",{^2012-04-20})	&& FohWd([cKalender],[dDate])

Fom() - Erster Tag im Monat

Returnwert: [Date], Berechnet den ERSTEN tag im Monat tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den ERSTEN tag im Monat tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.Fom(tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.Fom(tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "ersten" Tags des angegebenen Monats
ldDate1 = loDatum.Fom(1,2012)					&& Fom([nMonat,1|2|3|...|12],nJahr)
ldDate2 = loDatum.Fom({^2012-01-20})			&& Fom([dDate])

*/ Rückgabe des "ersten" Arbeitstags des angegebenen Monats incl. Betriebskalender
ldDate1WD = loDatum.FomWd("DE",1,2012)			&& FomWd([cKalender],[nMonat,1|2|3|...|12],nJahr)
ldDate2WD = loDatum.FomWd("DE",{^2012-01-20})	&& FomWd([cKalender],[dDate])

FomWd() - Erster Arbeitstag im Monat

Returnwert: [Date], Berechnet den ersten Arbeitstag im Monat tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den ersten Arbeitstag im Monat tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.FomWd(tcIdc14 AS STRING,tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.FomWd(tcIdc14,tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "ersten" Tags des angegebenen Monats
ldDate1 = loDatum.Fom(1,2012)					&& Fom([nMonat,1|2|3|...|12],nJahr)
ldDate2 = loDatum.Fom({^2012-01-20})			&& Fom([dDate])

*/ Rückgabe des "ersten" Arbeitstags des angegebenen Monats incl. Betriebskalender
ldDate1WD = loDatum.FomWd("DE",1,2012)			&& FomWd([cKalender],[nMonat,1|2|3|...|12],nJahr)
ldDate2WD = loDatum.FomWd("DE",{^2012-01-20})	&& FomWd([cKalender],[dDate])

Foq() - Erster Tag im Quartal

Returnwert: [Date], Berechnet den ersten Tag im Quartal tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den ersten Tag im Quartal tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.Foq(tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.Foq(tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "ersten" Tags des angegebenen Quartals
ldDate1 = loDatum.Foq(1,2012)					&& Foq([nQuartal,1|2|3|4],nJahr)
ldDate2 = loDatum.Foq({^2012-01-20})			&& Foq([dDate])

*/ Rückgabe des "ersten" Arbeitstags des angegebenen Quartals incl. Betriebskalender
ldDate1WD = loDatum.FoqWd("DE",1,2012)			&& FoqWd([cKalender],[nQuartal,1|2|3|4],nJahr)
ldDate2WD = loDatum.FoqWd("DE",{^2012-01-20})	&& FoqWd([cKalender],[dDate])

FoqWd() - Erster Arbeitstag im Quartal

Returnwert: [Date], Berechnet den ersten Arbeitstag im Quartal tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den ersten Arbeitstag im Quartal tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.FoqWd(tcIdc14 AS STRING,tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.FoqWd(tcIdc14,tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "ersten" Tags des angegebenen Quartals
ldDate1 = loDatum.Foq(1,2012)					&& Foq([nQuartal,1|2|3|4],nJahr)
ldDate2 = loDatum.Foq({^2012-01-20})			&& Foq([dDate])

*/ Rückgabe des "ersten" Arbeitstags des angegebenen Quartals incl. Betriebskalender
ldDate1WD = loDatum.FoqWd("DE",1,2012)			&& FoqWd([cKalender],[nQuartal,1|2|3|4],nJahr)
ldDate2WD = loDatum.FoqWd("DE",{^2012-01-20})	&& FoqWd([cKalender],[dDate])

Fow() - Erster Tag der Woche

Returnwert: [Date], Berechnet den ersten Tag der Woche tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den ersten Tag der Woche tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.Fow(tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.Fow(tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "ersten" Tags der angegebenen Woche
ldDate1 = loDatum.Fow(1,2012)					&& Fow([nQuartal,1|2|...|52],nJahr)
ldDate2 = loDatum.Fow({^2012-01-03})			&& Fow([dDate])

*/ Rückgabe des "ersten" Arbeitstags der angegebenen Woche incl. Betriebskalender
ldDate1WD = loDatum.FowWd("DE",1,2012)			&& FowWd([cKalender],[nWoche,1|2|...|52],nJahr)
ldDate2WD = loDatum.FowWd("DE",{^2012-01-03})	&& FowWd([cKalender],[dDate])

FowWd() - Erster Arbeitstag der Woche

Returnwert: [Date], Berechnet den ersten Arbeitstag der Woche tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den ersten Arbeitstag der Woche tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.FowWd(tcIdc14 AS STRING,tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.FowWd(tcIdc14,tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "ersten" Tags der angegebenen Woche
ldDate1 = loDatum.Fow(1,2012)					&& Fow([nQuartal,1|2|...|52],nJahr)
ldDate2 = loDatum.Fow({^2012-01-03})			&& Fow([dDate])

*/ Rückgabe des "ersten" Arbeitstags der angegebenen Woche incl. Betriebskalender
ldDate1WD = loDatum.FowWd("DE",1,2012)			&& FowWd([cKalender],[nWoche,1|2|...|52],nJahr)
ldDate2WD = loDatum.FowWd("DE",{^2012-01-03})	&& FowWd([cKalender],[dDate])

Foy() - Erster Tag im Jahr

Returnwert: [Date] Berechnet den ersten Tag im Jahr tpDate=[DT|I].

Hilfeinformation

Returnwert: [Date] Berechnet den ersten Tag im Jahr tpDate=[DT|I].

Aufrufinformation

Date = My.Functions.Datum.Foy(tpDate AS Variant)
Date = My.Functions.Datum.Foy(tpDate)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "ersten" Tags der angegebenen Woche
ldDate1 = loDatum.Foy(2012)						&& Foy([nJahr])
ldDate2 = loDatum.Foy({^2012-01-03})			&& Foy([dDate])

*/ Rückgabe des "ersten" Arbeitstags der angegebenen Woche incl. Betriebskalender
ldDate1WD = loDatum.FoyWd("DE",2012)			&& FoyWd([cKalender],[nJahr])
ldDate2WD = loDatum.FoyWd("DE",{^2012-01-03})	&& FoyWd([cKalender],[dDate])

FoyWd() - Erster Arbeitstag im Jahr

Returnwert: [Date], Berechnet den ersten Arbeitstag im Jahr tpDate=[DT|I]

Hilfeinformation

Returnwert: [Date], Berechnet den ersten Arbeitstag im Jahr tpDate=[DT|I]

Aufrufinformation

Date = My.Functions.Datum.FoyWd(tcIdc14 AS STRING,tpDate AS Variant)
Date = My.Functions.Datum.FoyWd(tcIdc14,tpDate)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "ersten" Tags der angegebenen Woche
ldDate1 = loDatum.Foy(2012)						&& Foy([nJahr])
ldDate2 = loDatum.Foy({^2012-01-03})			&& Foy([dDate])

*/ Rückgabe des "ersten" Arbeitstags der angegebenen Woche incl. Betriebskalender
ldDate1WD = loDatum.FoyWd("DE",2012)			&& FoyWd([cKalender],[nJahr])
ldDate2WD = loDatum.FoyWd("DE",{^2012-01-03})	&& FoyWd([cKalender],[dDate])

GetDosDate() - Datum aus DOS-Datum

Rückgabe:[Date], Gibt ein Datum aus einem DOS - Datum (Integer) zurück.

Hilfeinformation

Aufrufinformation

Date = My.Functions.Datum.GetDosDate(tiDate AS Integer)
Date = My.Functions.Datum.GetDosDate(tiDate)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate AS DATE
*/ So gehts schneller, wenn ein REPLACE benutzt wird
loDatum = My.Functions.Datum
ldDate  = loDatum.GetDosDate(17153)		&& 01.08.2013

GetDosTime() - Uhrzeit aus DOS-Time

Rückgabe:[String], Gibt eine Uhrzeit aus einer DOS - Zeit (Integer) zurück.

Hilfeinformation

Aufrufinformation

String = My.Functions.Datum.GetDosTime(tiTime AS Integer)
String = My.Functions.Datum.GetDosTime(tiTime)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,tcTime AS STRING
*/ So gehts schneller, wenn ein REPLACE benutzt wird
loDatum = My.Functions.Datum
tcTime  = loDatum.GetDosTime(7200)		&& '03:33:00'

GetGermanDays() - Deutsche Feiertage

Returnwert: [Integer], Ermittelt die angegebenen DEUTSCHEN Feiertage für das angegebene Jahr tiYear. Die Freiertage können in aHolyDays(n,m) abgefragt werden.

Hilfeinformation

Returnwert: [Integer], Ermittelt die angegebenen DEUTSCHEN Feiertage für das angegebene Jahr tiYear. Die Freiertage können in aHolyDays(n,m) abgefragt werden.

Aufrufinformation

Integer = My.Functions.Datum.GetGermanDays(tiJahr AS INTEGER,tc_2412_3112 AS STRING)
Integer = My.Functions.Datum.GetGermanDays(tiJahr,tc_2412_3112)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,lni AS Integer,laArray[1]
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Anzeige der Bundesländerkürzel
WAIT WINDOW loDatum.CountryHelp

*/ Setzen des Bundeslandes
loDatum.Country = "SL"				&& Für Saarland

*/ Ermitteln der Feiertage für das angegebene Bundesland
*/ Gültiger Zeitraum des Kalenders: 1900 - 2100
lni = loDatum.GetGermanDays(2012,"24,31")		&& Incl. dem 24.12. und 31.12.

*/ Prüfung
IF m.lni>0
	*/ In ein lokales Array kopieren
	=ACOPY(loDatum.aHolyDays,laArray)
	*/ Struktur von laArray[n,2]
	*/	laArray[n,1] = [D] , Feiertag
	*/	laArray[n,2] = [C] , Beschreibung des Feiertags
	*/ Erstellen einer Textdatei mit dem Inhalt des Arrays
	DISPLAY MEMORY TO FILE (My.Clients.Path.cTmpDir+"Saarländische-Feiertage.txt")  LIKE laArra* NOCONSOLE
	*/ Editieren der Datei
	MODIFY FILE (My.Clients.Path.cTmpDir+"Saarländische-Feiertage.txt")
ENDIF

GotoMonth() - Gehe N Monate weiter

Returnwert: [Date], Wie GOMONTH(tdDate,tnMonth) jedoch wird auch die Mitte berechnet 8 1,15,28|29|30|31

Hilfeinformation

Returnwert: [Date], Wie GOMONTH(tdDate,tnMonth) jedoch wird auch die Mitte berechnet 8 1,15,28|29|30|31

Aufrufinformation

Date = My.Functions.Datum.GotoMonth(tdDate AS DATE,tnMonth AS INTEGER)
Date = My.Functions.Datum.GotoMonth(tdDate,tnMonth)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des Monatsanfangs (01.)
ldDate1 = loDatum.GotoMonth({^2012-01-07},1)			&& 01.02.2012
ldDate2 = loDatum.GotoMonthWd("DE",{^2012-01-07},1)		&& 01.02.2012

*/ Rückgabe der Monatsmitte (15.)
ldDate1 = loDatum.GotoMonth({^2012-01-13},1)			&& 15.02.2012
ldDate2 = loDatum.GotoMonthWd("DE",{^2012-01-13},1)		&& 15.02.2012

*/ Rückgabe der Monatsende (15.)
ldDate1 = loDatum.GotoMonth({^2012-01-25},1)			&& 29.02.2012
ldDate2 = loDatum.GotoMonthWd("DE",{^2012-01-25},1)		&& 29.02.2012

*/ Bei GotoMonthWd() gibt es einen DRITTEN Parameter der Boolean ist!
*/	.T. - Wenn das errechnete Datum ein Feiertag ist, rechne Date_Minus()
*/	.F. - (Standard), wenn das errechnete Datum ein Feiertag ist, rechne Date_Plus()

GotoMonthWd() - Gehe N Monate weiter (Arbeitstag)

Returnwert: [Date], Wie GoToMonth() jedoch werden auch die Arbeitstage berechnet. Standard wird bei MoM() PLUS gerechnet!

Hilfeinformation

Returnwert: [Date], Wie GoToMonth() jedoch werden auch die Arbeitstage berechnet. Standard wird bei MoM() PLUS gerechnet!

Aufrufinformation

Date = My.Functions.Datum.GotoMonthWd(tcIdc14 AS STRING,tdDate AS DATE,tnMonth AS INTEGER,tlMomMinus AS Boolean)
Date = My.Functions.Datum.GotoMonthWd(tcIdc14,tdDate,tnMonth,tlMomMinus)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des Monatsanfangs (01.)
ldDate1 = loDatum.GotoMonth({^2012-01-07},1)			&& 01.02.2012
ldDate2 = loDatum.GotoMonthWd("DE",{^2012-01-07},1)		&& 01.02.2012

*/ Rückgabe der Monatsmitte (15.)
ldDate1 = loDatum.GotoMonth({^2012-01-13},1)			&& 15.02.2012
ldDate2 = loDatum.GotoMonthWd("DE",{^2012-01-13},1)		&& 15.02.2012

*/ Rückgabe der Monatsende (15.)
ldDate1 = loDatum.GotoMonth({^2012-01-25},1)			&& 29.02.2012
ldDate2 = loDatum.GotoMonthWd("DE",{^2012-01-25},1)		&& 29.02.2012

*/ Bei GotoMonthWd() gibt es einen DRITTEN Parameter der Boolean ist!
*/	.T. - Wenn das errechnete Datum ein Feiertag ist, rechne Date_Minus()
*/	.F. - (Standard), wenn das errechnete Datum ein Feiertag ist, rechne Date_Plus()

IsDayOfC15() - Ist der Tag ein Feiertag

Rückgabe:[Boolean], Ist das angegebene Datum im angegebenen Firmenkalender als Feiertag eingetragen?

Hilfeinformation

Aufrufinformation

Boolean = My.Functions.Datum.IsDayOfC15(tcIdc14 AS STRING,tpDate AS DATE)
Boolean = My.Functions.Datum.IsDayOfC15(tcIdc14,tpDate)

Codeinformation

IsDayOfC15R() - Rückgabe des Feiertages

Rückgabe:[String], Gibt den Namen des Feiertags zurück, falls vorhanden

Hilfeinformation

Aufrufinformation

String = My.Functions.Datum.IsDayOfC15R(tcIdc14 AS STRING,tpDate AS DATE)
String = My.Functions.Datum.IsDayOfC15R(tcIdc14,tpDate)

Codeinformation

LoGY() - Letzter Tag des Geschäftjahres

Rückgabe:[Date], Letzter Tag des Geschäftsjahres. Siehe auch Firmenparameter...

Hilfeinformation

Rückgabe:[Date], Letzter Tag des Geschäftsjahres. Siehe auch Firmenparameter...

Aufrufinformation

Date = My.Functions.Datum.LoGY(tpDate AS Variant)
Date = My.Functions.Datum.LoGY(tpDate)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "letzten" Tags des angegebenen Geschäftsjahres
ldDate1 = loDatum.LoGy(2012)					&& LoGy([nJahr])
ldDate2 = loDatum.LoGy({^2012-01-03})			&& LoGy([dDate])

*/ Rückgabe des "letzten" Arbeitstags des angegebenen Geschäftsjahres incl. Betriebskalender
ldDate1WD = loDatum.LoGyWd("DE",2012)			&& LoGyWd([cKalender],[nJahr])
ldDate2WD = loDatum.LoGyWd("DE",{^2012-01-03})	&& LoGyWd([cKalender],[dDate])

LoGYwd() - Letzter Arbeitstag des Geschäftsjahres

Rückgabe:[Date], Letzter Arbeitstag des Geschäftsjahres. Siehe auch Firmenparameter...

Hilfeinformation

Rückgabe:[Date], Letzter Arbeitstag des Geschäftsjahres. Siehe auch Firmenparameter...

Aufrufinformation

Date = My.Functions.Datum.LoGYwd(tcIdc14 AS STRING,tpDate AS Variant)
Date = My.Functions.Datum.LoGYwd(tcIdc14,tpDate)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "letzten" Tags des angegebenen Geschäftsjahres
ldDate1 = loDatum.LoGy(2012)					&& LoGy([nJahr])
ldDate2 = loDatum.LoGy({^2012-01-03})			&& LoGy([dDate])

*/ Rückgabe des "letzten" Arbeitstags des angegebenen Geschäftsjahres incl. Betriebskalender
ldDate1WD = loDatum.LoGyWd("DE",2012)			&& LoGyWd([cKalender],[nJahr])
ldDate2WD = loDatum.LoGyWd("DE",{^2012-01-03})	&& LoGyWd([cKalender],[dDate])

Loh() - Letzter Tag im Halbjahr

Returnwert: [Date], Berechnet den letzten Tag im Halbjahr tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den letzten Tag im Halbjahr tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.Loh(tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.Loh(tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "letzten" Tags des angegebenen Halbjahres
ldDate1 = loDatum.Loh(1,2012)				&& Loh([nHalbjahr,1|2],[nJahr])
ldDate2 = loDatum.Loh({^2012-01-03})		&& Loh([dDate])

*/ Rückgabe des "letzten" Arbeitstags des angegebenen Halbjahres incl. Betriebskalender
ldDate1WD = loDatum.LohWd("DE",1,2012)			&& LohWd([cKalender],[nHalbjahr,1|2],[nJahr])
ldDate2WD = loDatum.LohWd("DE",{^2012-01-03})	&& LohWd([cKalender],[dDate])

LohWd() - Letzter Arbeitstag im Halbjahr

Returnwert: [Date], Berechnet den letzten Arbeitstag im Halbjahr tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den letzten Arbeitstag im Halbjahr tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.LohWd(tcIdc14 AS STRING,tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.LohWd(tcIdc14,tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "letzten" Tags des angegebenen Halbjahres
ldDate1 = loDatum.Loh(1,2012)				&& Loh([nHalbjahr,1|2],[nJahr])
ldDate2 = loDatum.Loh({^2012-01-03})		&& Loh([dDate])

*/ Rückgabe des "letzten" Arbeitstags des angegebenen Halbjahres incl. Betriebskalender
ldDate1WD = loDatum.LohWd("DE",1,2012)			&& LohWd([cKalender],[nHalbjahr,1|2],[nJahr])
ldDate2WD = loDatum.LohWd("DE",{^2012-01-03})	&& LohWd([cKalender],[dDate])

Lom() - Letzter Tag im Monat

Returnwert: [Date], Berechnet den Letzten Tag im Monat tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den Letzten Tag im Monat tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.Lom(tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.Lom(tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "letzten" Tags des angegebenen Monats
ldDate1 = loDatum.Lom(1,2012)					&& Lom([nMonat,1|2|3|...|12],[nJahr])
ldDate2 = loDatum.Lom({^2012-01-03})			&& Lom([dDate])

*/ Rückgabe des "letzten" Arbeitstags des angegebenen Monats incl. Betriebskalender
ldDate1WD = loDatum.LomWd("DE",1,2012)			&& LomWd([cKalender],[nMonat,1|2|3|...|12],[nJahr])
ldDate2WD = loDatum.LomWd("DE",{^2012-01-03})	&& LomWd([cKalender],[dDate])

LomWd() - Letzter Arbeitstag im Monat

Returnwert: [Date], Berechnet den letzten Arbeitstag im Monat tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den letzten Arbeitstag im Monat tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.LomWd(tcIdc14 AS STRING,tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.LomWd(tcIdc14,tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "letzten" Tags des angegebenen Monats
ldDate1 = loDatum.Lom(1,2012)					&& Lom([nMonat,1|2|3|...|12],[nJahr])
ldDate2 = loDatum.Lom({^2012-01-03})			&& Lom([dDate])

*/ Rückgabe des "letzten" Arbeitstags des angegebenen Monats incl. Betriebskalender
ldDate1WD = loDatum.LomWd("DE",1,2012)			&& LomWd([cKalender],[nMonat,1|2|3|...|12],[nJahr])
ldDate2WD = loDatum.LomWd("DE",{^2012-01-03})	&& LomWd([cKalender],[dDate])

Loq() - Letzter Tag im Quartal

Returnwert: [Date], Berechnet den letzten Arbeitstag im Quartal tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den letzten Arbeitstag im Quartal tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.Loq(tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.Loq(tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "letzten" Tags des angegebenen Quartals
ldDate1 = loDatum.Loq(1,2012)					&& Loq([nQuartal,1|2|3|4],[nJahr])
ldDate2 = loDatum.Loq({^2012-01-03})			&& Loq([dDate])

*/ Rückgabe des "letzten" Arbeitstags des angegebenen Quartals incl. Betriebskalender
ldDate1WD = loDatum.LoqWd("DE",1,2012)			&& LoqWd([cKalender],[nQuartal,1|2|3|4],[nJahr])
ldDate2WD = loDatum.LoqWd("DE",{^2012-01-03})	&& LoqWd([cKalender],[dDate])

LoqWd() - Letzter Arbeitstag im Quartal

Returnwert: [Date], Berechnet den letzten Arbeitstag im Quartal tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den letzten Arbeitstag im Quartal tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.LoqWd(tcIdc14 AS STRING,tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.LoqWd(tcIdc14,tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "letzten" Tags des angegebenen Quartals
ldDate1 = loDatum.Loq(1,2012)					&& Loq([nQuartal,1|2|3|4],[nJahr])
ldDate2 = loDatum.Loq({^2012-01-03})			&& Loq([dDate])

*/ Rückgabe des "letzten" Arbeitstags des angegebenen Quartals incl. Betriebskalender
ldDate1WD = loDatum.LoqWd("DE",1,2012)			&& LoqWd([cKalender],[nQuartal,1|2|3|4],[nJahr])
ldDate2WD = loDatum.LoqWd("DE",{^2012-01-03})	&& LoqWd([cKalender],[dDate])

Low() - Letzter Tag der Woche

Returnwert: [Date], Berechnet den letzten Tag der Woche tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den letzten Tag der Woche tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.Low(tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.Low(tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "letzten" Tags der angegebenen Woche
ldDate1 = loDatum.Low(1,2012)					&& Low([nWoche,1|2|3|...|52],[nJahr])
ldDate2 = loDatum.Low({^2012-01-03})			&& Low([dDate])

*/ Rückgabe des "letzten" Arbeitstags der angegebenen Woche incl. Betriebskalender
ldDate1WD = loDatum.LowWd("DE",1,2012)			&& LowWd([cKalender],[nWoche,1|2|3|...|52],[nJahr])
ldDate2WD = loDatum.LowWd("DE",{^2012-01-03})	&& LowWd([cKalender],[dDate])

LowWd() - Letzter Arbeitstag der Woche

Returnwert: [Date], Berechnet den letzten Arbeitstag der Woche tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet den letzten Arbeitstag der Woche tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.LowWd(tcIdc14 AS STRING,tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.LowWd(tcIdc14,tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "letzten" Tags der angegebenen Woche
ldDate1 = loDatum.Low(1,2012)					&& Low([nWoche,1|2|3|...|52],[nJahr])
ldDate2 = loDatum.Low({^2012-01-03})			&& Low([dDate])

*/ Rückgabe des "letzten" Arbeitstags der angegebenen Woche incl. Betriebskalender
ldDate1WD = loDatum.LowWd("DE",1,2012)			&& LowWd([cKalender],[nWoche,1|2|3|...|52],[nJahr])
ldDate2WD = loDatum.LowWd("DE",{^2012-01-03})	&& LowWd([cKalender],[dDate])

Loy() - Letzter Tag im Jahr

Returnwert: [Date], Berechnet den letzten Tag im Jahr tpDate=[DT|I]

Hilfeinformation

Returnwert: [Date], Berechnet den letzten Tag im Jahr tpDate=[DT|I]

Aufrufinformation

Date = My.Functions.Datum.Loy(tpDate AS Variant)
Date = My.Functions.Datum.Loy(tpDate)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "letzten" Tags des angegebenen Jahres
ldDate1 = loDatum.Loy(2012)						&& Loy([nJahr])
ldDate2 = loDatum.Loy({^2012-01-03})			&& Loy([dDate])

*/ Rückgabe des "letzten" Arbeitstags des angegebenen Jahres incl. Betriebskalender
ldDate1WD = loDatum.LoyWd("DE",2012)			&& LoyWd([cKalender],[nJahr])
ldDate2WD = loDatum.LoyWd("DE",{^2012-01-03})	&& LoyWd([cKalender],[dDate])

LoyWd() - Letzter Arbeitstag im Jahr

Returnwert: [Date], Berechnet den letzten Arbeitstag im Jahr tpDate=[DT|I]

Hilfeinformation

Returnwert: [Date], Berechnet den letzten Arbeitstag im Jahr tpDate=[DT|I]

Aufrufinformation

Date = My.Functions.Datum.LoyWd(tcIdc14 AS STRING,tpDate AS Variant)
Date = My.Functions.Datum.LoyWd(tcIdc14,tpDate)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe des "letzten" Tags des angegebenen Jahres
ldDate1 = loDatum.Loy(2012)						&& Loy([nJahr])
ldDate2 = loDatum.Loy({^2012-01-03})			&& Loy([dDate])

*/ Rückgabe des "letzten" Arbeitstags des angegebenen Jahres incl. Betriebskalender
ldDate1WD = loDatum.LoyWd("DE",2012)			&& LoyWd([cKalender],[nJahr])
ldDate2WD = loDatum.LoyWd("DE",{^2012-01-03})	&& LoyWd([cKalender],[dDate])

MbD() - Monate zwischen zwei Datumsangaben

Returnwert: [Integer], Berechnet die Monate zwischen zwei Datumsangaben. Gleicher Monat=0

Hilfeinformation

Returnwert: [Integer], Berechnet die Monate zwischen zwei Datumsangaben. Gleicher Monat=0

Aufrufinformation

Integer = My.Functions.Datum.MbD(tdDate1 AS DATE,tdDate2 AS DATE)
Integer = My.Functions.Datum.MbD(tdDate1,tdDate2)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,tnDays AS Interger
*/ So gehts schneller
loDatum = My.Functions.Datum
tnDays  = loDatum.MbD(DATE()-100,DATE())	&& 4

MbDay() - Monate zwischen zwei Datumsangaben incl. Tag

Rückgabe:[Number], Monate zwischen zwei Datumsangaben incl. Prüfung des Tages.

Hilfeinformation

Rückgabe:[Number], Monate zwischen zwei Datumsangaben incl. Prüfung des Tages.

Aufrufinformation

Number = My.Functions.Datum.MbDay(tdDate1 AS DATE,tdDate2 AS DATE)
Number = My.Functions.Datum.MbDay(tdDate1,tdDate2)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,tnDays AS Interger
*/ So gehts schneller
loDatum = My.Functions.Datum
tnDays  = loDatum.MbDay(DATE()-100,DATE())	&& 3

Mom() - Mitte des Monats

Returnwert: [Date], Berechnet die Mitte des Monats (15te.) tpDate=[DT|I],tnYear=[I]

Hilfeinformation

Returnwert: [Date], Berechnet die Mitte des Monats (15te.) tpDate=[DT|I],tnYear=[I]

Aufrufinformation

Date = My.Functions.Datum.Mom(tpDate AS Variant,tnYear AS INTEGER)
Date = My.Functions.Datum.Mom(tpDate,tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe der Mitte des angegebenen Monats
ldDate1 = loDatum.Mom(1,2012)					&& Mom([nMonat,1|2|3|...|12],[nJahr])
ldDate2 = loDatum.Mom({^2012-01-03})			&& Mom([dDate])

*/ Rückgabe der Mitte des angegebenen Monats incl. Betriebskalender
ldDate1WD = loDatum.MomWd("DE",1,2012)			&& MomWd([cKalender],[nMonat,1|2|3|...|12],[nJahr])
ldDate2WD = loDatum.MomWd("DE",{^2012-01-03})	&& MomWd([cKalender],[dDate])

*/ Auch hier enthält MomWd() wieder einen DRITTEN Parameter!
*/ 	.T. - Bei einem Feiertag wird Date_Minus() gerechnet
*/	.F. - Bei einem Feiertag wird Date_Plus() gerechnet (Standard)

MomWd() - Mitte des Monats (Arbeitstag)

Returnwert: [Date], Berechnet die Mitte des Monats (15te.) tpDate=[DT|I], tnYear=[I], tlMomMinus=[L]. STandard wird PLUS berechnet, wenn der 15te. kein Arbeitstag ist!

Hilfeinformation

Returnwert: [Date], Berechnet die Mitte des Monats (15te.) tpDate=[DT|I], tnYear=[I], tlMomMinus=[L]. STandard wird PLUS berechnet, wenn der 15te. kein Arbeitstag ist!

Aufrufinformation

Date = My.Functions.Datum.MomWd(tcIdc14 AS STRING,tdDate AS DATE,tnYear AS INTEGER,tlMomMinus AS Boolean)
Date = My.Functions.Datum.MomWd(tcIdc14,tdDate,tnYear,tlMomMinus)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate1 AS Date,ldDate2 AS Date,ldDate1WD AS Date,ldDate2WD AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Rückgabe der Mitte des angegebenen Monats
ldDate1 = loDatum.Mom(1,2012)					&& Mom([nMonat,1|2|3|...|12],[nJahr])
ldDate2 = loDatum.Mom({^2012-01-03})			&& Mom([dDate])

*/ Rückgabe der Mitte des angegebenen Monats incl. Betriebskalender
ldDate1WD = loDatum.MomWd("DE",1,2012)			&& MomWd([cKalender],[nMonat,1|2|3|...|12],[nJahr])
ldDate2WD = loDatum.MomWd("DE",{^2012-01-03})	&& MomWd([cKalender],[dDate])

*/ Auch hier enthält MomWd() wieder einen DRITTEN Parameter!
*/ 	.T. - Bei einem Feiertag wird Date_Minus() gerechnet
*/	.F. - Bei einem Feiertag wird Date_Plus() gerechnet (Standard)

Ostern() - Gibt das Osterdatum zurück

Rückgabe:[Date], Gibt das Datum des Ostersonntags für das angegebene Jahr zurück

Hilfeinformation

Aufrufinformation

Date = My.Functions.Datum.Ostern(tiYear AS INTEGER)
Date = My.Functions.Datum.Ostern(tiYear)

Codeinformation

SCtoD() - Short to Date

Rückgabe:[Date], Wandelt ein einen SHORT - String YYMMDD in ein Datum um

Hilfeinformation

Aufrufinformation

Date = My.Functions.Datum.SCtoD(tcShortDate AS String)
Date = My.Functions.Datum.SCtoD(tcShortDate)

Codeinformation

SFDT() - Sekunden aus DateTime

Returnwert: [Integer], Gibt die Sekunden eines T Ausdrucks zurück.

Hilfeinformation

Returnwert: [Integer], Gibt die Sekunden eines T Ausdrucks zurück.

Aufrufinformation

Integer = My.Functions.Datum.SFDT(ttDateTime AS DATETIME)
Integer = My.Functions.Datum.SFDT(ttDateTime)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,liSeconds AS Integer
*/ So gehts schneller
loDatum = My.Functions.Datum

liSeconds = loDatum.SFDT({^2012-04-04T13:30:30})		&& Rückgabe: 48630 (Sekunden seit Mitternacht)

STOD() - C-Systemdatum nach Datum

Returnwert: [Date], Wandelt das Format JJJJMMTT in ein Datum [D] um. Umkehrfunktion zu DTOS(dDate)

Hilfeinformation

Returnwert: [Date], Wandelt das Format JJJJMMTT in ein Datum [D] um. Umkehrfunktion zu DTOS(dDate)
Übergabeparameter: "YYYYMMDD"

Aufrufinformation

Date = My.Functions.Datum.STOD(tcDTOS AS STRING)
Date = My.Functions.Datum.STOD(tcDTOS)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDate AS Date,lcDate AS String
*/ So gehts schneller
loDatum = My.Functions.Datum

lcDate  = DTOS({^2012-04-24})		&& Ergibt: "20120424"
ldDate  = loDatum.STOD(m.lcDate)	&& Ergibt: 24.04.2012

STOT() - C-DateTime nach DateTime

Rückgabe:[Datetime], Gibt einen DateTime Wert aufgrund eines Systemwertes zurück.

Hilfeinformation

Rückgabe:[Datetime], Gibt einen DateTime Wert aufgrund eines Systemwertes zurück.
Übergabeparameter: "YYYYMMDDHHMMSS"

Aufrufinformation

Datetime = My.Functions.Datum.STOT(tcDts AS STRING)
Datetime = My.Functions.Datum.STOT(tcDts)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ltDate AS Datetime,lcDate AS String
*/ So gehts schneller
loDatum = My.Functions.Datum

lcDate  = TTOC({^2012-04-24T13:30:00},1)		&& Ergibt: "20120424133000"
ltDate  = loDatum.STOT(m.lcDate)				&& Ergibt: 24.04.2012

SetDosDate() - DOS Datum aus DATE

Rückgabe:[Integer], Gibt das Datum im DOS Format zurück

Hilfeinformation

Aufrufinformation

Integer = My.Functions.Datum.SetDosDate(tdDate AS Date)
Integer = My.Functions.Datum.SetDosDate(tdDate)

Codeinformation

*/ Umkehrfunktion zu GetDosDate()

SetDosTime() - DOS Time aus TIME

Rückgabe:[Integer], Gibt die Uhrzeit im DOS Format zurück

Hilfeinformation

Aufrufinformation

Integer = My.Functions.Datum.SetDosTime(tvTime AS Variant,tcT AS String)
Integer = My.Functions.Datum.SetDosTime(tvTime,tcT)

Codeinformation

*/ Umkehrfunktion zu GetDosTime()

SetHolyDay() - Deutsche Feiertage

Setzt den Feiertag in aHolyDays(n,m). Prüfung auf das Bundesland erfolgt... Siehe auch THIS.Country

Hilfeinformation

Setzt den Feiertag in aHolyDays(n,m). Prüfung auf das Bundesland erfolgt... Siehe auch THIS.Country

Aufrufinformation

Variant = My.Functions.Datum.SetHolyDay(tdDate AS DATE,tcWhat AS STRING)
Variant = My.Functions.Datum.SetHolyDay(tdDate,tcWhat)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,tdDAte AS DATE,tcTime AS STRING
*/ So gehts schneller
loDatum = My.Functions.Datum
=loDatum.SetHolyDay({14.04.1969},'Mein Geburtstag...')

T2DZ() - Trennung von DateTime in Date und Time

Rückgabe:[Variant], Trennt einen DateTime Wert in Datum und Uhrzeit auf. Rückgabe ist entweder das Datum oder die Zeit oder über RdDate,RcTime abzufragen

Hilfeinformation

Aufrufinformation

Variant = My.Functions.Datum.T2DZ(ttDateTime AS Datetime,tcWhat AS String,RdDate AS Date @,RcTime AS String @)
Variant = My.Functions.Datum.T2DZ(ttDateTime,tcWhat,@RdDate,@RcTime)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,tdDAte AS DATE,tcTime AS STRING
*/ So gehts schneller
loDatum = My.Functions.Datum
[DATE]   = loDatum.T2DZ(DATETIME(),"D",@tdDate,@tcTime)
[STRING] = loDatum.T2DZ(DATETIME(),"T",@tdDate,@tcTime)

T2TZ() - Local DateTime nach Zulu-DateTime

Rückgabe:[Datetime], Wandelt einen lokalen DateTime Wert in einen Zulu DateTime Wert um. Rückgabe ist Zulu DateTime

Hilfeinformation

Aufrufinformation

Datetime = My.Functions.Datum.T2TZ(ttLocal AS Datetime)
Datetime = My.Functions.Datum.T2TZ(ttLocal)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ttZulu AS DateTime
*/ So gehts schneller
loDatum = My.Functions.Datum
ttZulu  = loDatum.T2TZ(DATETIME())		&& Während Sommerzeit: -2 Stunden

T2cTZ() - Local DateTime nach Zulu-Time

Rückgabe:[String], Umwandlung einer lokalen Zeitangabe in einen C-Zulutimewert YYYY-MMM-DDThh:mm:ss.000Z

Hilfeinformation

Aufrufinformation

String = My.Functions.Datum.T2cTZ(ttLocal AS Datetime)
String = My.Functions.Datum.T2cTZ(ttLocal)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,tcZulu AS String
*/ So gehts schneller
loDatum = My.Functions.Datum
tcZulu  = loDatum.T2cTZ(DATETIME())		&& Während Sommerzeit: -2 Stunden

TTOAT() - Sekunden in BDESekunden

Rückgabe: [Number], wandelt eine 60 Sekundenangabe in 100 Sekundenangabe um.

Hilfeinformation

Rückgabe: [Number], wandelt eine 60 Sekundenangabe in 100 Sekundenangabe um.

Aufrufinformation

Number = My.Functions.Datum.TTOAT(tnTTime AS NUMBER)
Number = My.Functions.Datum.TTOAT(tnTTime)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,lnTime AS Number
*/ So gehts schneller
loDatum = My.Functions.Datum

lnTime = loDatum.TTOAT(45.45)		&& Rückgabe: 75.75
*/ nMinuten60.nSekunden60, 45 Minuten und 45 Sekunden

TTOCint() - DateTime nach C-DateTime-International

Rückgabe: [Strig], Wandelt einen DateTime() Wert in einen internationalen String um. Ohne Stringbegrenzung!

Hilfeinformation

Rückgabe: [Strig], Wandelt einen DateTime() Wert in einen internationalen String um. Ohne Stringbegrenzung!

Aufrufinformation

Strig = My.Functions.Datum.TTOCint(ttDateTime AS DATETIME)
Strig = My.Functions.Datum.TTOCint(ttDateTime)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,lcDateTime AS String
*/ So gehts schneller
loDatum = My.Functions.Datum

lcDateTime = loDatum.TTOCint(DATETIME())	&& Format: [C] - {^YYYY-MM-DDThh:mm:ss}

TZ2T() - Zulu-DateTime nach local DateTime

Rückgabe:[Datetime], Wandelt einen Zulu DateTime Wert in einen lokalen DateTime Wert um. Rückgabe ist Local DateTime

Hilfeinformation

Aufrufinformation

Datetime = My.Functions.Datum.TZ2T(ttZulu AS Datetime)
Datetime = My.Functions.Datum.TZ2T(ttZulu)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ttLocal AS DateTime
*/ So gehts schneller
loDatum = My.Functions.Datum
ttLocal = loDatum.TZ2T(DATETIME()-7200)		&& Während Sommerzeit: -2 Stunden (7200 Sekunden)

TZ2cTZ() - Zulu-DateTime nach Zulu-DateTimeString

Rückgabe:[String], Umwandlung einer ZuluTime in einen ZuluTime String: YYYY-MM-DDThh:mm:ss.000Z

Hilfeinformation

Aufrufinformation

String = My.Functions.Datum.TZ2cTZ(ttZulu AS Datetime,tlNoMilliSeconds AS Boolean)
String = My.Functions.Datum.TZ2cTZ(ttZulu,tlNoMilliSeconds)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ttZulu AS DateTime,tcZulu AS STRING
*/ So gehts schneller
loDatum = My.Functions.Datum
ttZulu  = loDatum.T2TZ(DATETIME())		&& Während Sommerzeit: -2 Stunden (7200 Sekunden)
tcZulu  = loDatum.TZ2cTZ(m.ttZulu)		&& YYYY-MM-DDThh:mm:ss.000Z

TbTc() - Differenz zwischen zwei Zeiten

Returnwert: [String], Gibt die Zeitdifferenz zwischen zwei Zeiten im Format HH:MM:SS zurück. cTime1&2 = HH:MM:SS. Trenner nach Vorgabe von Time1

Hilfeinformation

Returnwert: [String], Gibt die Zeitdifferenz zwischen zwei Zeiten im Format HH:MM:SS zurück. cTime1&2 = HH:MM:SS. Trenner nach Vorgabe von Time1

Aufrufinformation

String = My.Functions.Datum.TbTc(tcTime1 AS STRING,tcTime2 AS STRING)
String = My.Functions.Datum.TbTc(tcTime1,tcTime2)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,tcTime AS String
*/ So gehts schneller
loDatum = My.Functions.Datum
tcTime   = loDatum.TbTc('15:25:00','12:15:00')		&& '03:10:00'

TimeZoneInfo() - System-Zeitzonen Objekt

Rückgabe:[Object], Gibt ein System-Zeitzonen Objekt zurück

Hilfeinformation

Rückgabe:[Object], Gibt ein System-Zeitzonen Objekt zurück

Aufrufinformation

Object = My.Functions.Datum.TimeZoneInfo(tnYear AS Integer)
Object = My.Functions.Datum.TimeZoneInfo(tnYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,loTimeZone AS Object,lcTimeZone AS String
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Gibt ein Systemzeit Zeitzonen Objekt zurück
loTimeZone = loDatum.TimeZoneInfo()

IF VARTYPE(loTimeZone)="O"
	*/ Dann lassen wir uns das Objekt in einen String umwandeln
	lcTimeZone = My.Functions.fOTS.ObjectToString(m.loTimeZone)
	*/ Anzeige des Zeitzonen Objekts
	=MESSAGEBOX(m.lcTimeZone,64,"Zeitzonen Objekt!")
ENDIF

Wod() - Kalenderwoche des Datums

Returnwert: [Integer], Berechnet die Kalenderwoche des Datums tpDate=[DT]

Hilfeinformation

Returnwert: [Integer], Berechnet die Kalenderwoche des Datums tpDate=[DT]

Aufrufinformation

Integer = My.Functions.Datum.Wod(tpDate AS DATE,tlWithYear AS Boolean)
Integer = My.Functions.Datum.Wod(tpDate,tlWithYear)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,liWeek AS Integer,lcWeek AS String
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Berechnen der Kalenderwoche aus einem Datum (Deutschland)
liWeek = loDatum.Wod({^2012-04-24})			&& Rückgabe: 17
lcWeek = loDatum.Wod({^2012-04-24},.T.)		&& Rückgabe: 17/2012

*/ Hierbei sind auch die Datumsfehler von MS ausgebügelt bezüglich der
*/ Berechnung der Kalenderwoche in Österreich!

cDowE() - Wochentag in Englisch

Gibt den Wochentag in englischer Schreibeise zurück.

Hilfeinformation

Aufrufinformation

Variant = My.Functions.Datum.cDowE(ttDate AS DATE)
Variant = My.Functions.Datum.cDowE(ttDate)

Codeinformation

cMonthE() - Monat in Englisch

Gibt den Monat in englischer Schreibeise zurück.

Hilfeinformation

Aufrufinformation

Variant = My.Functions.Datum.cMonthE(ttDate AS Date)
Variant = My.Functions.Datum.cMonthE(ttDate)

Codeinformation

cTZ2T() - Zulu-DateTimeString nach local DateTime

Rückgabe:[Datetime], Umwandlung eines C-Zulutime Wertes in eine Lokale Zeitangabe. YYYY-MMM-DDThh:mm:ss.000Z in DateTime

Hilfeinformation

Aufrufinformation

Datetime = My.Functions.Datum.cTZ2T(tcZulu AS String)
Datetime = My.Functions.Datum.cTZ2T(tcZulu)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ttLocal AS DateTime
*/ So gehts schneller
loDatum = My.Functions.Datum
ttLocal = loDatum.cTZ2T('2013-05-12T15:35:00.000Z')	&& 12.05.2013 17:35:00 (Für Deutschland)

cTZ2TZ() - Zulu-DateTimeString nach Zulu-DateTime

Rückgabe:[Datetime], Umwandeln eines C-ZuluTime Wertes in Zulu-DateTime.

Hilfeinformation

Aufrufinformation

Datetime = My.Functions.Datum.cTZ2TZ(tcZulu AS String)
Datetime = My.Functions.Datum.cTZ2TZ(tcZulu)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ttZulu AS DateTime
*/ So gehts schneller
loDatum = My.Functions.Datum
ttZulu = loDatum.cTZ2TZ('2013-05-12T15:35:00.000Z')	&& 12.05.2013 15:35:00

cTime2nTime() - C-Zeit nach N-Zeit

Rückgabe:[Number], Wandelt einen Zeitausdruck HH:MM:SS in den entsprechenden num. Wert um. tcWhat = "S" - Sekunden, "M" - Minuten, "H" - Stunden

Hilfeinformation

Rückgabe:[Number], Wandelt einen Zeitausdruck HH:MM:SS in den entsprechenden num. Wert um. tcWhat = "S" - Sekunden, "M" - Minuten, "H" - Stunden

Aufrufinformation

Number = My.Functions.Datum.cTime2nTime(tcTime AS STRING,tcWhat AS STRING)
Number = My.Functions.Datum.cTime2nTime(tcTime,tcWhat)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,tnTime AS Number
*/ So gehts schneller
loDatum = My.Functions.Datum
tnTime  = loDatum.cTime2nTime('15:00:00','H')		&& 15,0 Stunden
tnTime  = loDatum.cTime2nTime('15:00:00','M')		&& 900,0 Minuten
tnTime  = loDatum.cTime2nTime('15:00:00','S')		&& 54000,0 Sekunden

cTimesAdd() - Addieren zweier Zeiten

Rückgabe:[String], Addiert zwei cTime TIME() Werte und gibt diese im Format HH:MM:SS zurück. Trenner nach Systemvorgabe!

Hilfeinformation

Rückgabe:[String], Addiert zwei cTime TIME() Werte und gibt diese im Format HH:MM:SS zurück. Trenner nach Systemvorgabe!

Aufrufinformation

String = My.Functions.Datum.cTimesAdd(tcTime1 AS String, tcTime2 AS String)
String = My.Functions.Datum.cTimesAdd(tcTime1,tcTime2)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,tcTime AS String
*/ So gehts schneller
loDatum = My.Functions.Datum
tcTime  = loDatum.cTimesAdd('15:00:00','00:23:35')		&& '15:23:35'

cTimesSub() - Subtrahieren zweier Zeiten nach C-Zeit

Rückgabe:[String], Subtrahiert zwei TIME() Werte und gibt das Ergebnis im Format HH:MM:SS zurück. Trenner nach Systemvorgabe

Hilfeinformation

Rückgabe:[String], Subtrahiert zwei TIME() Werte und gibt das Ergebnis im Format HH:MM:SS zurück. Trenner nach Systemvorgabe

Aufrufinformation

String = My.Functions.Datum.cTimesSub(tcTime1 AS String, tcTime2 AS String)
String = My.Functions.Datum.cTimesSub(tcTime1,tcTime2)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,tcTime AS String
*/ So gehts schneller
loDatum = My.Functions.Datum
tcTime  = loDatum.cTimesAdd('15:00:00','00:23:35')		&& '14:36:25'

nTime2cTime() - N-Zeit nach C-Zeit

Rückgabe:[String], Wandelt eine Sekundenangabe in einen Zeitausdruck um. tcWhat = "S" - tnTime=Sekunden, "M" - tnTime=Minuten, "H" - tnTime=Stunden. tlNoDayTime=.T. => Stunden größer 23 . Trenner nach Systemvorgabe

Hilfeinformation

Rückgabe:[String], Wandelt eine Sekundenangabe in einen Zeitausdruck um. tcWhat = "S" - tnTime=Sekunden, "M" - tnTime=Minuten, "H" - tnTime=Stunden. tlNoDayTime=.T. => Stunden größer 23 . Trenner nach Systemvorgabe

Aufrufinformation

String = My.Functions.Datum.nTime2cTime(tnTime AS NUMBER, tcWhat AS STRING, tlNoDayTime AS Boolean)
String = My.Functions.Datum.nTime2cTime(tnTime,tcWhat,tlNoDayTime)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,tcTime AS String
*/ So gehts schneller
loDatum = My.Functions.Datum
*/ Umkehrfunktion zu cTime2nTime()
tcTime  = loDatum.nTime2cTime(15.5,'H')		&& '15:30:00'

nTimesSub() - Subtrahieren zweier Zeiten nach N-Zeit

Rückgabe:[Number], Subtrahiert zwei C-Zeitangaben und gibt den Wert in S-Sekunden, M-Minuten, H-Stunden zurück. Endzeit - Anfangszeit aus BDE (Beispiel)

Hilfeinformation

Rückgabe:[Number], Subtrahiert zwei C-Zeitangaben und gibt den Wert in S-Sekunden, M-Minuten, H-Stunden zurück. Endzeit - Anfangszeit aus BDE (Beispiel)

Aufrufinformation

Number = My.Functions.Datum.nTimesSub(tcTime1 AS String, tcTime2 AS String, tcWhat AS String)
Number = My.Functions.Datum.nTimesSub(tcTime1,tcTime2,tcWhat)

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,tnTime AS Number
*/ So gehts schneller
loDatum = My.Functions.Datum
tnTime  = loDatum.nTimesSub('15:00:00','00:23:35','H')		&& 14,6069

vTimesAdd() - Adden zweier Zeiten in verschiedenen Formaten

Addieren zweier Zeiten in in den Formaten "HH:MM:SS" oder nStunden,nMinuten,nSekunden angegeben werden können.

Hilfeinformation

Addition zweier Zeiten mit unterschiedlichen Formaten.

Aufrufinformation

Variant = My.Functions.Datum.vTimesAdd(tvTime1 AS Variant,tcT1 AS String,tvTime2 AS Variant,tcT2 AS String,tcTr AS String,tnDays AS Number @)
Variant = My.Functions.Datum.vTimesAdd(tvTime1,tcT1,tvTime2,tcT2,tcTr,@tnDays)

Codeinformation

*/ Codebeispiele:
*/ Es werden 1,5 Stunden addiert: Rückgabe = hh:mm:ss
cReturn = My.Functions.Datum.vTimesAdd(TIME(),"HMS",1.5,"H","HMS")
cReturn = My.Functions.Datum.vTimesAdd(TIME(),"HMS","1:30","HM","HMS")
*/ Es werden 1,5 Minuten addiert: Rückgabe = hh:mm:ss
cReturn = My.Functions.Datum.vTimesAdd(TIME(),"HMS",1.5,"M","HMS")
cReturn = My.Functions.Datum.vTimesAdd(TIME(),"HMS","1:30","MS","HMS")
*/ Es werden 15 Sekunden addiert: Rückgabe = hh:mm:ss
cReturn = My.Functions.Datum.vTimesAdd(TIME(),"HMS",25,"S","HMS")
*/ Mit Mitternachts Sprung...
lnDays  = 0
cReturn = My.Functions.Datum.vTimesAdd("22:54:00","HMS",1.5,"H","HMS",@lnDays)
cReturn = "00:24:00"
lnDays  = 1
*/ Numerische Rückgabe
nStunden  = My.Functions.Datum.vTimesAdd(TIME(),"HMS",1.5,"H","H")
nMinuten  = My.Functions.Datum.vTimesAdd(TIME(),"HMS",1.5,"H","M")
nSekunden = My.Functions.Datum.vTimesAdd(TIME(),"HMS",1.5,"H","S")

Liste der Properties von Datum

Country - Bundesland

Angabe des Bundeslandes für die Berechnung von Feiertagen. DE - Deutschland, BW - Badenwürtemberg, ... Alle Abkürzungen stehen in THIS.CountryHelp. Siehe dort... Wird kein Filter benötigt, so ist THIS.Country leer.

Hilfeinformation

Angabe des Bundeslandes für die Berechnung von Feiertagen. DE - Deutschland, BW - Badenwürtemberg, ... Alle Abkürzungen stehen in THIS.CountryHelp. Siehe dort... Wird kein Filter benötigt, so ist THIS.Country leer.

Aufrufinformation

String = My.Functions.Datum.Country

Codeinformation

CountryHelp - Kürzel der deutschen Bundesländer

Hilfe für die Einträge in THIS.Country. Ist THIS.Country = "" so werden alle Feiertage berechnet.

Hilfeinformation

Hilfe für die Einträge in THIS.Country. Ist THIS.Country = "" so werden alle Feiertage berechnet.

Aufrufinformation

String = My.Functions.Datum.CountryHelp

Codeinformation

FirstDayOfWeek - Erster Tag der Kalenderwoche

Wird mit SET("Fdow") im Init der Klasse gesetzt. Der erste Tag der Woche beginnt mit: 1 - Sonntag, 2 - Montag, 3 - Dienstag, ... 7 - Samstag

Hilfeinformation

Wird mit SET("Fdow") im Init der Klasse gesetzt. Der erste Tag der Woche beginnt mit: 1 - Sonntag, 2 - Montag, 3 - Dienstag, ... 7 - Samstag

Aufrufinformation

Number = My.Functions.Datum.FirstDayOfWeek

Codeinformation

FirstWeek - Berechnung der Ersten Woche im Jahr

Wird mit SET("Fweek") im INIT der Klasse gesetzt. Beschreibt wie die ERSTE Woche des Jahres zu berechnen ist. 2 - Erste 4 Tage einer Woche...

Hilfeinformation

Wird mit SET("Fweek") im INIT der Klasse gesetzt. Beschreibt wie die ERSTE Woche des Jahres zu berechnen ist. 2 - Erste 4 Tage einer Woche...

Aufrufinformation

Number = My.Functions.Datum.FirstWeek

Codeinformation

TZDateDL - Datum von Normalzeit nach Sommerzeit

Rückgabe: [DateTime], gibt das Datum der Umschaltung auf Sommerzeit zurück

Hilfeinformation

Rückgabe: [DateTime], gibt das Datum der Umschaltung auf Sommerzeit zurück

Aufrufinformation

DateTime = My.Functions.Datum.TZDateDL

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDateNS AS Date,ldDateSN AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Datum der Umschaltung von Normalzeit auf Sommerzeit
ldDateNS = loDatum.TZDateDL		&& Rückgabe: 25.03.2012 02:00:00 für Deutschland 2012
*/ Datum der Umschaltung von Sommerzeit auf Normalzeit
ldDateSN = loDatum.TZDateSD		&& Rückgabe: 28.10.2012 03:00:00 für Deutschland 2012

TZDateSD - Datum von Sommerzeit nach Normalzeit

Rückgabe: [DateTime], gibt das Datum der Umschaltung auf Standardzeit zurück

Hilfeinformation

Rückgabe: [DateTime], gibt das Datum der Umschaltung auf Standardzeit zurück

Aufrufinformation

DateTime = My.Functions.Datum.TZDateSD

Codeinformation

*/ Codebeispiel:
LOCAL loDatum AS My_Fu_Datum,ldDateNS AS Date,ldDateSN AS Date
*/ So gehts schneller
loDatum = My.Functions.Datum

*/ Datum der Umschaltung von Normalzeit auf Sommerzeit
ldDateNS = loDatum.TZDateDL		&& Rückgabe: 25.03.2012 02:00:00 für Deutschland 2012
*/ Datum der Umschaltung von Sommerzeit auf Normalzeit
ldDateSN = loDatum.TZDateSD		&& Rückgabe: 28.10.2012 03:00:00 für Deutschland 2012

TZbias - Zeitversatz zu UTC Normalzeit

Rückgabe: [Integer], gibt den Zeitversatz in Minuten zu UTC zurück.

Hilfeinformation

Rückgabe: [Integer], gibt den Zeitversatz in Minuten zu UTC zurück.

Aufrufinformation

DateTime = My.Functions.Datum.TZbias

Codeinformation

TZbiasDL - Zeitvbersatz zu UTC Sommerzeit

Rückgabe: [Integer], gibt den Zeitversatz in Minuten zu UTC zurück. Sommerzeit.

Hilfeinformation

Rückgabe: [Integer], gibt den Zeitversatz in Minuten zu UTC zurück. Sommerzeit.

Aufrufinformation

DateTime = My.Functions.Datum.TZbiasDL

Codeinformation

TZbiasNow - Zeitversatz zu UTC in diesem Moment

Rückgabe:[Interger], Gibt den Zeitversatz in Minuten zu UTC zurück IN DIESEM MOMENT.

Hilfeinformation

Rückgabe:[Interger], Gibt den Zeitversatz in Minuten zu UTC zurück IN DIESEM MOMENT.

Aufrufinformation

DateTime = My.Functions.Datum.TZbiasNow

Codeinformation

WorkDays - Arbeitstage in der Woche

Welche Wochentage werden als Arbeitstage gewertet. Wird für einige Berechnungsfunktionen genutzt. !Diese Klasse hat keinen Tabellenzugriff!

Hilfeinformation

Welche Wochentage werden als Arbeitstage gewertet. Wird für einige Berechnungsfunktionen genutzt. !Diese Klasse hat keinen Tabellenzugriff!

Aufrufinformation

String = My.Functions.Datum.WorkDays

Codeinformation

aHolyDays - Array mit deutschen Feiertagen

Array, dass Feiertage enthält.... aHolyDays(n,1)=[D] enthält ein Datum, aHolyDays(n,2)=[C] enthält den Begriff

Hilfeinformation

Array, dass Feiertage enthält.... aHolyDays(n,1)=[D] enthält ein Datum, aHolyDays(n,2)=[C] enthält den Begriff

Aufrufinformation

Array = My.Functions.Datum.aHolyDays[tiIndex1 AS Integer , tiIndex2 AS Integer]
Array = My.Functions.Datum.aHolyDays[tiIndex1,tiIndex2]

Codeinformation

*/ Aufbau des Arrays:
*/	aHolyDays[n,1] = [D] , Feiertag
*/	aHolyDays[n,2] = [C] , Beschreibung des Feiertages

aHolyDaysCount - Zähler von aHolyDays

Zähler für Feieretage. DIeses Array wird in einer Unterableitung genutzt!

Hilfeinformation

Zähler für Feieretage. DIeses Array wird in einer Unterableitung genutzt!

Aufrufinformation

Array = My.Functions.Datum.aHolyDaysCount

Codeinformation

cMethod - Methode des Fehlers

Methode in der der letzte Fehler auftrat.

Hilfeinformation

Methode in der der letzte Fehler auftrat.
Aufbau: [Fehlernummer] [Methode] [Zeilennummer] [Message]

Aufrufinformation

String = My.Functions.Datum.cMethod

Codeinformation

*/ Abruf...
WAIT WINDOW My.Functions.Datum.cMethod

cSEC2CT - Umwandlung eines num. Sekundenwerts in HH:MM:SS

Wert:[String], Wandelt einen Sekunden Wert in HH:MM:SS um. Trennzeichen ist immer :

Hilfeinformation

Aufrufinformation

String = My.Functions.Datum.cSEC2CT[tcIndex1 AS String | tiIndex1 AS Integer , tiIndex2 AS Integer]
String = My.Functions.Datum.cSEC2CT[tcIndex1|,tiIndex1,tiIndex2]

Codeinformation

nCT2SEC - Umwandlung von HH:MM:SS in einen num. Sekundenwert

Wert:[Integer], Wandelt einen cZeitwert in Sekunden um. 01:00:30 => 3630

Hilfeinformation

Aufrufinformation

Integer = My.Functions.Datum.nCT2SEC[tcIndex1 AS String | tiIndex1 AS Integer , tiIndex2 AS Integer]
Integer = My.Functions.Datum.nCT2SEC[tcIndex1|,tiIndex1,tiIndex2]

Codeinformation

nError - Fehlernummer d. Fehlers

Fehlernummer des letzten Fehlers.

Hilfeinformation

Fehlernummer des letzten Fehlers.
Ist der Wert kleiner null, so handelt es sich um einen logischen Fehler.

Aufrufinformation

Number = My.Functions.Datum.nError

Codeinformation

WAIT WINDOW My.Functions.Datum.nError

nLine - Zeilennummer d. Fehlers

Zeilennummer, in der der letzte Fehler auftrat

Hilfeinformation

Zeilennummer, in der der letzte Fehler auftrat

Aufrufinformation

Number = My.Functions.Datum.nLine

Codeinformation

WAIT WINDOW My.Functions.Datum.nLine

Siehe auch : Hauptmenü / Hauptindex / Such Index / Cursor Index / Programm Module / Tabellen Index / Tabellenmodule / Masken Index / Programmcode Index / Servicepacks / My.Struktur / Funktionen / Sonstiges Index

Lokale Benutzerhilfe : Meine eigene Hilfe / Zur�ck zur PMS³² - Hilfe

Dateiversion:1.0.04#3648 - H.U.DD#SSFF 02.12.2022 Senden Sie Ihren Kommentar zu diesem Thema an das Entwicklungsteam von PMS³² Weitere Informationen finden Sie unter der aktuellen PMS³² WEB-Hilfe
Die Informationen dieser Mitteilung sind vertraulich und nur f�r Sie bestimmt. Unbefugtes Weiterleiten, Ver�ffentlichen, Kopieren usw. sind untersagt und werden gerichtlich verfolgt. © PMS Compelec GmbH 2022 ® el-Projekt