node-paymo-api 0.0.3 → 0.0.5

package/src/abstract.ts

@@ -0,0 +1,220 @@
+import { AuthInterface, GenericCustomFilterType, GenericFilterType, GenericListConfig } from "./types"
+import XhrWrapper from './remote'
+
+export interface AbstractResourceInterface {}
+
+export class AbstractResource {
+  protected auth: AuthInterface = { userApi: '', password: '' }
+  protected resourceKey: string | null = null
+  protected responseKey: string | null = null
+  protected filterDates: string[] = []
+
+  constructor(auth: AuthInterface, resourceKey: string, responseKey: string | null = null) {
+    this.auth = auth
+    this.resourceKey = resourceKey
+    this.responseKey = responseKey
+  }
+
+  private constructUrl = (id?: number|null) => {
+    return this.resourceKey + (id ? '/' + id : '')
+  }
+
+  private constructAuth = () => {
+    return {
+      username: this.auth.userApi,
+      password: this.auth.password || 'apiKey',
+    }
+  }
+
+  private constructHeaders = () => {
+    return {
+      Accept: 'application/json',
+    }
+  }
+
+  private isTimestampKey = (k:string) => {
+    return ['created_on', 'updated_on'].findIndex(i=>k===i) > -1
+  }
+
+  private toTimestamp = (dt:string) => {
+    return Math.round((new Date(dt)).getTime() / 1000);
+  }
+
+  private processCustomFilters = (filters:GenericCustomFilterType) => {
+    const whereVar = Object.keys(filters).map(k=>{
+      const f = filters[k]
+      const fVal = f.value
+      const rKey = f.key ? f.key : k
+      const rOp = f.operator ? f.operator : '='
+      const rVal =
+        this.isTimestampKey(rKey) && typeof fVal === 'string'
+          ? this.toTimestamp(fVal)
+          : fVal
+      switch (f.operator) {
+        case 'in':
+        case 'not in':
+          const v = Array.isArray(rVal) ? rVal : [rVal]
+          return rKey + ' ' + rOp + ' (' + v.join(',') + ')'
+        case 'like':
+        case 'not like':
+          return rKey + ' ' + rOp + ' "' + rVal + '"'
+        default:
+          return rKey + rOp + rVal
+      }
+    }).filter(s=>s!=='').join(' and ')
+    return whereVar.trim()
+  }
+
+  private constructFilter = (
+    filters: GenericFilterType
+  ): string | null => {
+    const whereVar = Object.keys(filters).map(k=>{
+      const f = filters[k]
+      if (k==='_custom') {
+        return this.processCustomFilters(f)
+      } else if (Array.isArray(f)) {
+        return (k+' in ('+f.join(',')+')')
+      } else if (f === null || typeof f === 'string' || typeof f === 'number' || typeof f === 'boolean') {
+        const v = this.isTimestampKey(k) && typeof f === 'string' ? this.toTimestamp(f) : f
+        return (k+'='+f).trim()
+      }
+      return ''
+    }).filter(s=>s!=='').join(' and ')
+    return whereVar.trim()
+  }
+
+  private constructInclude = (includes: string[]): string | null => {
+    if (!includes.length) {
+      return null
+    }
+    return includes.join(',')
+  }
+
+  baseGet = async (id: number|null): Promise<object | null> => {
+    const response = await XhrWrapper.get({
+      url: this.constructUrl(id),
+      config: {
+        auth: this.constructAuth(),
+        headers: this.constructHeaders(),
+      },
+    })
+    const responseKey = this.responseKey!==null? this.responseKey : this.resourceKey
+    if (
+      responseKey &&
+      response &&
+      response.status >= 200 &&
+      response.status < 300 &&
+      response.data.hasOwnProperty(responseKey)
+    ) {
+      console.log('RESPONSE KEY', responseKey, response.data)
+      const data = response.data[responseKey]
+      if (Array.isArray(data)) {
+        console.log('AXIOS RESPONSE', data[0])
+        return data.length > 0 ? data[0] : null
+      } else if (data) {
+        return data
+      }
+    }
+    return null
+  }
+
+  baseList = async (config: GenericListConfig = {}): Promise<object[]> => {
+    const filter = this.constructFilter(config.filter ? config.filter : {})
+    const include = this.constructInclude(config.include ? config.include : [])
+    const response = await XhrWrapper.get({
+      url: this.constructUrl(),
+      config: {
+        auth: this.constructAuth(),
+        headers: this.constructHeaders(),
+        params:
+          filter || include
+            ? {
+                where: filter || undefined,
+                include: include || undefined,
+              }
+            : undefined,
+      },
+    })
+    const responseKey = this.responseKey!==null? this.responseKey : this.resourceKey
+    if (
+      responseKey &&
+      response &&
+      response.status >= 200 &&
+      response.status < 300 &&
+      response.data.hasOwnProperty(responseKey)
+    ) {
+      const data = response.data[responseKey]
+      console.log('AXIOS RESPONSE', data)
+      return data
+    }
+    return []
+  }
+
+  baseCreate = async (data: object) => {
+    const response = await XhrWrapper.post({
+      url: this.constructUrl(),
+      config: {
+        auth: this.constructAuth(),
+        headers: this.constructHeaders(),
+      },
+      data: data,
+    })
+    const responseKey = this.responseKey!==null? this.responseKey : this.resourceKey
+    if (
+      responseKey &&
+      response &&
+      response.status >= 200 &&
+      response.status < 300 &&
+      response.data.hasOwnProperty(responseKey)
+    ) {
+      const data = response.data[responseKey]
+      if (Array.isArray(data)) {
+        console.log('AXIOS RESPONSE', data[0])
+        return data.length > 0 ? data[0] : null
+      } else if (data) {
+        return data
+      }
+    }
+    return null
+  }
+
+  baseUpdate = async (id: number|null, data: object) => {
+    const response = await XhrWrapper.put({
+      url: this.constructUrl(id),
+      config: {
+        auth: this.constructAuth(),
+        headers: this.constructHeaders(),
+      },
+      data: data,
+    })
+    const responseKey = this.responseKey!==null? this.responseKey : this.resourceKey
+    if (
+      responseKey &&
+      response &&
+      response.status >= 200 &&
+      response.status < 300 &&
+      response.data.hasOwnProperty(responseKey)
+    ) {
+      const data = response.data[responseKey]
+      if (Array.isArray(data)) {
+        console.log('AXIOS RESPONSE', data[0])
+        return data.length > 0 ? data[0] : null
+      } else if (data) {
+        return data
+      }
+    }
+    return null
+  }
+
+  baseDelete = async (id: number): Promise<boolean> => {
+    const response = await XhrWrapper.delete({
+      url: this.constructUrl(id),
+      config: {
+        auth: this.constructAuth(),
+        headers: this.constructHeaders(),
+      },
+    })
+    return !!(response && response.status >= 200 && response.status < 300);
+
+  }
+}

package/src/index.ts

@@ -0,0 +1,23 @@
+import PaymoResourceHandler, { PaymoResourceHandlerInterface } from "./resources"
+
+class Paymo {
+  static instances: PaymoResourceHandlerInterface[] = []
+
+  static connect = (
+    userOrApi: string,
+    password: string | null = null
+  ): PaymoResourceHandlerInterface => {
+    let handler:
+      | PaymoResourceHandlerInterface
+      | undefined = Paymo.instances.find(i => i.isApiUser(userOrApi))
+    if (!handler) {
+      handler = new PaymoResourceHandler(userOrApi, password)
+      Paymo.instances.push(handler)
+    }
+    return handler
+  }
+}
+
+export default Paymo
+
+

package/src/remote.ts

@@ -0,0 +1,77 @@
+import axios, { AxiosResponse } from "axios"
+// export interface XhrWrapperInterface {
+//   get:()=>void
+//   post:()=>void
+//   put:()=>void
+//   delete:()=>void
+// }
+
+const paymoAxios = axios.create({
+  baseURL: 'https://app.paymoapp.com/api/',
+  headers: { Accept: 'application/json' },
+})
+
+class XhrWrapper {
+  static get = async (d: any): Promise<AxiosResponse | null> => {
+    console.log('AXIOS GET CALL', d)
+    return await paymoAxios.get(d.url, d.config).catch((e: Error) => {
+      console.log('ERROR:', e.message)
+      throw new Error('PAYMO GET FAILED :' + e)
+    })
+  }
+
+  static post = async (d: any) => {
+    console.log('AXIOS POST CALL', d)
+    return await paymoAxios.post(d.url, d.data, d.config).catch((e: Error) => {
+      console.log('ERROR:', e.message)
+      throw new Error('PAYMO POST FAILED :' + e)
+    })
+  }
+
+  static put = async (d: any) => {
+    console.log('AXIOS PUT CALL', d)
+    return await paymoAxios.put(d.url, d.data, d.config).catch((e: Error) => {
+      console.log('ERROR:', e.message)
+      throw new Error('PAYMO PUT FAILED :' + e)
+    })
+  }
+
+  static delete = async (d: any): Promise<AxiosResponse | null> => {
+    console.log('AXIOS DELETE CALL', d)
+    return await paymoAxios.delete(d.url, d.config).catch((e: Error) => {
+      console.log('ERROR:', e.message)
+      throw new Error('PAYMO DELETE FAILED :' + e)
+    })
+  }
+
+  static test = async () => {
+    const PAYMOAPI = 'YOUR_PAYMO_API_KEY'
+    const url = 'projects?include=client,tasks.entries'
+
+    const d = {
+      auth: {
+        username: PAYMOAPI,
+        password: 'abc123',
+      },
+      headers: {
+        Accept: 'application/json',
+      },
+    }
+
+    const instance = axios.create()
+    instance.defaults.headers.common = {}
+    instance.defaults.headers.common.accept = 'application/json'
+
+    //const { data } = await instance.get(generatedUrl);
+
+    console.log('AXIOS DEL CALL', d)
+
+    const response = await instance.get(url, d).catch((e: Error) => {
+      throw new Error('GET PAYMO FAILED :' + e)
+    })
+
+    console.log('DEL PAYMO RESPONSE', response)
+  }
+}
+
+export default XhrWrapper

package/src/resources/_template_/index.ts

@@ -0,0 +1,38 @@
+import { AbstractResource, AbstractResourceInterface } from '../../abstract'
+import { AuthInterface } from "../../types"
+import { _Template_ListConfig, _Template_TypeCreate, _Template_TypeResponse, _Template_TypeUpdate } from "./types"
+
+export interface _Template_Handler extends AbstractResourceInterface {
+  get: (id: number) => Promise<_Template_TypeResponse | null>
+  list: (config?: _Template_ListConfig) => Promise<_Template_TypeResponse[]>
+  create: (d: _Template_TypeCreate) => Promise<_Template_TypeResponse | null>
+  update: (id: number, data: _Template_TypeUpdate) => Promise<_Template_TypeResponse | null>
+  delete: (id: number) => Promise<boolean>
+}
+
+export class _Template_ extends AbstractResource implements _Template_Handler {
+  constructor(auth: AuthInterface) {
+    super(auth, '_template_')
+  }
+
+  get = async (id: number) => {
+    return (await this.baseGet(id)) as _Template_TypeResponse | null
+  }
+
+  list = async (config: _Template_ListConfig = {}) => {
+    return (await this.baseList(config)) as _Template_TypeResponse[]
+  }
+
+  create = async (data: _Template_TypeCreate) => {
+    return (await this.baseCreate(data)) as _Template_TypeResponse | null
+  }
+
+  update = async (id: number, data: _Template_TypeUpdate) => {
+    return (await this.baseUpdate(id, data)) as _Template_TypeResponse | null
+  }
+
+  delete = async (id: number) => {
+    return await this.baseDelete(id)
+  }
+
+}

package/src/resources/_template_/types.ts

@@ -0,0 +1,40 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types"
+
+// PAYMO API DOCS - 2019-12-11    /_template_    /_template_/####
+// =================================================================================================
+
+export interface _Template_TypeRead {
+  readonly id: number
+  readonly created_on: string
+  readonly updated_on: string
+}
+
+export interface _Template_TypeUpdate {
+
+}
+
+export type _Template_TypeResponse = Merge<_Template_TypeUpdate, Merge<_Template_TypeRead, {
+
+}>>
+
+export interface _Template_TypeCreate extends _Template_TypeUpdate {
+
+}
+
+export interface _Template_TypeFilter {
+
+}
+
+export interface _Template_FilterCondition extends _Template_TypeFilter {
+  _custom?: {
+    [k: string]: {
+      key?: Extract<keyof _Template_TypeFilter, string>
+      operator?:FilterOperator
+      value: string | number | boolean | null | number[]
+    }
+  }
+}
+
+export interface _Template_ListConfig extends GenericListConfig {
+  filter?:_Template_FilterCondition
+}

package/src/resources/bookings/index.ts

@@ -0,0 +1,61 @@
+import { AbstractResource, AbstractResourceInterface } from '../../abstract'
+import { AuthInterface } from '../../types'
+import {
+  BookingsListConfig,
+  BookingsTypeCreate,
+  BookingsTypeResponse,
+  BookingsTypeUpdate,
+} from './types'
+
+export interface BookingsHandler extends AbstractResourceInterface {
+  get: (id: number) => Promise<BookingsTypeResponse | null>
+  list: (config?: BookingsListConfig) => Promise<BookingsTypeResponse[]>
+  create: (d: BookingsTypeCreate) => Promise<BookingsTypeResponse | null>
+  update: (
+    id: number,
+    data: BookingsTypeUpdate
+  ) => Promise<BookingsTypeResponse | null>
+  delete: (id: number) => Promise<boolean>
+}
+
+export class Bookings extends AbstractResource implements BookingsHandler {
+  constructor(auth: AuthInterface) {
+    super(auth, 'bookings')
+    this.filterDates = ['start_date', 'end_date']
+  }
+
+  get = async (id: number) => {
+    return (await this.baseGet(id)) as BookingsTypeResponse | null
+  }
+
+  list = async (config: BookingsListConfig = {}) => {
+    const validConfig =
+      !!config &&
+      config.filter &&
+      (config.filter.user_task_id ||
+        config.filter.task_id ||
+        config.filter.user_id ||
+        config.filter.project_id ||
+        (config.filter.date_interval &&
+          Array.isArray(config.filter.date_interval) &&
+          config.filter.date_interval.length === 2) ||
+        (config.filter.start_date && config.filter.end_date))
+    if (!validConfig) {
+      console.log('Booking list requires at least one valid filter condition')
+      return []
+    }
+    return (await this.baseList(config)) as BookingsTypeResponse[]
+  }
+
+  create = async (data: BookingsTypeCreate) => {
+    return (await this.baseCreate(data)) as BookingsTypeResponse | null
+  }
+
+  update = async (id: number, data: BookingsTypeUpdate) => {
+    return (await this.baseUpdate(id, data)) as BookingsTypeResponse | null
+  }
+
+  delete = async (id: number) => {
+    return await this.baseDelete(id)
+  }
+}

package/src/resources/bookings/types.ts

@@ -0,0 +1,60 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types"
+
+// PAYMO API DOCS - 2019-12-11    /bookings    /bookings/####
+// =================================================================================================
+
+export interface BookingsTypeRead {
+  readonly id: number
+  readonly created_on: string
+  readonly updated_on: string
+  readonly creator_id: number
+}
+
+export interface BookingsTypeUpdate {
+  user_task_id?:number
+  start_date?:string
+  end_date?:string
+  hours_per_day?:number
+  description?:string
+}
+
+export type BookingsTypeResponse = Merge<BookingsTypeUpdate, Merge<BookingsTypeRead,  {
+  booked_hours:any|null
+  start_date: string
+  start_time: string|null
+  end_date:string
+  end_time:string|null
+}>>
+
+export interface BookingsTypeCreate extends BookingsTypeUpdate {
+  user_task_id:number
+  start_date:string
+  end_date:string
+  hours_per_day:number
+}
+
+export interface BookingsTypeFilter {
+  user_task_id?:number
+  task_id?:number
+  user_id?:number
+  project_id?:number
+  date_interval?:string[]
+
+  hours_per_day?:number
+  start_date?:string
+  end_date?:string
+}
+
+export interface BookingsFilterCondition extends BookingsTypeFilter {
+  _custom?: {
+    [k: string]: {
+      key?: Extract<keyof BookingsTypeFilter, string>
+      operator?:FilterOperator
+      value: string | number | boolean | null | number[]
+    }
+  }
+}
+
+export interface BookingsListConfig extends GenericListConfig {
+  filter?:BookingsFilterCondition
+}

package/src/resources/clientcontacts/index.ts

@@ -0,0 +1,38 @@
+import { AbstractResource, AbstractResourceInterface } from '../../abstract'
+import { AuthInterface } from "../../types"
+import { ClientContactsListConfig, ClientContactsTypeCreate, ClientContactsTypeResponse, ClientContactsTypeUpdate } from "./types"
+
+export interface ClientContactsHandler extends AbstractResourceInterface {
+  get: (id: number) => Promise<ClientContactsTypeResponse | null>
+  list: (config?: ClientContactsListConfig) => Promise<ClientContactsTypeResponse[]>
+  create: (d: ClientContactsTypeCreate) => Promise<ClientContactsTypeResponse | null>
+  update: (id: number, data: ClientContactsTypeUpdate) => Promise<ClientContactsTypeResponse | null>
+  delete: (id: number) => Promise<boolean>
+}
+
+export class ClientContacts extends AbstractResource implements ClientContactsHandler {
+  constructor(auth: AuthInterface) {
+    super(auth, 'clientcontacts')
+  }
+
+  get = async (id: number) => {
+    return (await this.baseGet(id)) as ClientContactsTypeResponse | null
+  }
+
+  list = async (config: ClientContactsListConfig = {}) => {
+    return (await this.baseList(config)) as ClientContactsTypeResponse[]
+  }
+
+  create = async (data: ClientContactsTypeCreate) => {
+    return (await this.baseCreate(data)) as ClientContactsTypeResponse | null
+  }
+
+  update = async (id: number, data: ClientContactsTypeUpdate) => {
+    return (await this.baseUpdate(id, data)) as ClientContactsTypeResponse | null
+  }
+
+  delete = async (id: number) => {
+    return await this.baseDelete(id)
+  }
+
+}

package/src/resources/clientcontacts/types.ts

@@ -0,0 +1,69 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types"
+
+// PAYMO API DOCS - 2019-12-11    /clientcontacts    /clientcontacts/####
+// =================================================================================================
+
+export interface ClientContactsTypeRead {
+  readonly id: number
+  readonly created_on: string
+  readonly updated_on: string
+  readonly image_thumb_large?: string
+  readonly image_thumb_medium?: string
+  readonly image_thumb_small?: string
+}
+
+export interface ClientContactsTypeUpdate {
+  name?: string
+  email?: string
+  mobile?:string
+  phone?: string
+  fax?:string
+  skype?: string
+  notes?:string
+  position?: string
+  is_main?:boolean
+  access?:boolean
+  client_id?:number
+  password?:string
+}
+
+export type ClientContactsTypeResponse = Merge<ClientContactsTypeUpdate, Merge<ClientContactsTypeRead, {
+  image:string|null
+  phone:string|null
+  position:string|null
+  skype:string|null
+}>>
+
+export interface ClientContactsTypeCreate extends ClientContactsTypeUpdate {
+  name: string
+  client_id:number
+}
+
+export interface ClientContactsTypeFilter {
+  id?: number
+  created_on?: string
+  updated_on?: string
+  name?: string
+  email?: string
+  mobile?:string
+  phone?: string
+  fax?:string
+  skype?: string
+  is_main?:boolean
+  access?:boolean
+  client_id?:number
+}
+
+export interface ClientContactsFilterCondition extends ClientContactsTypeFilter {
+  _custom?: {
+    [k: string]: {
+      key?: Extract<keyof ClientContactsTypeFilter, string>
+      operator?:FilterOperator
+      value: string | number | boolean | null | number[]
+    }
+  }
+}
+
+export interface ClientContactsListConfig extends GenericListConfig {
+  filter?:ClientContactsFilterCondition
+}

package/src/resources/clients/index.ts

@@ -0,0 +1,38 @@
+import { AbstractResource, AbstractResourceInterface } from '../../abstract'
+import { AuthInterface } from "../../types"
+import { ClientsListConfig, ClientTypeCreate, ClientTypeResponse, ClientTypeUpdate } from "./types"
+
+export interface ClientsHandler extends AbstractResourceInterface {
+  get: (id: number) => Promise<ClientTypeResponse | null>
+  list: (config?: ClientsListConfig) => Promise<ClientTypeResponse[]>
+  create: (d: ClientTypeCreate) => Promise<ClientTypeResponse | null>
+  update: (id: number, data: ClientTypeUpdate) => Promise<ClientTypeResponse | null>
+  delete: (id: number) => Promise<boolean>
+}
+
+export class Clients extends AbstractResource implements ClientsHandler {
+  constructor(auth: AuthInterface) {
+    super(auth, 'clients')
+  }
+
+  get = async (id: number) => {
+    return (await this.baseGet(id)) as ClientTypeResponse | null
+  }
+
+  list = async (config: ClientsListConfig = {}) => {
+    return (await this.baseList(config)) as ClientTypeResponse[]
+  }
+
+  create = async (data: ClientTypeCreate) => {
+    return (await this.baseCreate(data)) as ClientTypeResponse | null
+  }
+
+  update = async (id: number, data: ClientTypeUpdate) => {
+    return (await this.baseUpdate(id, data)) as ClientTypeResponse | null
+  }
+
+  delete = async (id: number) => {
+    return await this.baseDelete(id)
+  }
+
+}