@esolve/ng-esolve-connect 0.6.1 → 0.7.3

package/lib/account/esolve-address-set-data.d.ts

@@ -0,0 +1,17 @@
+import { EsolveAddressType } from './esolve-address-record';
+export interface EsolveAddressPostData {
+    addresses_id?: number;
+    recipient?: string;
+    address_type?: EsolveAddressType;
+    pobox?: string;
+    place_name?: string;
+    street_number?: string | number;
+    street?: string;
+    suburb?: string;
+    sub_region?: string;
+    city?: string;
+    province?: string;
+    country?: string;
+    postal_code?: string;
+    description?: string;
+}

package/lib/account/esolve-geocode-result.d.ts

@@ -0,0 +1,16 @@
+export interface EsolveGeocodeResult {
+    status: string;
+    checksum: string;
+    cached: boolean;
+    error_message?: string;
+    formatted_address?: string;
+    street_number?: string;
+    street?: string;
+    suburb?: string;
+    city?: string;
+    province?: string;
+    country?: string;
+    postal_code?: string;
+    latitude?: number;
+    longitude?: number;
+}

package/lib/account/esolve-registration-post-response-item.d.ts

@@ -0,0 +1,7 @@
+import { EsolvePostResponseItem } from '../shared/esolve-response';
+export interface EsolveRegistrationPostResponseItem extends EsolvePostResponseItem {
+    esolve_id: number;
+    guest: boolean;
+    authentication_required: boolean;
+    auto_login: boolean;
+}

package/lib/account/esolve-registration-result.d.ts

@@ -0,0 +1,9 @@
+import { EsolveResponseResult } from '../shared/response-handler/esolve-response-result';
+import { EsolveRegistrationPostResponseItem } from './esolve-registration-post-response-item';
+export declare class EsolveRegistrationResult extends EsolveResponseResult {
+    user_id: number;
+    guest: boolean;
+    authentication_required: boolean;
+    auto_login: boolean;
+    constructor(response: EsolveRegistrationPostResponseItem);
+}

package/lib/account/esolve-user-account-data.d.ts

@@ -0,0 +1,17 @@
+export interface EsolveUserAccountData {
+    email?: string;
+    loyaltynumber?: string;
+    title?: string;
+    initials?: string;
+    firstname?: string;
+    surname?: string;
+    idnumber?: string;
+    telnumber?: string;
+    cellnumber?: string;
+    fax?: string;
+    busname?: string;
+    vatnum?: string;
+    busdescript?: string;
+    business_type?: string;
+    registration_type?: string;
+}

package/lib/account/esolve-user-account-record.d.ts

@@ -0,0 +1,21 @@
+export interface EsolveUserAccountRecord {
+    userid: number;
+    email: string;
+    registration_type: string;
+    account: string;
+    loyaltynumber: string;
+    gender: string;
+    title: string;
+    initials: string;
+    firstname: string;
+    surname: string;
+    idnumber: string;
+    telnumber: string;
+    cellnumber: string;
+    fax: string;
+    busname: string;
+    vatnum: string;
+    busdescript: string;
+    business_type: string;
+    language: string;
+}

package/lib/account/esolve-user-account-result.d.ts

@@ -0,0 +1,6 @@
+import { EsolvePostResponseItem } from '../shared/esolve-response';
+import { EsolveResponseResult } from '../shared/response-handler/esolve-response-result';
+export declare class EsolveUserAccountResult extends EsolveResponseResult {
+    id: number;
+    constructor(response: EsolvePostResponseItem);
+}

package/lib/account/esolve-user-account.d.ts

@@ -0,0 +1,29 @@
+export declare class EsolveUserAccount {
+    esolve_id: number;
+    email: string;
+    registration_type: string;
+    title: string;
+    first_name: string;
+    last_name: string;
+    initials: string;
+    gender: string;
+    identification_number: string;
+    account_number?: string;
+    loyalty_number?: string;
+    business_details?: EsolveUserAccountBusiness;
+    contact_details?: EsolveUserAccountContact;
+    constructor(esolve_id: number, email: string, registration_type: string, title: string, first_name: string, last_name: string, initials: string, gender: string, identification_number: string);
+}
+export declare class EsolveUserAccountBusiness {
+    name: string;
+    vat_number: string;
+    description: string;
+    type: string;
+    constructor(name: string, vat_number: string, description: string, type: string);
+}
+export declare class EsolveUserAccountContact {
+    tel_number?: string | undefined;
+    cell_number?: string | undefined;
+    fax_number?: string | undefined;
+    constructor(tel_number?: string | undefined, cell_number?: string | undefined, fax_number?: string | undefined);
+}

package/lib/auth/esolve-auth-interceptor.service.d.ts

@@ -1,7 +1,7 @@
 import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { EsolveConnectConfig } from '../esolve-connect.config';
-import { EsolveSessionService } from './esolve-session.service';
+import { EsolveSessionService } from '../session/esolve-session.service';
 import * as i0 from "@angular/core";
 export declare class EsolveAuthInterceptorService implements HttpInterceptor {
     private config;

package/lib/auth/esolve-auth.service.d.ts

@@ -1,7 +1,8 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
+import { CookieService } from 'ngx-cookie-service';
 import { EsolveConnectConfig } from '../esolve-connect.config';
-import { EsolveSessionService } from './esolve-session.service';
+import { EsolveSessionService } from '../session/esolve-session.service';
 import { EsolveErrorHandlerService } from '../shared/error-handler/esolve-error-handler.service';
 import * as i0 from "@angular/core";
 interface EsolveAuthResponseData {
@@ -21,12 +22,13 @@ export declare class EsolveAuthService {
     private http;
     private session;
     private errorHandler;
-    constructor(config: EsolveConnectConfig, http: HttpClient, session: EsolveSessionService, errorHandler: EsolveErrorHandlerService);
+    private cookieService;
+    constructor(config: EsolveConnectConfig, http: HttpClient, session: EsolveSessionService, errorHandler: EsolveErrorHandlerService, cookieService: CookieService);
     private checkAccessToken;
     getAccessToken(email: string, password: string, anonymous?: boolean): Observable<EsolveAuthResponseData>;
     autoLogin(): void;
     login(email: string, password: string): Observable<number>;
-    logout(): void;
+    logout(): Promise<EsolveAuthResponseData>;
     private handleExpiration;
     private handleAuthentication;
     private handleError;

package/lib/cart/esolve-cart.service.d.ts

@@ -1,54 +1,26 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveErrorHandlerService } from '../shared/error-handler/esolve-error-handler.service';
+import { EsolveResponseHandlerService } from '../shared/response-handler/esolve-response-handler.service';
 import { EsolveCart, EsolveCartSetAction, EsolveCartSetItem } from './esolve-cart-item';
 import { EsolveCartItemResponse } from './esolve-cart-item-response';
-import { EsolveStockLocation } from './esolve-stock-location';
-import { EsolvePaymentMethod } from './esolve-payment-method';
-import { EsolvePaymentMethodOptions } from './esolve-payment-method-record';
-import { EsolveShippingMethod } from './esolve-shipping-method';
-import { EsolveShippingMethodOptions } from './esolve-shipping-method-record';
-import { EsolveShippingCost } from './esolve-shipping-cost';
-import { EsolveShippingCostOptions } from './esolve-shipping-cost-record';
 import { EsolveCartTotals } from './esolve-cart-totals';
-import { EsolveErrorHandlerService } from '../shared/error-handler/esolve-error-handler.service';
+import { EsolveCheckoutResult } from './esolve-checkout-result';
 import * as i0 from "@angular/core";
 export declare class EsolveCartService {
     private config;
     private http;
     private errorHandler;
+    private responseHandler;
     private _cached_tracking;
-    constructor(config: EsolveConnectConfig, http: HttpClient, errorHandler: EsolveErrorHandlerService);
+    constructor(config: EsolveConnectConfig, http: HttpClient, errorHandler: EsolveErrorHandlerService, responseHandler: EsolveResponseHandlerService);
     /**
      * Processes the eSolve tree records.
      * @param cart_item_records Records to process
      * @returns An array of processed cart items
      */
     private processCart;
-    /**
-     * Processes the eSolve stock location records.
-     * @param records Records to process
-     * @returns An array of processed stock location records
-     */
-    private processStockLocations;
-    /**
-     * Processes the eSolve shipping method records.
-     * @param records Records to process
-     * @returns An array of processed shipping methods
-     */
-    private processShippingMethods;
-    /**
-     * Processes the eSolve payment method records.
-     * @param records Records to process
-     * @returns An array of processed payment methods.
-     */
-    private processPaymentMethods;
-    /**
-     * Processes the eSolve shipping costs record.
-     * @param record Data to process
-     * @returns Processed shipping costs
-     */
-    private processShippingCost;
     /**
      * Processes the eSolve cart totals
      * @param record Data to process
@@ -67,27 +39,6 @@ export declare class EsolveCartService {
      * @returns An `Observable` with an array of responses that gives feedback on the requested changes
      */
     setCart(items: EsolveCartSetItem[], action?: EsolveCartSetAction): Observable<EsolveCartItemResponse[]>;
-    /**
-     * Retrieves a list of stock locations
-     * @returns An `Observable` with an array of stock locations
-     */
-    getStockLocations(): Observable<EsolveStockLocation[]>;
-    /**
-     * Retrieves a list of shipping methods
-     * @returns An `Observable` with an array of shipping methods
-     */
-    getShippingMethods(options?: EsolveShippingMethodOptions): Observable<EsolveShippingMethod[]>;
-    /**
-     * Retrieves a list of payment methods
-     * @returns  An `Observable` with an array of payment methods
-     */
-    getPaymentMethods(options?: EsolvePaymentMethodOptions): Observable<EsolvePaymentMethod[]>;
-    /**
-     * Retrieves the shipping costs
-     * @param options Shipping cost options
-     * @returns An `Observable` with the shipping costs
-     */
-    getShippingCost(options: EsolveShippingCostOptions): Observable<EsolveShippingCost>;
     /**
      * Retrieves the totals of the cart with all the totals calculated
      * @returns An `Observable` with an object containing cart totals
@@ -108,7 +59,7 @@ export declare class EsolveCartService {
      * @param comments Additional comments on the cart
      * @returns An `Observable` with the transaction ID
      */
-    checkout(type: 'order' | 'quote', addresses_id: number, shipping_id: number, payment_method_id?: number, location_id?: number, comments?: string): Observable<number>;
+    checkout(type: 'order' | 'quote', addresses_id: number, shipping_id: number, payment_method_id?: number, location_id?: number, comments?: string): Observable<EsolveCheckoutResult>;
     static ɵfac: i0.ɵɵFactoryDeclaration<EsolveCartService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<EsolveCartService>;
 }

package/lib/cart/esolve-checkout-result.d.ts

@@ -0,0 +1,6 @@
+import { EsolveResponseResult } from '../shared/response-handler/esolve-response-result';
+import { EsolveCheckoutResponse } from './esolve-checkout';
+export declare class EsolveCheckoutResult extends EsolveResponseResult {
+    id: number;
+    constructor(response: EsolveCheckoutResponse);
+}

package/lib/locations/esolve-locations.service.d.ts

@@ -0,0 +1,23 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveStockLocation } from './esolve-stock-location';
+import * as i0 from "@angular/core";
+export declare class EsolveLocationsService {
+    private config;
+    private http;
+    constructor(config: EsolveConnectConfig, http: HttpClient);
+    /**
+     * Processes the eSolve stock location records.
+     * @param records Records to process
+     * @returns An array of processed stock location records
+     */
+    private processStockLocations;
+    /**
+     * Retrieves a list of stock locations
+     * @returns An `Observable` with an array of stock locations
+     */
+    getStockLocations(): Observable<EsolveStockLocation[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsolveLocationsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EsolveLocationsService>;
+}

package/lib/payment/esolve-card-data.d.ts

@@ -0,0 +1,7 @@
+export interface EsolveCardData {
+    card_number: string;
+    name: string;
+    cvv: string;
+    expiry_month: string;
+    expiry_year: string;
+}

package/lib/payment/esolve-payment-method-options.d.ts

@@ -0,0 +1,5 @@
+export interface EsolvePaymentMethodOptions {
+    live?: boolean;
+    location_id?: number;
+    is_gateway?: boolean;
+}

package/lib/{cart → payment}/esolve-payment-method-record.d.ts

@@ -40,8 +40,3 @@ export interface EsolvePaymentMethodRecord {
     sort_priority: number;
     image_url: string;
 }
-export interface EsolvePaymentMethodOptions {
-    live?: boolean;
-    location_id?: number;
-    is_gateway?: boolean;
-}

package/lib/{cart → payment}/esolve-payment-method.d.ts

@@ -33,10 +33,10 @@ export declare class EsolvePaymentMethod {
     on_account: boolean;
     sort_priority: number;
     image_url: string;
-    banking_details: BankingDetails;
+    banking_details: EsolveBankingDetails;
     constructor(record: EsolvePaymentMethodRecord);
 }
-export declare class BankingDetails {
+export declare class EsolveBankingDetails {
     bank_name: string;
     account_holder: string;
     account: string;

package/lib/payment/esolve-payment-response.d.ts

@@ -0,0 +1,13 @@
+import { EsolvePostResponseItem } from '../shared/esolve-response';
+export interface EsolvePaymentResponse extends EsolvePostResponseItem {
+    esolve_id: number;
+    gateway_error_message?: string;
+    three_d_secure?: boolean;
+    redirect_url?: string;
+    form_inputs?: EsolvePaygateFormInput[];
+    form_html?: string;
+}
+export interface EsolvePaygateFormInput {
+    key: string;
+    value: string;
+}

package/lib/payment/esolve-payment-result.d.ts

@@ -0,0 +1,10 @@
+import { EsolveResponseResult } from '../shared/response-handler/esolve-response-result';
+import { EsolvePaygateFormInput, EsolvePaymentResponse } from './esolve-payment-response';
+export declare class EsolvePaymentResult extends EsolveResponseResult {
+    gateway_error_message?: string;
+    three_d_secure?: boolean;
+    redirect_url?: string;
+    form_inputs?: EsolvePaygateFormInput[];
+    form_html?: string;
+    constructor(response: EsolvePaymentResponse);
+}

package/lib/payment/esolve-payment.service.d.ts

@@ -0,0 +1,61 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveErrorHandlerService } from '../shared/error-handler/esolve-error-handler.service';
+import { EsolveResponseHandlerService } from '../shared/response-handler/esolve-response-handler.service';
+import { EsolvePaymentMethod } from './esolve-payment-method';
+import { EsolvePaymentMethodOptions } from './esolve-payment-method-options';
+import { EsolveCardData } from './esolve-card-data';
+import { EsolveVaultItem } from './esolve-vault-item';
+import { EsolveVaultItemResult } from './esolve-vault-item-result';
+import { EsolvePaymentResult } from './esolve-payment-result';
+import * as i0 from "@angular/core";
+export declare class EsolvePaymentService {
+    private config;
+    private http;
+    private errorHandler;
+    private responseHandler;
+    constructor(config: EsolveConnectConfig, http: HttpClient, errorHandler: EsolveErrorHandlerService, responseHandler: EsolveResponseHandlerService);
+    /**
+     * Processes the eSolve payment method records.
+     * @param records Records to process
+     * @returns An array of processed payment methods.
+     */
+    private processPaymentMethods;
+    /**
+     * Processes the eSolve vault records.
+     * @param records Records to process
+     * @returns An array of processed vault items (a.k.a. cards)
+     */
+    private processVaultItems;
+    private generateExpiry;
+    /**
+     * Retrieves a list of payment methods.
+     * @param options Filter options
+     * @returns An `Observable` with an array of payment methods
+     */
+    getPaymentMethods(options?: EsolvePaymentMethodOptions): Observable<EsolvePaymentMethod[]>;
+    /**
+     * Retrieves a list of saved cards from the vault.
+     * @param payment_methods_id eSolve ID of a payment method
+     * @returns An `Observable` with an array of saved bank cards
+     */
+    getVault(payment_methods_id?: number): Observable<EsolveVaultItem[]>;
+    /**
+     * Sets a new card in the vault OR updates an existing one.
+     * @param payment_methods_id Selected payment method
+     * @param card_data Information of bank card
+     * @returns An `Observable` with the result of the vault set.
+     */
+    setVaultItem(payment_methods_id: number, card_data: EsolveCardData): Observable<EsolveVaultItemResult>;
+    /**
+     * Sets the payment for the specified transaction using selected payment method.
+     * @param transaction_id eSolve ID to the transaction
+     * @param payment_methods_id eSolve ID to the selected payment method
+     * @param card ID of selected card from the vault or information to a brand new card
+     * @returns An `Observable` with the result of the payment
+     */
+    setPayment(transaction_id: number, payment_methods_id: number, card: EsolveCardData | number): Observable<EsolvePaymentResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsolvePaymentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EsolvePaymentService>;
+}

package/lib/payment/esolve-vault-item-result.d.ts

@@ -0,0 +1,10 @@
+import { EsolveResponseResult } from '../shared/response-handler/esolve-response-result';
+import { EsolveVaultResponse } from './esolve-vault-response';
+export declare class EsolveVaultItemResult extends EsolveResponseResult {
+    id: number;
+    token?: string;
+    card_valid?: boolean;
+    card_details_validated?: boolean;
+    gateway_error_message?: string;
+    constructor(response: EsolveVaultResponse);
+}

package/lib/payment/esolve-vault-item.d.ts

@@ -0,0 +1,10 @@
+export declare class EsolveVaultItem {
+    id: number;
+    last4: string;
+    brand: string;
+    private expiry;
+    get expiry_month(): string;
+    get expiry_year(): number;
+    get masked_number(): string;
+    constructor(id: number, last4: string, brand: string, expiry_timestamp: number);
+}

package/lib/payment/esolve-vault-record.d.ts

@@ -0,0 +1,11 @@
+export interface EsolveVaultRecord {
+    id: number;
+    payment_methods_id: number;
+    description: string;
+    token: string;
+    brand: string;
+    last4: string;
+    expiry: string;
+    expiry_timestamp: number;
+    default: boolean;
+}

package/lib/payment/esolve-vault-response.d.ts

@@ -0,0 +1,9 @@
+import { EsolvePostResponseItem } from '../shared/esolve-response';
+export interface EsolveVaultResponse extends EsolvePostResponseItem {
+    esolve_id: number;
+    card_valid?: boolean;
+    card_details_validated?: boolean;
+    gateway_error_message?: string;
+    user_vault_id?: number;
+    token?: string;
+}

package/lib/shared/error-handler/esolve-error-handler.service.d.ts

@@ -5,7 +5,7 @@ export declare class EsolveErrorHandlerService {
     constructor();
     private parseException;
     private parseErrors;
-    handleHttpError(service_type: string, errorRes: HttpErrorResponse | any): Observable<never>;
+    handleHttpPostError(service_type: string, errorRes: HttpErrorResponse | any): Observable<never>;
     static ɵfac: i0.ɵɵFactoryDeclaration<EsolveErrorHandlerService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<EsolveErrorHandlerService>;
 }

package/lib/shared/esolve-response.d.ts

@@ -21,14 +21,14 @@ export interface EsolvePostResponseItem {
     status: EsolvePostResponseStatus;
     log: EsolveResponseLogItem[];
 }
+export interface EsolveResponseLogItem {
+    type: 'success' | 'error';
+    message_code: string;
+    message: string;
+}
 interface EsolvePostResponseStatus {
     state: 'warning' | 'success' | 'error' | 'none';
     errors: number;
     success: number;
 }
-interface EsolveResponseLogItem {
-    type: 'success' | 'error';
-    message_code: string;
-    message: string;
-}
 export {};

package/lib/shared/response-handler/esolve-response-handler.service.d.ts

@@ -0,0 +1,15 @@
+import { EsolvePostResponseItem, EsolveSetResponse } from '../esolve-response';
+import { EsolveResponseResult } from './esolve-response-result';
+import * as i0 from "@angular/core";
+export declare class EsolveResponseHandlerService {
+    constructor();
+    /**
+     * Parse single HTTP response
+     * @param http_response HTTP Response to eSolve service
+     * @param resultHandler Function to parse response to a result
+     * @returns Parsed result of response
+     */
+    validateSingleHttpResponse<R extends EsolveResponseResult, T extends EsolvePostResponseItem>(http_response: EsolveSetResponse<T>, resultHandler: (response: T) => R): R;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsolveResponseHandlerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EsolveResponseHandlerService>;
+}

package/lib/shared/response-handler/esolve-response-result.d.ts

@@ -0,0 +1,6 @@
+import { EsolvePostResponseItem, EsolveResponseLogItem } from '../esolve-response';
+export declare class EsolveResponseResult {
+    success_log: EsolveResponseLogItem[];
+    error_log: EsolveResponseLogItem[];
+    constructor(response: EsolvePostResponseItem);
+}

package/lib/{cart → shipping}/esolve-shipping-cost-record.d.ts

@@ -7,8 +7,3 @@ export interface EsolveShippingCostRecord {
     vat_on_insurance: number;
     total_saving_on_insurance: number;
 }
-export interface EsolveShippingCostOptions {
-    location_id?: number;
-    addresses_id: number;
-    shipping_id: number;
-}

package/lib/shipping/esolve-shipping-method-options.d.ts

@@ -0,0 +1,4 @@
+export interface EsolveShippingMethodOptions {
+    location_id?: number;
+    addresses_id?: number;
+}

package/lib/{cart → shipping}/esolve-shipping-method-record.d.ts

@@ -31,7 +31,3 @@ export interface EsolveShippingMethodRecord {
     shipping_slot_delay_hours: number;
     image_url: string;
 }
-export interface EsolveShippingMethodOptions {
-    location_id?: number;
-    addresses_id?: number;
-}

package/lib/shipping/esolve-shipping.service.d.ts

@@ -0,0 +1,37 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveShippingMethod } from './esolve-shipping-method';
+import { EsolveShippingMethodOptions } from './esolve-shipping-method-options';
+import { EsolveShippingCost } from './esolve-shipping-cost';
+import * as i0 from "@angular/core";
+export declare class EsolveShippingService {
+    private config;
+    private http;
+    constructor(config: EsolveConnectConfig, http: HttpClient);
+    /**
+     * Processes the eSolve shipping method records.
+     * @param records Records to process
+     * @returns An array of processed shipping methods
+     */
+    private processShippingMethods;
+    /**
+     * Processes the eSolve shipping costs record.
+     * @param record Data to process
+     * @returns Processed shipping costs
+     */
+    private processShippingCost;
+    /**
+     * Retrieves a list of shipping methods
+     * @returns An `Observable` with an array of shipping methods
+     */
+    getShippingMethods(options?: EsolveShippingMethodOptions): Observable<EsolveShippingMethod[]>;
+    /**
+     * Retrieves the shipping costs
+     * @param options Shipping cost options
+     * @returns An `Observable` with the shipping costs
+     */
+    getShippingCost(shipping_id: number, addresses_id: number, location_id?: number): Observable<EsolveShippingCost>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsolveShippingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EsolveShippingService>;
+}