rotacloud 1.0.11 → 1.0.14

package/src/interfaces/availability.interface.ts

@@ -3,7 +3,7 @@ export interface ApiAvailabilityPeriod {
   end_time: string;
 }
 
-export interface ApiAvailabilityDates {
+export interface ApiAvailabilityDate {
   date: string;
   available: ApiAvailabilityPeriod[];
   unavailable: ApiAvailabilityPeriod[];
@@ -11,5 +11,5 @@ export interface ApiAvailabilityDates {
 
 export interface ApiAvailability {
   user: number;
-  dates: ApiAvailabilityDates[];
+  dates: ApiAvailabilityDate[];
 }

package/src/interfaces/query-params/availability-query-params.interface.ts

@@ -1,5 +1,12 @@
 export interface AvailabilityQueryParams {
+  /** Start of date range for fetching availability (ISO date format `YYYY-MM-DD`) */
   start?: string;
+  /** End of date range for fetching availability (inclusive) (ISO date format `YYYY-MM-DD`)  */
   end?: string;
+  /**
+   * List of user IDs to get availability for
+   *
+   * If undefined, all users on the account will be selected
+   */
   users?: number[];
 }

package/src/models/availability.model.ts

@@ -1,8 +1,8 @@
-import { ApiAvailability, ApiAvailabilityDates } from '../interfaces/index.js';
+import { ApiAvailability, ApiAvailabilityDate } from '../interfaces/index.js';
 
 export class Availability {
   public user: number;
-  public dates: ApiAvailabilityDates[];
+  public dates: ApiAvailabilityDate[];
 
   constructor(availability: ApiAvailability) {
     this.user = availability.user;

package/src/models/user.model.ts

@@ -31,41 +31,41 @@ export interface TeamProperties {
 
 // Models should be an abstraction over Api Models/Responses
 export class User {
-  id: number;
-  created_at: number;
-  created_by: number;
-  deleted: boolean;
-  deleted_at: number | null;
-  deleted_by: number | null;
-  level: string;
-  first_name: string;
-  middle_name: string | null;
-  last_name: string;
-  preferred_name: string | null;
-  photo: string | null;
-  two_factor_enabled: boolean;
-  email: string;
-  has_account: boolean;
-  invite_sent: boolean;
-  group: number | null;
-  locations: number[];
-  roles: number[];
-  default_role: number | null;
-  dob: string | null;
-  start_date: string | null;
-  final_working_date: string | null;
-  weekly_hours: number | null;
-  holiday_allowance: number;
-  holiday_allowance_unit: string;
-  payroll_id: string | null;
-  salary: number;
-  salary_type: string;
-  overtime_rate: number;
-  role_rates: LeaveRates;
-  leave_rates: RoleRates;
-  leave_rates_unit: string;
-  leave_rates_type: string;
-  notes: string | null;
+  public id: number;
+  public created_at: number;
+  public created_by: number;
+  public deleted: boolean;
+  public deleted_at: number | null;
+  public deleted_by: number | null;
+  public level: string;
+  public first_name: string;
+  public middle_name: string | null;
+  public last_name: string;
+  public preferred_name: string | null;
+  public photo: string | null;
+  public two_factor_enabled: boolean;
+  public email: string;
+  public has_account: boolean;
+  public invite_sent: boolean;
+  public group: number | null;
+  public locations: number[];
+  public roles: number[];
+  public default_role: number | null;
+  public dob: string | null;
+  public start_date: string | null;
+  public final_working_date: string | null;
+  public weekly_hours: number | null;
+  public holiday_allowance: number;
+  public holiday_allowance_unit: string;
+  public payroll_id: string | null;
+  public salary: number;
+  public salary_type: string;
+  public overtime_rate: number;
+  public role_rates: LeaveRates;
+  public leave_rates: RoleRates;
+  public leave_rates_unit: string;
+  public leave_rates_type: string;
+  public notes: string | null;
 
   constructor(user: ApiUser) {
     this.id = user.id;

package/src/rotacloud.ts

@@ -1,6 +1,7 @@
 import {
   AccountsService,
   AttendanceService,
+  AvailabilityService,
   DaysOffService,
   GroupsService,
   LeaveEmbargoesService,
@@ -19,6 +20,7 @@ export class RotaCloud {
   public defaultAPIURI = 'https://api.rotacloud.com/v1';
   public accounts = new AccountsService();
   public attendance = new AttendanceService();
+  public availability = new AvailabilityService();
   public daysOff = new DaysOffService();
   public group = new GroupsService();
   public leaveEmbargoes = new LeaveEmbargoesService();

package/src/services/accounts.service.ts

@@ -13,6 +13,19 @@ class AccountsService extends Service {
     }
   }
 
+  listAll(): Promise<Account[]>;
+  async listAll() {
+    try {
+      const accounts = [] as Account[];
+      for await (const account of this.list()) {
+        accounts.push(account);
+      }
+      return accounts;
+    } catch (err) {
+      return err;
+    }
+  }
+
   listByPage(options?: Options<InternalQueryParams>) {
     return super.iterator<ApiAccount>({ url: this.apiPath }, options).byPage();
   }

package/src/services/attendance.service.ts

@@ -47,6 +47,19 @@ class AttendanceService extends Service {
     }
   }
 
+  listAll(): Promise<Attendance[]>;
+  async listAll() {
+    try {
+      const attendance = [] as Attendance[];
+      for await (const atten of this.list()) {
+        attendance.push(atten);
+      }
+      return attendance;
+    } catch (err) {
+      return err;
+    }
+  }
+
   listByPage(options?: Options<AttendanceQueryParams & InternalQueryParams>) {
     return super.iterator<ApiAttendance>({ url: this.apiPath }, options).byPage();
   }

package/src/services/availability.service.ts

@@ -0,0 +1,23 @@
+import { Service, Options, RequirementsOf } from './index.js';
+
+import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.inteface.js';
+import { AvailabilityQueryParams } from '../interfaces/query-params/availability-query-params.interface.js';
+import { Availability } from '../models/availability.model.js';
+import { ApiAvailability } from '../interfaces/availability.interface.js';
+
+type RequiredProps = 'start' | 'end';
+type RequiredOptions<T> = RequirementsOf<Options<T>, 'params'>;
+
+export class AvailabilityService extends Service {
+  private apiPath = '/availability';
+
+  async *list(options: RequiredOptions<RequirementsOf<AvailabilityQueryParams, RequiredProps> & InternalQueryParams>) {
+    for await (const res of super.iterator<ApiAvailability>({ url: this.apiPath }, options)) {
+      yield new Availability(res);
+    }
+  }
+
+  listByPage(options: RequiredOptions<RequirementsOf<AvailabilityQueryParams, RequiredProps> & InternalQueryParams>) {
+    return super.iterator<ApiAvailability>({ url: this.apiPath }, options).byPage();
+  }
+}

package/src/services/days-off.service.ts

@@ -39,6 +39,19 @@ class DaysOffService extends Service<ApiDaysOff> {
     }
   }
 
+  listAll(): Promise<DaysOff[]>;
+  async listAll() {
+    try {
+      const daysOff = [] as DaysOff[];
+      for await (const dayOff of this.list()) {
+        daysOff.push(dayOff);
+      }
+      return daysOff;
+    } catch (err) {
+      return err;
+    }
+  }
+
   listByPage(options?: Options<DaysOffQueryParams & InternalQueryParams>) {
     return super.iterator({ url: this.apiPath }, options).byPage();
   }

package/src/services/groups.service.ts

@@ -41,6 +41,19 @@ class GroupsService extends Service {
     }
   }
 
+  listAll(): Promise<Group[]>;
+  async listAll() {
+    try {
+      const groups = [] as Group[];
+      for await (const group of this.list()) {
+        groups.push(group);
+      }
+      return groups;
+    } catch (err) {
+      return err;
+    }
+  }
+
   listByPage(options?: Options<GroupsQueryParams & InternalQueryParams>) {
     return super.iterator<ApiGroup>({ url: this.apiPath }, options).byPage();
   }

package/src/services/index.ts

@@ -1,6 +1,7 @@
 export * from './service.js';
 export * from './accounts.service.js';
 export * from './attendance.service.js';
+export * from './availability.service.js';
 export * from './days-off.service.js';
 export * from './groups.service.js';
 export * from './leave-request.service.js';

package/src/services/leave-embargoes.service.ts

@@ -47,6 +47,19 @@ class LeaveEmbargoesService extends Service {
     }
   }
 
+  listAll(): Promise<LeaveEmbargo[]>;
+  async listAll() {
+    try {
+      const leave = [] as LeaveEmbargo[];
+      for await (const leaveEmbargoRecord of this.list()) {
+        leave.push(leaveEmbargoRecord);
+      }
+      return leave;
+    } catch (err) {
+      return err;
+    }
+  }
+
   listByPage(options?: Options<UsersQueryParams & InternalQueryParams>) {
     return super.iterator<ApiLeaveEmbargo>({ url: this.apiPath }, options).byPage();
   }

package/src/services/leave-request.service.ts

@@ -47,6 +47,19 @@ class LeaveRequestService extends Service {
     }
   }
 
+  listAll(): Promise<LeaveRequest[]>;
+  async listAll() {
+    try {
+      const leave = [] as LeaveRequest[];
+      for await (const leaveRequestRecord of this.list()) {
+        leave.push(leaveRequestRecord);
+      }
+      return leave;
+    } catch (err) {
+      return err;
+    }
+  }
+
   listByPage(options?: Options<LeaveQueryParams & InternalQueryParams>) {
     return super.iterator<ApiLeaveRequest>({ url: `${this.apiPath}` }, options).byPage();
   }

package/src/services/leave.service.ts

@@ -42,6 +42,19 @@ class LeaveService extends Service {
     }
   }
 
+  listAll(): Promise<Leave[]>;
+  async listAll() {
+    try {
+      const leave = [] as Leave[];
+      for await (const leaveRecord of this.list()) {
+        leave.push(leaveRecord);
+      }
+      return leave;
+    } catch (err) {
+      return err;
+    }
+  }
+
   async *listLeaveTypes(options?: Options<InternalQueryParams>) {
     for await (const res of super.iterator<ApiLeaveType>({ url: this.apiPath }, options)) {
       yield new LeaveType(res);

package/src/services/locations.service.ts

@@ -44,6 +44,19 @@ class LocationsService extends Service {
     }
   }
 
+  listAll(): Promise<Location[]>;
+  async listAll() {
+    try {
+      const locations = [] as Location[];
+      for await (const location of this.list()) {
+        locations.push(location);
+      }
+      return locations;
+    } catch (err) {
+      return err;
+    }
+  }
+
   listByPage(options?: Options<LocationsQueryParams & InternalQueryParams>) {
     return super.iterator<ApiLocation>({ url: this.apiPath }, options).byPage();
   }

package/src/services/roles.service.ts

@@ -41,6 +41,19 @@ class RolesService extends Service {
     }
   }
 
+  listAll(): Promise<Role[]>;
+  async listAll() {
+    try {
+      const roles = [] as Role[];
+      for await (const role of this.list()) {
+        roles.push(role);
+      }
+      return roles;
+    } catch (err) {
+      return err;
+    }
+  }
+
   listByPage(options?: Options<RolesQueryParams & InternalQueryParams>) {
     return super.iterator<ApiRole>({ url: this.apiPath }, options).byPage();
   }

package/src/services/shifts.service.ts

@@ -41,6 +41,19 @@ class ShiftsService extends Service {
     }
   }
 
+  listAll(): Promise<Shift[]>;
+  async listAll() {
+    try {
+      const shifts = [] as Shift[];
+      for await (const shift of this.list()) {
+        shifts.push(shift);
+      }
+      return shifts;
+    } catch (err) {
+      return err;
+    }
+  }
+
   listByPage(options?: Options<ShiftsQueryParams & InternalQueryParams>) {
     return super.iterator<ApiShift>({ url: this.apiPath }, options).byPage();
   }

package/src/services/users.service.ts

@@ -41,6 +41,19 @@ class UsersService extends Service {
     }
   }
 
+  listAll(): Promise<User[]>;
+  async listAll() {
+    try {
+      const users = [] as User[];
+      for await (const user of this.list()) {
+        users.push(user);
+      }
+      return users;
+    } catch (err) {
+      return err;
+    }
+  }
+
   listByPage(options?: Options<UsersQueryParams & InternalQueryParams>) {
     return super.iterator<ApiUser>({ url: this.apiPath }, options).byPage();
   }

package/src/version.ts

@@ -1 +1 @@
-export const Version = { version: "1.0.11" }
+export const Version = { version: '1.0.13' }