@acorex/core 5.0.4 → 5.0.5

package/src/lib/dateTime/georgian.calendar.ts

@@ -0,0 +1,157 @@
+import { AXCalendar, AXDateTime, TimeUnit } from "./datetime.class";
+
+export class GeorgianCalendar implements AXCalendar {
+
+    monthNames = [
+        "January", "February", "March",
+        "April", "May", "June", "July",
+        "August", "September", "October",
+        "November", "December"
+    ];
+
+    monthShortNames = [
+        "Jan", "Feb", "Mar",
+        "Apr", "May", "Jun", "Jul",
+        "Aug", "Sep", "Oct",
+        "Nov", "Dec"
+    ];
+
+    dayNames = [
+        "Sunday", "Monday", "Tuesday", "Wednesday",
+        "Thursday", "Friday", "Saturday"
+    ];
+
+    dayShortNames = [
+        "Sun", "Mon", "Tue", "Wed",
+        "Thu", "Fri", "Sat"
+    ];
+
+    name(): string {
+        return 'gregorian'
+    }
+
+    dayInMonth(date: Date): number {
+        return date.getDate();
+    }
+
+    dayOfYear(date: Date): number {
+        const start = +new Date(date.getFullYear(), 0, 0);
+        const diff = +date - start;
+        const oneDay = 1000 * 60 * 60 * 24;
+        return Math.floor(diff / oneDay);
+    }
+
+    dayInWeek(date: Date): number {
+        return date.getDay() + 1;
+    }
+
+    year(date: Date): number {
+        return date.getFullYear();
+    }
+
+    monthOfYear(date: Date): number {
+        return date.getMonth() + 1;
+    }
+
+    add(date: Date, unit: TimeUnit, amount: number): AXDateTime {
+        let value = date.valueOf();
+        switch (unit) {
+            case 'second':
+                value += 1000 * amount;
+                break
+            case 'minute':
+                value += 60000 * amount;
+                break
+            case 'hour':
+                value += 3600000 * amount;
+                break
+            case 'month':
+                const v = new Date(value);
+                var mo = date.getMonth();
+                var yr = date.getFullYear();
+                mo = (mo + amount) % 12;
+                if (0 > mo) {
+                    yr += (date.getMonth() + amount - mo - 12) / 12;
+                    mo += 12;
+                }
+                else
+                    yr += ((date.getMonth() + amount - mo) / 12);
+                v.setMonth(mo);
+                v.setFullYear(yr);
+                value = v.valueOf();
+                break
+            case 'week':
+                value += 7 * 86400000 * amount;
+                break
+            case 'year':
+                const yv = new Date(value);
+                yv.setFullYear(yv.getFullYear() + amount);
+                value = v.valueOf();
+                break
+            case 'day':
+            default:
+                value += 86400000 * amount;
+        }
+        return new AXDateTime(new Date(value), this.name());
+    }
+
+    set(date: Date, unit: TimeUnit, value: number): AXDateTime {
+        throw new Error("Method not implemented.");
+    }
+
+    startOf(date: Date, unit: TimeUnit): AXDateTime {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), clone.getSeconds(), 0);
+                return new AXDateTime(clone, this.name());
+            case 'minute':
+                clone.setHours(clone.getHours(), clone.getMinutes(), 0, 0);
+                return new AXDateTime(clone, this.name());
+            case 'hour':
+                clone.setHours(clone.getHours(), 0, 0, 0);
+                return new AXDateTime(clone, this.name());
+            default:
+            case 'day':
+                clone.setHours(0, 0, 0, 0);
+                return new AXDateTime(clone, this.name());
+            case "week":
+                const diff = clone.getDate() - clone.getDay() + (clone.getDay() === 0 ? -6 : 1);
+                clone.setDate(diff)
+                return new AXDateTime(clone, this.name()).startOf('day');
+            case "month":
+                clone.setDate(1)
+                return new AXDateTime(clone, this.name()).startOf('day');
+            case "year":
+                clone.setMonth(0);
+                clone.setDate(1);
+                return new AXDateTime(clone, this.name()).startOf('day');
+        }
+    }
+
+    endOf(date: Date, unit: TimeUnit): AXDateTime {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), clone.getSeconds(), 999);
+                return new AXDateTime(clone, this.name());
+            case 'minute':
+                clone.setHours(clone.getHours(), clone.getMinutes(), 59, 999);
+                return new AXDateTime(clone, this.name());
+            case 'hour':
+                clone.setHours(clone.getHours(), 59, 59, 999);
+                return new AXDateTime(clone, this.name());
+            default:
+            case 'day':
+                clone.setHours(23, 59, 59, 999);
+                return new AXDateTime(clone, this.name());
+            case 'week':
+                return this.startOf(date, 'week').add('day', 6).endOf('day');
+            case 'month':
+                return new AXDateTime(new Date(date.getFullYear(), date.getMonth() + 1, 0), this.name()).endOf('day');
+            case "year":
+                clone.setMonth(11);
+                return new AXDateTime(clone, this.name()).endOf('month');
+        }
+    }
+}

package/{lib/dateTime/index.d.ts → src/lib/dateTime/index.ts}

@@ -1,4 +1,4 @@
-export * from './datetime.class';
-export * from './datetime.module';
-export * from './datetime.pipe';
-export * from './georgian.calendar';
+export * from './datetime.class';
+export * from './datetime.module';
+export * from './datetime.pipe';
+export * from './georgian.calendar';

package/src/lib/dateTime/jalali.calendar.ts

@@ -0,0 +1,376 @@
+import { AXCalendar, AXDateTime, TimeUnit } from "./datetime.class";
+
+export class JalaliCalendar implements AXCalendar {
+
+    monthNames = ("فروردین_اردیبهشت_خرداد_تیر_مرداد_شهریور_مهر_آبان_آذر_دی_بهمن_اسفند").split("_");
+
+    monthShortNames = ("فروردین_اردیبهشت_خرداد_تیر_مرداد_شهریور_مهر_آبان_آذر_دی_بهمن_اسفند").split("_");
+
+    dayNames = ("شنبه_یکشنبه_دوشنبه_سه شنبه_چهارشنبه_پنج شنبه_جمعه").split("_");
+
+    dayShortNames = "ش_ی_د_س_چ_پ_ج".split("_")
+
+    name(): string {
+        return 'jalali'
+    }
+
+    dayInMonth(date: Date): number {
+        return this.toJalali(date).day;
+    }
+
+    dayOfYear(date: Date): number {
+        const j = this.toJalali(date);
+        return (j.month <= 6 ? ((j.month - 1) * 31) : ((6 * 31) + (j.month - 7) * 30)) + j.day;
+    }
+
+    dayInWeek(date: Date): number {
+        return date.getDay() == 6 ? 1 : date.getDay() + 2;
+    }
+
+    year(date: Date): number {
+        return this.toJalali(date).year;
+    }
+
+    monthOfYear(date: Date): number {
+        return this.toJalali(date).month;
+    }
+
+
+    add(date: Date, unit: TimeUnit, amount: number): AXDateTime {
+        let value = date.valueOf();
+        switch (unit) {
+            case 'second':
+                value += 1000 * amount;
+                break
+            case 'minute':
+                value += 60000 * amount;
+                break
+            case 'hour':
+                value += 3600000 * amount;
+                break
+            case 'month':
+                {
+                    const v = new Date(value);
+                    let jd = this.dayInMonth(date);
+                    let jm = this.monthOfYear(date);
+                    let jy = this.year(date);
+                    jm = (jm + amount) % 12;
+                    if (0 > jm) {
+                        jy += (this.monthOfYear(date) + amount - jm - 12) / 12;
+                        jm += 12;
+                    }
+                    else {
+                        jy += ((this.monthOfYear(date) + amount - jm) / 12);
+                    }
+                    const vv = this.toGregorian(jy, jm, jd);
+                    v.setFullYear(vv.getFullYear());
+                    v.setMonth(vv.getMonth());
+                    v.setDate(vv.getDate());
+                    value = v.valueOf();
+                    break
+                }
+            case 'week':
+                value += 7 * 86400000 * amount;
+                break
+            case 'year':
+                {
+                    const v = new Date(value);
+                    let jd = this.dayInMonth(date);
+                    let jm = this.monthOfYear(date);
+                    let jy = this.year(date);
+                    const vv = this.toGregorian(jy + amount, jm, jd);
+                    v.setFullYear(vv.getFullYear());
+                    v.setMonth(vv.getMonth());
+                    v.setDate(vv.getDate());
+                    value = v.valueOf();
+                }
+                break
+            case 'day':
+            default:
+                value += 86400000 * amount;
+        }
+        return new AXDateTime(new Date(value), this.name());
+    }
+
+    set(date: Date, unit: TimeUnit, value: number): AXDateTime {
+        throw new Error("Method not implemented.");
+    }
+
+    startOf(date: Date, unit: TimeUnit): AXDateTime {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), clone.getSeconds(), 0);
+                return new AXDateTime(clone, this.name());
+            case 'minute':
+                clone.setHours(clone.getHours(), clone.getMinutes(), 0, 0);
+                return new AXDateTime(clone, this.name());
+            case 'hour':
+                clone.setHours(clone.getHours(), 0, 0, 0);
+                return new AXDateTime(clone, this.name());
+            default:
+            case 'day':
+                clone.setHours(0, 0, 0, 0);
+                return new AXDateTime(clone, this.name());
+            case "week":
+                return new AXDateTime(clone, this.name()).add('day', -this.dayInWeek(clone) + 1).startOf('day');
+            case "month":
+                {
+                    const jy = this.year(date);
+                    const jm = this.monthOfYear(date);
+                    const gDate = this.toGregorian(jy, jm, 1);
+                    return new AXDateTime(gDate, this.name()).startOf('day');
+                }
+            case "year":
+                {
+                    const jy = this.year(date);
+                    const gDate = this.toGregorian(jy, 1, 1);
+                    return new AXDateTime(gDate, this.name()).startOf('day');
+                }
+        }
+    }
+
+    endOf(date: Date, unit: TimeUnit): AXDateTime {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), clone.getSeconds(), 999);
+                return new AXDateTime(clone, this.name());
+            case 'minute':
+                clone.setHours(clone.getHours(), clone.getMinutes(), 59, 999);
+                return new AXDateTime(clone, this.name());
+            case 'hour':
+                clone.setHours(clone.getHours(), 59, 59, 999);
+                return new AXDateTime(clone, this.name());
+            default:
+            case 'day':
+                clone.setHours(23, 59, 59, 999);
+                return new AXDateTime(clone, this.name());
+            case 'week':
+                {
+                    return this.startOf(date, 'week').add('day', 6).endOf('day');
+                }
+            case 'month':
+                {
+                    const jy = this.year(date);
+                    const jm = this.monthOfYear(date);
+                    const jd = this.monthLength(jy, jm);
+                    const gDate = this.toGregorian(jy, jm, jd);
+                    return new AXDateTime(gDate, this.name()).endOf('day');
+                }
+            case "year":
+                let jy = this.year(date);
+                const gDate = this.toGregorian(jy, 12, this.monthLength(jy, 12));
+                return new AXDateTime(gDate, this.name()).endOf('day');
+        }
+    }
+
+
+
+    toJalali(date: Date): { year: number, month: number, day: number } {
+        const gy = date.getFullYear();
+        const gm = date.getMonth() + 1;
+        const gd = date.getDate();
+        const r = this.d2j(this.g2d(gy, gm, gd))
+        return {
+            year: r.jy,
+            month: r.jm,
+            day: r.jd,
+        }
+    }
+
+    /*
+      Converts a Jalaali date to Gregorian.
+    */
+    toGregorian(jy, jm, jd) {
+        const g = this.d2g(this.j2d(jy, jm, jd))
+        return new Date(g.gy, g.gm - 1, g.gd);
+    }
+
+    /*
+      Checks whether a Jalaali date is valid or not.
+    */
+    isValid(jy, jm, jd) {
+        return jy >= -61 && jy <= 3177 &&
+            jm >= 1 && jm <= 12 &&
+            jd >= 1 && jd <= this.monthLength(jy, jm)
+    }
+
+    /*
+      Is this a leap year or not?
+    */
+    isLeapYear(jy) {
+        return this.jalCal(jy).leap === 0
+    }
+
+    /*
+      Number of days in a given month in a Jalaali year.
+    */
+    monthLength(jy, jm) {
+        if (jm <= 6) return 31
+        if (jm <= 11) return 30
+        if (this.isLeapYear(jy)) return 30
+        return 29
+    }
+
+
+    private jalCal(jy) {
+        // Jalaali years starting the 33-year rule.
+        let breaks = [-61, 9, 38, 199, 426, 686, 756, 818, 1111, 1181, 1210
+            , 1635, 2060, 2097, 2192, 2262, 2324, 2394, 2456, 3178
+        ]
+            , bl = breaks.length
+            , gy = jy + 621
+            , leapJ = -14
+            , jp = breaks[0]
+            , jm
+            , jump
+            , leap
+            , leapG
+            , march
+            , n
+            , i
+
+        if (jy < jp || jy >= breaks[bl - 1])
+            throw new Error('Invalid Jalaali year ' + jy)
+
+        // Find the limiting years for the Jalaali year jy.
+        for (i = 1; i < bl; i += 1) {
+            jm = breaks[i]
+            jump = jm - jp
+            if (jy < jm)
+                break
+            leapJ = leapJ + this.div(jump, 33) * 8 + this.div(this.mod(jump, 33), 4)
+            jp = jm
+        }
+        n = jy - jp
+
+        // Find the number of leap years from AD 621 to the beginning
+        // of the current Jalaali year in the Persian calendar.
+        leapJ = leapJ + this.div(n, 33) * 8 + this.div(this.mod(n, 33) + 3, 4)
+        if (this.mod(jump, 33) === 4 && jump - n === 4)
+            leapJ += 1
+
+        // And the same in the Gregorian calendar (until the year gy).
+        leapG = this.div(gy, 4) - this.div((this.div(gy, 100) + 1) * 3, 4) - 150
+
+        // Determine the Gregorian date of Farvardin the 1st.
+        march = 20 + leapJ - leapG
+
+        // Find how many years have passed since the last leap year.
+        if (jump - n < 6)
+            n = n - jump + this.div(jump + 4, 33) * 33
+        leap = this.mod(this.mod(n + 1, 33) - 1, 4)
+        if (leap === -1) {
+            leap = 4
+        }
+
+        return {
+            leap: leap
+            , gy: gy
+            , march: march
+        }
+    }
+
+    /*
+      Converts a date of the Jalaali calendar to the Julian Day number.
+      @param jy Jalaali year (1 to 3100)
+      @param jm Jalaali month (1 to 12)
+      @param jd Jalaali day (1 to 29/31)
+      @return Julian Day number
+    */
+    private j2d(jy, jm, jd) {
+        let r = this.jalCal(jy)
+        return this.g2d(r.gy, 3, r.march) + (jm - 1) * 31 - this.div(jm, 7) * (jm - 7) + jd - 1
+    }
+
+    /*
+      Converts the Julian Day number to a date in the Jalaali calendar.
+      @param jdn Julian Day number
+      @return
+        jy: Jalaali year (1 to 3100)
+        jm: Jalaali month (1 to 12)
+        jd: Jalaali day (1 to 29/31)
+    */
+    private d2j(jdn) {
+        let gy = this.d2g(jdn).gy // Calculate Gregorian year (gy).
+            , jy = gy - 621
+            , r = this.jalCal(jy)
+            , jdn1f = this.g2d(gy, 3, r.march)
+            , jd
+            , jm
+            , k
+
+        // Find number of days that passed since 1 Farvardin.
+        k = jdn - jdn1f
+        if (k >= 0) {
+            if (k <= 185) {
+                // The first 6 months.
+                jm = 1 + this.div(k, 31)
+                jd = this.mod(k, 31) + 1
+                return {
+                    jy: jy
+                    , jm: jm
+                    , jd: jd
+                }
+            } else {
+                // The remaining months.
+                k -= 186
+            }
+        } else {
+            // Previous Jalaali year.
+            jy -= 1
+            k += 179
+            if (r.leap === 1)
+                k += 1
+        }
+        jm = 7 + this.div(k, 30)
+        jd = this.mod(k, 30) + 1
+        return {
+            jy: jy
+            , jm: jm
+            , jd: jd
+        }
+    }
+
+
+    private g2d(gy, gm, gd) {
+        let d = this.div((gy + this.div(gm - 8, 6) + 100100) * 1461, 4)
+            + this.div(153 * this.mod(gm + 9, 12) + 2, 5)
+            + gd - 34840408
+        d = d - this.div(this.div(gy + 100100 + this.div(gm - 8, 6), 100) * 3, 4) + 752
+        return d
+    }
+
+
+    private d2g(jdn) {
+        let j
+            , i
+            , gd
+            , gm
+            , gy
+        j = 4 * jdn + 139361631
+        j = j + this.div(this.div(4 * jdn + 183187720, 146097) * 3, 4) * 4 - 3908
+        i = this.div(this.mod(j, 1461), 4) * 5 + 308
+        gd = this.div(this.mod(i, 153), 5) + 1
+        gm = this.mod(this.div(i, 153), 12) + 1
+        gy = this.div(j, 1461) - 100100 + this.div(8 - gm, 6)
+        return {
+            gy: gy
+            , gm: gm
+            , gd: gd
+        }
+    }
+
+    /*
+      Utility helper functions.
+    */
+    private div(a, b) {
+        return ~~(a / b)
+    }
+
+    private mod(a, b) {
+        return a - ~~(a / b) * b
+    }
+
+}

package/src/lib/http/http-error.class.ts

@@ -0,0 +1,7 @@
+export interface IHttpError {
+    message?: string;
+    status?: number;
+    code?: string;
+    handled: boolean;
+    error: any | null
+}

package/src/lib/http/http-events.interceptor.ts

@@ -0,0 +1,14 @@
+import { IHttpError } from './http-error.class';
+import { InjectionToken } from '@angular/core';
+import { AXHttpRequestOptions } from './http-request.class';
+
+export const AX_HTTP_EVENT_INTERCEPTOR = new InjectionToken<AXHttpEventInterceptor>('ax.http.events');
+
+export interface AXHttpEventInterceptor {
+    begin(request: AXHttpRequestOptions): Promise<AXHttpRequestOptions>;
+    success(request: AXHttpRequestOptions, result: any): Promise<any>;
+    complete(request: AXHttpRequestOptions);
+    error(request: AXHttpRequestOptions, error: IHttpError);
+}
+
+

package/src/lib/http/http-request.class.ts

@@ -0,0 +1,14 @@
+export interface AXHttpRequestOptions {
+    url?: any,
+    params?: {
+        [param: string]: any;
+    },
+    body?: {
+        [param: string]: any;
+    },
+    headers?: {
+        [header: string]: any;
+    },
+    method?: 'get' | 'post' | 'put' | 'delete';
+    responseType?: any;
+}

package/src/lib/http/http-result.class.ts

@@ -0,0 +1,34 @@
+import { IHttpError } from './http-error.class';
+
+export class HttpResult<T> {
+    private _executor: (result: (e?: T) => void, error: (e?: IHttpError) => void, complete: () => void) => void;
+    constructor(
+        executor: (
+            result: (e?: T) => void,
+            error: (e?: IHttpError) => void,
+            complete: () => void
+        ) => void
+    ) {
+        this._executor = executor;
+        setTimeout(() => {
+            this._executor(this.resultAction, this.errorAction, this.completeAction);
+        }, 50);
+    }
+
+    private resultAction: (e?: T) => void;
+    private errorAction: (e?: IHttpError) => void;
+    private completeAction: () => void;
+
+    result(action: (e?: T) => void): HttpResult<T> { 
+        this.resultAction = action;
+        return this;
+    }
+    error(action: (e?: IHttpError) => void): HttpResult<T> {
+        this.errorAction = action;
+        return this;
+    }
+    complete(action: () => void): HttpResult<T> {
+        this.completeAction = action;
+        return this;
+    }
+}

package/src/lib/http/http.module.ts

@@ -0,0 +1,25 @@
+import { NgModule, ModuleWithProviders } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HttpClientModule } from '@angular/common/http';
+import { AXHttpService } from './http.service';
+
+
+@NgModule({
+  declarations: [],
+  imports: [
+    CommonModule,
+    HttpClientModule
+  ],
+  exports: [HttpClientModule],
+  providers: [
+    AXHttpService
+  ]
+})
+export class AXHttpModule {
+  static forRoot(): ModuleWithProviders {
+    return {
+      ngModule: AXHttpModule,
+      providers: [AXHttpService]
+    };
+  }
+}