1"use strict"; 2 3/** 4 * Toolsammlung für den Umgang mit Datum und Uhrzeit. 5 */ 6class HRDate 7{ 8 /** 9 * Die deutschen Monatsbezeichner. 10 */ 11 static MonthNames = new Array("Januar","Februar","März","April","Mai","Juni","Juli", "August", "September", "Oktober", "November", "Dezember"); 12 13 /** 14 * Die deutschen Wochentagsbezeichner. 15 */ 16 static DayNames = new Array("Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag"); 17 18 /** 19 * Ein Tag in Millisekunden. 20 */ 21 static DaysInMs = 864e5; 22 23 /** 24 * Eine Woche in Millisekunden. 25 */ 26 static WeeksInMs = this.DaysInMs * 7; 27 28 /** 29 * Ein Monat in Millisekunden. 30 */ 31 static MonthsInMs = this.WeeksInMs * 4; 32 33 /** 34 * Ein Jahr in Millisekunden. 35 */ 36 static YearsInMs = this.MonthsInMs * 12; 37 38 /** 39 * Auflistung der Tage pro Monate. 40 */ 41 static NumberDaysInMonths = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31); 42 43 /** 44 * Getter für die Zeitkomponenten der übergebenen 45 * Zeit in ms. Gibt die verbliebenen Tage, Stunden, Minuten, 46 * Sekunden und auch Millisekunden in einem js-Objekt zurück. 47 * 48 * @param time die Zeit in Millisekunden. 49 * @return Die verbliebenen Tage, Stunden, Minuten, Sekunden und auch Millisekunden in einem js-Objekt. 50 */ 51 static getTimeComponentsFromMs(time) 52 { 53 let timeObj = {days: 0, hours: 0, minutes: 0, seconds: 0, milliseconds: 0}; 54 55 if (time > 0) 56 { 57 timeObj.days = Math.floor((time / (1000 * 60 * 60 * 24)) % 365) 58 timeObj.hours = Math.floor((time / (1000 * 60 * 60)) % 24); 59 timeObj.minutes = Math.floor((time / (1000 * 60)) % 60); 60 timeObj.seconds = Math.floor((time / 1000) % 60); 61 timeObj.milliseconds = Math.floor((time % 1000) / 100); 62 } 63 64 return timeObj; 65 } 66 67 /** 68 * Implementiert die Osterformel zur dyn. Berechnung von beweglichen 69 * Feiertagen. Damit nicht jedes mal neu durchgelaufen werden muss, wird das 70 * Ergebnis fuer jedes Jahr zwischengespeichert. 71 * 72 * @param jahr Das Jahr, für das der Ostersonntag berechnet werden soll. 73 * @return Der Ostersonntag. 74 */ 75 static getGaussianEaster(jahr) 76 { 77 let easterSunday = ""; 78 try 79 { 80 if (jahr && typeof(jahr) == "number") 81 { 82 const k = Math.floor(jahr / 100); 83 const tmp = Math.floor((3 * k + 3) / 4); 84 const m = Math.floor(15 + tmp - Math.floor((8 * k + 13) / 25)); 85 const s = 2 - tmp; 86 const a = jahr % 19; 87 const d = (19 * a + m) % 30; 88 const r = Math.floor((d / 29) + (d / 28 - d / 29) * (a / 11)); 89 const og = 21 + d - r; 90 const sz = Math.floor(7 - (jahr + Math.floor(jahr / 4) + s) % 7); 91 const oe = 7 - (og - sz) % 7; 92 const os = og + oe; 93 94 if (os > 31) 95 easterSunday = new Date((new Date(jahr, 3, os - 31).getTime())); 96 else 97 easterSunday = new Date((new Date(jahr, 2, os).getTime())); 98 } 99 } 100 catch (e) 101 { 102 if (typeof(HRLogError) === 'function') 103 HRLogError(e); 104 } 105 106 return easterSunday; 107 } 108 109 /** 110 * Diese Methode prüft, ob es sich beim übergebenen Datum um einen Feiertag handelt. 111 * Um auch nicht bundeseinheitliche Feiertage prüfen zu können kann optional die 112 * Abkürzung des Bundeslands angegeben werden. Wird kein Bundesland angegeben werden 113 * nur bundeseinheitliche Feiertage geprüft. 114 * 115 * Die Abkürzungen des Bundestage entsprechen der EU-Vorgabe und sind wie folgt: 116 * BW: Baden-Württemberg 117 * BY: Bayern 118 * BE: Berlin 119 * BB: Brandenburg 120 * HB: Bremen 121 * HH: Hamburg 122 * HE: Hessen 123 * MV: Mecklenburg-Vorpommern 124 * NI: Niedersachsen 125 * NW: Nordrhein-Westfalen 126 * RP: Rheinland-Pfalz 127 * SL: Saarland 128 * SN: Sachsen 129 * ST: Sachsen-Anhalt 130 * SH: Schleswig-Holstein 131 * TH: Thüringen 132 * 133 * @param datum Datum 134 * @param bl Abkürzung des Bundesland 135 * @return Name des Feiertags oder Leerstring, wenn das übergebene Datum kein Feiertag ist. 136 */ 137 static checkFeiertag(datum, bl) 138 { 139 if (datum != null && bl != null) 140 { 141 const jahr = datum.getFullYear(); 142 const monat = datum.getMonth(); 143 const tag = datum.getDate(); 144 const eintagInMs = 24*60*60*1000; 145 146 // Feiertage mit festem Datum. 147 if (monat === 0) 148 { 149 if (tag == 1) 150 { 151 return "Neujahr"; 152 } 153 else if (tag == 6 && (bl.equalsIgnoreCase("BW") || bl.equalsIgnoreCase("BY") || bl.equalsIgnoreCase("ST"))) 154 { 155 return "Heilige 3 Koenige"; 156 } 157 } 158 else if (monat == 4 && tag == 1) 159 return "Maifeiertag"; 160 else if (monat == 7 && tag == 15 && (bl.equalsIgnoreCase("BY") || bl.equalsIgnoreCase("SL"))) 161 return "Mariae Himmelfahrt"; 162 else if (monat == 9) 163 { 164 if (tag == 3) 165 return "T. d. dt. Einheit"; 166 else if (tag == 31) 167 { 168 // Reformationstag (zum 500. Jubilaeum 2017 auch in ein paar 169 // zusaetzlichen Laendern) 170 if (bl.equalsIgnoreCase("BB") || bl.equalsIgnoreCase("MV") || bl.equalsIgnoreCase("SN") 171 || bl.equalsIgnoreCase("ST") || bl.equalsIgnoreCase("TH") || (jahr == 2017 && (bl.equalsIgnoreCase("HE") 172 || bl.equalsIgnoreCase("NW") || bl.equalsIgnoreCase("SL")))) 173 { 174 return "Reformationstag"; 175 } 176 } 177 } 178 else if (monat == 10 && tag == 1) 179 { 180 if (bl.equalsIgnoreCase("BW") || bl.equalsIgnoreCase("BY") || bl.equalsIgnoreCase("NW") || bl.equalsIgnoreCase("RP") || bl.equalsIgnoreCase("SL")) 181 return "Allerheiligen"; 182 } 183 else if (monat == 11) 184 { 185 if (tag == 25) 186 return "1. Weihnachtstag"; 187 else if (tag == 26) 188 return "2. Weihnachtstag"; 189 } 190 191 // 192 // Bewegliche Feiertage, die sich alle vom Ostersonntag ableiten lassen.
193 // Berechnung mit Hilfe der Gaußschen Osterformel. 194 // 195 const ostersonntag = this.getGaussianEaster(jahr); 196 if (this.isSameDay(datum, ostersonntag) && bl.equalsIgnoreCase("BB")) 197 return "Ostersonntag"; 198 199 const karfreitag = new Date(ostersonntag.getTime() - 2 * eintagInMs); 200 if (this.isSameDay(datum, karfreitag)) 201 return "Karfreitag"; 202 203 const ostermontag = new Date(ostersonntag.getTime() + eintagInMs); 204 if (this.isSameDay(datum, ostermontag)) 205 return "Ostermontag"; 206 207 const christiHimmelfahrt = new Date(ostersonntag.getTime() + 39 * eintagInMs); 208 if (this.isSameDay(datum, christiHimmelfahrt)) 209 return "Christi Himmelfahrt"; 210 211 if (bl.equalsIgnoreCase("BB") || bl.equalsIgnoreCase("HE")) 212 { 213 const pfingstSonntag = new Date(ostersonntag.getTime() + 49 * eintagInMs); 214 if (this.isSameDay(datum, pfingstSonntag)) 215 return "Pfingstsonntag"; 216 } 217 218 const pfingstMontag = new Date(ostersonntag.getTime() + 50 * eintagInMs); 219 if (this.isSameDay(datum, pfingstMontag)) 220 return "Pfingstmontag"; 221 222 if (bl.equalsIgnoreCase("BW") || bl.equalsIgnoreCase("BY") 223 || bl.equalsIgnoreCase("HE") || bl.equalsIgnoreCase("NW") 224 || bl.equalsIgnoreCase("RP") || bl.equalsIgnoreCase("SL")) 225 { 226 const fronleichnam = new Date(ostersonntag.getTime() + 60 * eintagInMs); 227 if (this.isSameDay(datum, fronleichnam)) 228 return "Fronleichnam"; 229 } 230 231 if (bl.equalsIgnoreCase("SN")) //Buss- und Bettag (Erster Mittwoch VOR 23.11.) 232 { 233 const bussUndBettag = new Date(jahr, 10, 22); 234 bussUndBettag = new Date(jahr, 10, 22 - ((bussUndBettag.getDay() + 4) % 7)); 235 if (this.isSameDay(datum, bussUndBettag)) 236 return "Buss- und Bettag"; 237 } 238 } 239 240 return ""; 241 } 242 243 /** 244 * Überprüft, ob zwei gegebene Daten bis auf den Tag identisch sind. 245 * 246 * @param datum1 Das erste Datum. 247 * @param datum2 Das Vergleichsdatum. 248 * @return true, falls die Daten bis auf den Tag identisch sind. 249 */ 250 static isSameDay(datum1, datum2) 251 { 252 // Etwas krude Prüfung zur Feststellung, dass wirklich Datumsobjekte übergeben wurden. Kann man in Zukunft vllt. verbessern. 253 if (datum1 != null && datum2 != null && typeof(datum1.getFullYear) == 'function' && typeof(datum2.getFullYear) == 'function') 254 return (datum1.getFullYear() == datum2.getFullYear() && datum1.getMonth() == datum2.getMonth() && datum1.getDate() == datum2.getDate()) 255 256 return false; 257 } 258 259 /** 260 * Liefert den Wochentag zum angegebenen Date-Objekt (Montag = 1, Dienstag = 2, ..., Sonntag = 7). 261 * 262 * @param datum Das Date-Objekt. 263 * @return Der Wochentag oder 0, falls das übergebene Datum nicht vom korrekten Typ war. 264 */ 265 static getDayOfWeek(datum) 266 { 267 if (datum && datum instanceof Date) 268 { 269 let dayOfWeek = datum.getDay(); 270 if (dayOfWeek === 0) 271 dayOfWeek = 7; 272 273 return dayOfWeek; 274 } 275 276 return 0; 277 } 278 279 /** 280 * Prüft, ob das übergebene Datum in der Vergangheit liegt. 281 * 282 * @param datum Das zu prüfende Datum. 283 * @return true, wenn das übergebene Datum in der Vergangheit liegt. 284 */ 285 static isInPast(datum) 286 { 287 return (datum && datum < new Date()); 288 } 289 290 /** 291 * Prüft, ob das übergebene Datum in der Zukunft liegt. 292 * 293 * @param datum Das zu prüfende Datum. 294 * @return true, wenn das übergebene Datum in der Zukunft liegt. 295 */ 296 static isInFuture(datum) 297 { 298 return (datum && datum > new Date()); 299 } 300 301 /** 302 * Gibt den Mitternachtszeitpunkt (00:00 Uhr) des übergebenen Tages zurück. 303 * 304 * @param datum Das Datum. 305 * @return Der Mitternachtszeitpunkt des übergebenen Tages. 306 */ 307 static getMidnight(datum) 308 { 309 const dateCopy = datum; 310 dateCopy.setHours(0, 0, 0, 0); 311 return dateCopy; 312 } 313 314 /** 315 * Setzt die Uhrzeit des übergeben Datums auf Mitternacht. 316 * 317 * @return Das übergebene Datum, wobei dessen Uhrzeit nun auf Mitternacht gesetzt wurde. 318 */ 319 static setMidnight(datum) 320 { 321 datum.setHours(0, 0, 0, 0); 322 } 323 324 /** 325 * Aus der übergebenen Zeichenkette wird ein neues Datum erzeugt. 326 * 327 * @param dateString Das Datum als Zeichenkette. 328 * @param format Formatstring zur Formatierung des Datums {@link https://docs.oracle.com/javase/
3287/docs/api/java/text/SimpleDateFormat.html}. 329 */ 330 static parseDate(dateString, format) 331 { 332 try 333 { 334 const date = dayjs(dateString, this.transformToDayJsFormat(format)); 335 if (date && date.isValid()) 336 return date.toDate(); 337 } 338 catch (e) 339 { 340 if (typeof(HRLogError) === 'function') 341 HRLogError(e); 342 } 343 344 return null; 345 } 346 347 /** 348 * Wandelt das Datumsformat SimpleDateFormat zu einem Day.js (Datumsformat) um. 349 * 350 * @param simpleDateFormat Das Datumsformat. 351 * @return Gibt das Datumsformat der Day.js als Zeichenkette aus. 352 */ 353 static transformToDayJsFormat(simpleDateFormat) 354 { 355 let newDayJsFormat = ""; 356 if (!simpleDateFormat) 357 { 358 return newDayJsFormat; 359 } 360 for (let i = 0; i < simpleDateFormat.length; i++) 361 { 362 switch (simpleDateFormat.charAt(i)) 363 { 364 // Jahr 365 case "y": newDayJsFormat += "Y"; 366 break; 367 // Tag 368 case "d": newDayJsFormat += "D"; 369 break; 370 case "u": 371 case "E": newDayJsFormat += "d"; 372 break; 373 // Zeitzonen 374 case "z": newDayJsFormat += "Z"; 375 break; 376 // AM oder PM 377 case "a": newDayJsFormat += "A"; 378 break; 379 // Trenner: 380 case ".": 381 case "-": 382 case ":": 383 case " ": 384 // Monat 385 case "M": 386 // Stunden 387 case "H": 388 case "h": 389 // Minuten 390 case "m": 391 // Sekunden 392 case "s": 393 // Millisekunden 394 case "S": newDayJsFormat += simpleDateFormat.charAt(i); 395 break; 396 } 397 } 398 return newDayJsFormat; 399 } 400 401 /** 402 * Parst die Zeichenkette eines Datums, welches in einem unserer frameworkinternen Standard-Formate vorliegt: 403 * 404 * <ul> 405 * <li>dd.MM.yyyy</li> 406 * <li>dd.MM.yyyy HH:mm:ss</li> 407 * <li>dd.MM.yyyy HH:mm</li> 408 * <li>dd.MM.yyyy HH</li> 409 * </ul> 410 * 411 * der Zeichenkette findet die Funktion selbstständig heraus, welches Format sie 412 * vor sich liegen hat. 413 * 414 * @param dateString Die Zeichenkette in einem der obigen Formate. 415 * @return Das Date-Objekt oder null, falls etwas beim Parsen schief gelaufen ist (z.B. , 416 * weil man das falsche Format verwendet hat). 417 */ 418 static parseDefaultFormatDate(dateString) 419 { 420 if (dateString) 421 { 422 try 423 { 424 const date = dayjs(dateString.trim(), ['DD.MM.YYYY', 'DD.MM.YYYY HH:mm:ss', 'DD.MM.YYYY HH:mm', 'DD.MM.YYYY HH'], 'de', true); 425 if (date && date.isValid()) 426 return date.toDate(); 427 } 428 catch (e) 429 { 430 if (typeof(HRLogError) === 'function') 431 HRLogError(e); 432 } 433 } 434 435 return null; 436 } 437 438 /** 439 * @see #parseDate. Parst Daten 440 */ 441 static parseDefaultFormatDateTime(dateString) 442 { 443 return this.parseDate(dateString, 'dd.MM.yyyy hh:mm:ss'); 444 } 445 446 /** 447 * Liefert eine Zeichenkette mit einem formatierten Datum zurück. 448 * 449 * @param date Das zu formatierende als Zeichenkette oder als Date-Objekt. 450 * @param format Formatstring zur Formatierung des Datums {@link https://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html}. 451 * @return Das formatierte Datum als Zeichenkette oder eine leere Zeichenkette, falls null übergeben wurde. 452 */ 453 static print(date, format) 454 { 455 try 456 { 457 if (date) 458 return dayjs(date).format(this.transformToDayJsFormat(format)); 459 } 460 catch (e) 461 { 462 if (typeof(HRLogError) === 'function') 463 HRLogError(e); 464 } 465 466 return ""; 467 } 468 469 /** 470 * Liefert das aktuelle Datum und Uhrzeit als Objekt zurück. 471 * 472 * @return Ein Date-Objekt, das dem aktuellen Datum / Uhrzeit entspricht. 473 */ 474 static getNow() 475 { 476 return new Date(); 477 } 478 479 /** 480 * Berechnet die Differenz zweier Zeitpunkte, welche als Datum im deutschen Format 481 * angegeben werden müssen. Das Ergebnis wird in Millisekunden zurückgegeben. 482 * 483 * @param start Startzeitpunkt als Zeichenkette. 484 * @param ende Endzeitpunkt als Zeichenkette. 485 * 486 * @return Differenz der beiden Zeitpunkte in [ms]. 487 */ 488 static getDifferenceInMs(start, ende) 489 { 490 try 491 { 492 return new Date(this.parseDefaultFormatDate(ende) - this.parseDefaultFormatDate(start)).getTime(); 493 } 494 catch(e) 495 { 496 if (typeof(HRLogError) === 'function') 497 HRLogError(e); 498 } 499 } 500 501 /** 502 * Konvertiert Millisekunden zu Minuten. 503 * 504 * @param millis 505 * 506 * @return Minuten [min]. 507 */ 508 static msToMin(millis) 509 { 510 return (millis/(1000*60)); 511 } 512 513 /** 514 * Konvertiert Datum in deutscher Notation zu Millisekunden. 515 * 516 * @param datum Das zu konvertierende Datum. 517 * 518 * @return Datum in [ms]. 519 */ 520 static toMs(datum) 521 { 522 try 523 { 524 var dateParts = datum.replace(/\s/g, ".").replace(/:/g, ".").split("."); 525 return new Date(dateParts[2], dateParts[1]-1, dateParts[0], dateParts[3], dateParts[4]).getTime(); 526 } 527 catch(e) 528 { 529 if (typeof(HRLogError) === 'function') 530 HRLogError(e); 531 } 532 533 return 0; 534 } 535 536 /** 537 * Liefert zu gegebenem Datums-Objekt den passenden String des Wochentages. 538 * 539 * @param alternativeAusgabe Ein Array mit alternativen Ausgabestrings für die Wochentage. Beachte, dass 540 * an erster Stelle der Ausgabestring von Sonntag stehen muss. 541 */ 542 static getDayOfWeekStr(datum) 543 {
544 try 545 { 546 var dayOfWeek = datum.getDay(); 547 return this.DayNames[dayOfWeek]; 548 } 549 catch (e) 550 { 551 if (typeof(HRLogError) === 'function') 552 HRLogError(e); 553 } 554 555 return ""; 556 } 557 558 /** 559 * Liefert den vollen Monatsnamen zum angegebenen Date-Objekt. 560 * 561 * @param Der (volle) Name des Monats. 562 * @param length Die Anzahl der Zeichen des Monats, die maximal angezeigt werden sollen. 563 * @return Der volle Monatsnamen zum angegebenen Date-Objekt. 564 */ 565 static getMonthName(datum, length) 566 { 567 let ausgabe = ""; 568 try 569 { 570 if (datum) 571 { 572 ausgabe = this.MonthNames[datum.getMonth()]; 573 if (length && length > 0 && length < ausgabe.length) 574 ausgabe = ausgabe.substring(0, length); 575 } 576 } 577 catch (e) 578 { 579 if (typeof(HRLogError) === 'function') 580 HRLogError(e); 581 } 582 583 return ausgabe; 584 } 585 586 /** 587 * Überprüft, ob zwei gegebene Daten bis auf die Minute identisch sind. 588 * 589 * @param datum1 Das erste Vergleichsdatum. 590 * @param datum2 Das zweite Vergleichsdatum. 591 * @return true, falls die gegebenen Daten bis auf die Minute übereinstimmen und false, wenn nicht. 592 */ 593 static isSameMinute(datum1, datum2) 594 { 595 try 596 { 597 return (datum1.getFullYear() == datum2.getFullYear() && datum1.getMonth() == datum2.getMonth() && datum1.getDate() == datum2.getDate() && datum1.getHours() == datum2.getHours() && datum1.getMinutes() == datum2.getMinutes()); 598 } 599 catch (e) 600 { 601 if (typeof(HRLogError) === 'function') 602 HRLogError(e); 603 } 604 } 605 606 /** 607 * Gibt abhängig vom jeweiligen Jahr die Anzahl an Tagen des 608 * gewünschten Monats wieder. 609 * 610 * @param month Der gewünschte Monat als Zahl zwischen 0 (= Januar) und 11 (= Dezember) 611 * @param year Das Jahr, zu dem die Zahl der Tage bestimmt werden soll 612 * (nur wichtig für die Bestimmung des Februars im Schaltjahr). 613 * 614 * @return Die Anzahl der Tage des Monats oder -1, falls eine Eingabe nicht korrekt war. 615 */ 616 static getNumberDaysOfMonth(month, year) 617 { 618 if (typeof(month) != "number" || month <= 0 || month > 12 || typeof(year) != "number") 619 return -1; 620 621 try 622 { 623 // Schaltjahr: Februar hat 29 statt 28 Tage. 624 if (this.isLeapYear(year) && month == 2) 625 return 29; 626 627 return this.NumberDaysInMonths[month]; 628 } 629 catch (e) 630 { 631 if (typeof(HRLogError) === 'function') 632 HRLogError(e); 633 } 634 } 635 636 /** 637 * Ermittelt, der wievielte Tag des Jahres das übergebene Datum ist. 638 * 639 * @param datum Das zu prüfende Datum. 640 * @return Die Anzahl Tage, die in diesem Jahr bis zu dem Datum vergangen sind. 641 */ 642 static getDayOfYear(datum) 643 { 644 try 645 { 646 const todayInMs = (new Date(datum.getFullYear(), datum.getMonth(), datum.getDate(), 0, 0, 0)).getTime(); 647 const yearStartInMs = (new Date(datum.getFullYear(), 0, 0, 0, 0, 0)).getTime(); 648 return Math.floor((todayInMs - yearStartInMs)/todayInMs); 649 } 650 catch (e) 651 { 652 if (typeof(HRLogError) === 'function') 653 HRLogError(e); 654 } 655 } 656 657 /** 658 * Prüfung eines Jahres auf ein Schaltjahr. 659 * 660 * @param year das zu prüfende Jahr. 661 * @return true, falls es sich um ein Schaltjahr handelt und false, wenn nicht. 662 */ 663 static isLeapYear(year) 664 { 665 if (typeof(year) === 'integer') 666 return ((year % 400 == 0 || year % 100 != 0) && year % 4 == 0); 667 668 return false; 669 } 670 671 /** 672 * Ermittelt die Anzahl der Kalenderwochen eines Jahres nach dem seit 2006 gültigen Standard ISO 8601 673 * (demnach hat ein Jahr 52 oder 53 Wochen). 674 * 675 * Copyright Mihai Bazon, 2002-2005 | www.bazon.net/mishoo 676 * 677 * @param datum Das zu prüfende Datum. 678 * @return Die Anzahl der Kalenderwochen eines Jahres (52 oder 53). 679 */ 680 static getNumberOfWeeks(datum) 681 { 682 const d = new Date(datum.getFullYear(), datum.getMonth(), datum.getDate(), 0, 0, 0); 683 d.setDate(d.getDate() - (d.getDay() + 6) % 7 + 3); 684 const ms = d.valueOf(); 685 d.setMonth(0); 686 d.setDate(4); // Donnerstag der ersten Woche. 687 return Math.round((ms - d.valueOf()) / (7 * this.DaysInMs)) + 1; 688 } 689 690 /** 691 * Berechnet die Differenz zwischen zwei Daten bezüglich der übergebenen Zeiteinheit (z.B. in Tagen, Monaten, Jahren). 692 * 693 * @param date1 Das erste Datum. 694 * @param date2 Das zweite Datum. 695 * @param unit Die Einheit, in der die Differenz zurückgegeben soll. Siehe hier: https://day.js.org/docs/en/display/difference 696 * @param floatingNumber true, falls eine Kommazahl gewünscht ist. 697 * @returns 698 */ 699 static getTimeDifference(date1, date2, unit, floatingNumber) 700 { 701 return dayjs(date1).diff(dayJsDate2, 'day', floatingNumber); 702 } 703 704 /** 705 * @see #getTimeDifference(date1, date2, unit, floatingNumber). 706 */ 707 static getTimeDifferenceInDays(date1, date2) 708 { 709 this.getTimeDifference(date1, date2, 'day', floatingNumber); 710 } 711 712 /** 713 * @see #getTimeDifference(date1, date2, unit, floatingNumber). 714 */ 715 static getTimeDifferenceInWeeks(date1, date2) 716 { 717 this.getTimeDifference(date1, date2, 'week', floatingNumber); 718 } 719 720 /** 721 * @see #getTimeDifference(date1, date2, unit, floatingNumber). 722 */ 723 static getTimeDifferenceInMonths(date1, date2) 724 { 725 this.getTimeDifference(date1, date2, 'month', floatingNumber); 726 } 727 728 /** 729 * @see #getTimeDifference(date1, date2, unit, floatingNumber). 730 */ 731 static getTimeDifferenceInYears(date1, date2) 732 { 733 this.getTimeDifference(date1, date2, 'year', floatingNumber); 734 } 735 736 /** 737 * Prüft, ob das übergebene Datumsobjekt valide ist. 738 * 739 * @param date Das Datumsobjekt. 740 * @return true, falls das Objekt valide ist. 741 */ 742 static isValidDateObject(date) 743 {
744 try 745 { 746 return date instanceof Date && !isNaN(date) ? true : false; 747 } 748 catch (e) 749 { 750 if (typeof(HRLogError) === 'function') 751 HRLogError(new Error("HRDate.isValidDateObject: Prüfung, ob das übergebene Datum valide ist, ist fehlgeschlagen.")); 752 } 753 754 return false; 755 } 756 757 /** 758 * 759 * Funktion überprüft, ob sich die gegebenen Zeitspannen überlappen. 760 * 761 * @param startPeriod1 Beginn der ersten Zeitspanne. 762 * @param endPeriod1 Ende der ersten Zeitspanne. 763 * @param startPeriod2 Beginn der zweiten Zeitspanne. 764 * @param endPeriod2 Ende der zweiten Zeitspanne. 765 * @return true, wenn sich die Zeiträume überlappen, ansonsten false. 766 */ 767 static isPeriodOverlappingPeriod(startPeriod1, endPeriod1, startPeriod2, endPeriod2) 768 { 769 try 770 { 771 // 772 // Zuerst Prüfung der Eingaben. 773 // 774 if (!startPeriod1 || !endPeriod1 || !startPeriod2 || !endPeriod2) 775 return false; 776 777 // Prüfung auf Überlappung der Zeiträume 778 if (startPeriod1 <= endPeriod2 && startPeriod2 <= endPeriod1) 779 return true; 780 } 781 catch(e) 782 { 783 if (typeof(HRLogError) === 'function') 784 HRLogError(new Error("HRDate.isPeriodOverlappingPeriod: Prüfung, ob sich zwei gegebene Zeitspannen überlappen, ist fehlgeschlagen.")); 785 } 786 return false; 787 } 788 789 /** 790 * Funktion überprüft, ob der Zeitpunkt (durch day, month, year spezifiziert) 791 * innerhalb der Zeitspanne zwischen startPeriod und endPeriod liegt. 792 * Der Anfangs und Endpunkt sind einschliessend gemeint. 793 * 794 * @param startPeriod Anfangspunkt der Zeitspanne. 795 * @param endPeriod Endzeitpunkt der Zeitspanne. 796 * @param day Tagesangabe des Zeitpunkts der getestet werden soll (von 1 beginnend). 797 * @param month Monatsangabe des Zeitpunkts der getestet werden soll (von 1 beginnend). 798 * @param year Jahresangabe des Zeitpunkts der getestet werden soll. 799 * @return true, wenn der Zeitpunkt innerhalb der Zeitspanne liegt ansonsten false. 800 */ 801 static isDateInPeriod(startPeriod, endPeriod, day, month, year) 802 { 803 try 804 { 805 // Zuerst Prüfung der Eingaben. 806 if (startPeriod == null || endPeriod == null || startPeriod > endPeriod) 807 return false; 808 809 const zeitpunkt = new Date(new Date(year, month, day).getTime()); 810 return (startPeriod <= zeitpunkt && endPeriod >= zeitpunkt); 811 } 812 catch(e) 813 { 814 if (typeof(HRLogError) === 'function') 815 HRLogError(new Error("HRIsDateInPeriod: Prüfung, ob sich ein Datum in einer gegebenen Zeitspanne befindet, ist fehlgeschlagen.")); 816 } 817 818 return false; 819 } 820 821 /** 822 * Prüft, ob zwei Datumsobjekte den selben Tag repräsentieren. 823 * 824 * @param date1 Das erste Datumsobjekt für den Vergleich. 825 * @param date2 Das zweite Datumsobjekt für den Vergleich. 826 * @return true, falls es sich um den selben Tag handelt. 827 */ 828 static isSameDay(date1, date2) 829 { 830 try 831 { 832 return (date1.getFullYear() === date2.getFullYear() && date1.getMonth() === date2.getMonth() && date1.getDate() === date2.getDate()); 833 } 834 catch (e) 835 { 836 if (typeof(HRLogError) === 'function') 837 HRLogError(new Error("isSameDay: Prüfung auf den selben Tag fehlgeschlagen.")); 838 } 839 840 return false; 841 } 842 843 /** 844 * Wandelt den übergebenen Wert in ein Javascript Date Objekt. 845 * Zur Zeit werden folgende Datentypen unterstützt: 846 * Date (es wird dateValue zurückgegeben), Array (es wird das erste Element
847 * in ein Date gewandelt, String (es wird parseDate verwendet, 848 * number (die Zahl wird als Millisekunden seit 01.01.1970 interpretiert). 849 * 850 * @param dateValue der Datumswert, der konvertiert werden soll. 851 * @return Das passende Date-Objekt. 852 */ 853 static toDate(dateValue) 854 { 855 let datum = null; 856 857 try 858 { 859 if (dateValue != null) 860 { 861 if (typeof(dateValue) == 'object') 862 { 863 if (dateValue instanceof Date) 864 datum = dateValue; 865 else if (dateValue instanceof Array && dateValue.length > 0) 866 datum = this.toDate(dateValue[0]); 867 } 868 else if (typeof(dateValue) == 'string') 869 datum = this.parseDate(dateValue); 870 else if (typeof(dateValue) == 'number') 871 datum = new Date(dateValue); 872 } 873 } 874 catch (e) 875 { 876 if (typeof(HRLogError) === 'function') 877 HRLogError(e); 878 } 879 880 return datum; 881 } 882 883 /** 884 * Addiert Anzahl Tage zu dem übergebenen Datum dazu und gibt ein neues Date-Objekt zurück. 885 * Das übergebenen Datum wird nicht verändert. 886 * 887 * @param date1 Datum zu dem days Tage dazu addiert werden sollen. 888 * @param days Anzahl Tage (dürfen auch < 0 sein) 889 * @return Ein neues Datums-Objekt. 890 */ 891 static addDays(date1, days) 892 { 893 try 894 { 895 const datum = this.toDate(date1); 896 if (datum != null) 897 return new Date(datum.getFullYear(), datum.getMonth(), datum.getDate() + days, datum.getHours(), datum.getMinutes(), datum.getSeconds()); 898 } 899 catch (e) 900 { 901 if (typeof(HRLogError) === 'function') 902 HRLogError(e); 903 } 904 return date1; 905 } 906 907 /** 908 * Addiert Anzahl Monate zu dem übergebenen Datum dazu und gibt ein neues Date-Objekt zurück. 909 * Das übergebenen Datum wird nicht verändert. 910 * 911 * @param date1 Datum zu dem months Monate dazu addiert werden sollen. 912 * @param months Anzahl Monate (dürfen auch < 0 sein) 913 * @return Ein neues Datums-Objekt. 914 */ 915 static addMonths(date1, months) 916 { 917 try 918 { 919 const datum = this.toDate(date1); 920 if (datum != null) 921 return new Date(datum.getFullYear(), datum.getMonth() + months, datum.getDate(), datum.getHours(), datum.getMinutes(), datum.getSeconds()); 922 } 923 catch (e) 924 { 925 if (typeof(HRLogError) === 'function') 926 HRLogError(e); 927 } 928 return date1; 929 } 930 931 /** 932 * Addiert Anzahl Jahre zu dem übergebenen Datum dazu und gibt ein neues Date-Objekt zurück. 933 * Das übergebenen Datum wird nicht verändert. 934 * 935 * @param date1 Datum zu dem years Jahre dazu addiert werden sollen. 936 * @param years Anzahl Jahre (dürfen auch < 0 sein) 937 * @return Ein neues Datums-Objekt. 938 */ 939 static addYears(date1, years) 940 { 941 try 942 { 943 const datum = this.toDate(date1); 944 if (datum != null) 945 return new Date(datum.getFullYear() + years, datum.getMonth(), datum.getDate(), datum.getHours(), datum.getMinutes(), datum.getSeconds()); 946 } 947 catch (e) 948 { 949 if (typeof(HRLogError) === 'function') 950 HRLogError(e); 951 } 952 return date1; 953 } 954 955 /** 956 * Addiert Anzahl Stunden zu dem übergebenen Datum dazu und gibt ein neues Date-Objekt zurück. 957 * Das übergebenen Datum wird nicht verändert. 958 * 959 * @param date1 Datum zu dem hours Stunden dazu addiert werden sollen. 960 * @param hours Anzahl Stunden (dürfen auch < 0 sein) 961 * @return Ein neues Datums-Objekt. 962 */ 963 static addHours(date1, hours) 964 { 965 try 966 { 967 const datum = this.toDate(date1); 968 if (datum != null) 969 return new Date(datum.getFullYear(), datum.getMonth(), datum.getDate(), datum.getHours() + hours, datum.getMinutes(), datum.getSeconds()); 970 } 971 catch (e) 972 { 973 if (typeof(HRLogError) === 'function') 974 HRLogError(e); 975 } 976 return date1; 977 } 978 979 /** 980 * Addiert Anzahl Minuten zu dem übergebenen Datum dazu und gibt ein neues Date-Objekt zurück. 981 * Das übergebenen Datum wird nicht verändert. 982 * 983 * @param date1 Datum zu dem minutes Minuten dazu addiert werden sollen. 984 * @param minutes Anzahl Minuten (dürfen auch < 0 sein) 985 * @return Ein neues Datums-Objekt. 986 */ 987 static addMinutes(date1, minutes) 988 {
989 try 990 { 991 const datum = this.toDate(date1); 992 if (datum != null) 993 return new Date(datum.getFullYear(), datum.getMonth(), datum.getDate(), datum.getHours(), datum.getMinutes() + minutes, datum.getSeconds()); 994 } 995 catch (e) 996 { 997 if (typeof(HRLogError) === 'function') 998 HRLogError(e); 999 } 1000 return date1; 1001 } 1002 1003 /** 1004 * Addiert Anzahl Sekunden zu dem übergebenen Datum dazu und gibt ein neues Date-Objekt zurück. 1005 * Das übergebenen Datum wird nicht verändert. 1006 * 1007 * @param date1 Datum zu dem seconds Sekunden dazu addiert werden sollen. 1008 * @param seconds Anzahl Sekunden (dürfen auch < 0 sein) 1009 * @return Ein neues Datums-Objekt. 1010 */ 1011 static addSeconds(date1, seconds) 1012 { 1013 try 1014 { 1015 const datum = this.toDate(date1); 1016 if (datum != null) 1017 return new Date(datum.getFullYear(), datum.getMonth(), datum.getDate(), datum.getHours(), datum.getMinutes(), datum.getSeconds() + seconds); 1018 } 1019 catch (e) 1020 { 1021 if (typeof(HRLogError) === 'function') 1022 HRLogError(e); 1023 } 1024 return date1; 1025 } 1026 1027 /** 1028 * Getter für den darauffolgenden Tag. 1029 * 1030 * @param date Das Datum, dessen darauffolgender Tag ermittelt werden soll. 1031 */ 1032 static getNextDay(date) 1033 { 1034 try 1035 { 1036 if (date) 1037 { 1038 const nextDay = new Date(date.getTime()); 1039 nextDay.setDate(nextDay.getDate()+1); 1040 return nextDay; 1041 } 1042 } 1043 catch (e) 1044 { 1045 if (typeof(HRLogError) === 'function') 1046 HRLogError(e); 1047 } 1048 1049 return null; 1050 } 1051 1052 /** 1053 * Prüft, ob das übergebene Datum mit dem morgigen Tag übereinstimmt. 1054 * 1055 * @param Das zu prüfende Datum. 1056 * @return true, falls das übergebene Datum morgen ist. 1057 */ 1058 static isTomorrow(date) 1059 { 1060 try 1061 { 1062 if (date) 1063 { 1064 const tomorrow = this.getNextDay(new Date()); 1065 if (tomorrow) 1066 return (tomorrow && tomorrow.getFullYear() == date.getFullYear() && tomorrow.getMonth() == date.getMonth() && tomorrow.getDate() == date.getDate()) 1067 } 1068 } 1069 catch (e) 1070 { 1071 if (typeof(HRLogError) === 'function') 1072 HRLogError(e); 1073 } 1074 1075 return false; 1076 } 1077 1078 /** 1079 * Die verbleibende Zeit bis zu einem bestimmten Datum bis auf Sekundengenauigkeit. 1080 * 1081 * @param targetDate Das Zieldatum. 1082 * @return Es wird ein Objekt bestehend aus den Zeiteinheiten days, hours, minutes, 1083 * seconds geliefert, welches die Zeitdifferenz repräsentiert. Das Objekt lässt sich 1084 * also beispielhaft folgendermaßen lesen: Bis zum gewünschten Datum sind es noch 3 Tage, 1 Stunde, 1085 * 4 Minuten und 1 Sekunde. 1086 */ 1087 static computeRemainingTime(targetDate) 1088 { 1089 // Default-Rückgabe-Objekt. 1090 const timeDiff = { 1091 days: -1, 1092 hours: -1, 1093 minutes: -1, 1094 seconds: -1 1095 }; 1096 1097 try 1098 { 1099 if (targetDate) 1100 { 1101 const now = new Date(); 1102 const difference = targetDate - now; 1103 timeDiff.days = Math.floor(difference / (1000 * 60 * 60 * 24)); 1104 timeDiff.hours = Math.floor((difference % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60)); 1105 timeDiff.minutes = Math.floor((difference % (1000 * 60 * 60)) / (1000 * 60)); 1106 timeDiff.seconds = Math.floor((difference % (1000 * 60)) / 1000); 1107 } 1108 } 1109 catch (e) 1110 { 1111 if (typeof(HRLogError) === 'function') 1112 HRLogError(e); 1113 } 1114 1115 return timeDiff; 1116 } 1117} 1118 1119/** 1120 * Sammlung von als @deprecated gekennzeichneten Funktionen. Diese werden durch die entsprechenden statischen HRDate-Funktionen ersetzt. 1121 * Achtung: Die Funktionen können nach Einspielen von Version 2.17.0 alle bei den Kunden ersetzt werden und die alten Signaturen 1122 * schließlich entfernt werden. 1123 */ 1124 1125/** 1126 * @deprecated 1127 */ 1128function HRCheckFeiertag(datum, bl) 1129{ 1130 return HRDate.checkFeiertag(datum, bl); 1131} 1132 1133/** 1134 * @deprecated 1135 */ 1136function HRParseDate(dateString) 1137{ 1138 return HRDate.parseDefaultFormatDate(dateString); 1139} 1140 1141/** 1142 * @deprecated 1143 */ 1144function HRFormatDate(dateString) 1145{ 1146 return HRDate.print(dateString, 'dd.MM.yyyy'); 1147}
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.