add prices and other improvements

.vscode/launch.json

@@ -20,6 +20,15 @@
             "console": "integratedTerminal",
             "internalConsoleOptions": "neverOpen",
             "protocol": "inspector"
+        },
+        {
+            "name": "Attach by Process ID",
+            "processId": "${command:PickProcess}",
+            "request": "attach",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "type": "node"
         }
     ]
 }

package.json

@@ -9,7 +9,8 @@
   ],
   "scripts": {
     "build": "tsc",
-    "test": "./node_modules/.bin/nyc ./node_modules/.bin/mocha -r ts-node/register test/*.ts"
+    "auth": "./node_modules/.bin/ts-node ./test/http-server-oauth-authorize.ts",
+    "test": "./node_modules/.bin/nyc ./node_modules/.bin/mocha -r ts-node/register test/*.spec.ts"
   },
   "author": "Gustaf Ridderstolpe, Enfo Sweden AB",
   "repository": "github:obrut/fortnox",
@@ -45,7 +46,9 @@
       "src/**/*"
     ],
     "exclude": [
-      "**/*.d.ts"
+      "**/*.d.ts",
+      "src/dispatch.ts",
+      "src/utils.ts"
     ],
     "reporter": [
       "text"

src/articles.ts

@@ -8,12 +8,10 @@ type ArticleResult = {
 
 export class Articles {
     private dispatch: Dispatch;
-    private util: Util;
     private path = 'articles';
 
     constructor(dispatch: Dispatch){
         this.dispatch = dispatch;
-        this.util = new Util();
     }
 
     async get(articleNumber: string) {
@@ -22,10 +20,7 @@ export class Articles {
     }
 
     async getAll(filter?: string) {
-        let path = this.path;
-        if (filter)
-            path += '?filter=' + filter;
-        const result = await this.util.getAllPages(path, 'Articles', this.dispatch) as FNArticle[];
+        const result = await Util.getAllPages(this.path, 'Articles', this.dispatch, filter) as FNArticle[];
         return result;
     }
 

src/customers.ts

@@ -8,12 +8,10 @@ type CustomerResult = {
 
 export class Customers {
     private dispatch: Dispatch;
-    private util: Util;
     private path = 'customers'
 
     constructor(dispatch: Dispatch){
         this.dispatch = dispatch;
-        this.util = new Util();
     }
 
     async get(customerNumber: string) {
@@ -22,10 +20,7 @@ export class Customers {
     }
 
     async getAll(filter?: string) {
-        let path = this.path;
-        if (filter)
-            path += '?filter=' + filter;
-        const result = await this.util.getAllPages(path, 'Customers', this.dispatch) as FNCustomer[];
+        const result = await Util.getAllPages(this.path, 'Customers', this.dispatch, filter) as FNCustomer[];
         return result;
     }
 

src/dispatch.ts

@@ -1,40 +1,55 @@
 import fetch from 'node-fetch';
 import { Defaults } from './types/defaults';
+import { Util } from './utils';
 
 export class Dispatch {
     private host: string;
     private defaults: Defaults;
 
-    constructor(config: {Host: string, Defaults: Defaults}) {
+    constructor(config: { Host: string, Defaults: Defaults }) {
         this.host = config.Host,
-        this.defaults = config.Defaults
+            this.defaults = config.Defaults
     }
 
     async get(path?: string) {
-        const response = await fetch(`${this.host}${path}`, { method: 'GET', headers: this.defaults.headers });
-        if (response.status === 200)
-            return await response.json() as object;
-        throw new Error(response.statusText);
+        const timeouts = [250, 250, 250, 500, 1000, 2000, 4000, 8000];
+        let timeout = 0;
+
+        while (true) {
+            const response = await fetch(`${this.host}${path}`, { method: 'GET', headers: this.defaults.headers })
+            if (response.status === 200) {
+                return await response.json() as object;
+            }
+
+            // 429 = too many requests (overload), use exponential retries
+            if (response.status === 429 && timeout < timeouts.length) {
+                await Util.delay(timeouts[timeout]);
+                timeout += 1;
+                continue;
+            }
+
+            throw await Util.makeErrorFromResponse(response)
+        }
     }
 
     async post(path: string, body: any) {
         const response = await fetch(`${this.host}${path}`, { method: 'POST', headers: this.defaults.headers, body: JSON.stringify(body, null, 4) });
         if (response.status === 201)
             return await response.json() as object;
-        throw new Error(response.statusText);
+        throw await Util.makeErrorFromResponse(response);
     }
 
     async put(path: string, body?: any) {
         const response = await fetch(`${this.host}${path}`, { method: 'PUT', headers: this.defaults.headers, body: body && JSON.stringify(body, null, 4) });
         if (response.status === 200)
             return await response.json() as object;
-        throw new Error(response.statusText);
+        throw await Util.makeErrorFromResponse(response);
     }
 
     async delete(path: string) {
         const response = await fetch(`${this.host}${path}`, { method: 'DELETE', headers: this.defaults.headers });
         if (response && response.status === 204)
             return response.ok;
-        throw new Error(response.statusText);
+        throw await Util.makeErrorFromResponse(response);
     }
 }

src/index.ts

@@ -1,33 +1,42 @@
 import { Articles } from './articles';
 import { Customers } from './customers';
 import { Invoices } from './invoices';
+import { Prices } from './prices';
 import { SupplierInvoices } from './supplierinvoices'
 import { Dispatch } from './dispatch';
 import { Suppliers } from './suppliers';
 import { Defaults } from './types/defaults';
 
 export class Fortnox {
-    constructor(config: { host: string, clientSecret: string, accessToken: string }){
+    constructor(config: {
+        host: string,
+        bearerToken?: string,
+        clientSecret?: string,
+        accessToken?: string,
+    }) {
         const defaults: Defaults = {
             json: true,
             headers: {
-                'client-secret': config.clientSecret,
-                'access-token': config.accessToken,
+                ...(config.bearerToken && { 'Authorization': `Bearer ${config.bearerToken}` }),
+                ...(config.clientSecret && { 'client-secret': config.clientSecret }),
+                ...(config.accessToken && { 'access-token': config.accessToken }),
                 'Content-Type': 'application/json',
                 'Accept': 'application/json'
             }
         }
-        const dispatch = new Dispatch( {Host: config.host, Defaults: defaults } );
+        const dispatch = new Dispatch({ Host: config.host, Defaults: defaults });
         this.articles = new Articles(dispatch);
         this.customers = new Customers(dispatch);
         this.invoices = new Invoices(dispatch);
         this.supplierInvoices = new SupplierInvoices(dispatch);
         this.suppliers = new Suppliers(dispatch);
+        this.prices = new Prices(dispatch);
     }
 
     public articles: Articles;
     public customers: Customers;
     public invoices: Invoices;
     public supplierInvoices: SupplierInvoices;
     public suppliers: Suppliers;
+    public prices: Prices;
 }

src/invoices.ts

@@ -8,26 +8,24 @@ type InvoiceResult = {
 
 export class Invoices {
     private dispatch: Dispatch;
-    private util: Util;
     private path = 'invoices';
 
     constructor(dispatch: Dispatch){
         this.dispatch = dispatch;
-        this.util = new Util();
     }
 
     async get(documentNumber?: string) {
         const result = await this.dispatch.get(`${this.path}/${documentNumber || ''}`) as InvoiceResult;
         return result.Invoice;
     }
 
-    async getAll(filter: string) {
-        const result = await this.util.getAllPages(this.path + '?filter=' + filter, 'Invoices', this.dispatch) as InvoiceResult[];
+    async getAll(filter?: string) {
+        const result = await Util.getAllPages(this.path, 'Invoices', this.dispatch, filter) as FNInvoice[];
         return result;
     }
 
     async getByCustomer(customerNumber: string) {
-        const allInvoices = await this.util.getAllPages(`${this.path}/`, 'Invoices', this.dispatch);
+        const allInvoices = await Util.getAllPages(this.path, 'Invoices', this.dispatch);
         return allInvoices.filter(invoice => invoice.CustomerNumber.toLowerCase() == customerNumber.toLowerCase());
     }
 

src/prices.ts

@@ -0,0 +1,44 @@
+import { Dispatch } from './dispatch';
+import { FNPrice } from './types/FNPrice';
+import { Util } from './utils';
+
+type PriceResult = {
+    Price: FNPrice
+}
+
+export class Prices {
+    private dispatch: Dispatch;
+    private path = 'prices';
+
+    constructor(dispatch: Dispatch) {
+        this.dispatch = dispatch;
+    }
+
+    async getAll(priceList?: string, articleNumber?: string) {
+        let path = `${this.path}/sublist`;
+        if (priceList)
+            path += `/${priceList}`;
+        if (articleNumber)
+            path += `/${articleNumber}`
+        const result = await Util.getAllPages(path, 'Prices', this.dispatch) as FNPrice[];
+        return result;
+    }
+
+    async create(price: any) {
+        const result = await this.dispatch.post(this.path, { Price: price }) as PriceResult;
+        return result.Price;
+    }
+
+    async update(price: FNPrice) {
+        const result = await this.dispatch.put(`${this.path}/${price.PriceList}/${price.ArticleNumber}/${price.FromQuantity}`, { Price: price }) as PriceResult;
+        return result.Price;
+    }
+
+    async remove(priceList: string, articleNumber: string, fromQuantity?: number) {
+        let path = `${this.path}/${priceList}/${articleNumber}`;
+        if (fromQuantity)
+            path += `/${fromQuantity}`;
+        const result = await this.dispatch.delete(path);
+        return result;
+    }
+}

src/supplierinvoices.ts

@@ -9,12 +9,10 @@ type SupplierInvoiceResult = {
 
 export class SupplierInvoices {
     private dispatch: Dispatch;
-    private util: Util;
     private path = 'supplierinvoices';
 
     constructor(dispatch: Dispatch){
         this.dispatch = dispatch;
-        this.util = new Util();
     }
 
     async get(givenNumber?: string) {
@@ -23,10 +21,7 @@ export class SupplierInvoices {
     }
 
     async getAll(filter?: string) {
-        let path = this.path;
-        if (filter)
-            path += '?filter=' + filter;
-        const result = await this.util.getAllPages(path, 'SupplierInvoices', this.dispatch) as FNSupplierInvoice[];
+        const result = await Util.getAllPages(this.path, 'SupplierInvoices', this.dispatch, filter) as FNSupplierInvoice[];
         return result;
     }
 

src/suppliers.ts

@@ -3,30 +3,24 @@ import { FNSupplier } from './types/FNSupplier';
 import { Util } from './utils';
 
 type SupplierResult = {
-    Supplier: FNSupplier,
-    Suppliers: FNSupplier[]
+    Supplier: FNSupplier
 }
 
 export class Suppliers {
     private dispatch: Dispatch;
-    private util: Util;
     private path = 'suppliers';
 
     constructor(dispatch: Dispatch){
         this.dispatch = dispatch;
-        this.util = new Util();
     }
 
-    async get(supplierNumber?: string) {
-        const result = await this.dispatch.get(this.path) as SupplierResult;
-        return supplierNumber ? result.Supplier : result.Suppliers;
+    async get(supplierNumber: string) {
+        const result = await this.dispatch.get(`${this.path}/${supplierNumber}`) as SupplierResult;
+        return result.Supplier;
     }
 
     async getAll(filter?: string) {
-        let path = this.path;
-        if (filter)
-            path += '?filter=' + filter;
-        const result = await this.util.getAllPages(path, 'Suppliers', this.dispatch) as FNSupplier[];
+        const result = await Util.getAllPages(this.path, 'Suppliers', this.dispatch, filter) as FNSupplier[];
         return result;
     }
 

src/types/FNPrice.ts

@@ -0,0 +1,6 @@
+export type FNPrice = {
+    ArticleNumber?: string,
+    FromQuantity?: number,
+    Price?: number,
+    PriceList?: string,
+}

src/utils.ts

@@ -1,21 +1,47 @@
 import { Dispatch } from "./dispatch";
 
 export class Util {
-    async getAllPages(path: string, arrayName: string, dispatch: Dispatch) {
+    static async getAllPages(path: string, arrayName: string, dispatch: Dispatch, filter?: string) {
         const items: any = await dispatch.get(path);
 
+        if (filter)
+            path += '?filter=' + filter;
+
         let allItems: any[] = [];
         const totalPages = Number.parseInt(items.MetaInformation['@TotalPages']);
         allItems.push(...items[arrayName]);
 
         if (totalPages > 1){
             let currentPage: number = 2;
             while(currentPage <= totalPages) {
-                allItems.push(...await dispatch.get(path + '&page=' + currentPage)[arrayName]);
+                const pageItems: any = await dispatch.get(path + (filter ? '&' : '?') + 'page=' + currentPage);
+                allItems.push(...pageItems[arrayName]);
                 currentPage++;
             }
         }
 
         return allItems;
     }
+
+    // convert fortnox error into standard error
+    static async makeErrorFromResponse (response: any) {
+
+        // get fortnox error if exist
+        if (response?.headers?.get('content-type')?.startsWith('application/json')) {
+            const fnError = await response.json();
+            const fnMessage = fnError?.ErrorInformation?.message;
+            if (fnMessage) {
+                return new Error(fnMessage);
+            }
+        }
+
+        return new Error(response.statusText ?? "An error has occured");
+    }
+
+    // a promise that resolves after specified amount of time
+    static delay(ms: number): Promise<void> {
+        return new Promise((resolve: () => void) => {
+            setTimeout(resolve, ms);
+        });
+    }
 }