Merge pull request #19 from fLotte-meets-HWR-DB/develop

Develop

src/datasources/db/cargobikeAPI.ts

@@ -26,7 +26,7 @@ import { Equipment } from '../../model/Equipment';
 import { Engagement } from '../../model/Engagement';
 import { Provider } from '../../model/Provider';
 import { TimeFrame } from '../../model/TimeFrame';
-import { ActionLogger, deleteEntity, LockUtils } from './utils';
+import { ActionLogger, deleteEntity, getAllEntity, LockUtils } from './utils';
 import { EquipmentType } from '../../model/EquipmentType';
 import { BikeEventType } from '../../model/BikeEventType';
 import { UserInputError } from 'apollo-server-express';
@@ -42,14 +42,8 @@ export class CargoBikeAPI extends DataSource {
         this.connection = getConnection();
     }
 
-    async getCargoBikes (offset: number, limit: number) {
+    async getCargoBikes (offset?: number, limit?: number) {
-        return await this.connection.createQueryBuilder()
+        return await getAllEntity(this.connection, CargoBike, 'cb', offset, limit);
-            .select('cargoBike')
-            .from(CargoBike, 'cargoBike')
-            .orderBy('name', 'ASC')
-            .offset(offset)
-            .limit(limit)
-            .getMany();
     }
 
     /**
@@ -221,7 +215,14 @@ export class CargoBikeAPI extends DataSource {
             .loadOne();
     }
 
-    async bikeEventsByCargoBikeId (id: number, offset: number = 0, limit:number = 100) {
+    async bikeEventsByCargoBikeId (id: number, offset?: number, limit?: number) {
+        if (offset === null || limit === null) {
+            return await this.connection.getRepository(CargoBike)
+                .createQueryBuilder('cb')
+                .relation(CargoBike, 'bikeEvents')
+                .of(id)
+                .loadMany();
+        } else {
             return await this.connection.getRepository(CargoBike)
                 .createQueryBuilder('cb')
                 .skip(offset)
@@ -230,6 +231,7 @@ export class CargoBikeAPI extends DataSource {
                 .of(id)
                 .loadMany();
         }
+    }
 
     async createBikeEventType (bikeEventType: any) {
         return (await this.connection.getRepository(BikeEventType)
@@ -267,22 +269,12 @@ export class CargoBikeAPI extends DataSource {
         return await this.bikeEventTypeById(bikeEventType.id);
     }
 
-    async bikeEventTypes (offset: number, limit: number) {
+    async bikeEventTypes (offset?: number, limit?: number) {
-        return await this.connection.getRepository(BikeEventType)
+        return await getAllEntity(this.connection, BikeEventType, 'bet', offset, limit);
-            .createQueryBuilder('bet')
-            .select()
-            .skip(offset)
-            .take(limit)
-            .getMany();
     }
 
-    async bikeEvents (offset: number, limit: number) {
+    async bikeEvents (offset?: number, limit?: number) {
-        return await this.connection.getRepository(BikeEvent)
+        return await getAllEntity(this.connection, BikeEvent, 'be', offset, limit);
-            .createQueryBuilder('be')
-            .select()
-            .skip(offset)
-            .take(limit)
-            .getMany();
     }
 
     async bikeEventTypeById (id: number) {
@@ -343,13 +335,23 @@ export class CargoBikeAPI extends DataSource {
      * @param limit
      * @param id
      */
-    async equipmentByCargoBikeId (offset: number, limit: number, id: number) {
+    async equipmentByCargoBikeId (id: number, offset?: number, limit?: number) {
+        if (offset == null || limit === null) {
+            return await this.connection.getRepository(Equipment)
+                .createQueryBuilder('equipment')
+                .select()
+                .where('equipment."cargoBikeId" = :id', { id: id })
+                .getMany();
+        } else {
             return await this.connection.getRepository(Equipment)
                 .createQueryBuilder('equipment')
                 .select()
                 .where('equipment."cargoBikeId" = :id', { id: id })
+                .skip(offset)
+                .take(limit)
                 .getMany();
         }
+    }
 
     async createEquipment ({ equipment }: { equipment: any }) {
         return await this.connection.getRepository(Equipment)

src/datasources/db/contactinformationAPI.ts

@@ -21,7 +21,7 @@ import { DataSource } from 'apollo-datasource';
 import { Connection, EntityManager, getConnection } from 'typeorm';
 import { ContactInformation } from '../../model/ContactInformation';
 import { Person } from '../../model/Person';
-import { ActionLogger, deleteEntity, LockUtils } from './utils';
+import { ActionLogger, deleteEntity, getAllEntity, LockUtils } from './utils';
 import { GraphQLError } from 'graphql';
 import { LendingStation } from '../../model/LendingStation';
 
@@ -32,13 +32,8 @@ export class ContactInformationAPI extends DataSource {
         this.connection = getConnection();
     }
 
-    async contactInformation (offset: number, limit: number) {
+    async contactInformation (offset?: number, limit?: number) {
-        return await this.connection.getRepository(ContactInformation)
+        return await getAllEntity(this.connection, ContactInformation, 'ci', offset, limit);
-            .createQueryBuilder('ci')
-            .select()
-            .offset(offset)
-            .limit(limit)
-            .getMany();
     }
 
     async contactInformationById (id: number) {
@@ -91,13 +86,8 @@ export class ContactInformationAPI extends DataSource {
         return await deleteEntity(this.connection, Person, 'p', id, userId);
     }
 
-    async persons (offset: number, limit: number) {
+    async persons (offset?: number, limit?: number) {
-        return await this.connection.getRepository(Person)
+        return await getAllEntity(this.connection, Person, 'p', offset, limit);
-            .createQueryBuilder('person')
-            .select()
-            .skip(offset)
-            .take(limit)
-            .getMany();
     }
 
     async personById (id: number) {

src/datasources/db/lendingstationAPI.ts

@@ -24,7 +24,7 @@ import { Connection, EntityManager, getConnection } from 'typeorm';
 import { CargoBike } from '../../model/CargoBike';
 import { LendingStation } from '../../model/LendingStation';
 import { TimeFrame } from '../../model/TimeFrame';
-import { ActionLogger, deleteEntity, genDateRange, LockUtils } from './utils';
+import { ActionLogger, deleteEntity, genDateRange, getAllEntity, LockUtils } from './utils';
 
 export class LendingStationAPI extends DataSource {
     connection : Connection
@@ -44,14 +44,8 @@ export class LendingStationAPI extends DataSource {
     /**
      * get all lendingStations
      */
-    async lendingStations (offset: number, limit: number) {
+    async lendingStations (offset?: number, limit?: number) {
-        return await this.connection.getRepository(LendingStation)
+        return await getAllEntity(this.connection, LendingStation, 'ls', offset, limit);
-            .createQueryBuilder('lendingStation')
-            .select()
-            .offset(offset)
-            .limit(limit)
-            .orderBy('name', 'ASC')
-            .getMany() || new GraphQLError('Internal Server Error: could not query data from table lendingStation');
     }
 
     /**
@@ -79,13 +73,8 @@ export class LendingStationAPI extends DataSource {
             .loadOne();
     }
 
-    async timeFrames (offset: number, limit: number) {
+    async timeFrames (offset?: number, limit?: number) {
-        return await this.connection.getRepository(TimeFrame)
+        return await getAllEntity(this.connection, TimeFrame, 'tf', offset, limit);
-            .createQueryBuilder('timeframe')
-            .select()
-            .offset(offset)
-            .limit(limit)
-            .getMany() || [];
     }
 
     async timeFramesByCargoBikeId (id: number) {

src/datasources/db/participantAPI.ts

@@ -23,7 +23,7 @@ import { ContactInformation } from '../../model/ContactInformation';
 import { Engagement } from '../../model/Engagement';
 import { Participant } from '../../model/Participant';
 import { EngagementType } from '../../model/EngagementType';
-import { ActionLogger, deleteEntity, genDateRange, LockUtils } from './utils';
+import { ActionLogger, deleteEntity, genDateRange, getAllEntity, LockUtils } from './utils';
 import { UserInputError } from 'apollo-server-express';
 import { GraphQLError } from 'graphql';
 
@@ -42,13 +42,8 @@ export class ParticipantAPI extends DataSource {
             .getOne();
     }
 
-    async getParticipants (offset: number, limit: number) {
+    async getParticipants (offset?: number, limit?: number) {
-        return await this.connection.getRepository(Participant)
+        return await getAllEntity(this.connection, Participant, 'p', offset, limit);
-            .createQueryBuilder('participant')
-            .select()
-            .offset(offset)
-            .limit(limit)
-            .getMany();
     }
 
     async participantByEngagementId (id: number) {
@@ -84,18 +79,25 @@ export class ParticipantAPI extends DataSource {
             .getMany();
     }
 
-    async engagementByCargoBikeId (offset: number, limit: number, id: number) {
+    async engagementByCargoBikeId (id: number, offset?: number, limit?: number) {
+        if (limit === null || offset === null) {
+            return await this.connection.getRepository(Engagement)
+                .createQueryBuilder('engagement')
+                .select()
+                .where('engagement."cargoBikeId" = :id', { id: id })
+                .orderBy('engagement."dateRange"', 'DESC')
+                .getMany();
+        } else {
             return await this.connection.getRepository(Engagement)
                 .createQueryBuilder('engagement')
                 .select()
-            .where('engagement."cargoBikeId" = :id', {
+                .where('engagement."cargoBikeId" = :id', { id: id })
-                id: id
-            })
                 .skip(offset)
                 .take(limit)
                 .orderBy('engagement."dateRange"', 'DESC')
                 .getMany();
         }
+    }
 
     async currentEngagementByCargoBikeId (id: number) {
         return await this.connection.getRepository(Engagement)
@@ -107,13 +109,8 @@ export class ParticipantAPI extends DataSource {
             .getMany();
     }
 
-    async engagements (offset: number, limit: number) {
+    async engagements (offset?: number, limit?: number) {
-        return await this.connection.getRepository(Engagement)
+        return await getAllEntity(this.connection, Engagement, 'e', offset, limit);
-            .createQueryBuilder('e')
-            .select()
-            .skip(offset)
-            .take(limit)
-            .getMany();
     }
 
     async engagementById (id: number) {
@@ -132,13 +129,8 @@ export class ParticipantAPI extends DataSource {
             .getOne();
     }
 
-    async engagementTypes (offset: number, limit: number) {
+    async engagementTypes (offset?: number, limit?: number) {
-        return await this.connection.getRepository(EngagementType)
+        return await getAllEntity(this.connection, Engagement, 'e', offset, limit);
-            .createQueryBuilder('et')
-            .select()
-            .skip(offset)
-            .take(limit)
-            .getMany();
     }
 
     async engagementTypeByEngagementId (id: number) {

src/datasources/db/providerAPI.ts

@@ -24,7 +24,7 @@ import { Organisation } from '../../model/Organisation';
 import { UserInputError } from 'apollo-server-express';
 import { CargoBike } from '../../model/CargoBike';
 import { LendingStation } from '../../model/LendingStation';
-import { ActionLogger, deleteEntity, LockUtils } from './utils';
+import { ActionLogger, deleteEntity, getAllEntity, LockUtils } from './utils';
 import { GraphQLError } from 'graphql';
 
 export class ProviderAPI extends DataSource {
@@ -42,13 +42,8 @@ export class ProviderAPI extends DataSource {
             .getOne();
     }
 
-    async provider (offset: number, limit: number) {
+    async provider (offset?: number, limit?: number) {
-        return await this.connection.getRepository(Provider)
+        return await getAllEntity(this.connection, Provider, 'p', offset, limit);
-            .createQueryBuilder('provider')
-            .select()
-            .skip(offset)
-            .take(limit)
-            .getMany();
     }
 
     async providerByOrganisationId (id: number) {
@@ -75,13 +70,8 @@ export class ProviderAPI extends DataSource {
             .loadOne();
     }
 
-    async organisations (offset: number, limit: number) {
+    async organisations (offset?: number, limit?: number) {
-        return await this.connection.getRepository(Organisation)
+        return await getAllEntity(this.connection, Organisation, 'o', offset, limit);
-            .createQueryBuilder('o')
-            .select()
-            .skip(offset)
-            .limit(limit)
-            .getMany();
     }
 
     async organisationById (id: number) {

src/datasources/db/utils.ts

@@ -64,6 +64,22 @@ export async function deleteEntity (connection: Connection, target: ObjectType<L
     });
 }
 
+export async function getAllEntity (connection: Connection, target: ObjectType<any>, alias: string, offset?: number, limit?: number) {
+    if (offset === null || limit === null) {
+        return await connection.getRepository(target)
+            .createQueryBuilder(alias)
+            .select()
+            .getMany();
+    } else {
+        return await connection.getRepository(target)
+            .createQueryBuilder(alias)
+            .select()
+            .skip(offset)
+            .take(limit)
+            .getMany();
+    }
+}
+
 export class LockUtils {
     static async findById (connection: Connection, target: ObjectType<Lockable>, alias: string, id: number): Promise<Lockable> {
         return await connection.getRepository(target)

src/datasources/db/workshopAPI.ts

@@ -21,7 +21,7 @@ import { DataSource } from 'apollo-datasource';
 import { Connection, EntityManager, getConnection } from 'typeorm';
 import { WorkshopType } from '../../model/WorkshopType';
 import { Workshop } from '../../model/Workshop';
-import { ActionLogger, deleteEntity, LockUtils } from './utils';
+import { ActionLogger, deleteEntity, getAllEntity, LockUtils } from './utils';
 import { UserInputError } from 'apollo-server-express';
 import { GraphQLError } from 'graphql';
 import { Participant } from '../../model/Participant';
@@ -126,13 +126,8 @@ export class WorkshopAPI extends DataSource {
             .getOne();
     }
 
-    async workshopTypes (offset: number, limit: number) {
+    async workshopTypes (offset?: number, limit?: number) {
-        return await this.connection.getRepository(WorkshopType)
+        return getAllEntity(this.connection, WorkshopType, 'wt', offset, limit);
-            .createQueryBuilder('w')
-            .select()
-            .skip(offset)
-            .take(limit)
-            .getMany();
     }
 
     async workshopById (id: number) {
@@ -148,13 +143,8 @@ export class WorkshopAPI extends DataSource {
      * @param offset
      * @param limit
      */
-    async workshops (offset: number, limit: number) {
+    async workshops (offset?: number, limit?: number) {
-        return await this.connection.getRepository(Workshop)
+        return await getAllEntity(this.connection, Workshop, 'w', offset, limit);
-            .createQueryBuilder('w')
-            .select()
-            .skip(offset)
-            .take(limit)
-            .getMany();
     }
 
     async trainer1ByWorkshopId (id: number) {

src/resolvers/cargoBikeResolver.ts

@@ -30,14 +30,14 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        cargoBikes: (_: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        cargoBikes: (_: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadBike)) {
                 return dataSources.cargoBikeAPI.getCargoBikes(offset, limit);
             } else {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        bikeEvents: (_:any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        bikeEvents: (_:any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadBikeEvent)) {
                 return dataSources.cargoBikeAPI.bikeEvents(offset, limit);
             } else {
@@ -58,14 +58,14 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        bikeEventTypes: (_:any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        bikeEventTypes: (_:any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadBikeEvent)) {
                 return dataSources.cargoBikeAPI.bikeEventTypes(offset, limit);
             } else {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        equipment: (_:any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        equipment: (_:any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadEquipment)) {
                 return dataSources.cargoBikeAPI.getEquipment(offset, limit);
             } else {
@@ -79,7 +79,7 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        equipmentTypes: (_:any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        equipmentTypes: (_:any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadEquipment)) {
                 return dataSources.cargoBikeAPI.equipmentTypes(offset, limit);
             } else {
@@ -102,23 +102,23 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        engagement (parent: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) {
+        engagement (parent: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) {
             if (req.permissions.includes(Permission.ReadEngagement)) {
-                return dataSources.participantAPI.engagementByCargoBikeId(offset, limit, parent.id);
+                return dataSources.participantAPI.engagementByCargoBikeId(parent.id, offset, limit);
             } else {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        participants (parent: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) { // TODO should be done with engagements
+        participants (parent: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) { // TODO should be done with engagements
             if (req.permissions.includes(Permission.ReadParticipant)) {
                 return dataSources.participantAPI.participantsByCargoBikeId(parent.id);
             } else {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        equipment (parent: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) {
+        equipment (parent: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) {
             if (req.permissions.includes(Permission.ReadEquipment)) {
-                return dataSources.cargoBikeAPI.equipmentByCargoBikeId(offset, limit, parent.id);
+                return dataSources.cargoBikeAPI.equipmentByCargoBikeId(parent.id, offset, limit);
             } else {
                 return new GraphQLError('Insufficient Permissions');
             }
@@ -130,7 +130,7 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        bikeEvents (parent: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) {
+        bikeEvents (parent: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) {
             if (req.permissions.includes(Permission.ReadBikeEvent)) {
                 return dataSources.cargoBikeAPI.bikeEventsByCargoBikeId(parent.id, offset, limit);
             } else {
@@ -173,6 +173,10 @@ export default {
         isLockedByMe: (parent: any, __: any, { req }: { req: any }) => isLockedByMe(parent, { req }),
         isLocked: (parent: any, __: any, { req }: { req: any }) => isLocked(parent, { req })
     },
+    EquipmentType: {
+        isLockedByMe: (parent: any, __: any, { req }: { req: any }) => isLockedByMe(parent, { req }),
+        isLocked: (parent: any, __: any, { req }: { req: any }) => isLocked(parent, { req })
+    },
     BikeEvent: {
         cargoBike (parent: any, __: any, { dataSources, req }: { dataSources: any, req: any }) {
             if (req.permissions.includes(Permission.ReadBike)) {

src/resolvers/contactInformationResolvers.ts

@@ -24,7 +24,7 @@ import { isLocked, isLockedByMe } from '../datasources/db/utils';
 
 export default {
     Query: {
-        contactInformation: (_: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        contactInformation: (_: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadPerson)) {
                 return dataSources.contactInformationAPI.contactInformation(offset, limit);
             } else {
@@ -45,7 +45,7 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        persons: (_: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        persons: (_: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadPerson)) {
                 return dataSources.contactInformationAPI.persons(offset, limit);
             } else {

src/resolvers/lendingStationResolvers.ts

@@ -31,7 +31,7 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        lendingStations: (_: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        lendingStations: (_: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadLendingStation)) {
                 return dataSources.lendingStationAPI.lendingStations(offset, limit);
             } else {
@@ -45,7 +45,7 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        timeFrames: (_: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        timeFrames: (_: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadTimeFrame)) {
                 return dataSources.lendingStationAPI.timeFrames(offset, limit);
             } else {

src/resolvers/participantResolvers.ts

@@ -30,7 +30,7 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        participants: (_: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        participants: (_: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadParticipant)) {
                 return dataSources.participantAPI.getParticipants(offset, limit);
             } else {
@@ -44,7 +44,7 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        engagements: (_: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        engagements: (_: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadEngagement)) {
                 return dataSources.participantAPI.engagements(offset, limit);
             } else {
@@ -58,7 +58,7 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        engagementTypes: (_: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        engagementTypes: (_: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadEngagement)) {
                 return dataSources.participantAPI.engagementTypes(offset, limit);
             } else {

src/resolvers/providerResolvers.ts

@@ -23,7 +23,7 @@ import { isLocked, isLockedByMe } from '../datasources/db/utils';
 
 export default {
     Query: {
-        providers: (_: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        providers: (_: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadProvider)) {
                 return dataSources.providerAPI.provider(offset, limit);
             } else {
@@ -37,7 +37,7 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        organisations: (_: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        organisations: (_: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadOrganisation)) {
                 return dataSources.providerAPI.organisations(offset, limit);
             } else {

src/resolvers/workshopResolvers.ts

@@ -31,7 +31,7 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        workshopTypes: (_: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        workshopTypes: (_: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadWorkshop)) {
                 return dataSources.workshopAPI.workshopTypes(offset, limit);
             } else {
@@ -45,7 +45,7 @@ export default {
                 return new GraphQLError('Insufficient Permissions');
             }
         },
-        workshops: (_: any, { offset, limit }: { offset: number, limit: number }, { dataSources, req }: { dataSources: any, req: any }) => {
+        workshops: (_: any, { offset, limit }: { offset?: number, limit?: number }, { dataSources, req }: { dataSources: any, req: any }) => {
             if (req.permissions.includes(Permission.ReadWorkshop)) {
                 return dataSources.workshopAPI.workshops(offset, limit);
             } else {

src/schema/type-defs.ts

@@ -57,8 +57,10 @@ export default gql`
         Does not refer to an extra table in the database.
         """
         dimensionsAndLoad: DimensionsAndLoad!
+        "If offset or limit is not provided, both values are ignored"
         bikeEvents(offset: Int, limit: Int): [BikeEvent]
-        equipment(offset: Int!, limit: Int!): [Equipment]
+        "If offset or limit is not provided, both values are ignored"
+        equipment(offset: Int, limit: Int): [Equipment]
         "Refers to equipment that is not unique. See kommentierte info tabelle -> Fragen -> Frage 2"
         equipmentType: [EquipmentType]
         "Sticker State"
@@ -71,7 +73,8 @@ export default gql`
         lendingStation: LendingStation
         taxes: Taxes
         currentEngagements: [Engagement]
-        engagement(offset: Int!, limit: Int!): [Engagement]
+        "If offset or limit is not provided, both values are ignored"
+        engagement(offset: Int, limit: Int): [Engagement]
         timeFrames: [TimeFrame]
         isLocked: Boolean!
         isLockedByMe: Boolean!
@@ -670,6 +673,8 @@ export default gql`
         name: String!
         isLockedByMe: Boolean!
         isLocked: Boolean!
+        "null if not locked by other user"
+        lockedBy: ID
         lockedUntil: Date
     }
 
@@ -960,41 +965,55 @@ export default gql`
     type Query {
         "Will (eventually) return all properties of cargo bike"
         cargoBikeById(id:ID!): CargoBike
-        "returns cargoBikes ordered by name ascending, relations are not loaded, use cargoBikeById instead"
+        "Returns cargoBikes ordered by name ascending. If offset or limit is not provided, both values are ignored."
-        cargoBikes(offset: Int!, limit: Int!): [CargoBike!]!
+        cargoBikes(offset: Int, limit: Int): [CargoBike!]!
         engagementById(id: ID!): Engagement
-        engagements(offset: Int!, limit: Int!): [Engagement!]!
+        "If offset or limit is not provided, both values are ignored"
+        engagements(offset: Int, limit: Int): [Engagement!]!
         engagementTypeById(id: ID!): EngagementType
-        engagementTypes(offset: Int!, limit: Int!): [EngagementType!]!
+        "If offset or limit is not provided, both values are ignored"
+        engagementTypes(offset: Int, limit: Int): [EngagementType!]!
         "equipment by id, will return null if id not found"
         equipmentById(id: ID!): Equipment
-        equipment(offset: Int!, limit: Int!): [Equipment!]!
+        "If offset or limit is not provided, both values are ignored"
+        equipment(offset: Int, limit: Int): [Equipment!]!
         equipmentTypeById(id: ID!): EquipmentType
-        equipmentTypes(offset: Int!, limit: Int!): [EquipmentType!]!
+        "If offset or limit is not provided, both values are ignored"
+        equipmentTypes(offset: Int, limit: Int): [EquipmentType!]!
         "return null if id not found"
         providerById(id:ID!): Provider
-        "Returns providers with pagination"
+        "Returns providers with pagination. If offset or limit is not provided, both values are ignored"
-        providers(offset: Int!, limit: Int!): [Provider!]!
+        providers(offset: Int, limit: Int): [Provider!]!
         "participant by id"
         participantById(id:ID!):  Participant
-        participants(offset: Int!, limit: Int!): [Participant!]!
+        "If offset or limit is not provided, both values are ignored"
+        participants(offset: Int, limit: Int): [Participant!]!
         workshopTypeById(id: ID!): WorkshopType
-        workshopTypes(offset: Int!, limit: Int!): [WorkshopType!]!
+        "If offset or limit is not provided, both values are ignored"
+        workshopTypes(offset: Int, limit: Int): [WorkshopType!]!
         workshopById(id: ID!): Workshop
-        workshops(offset: Int!, limit: Int!): [Workshop!]!
+        "If offset or limit is not provided, both values are ignored"
+        workshops(offset: Int, limit: Int): [Workshop!]!
         lendingStationById(id:ID!): LendingStation
-        lendingStations(offset: Int!, limit: Int!): [LendingStation!]!
+        "If offset or limit is not provided, both values are ignored"
+        lendingStations(offset: Int, limit: Int): [LendingStation!]!
         organisationById(id: ID!): Organisation
-        organisations(offset: Int!, limit: Int!): [Organisation!]!
+        "If offset or limit is not provided, both values are ignored"
+        organisations(offset: Int, limit: Int): [Organisation!]!
         timeFrameById(id: ID!): TimeFrame
-        timeFrames(offset: Int!, limit: Int!): [TimeFrame!]!
+        "If offset or limit is not provided, both values are ignored"
+        timeFrames(offset: Int, limit: Int): [TimeFrame!]!
         contactInformationById(id: ID!): ContactInformation
-        contactInformation(offset: Int!, limit: Int!): [ContactInformation!]!
+        "If offset or limit is not provided, both values are ignored"
+        contactInformation(offset: Int, limit: Int): [ContactInformation!]!
         personById(id: ID!): Person
-        persons(offset: Int!, limit: Int!): [Person!]
+        "If offset or limit is not provided, both values are ignored"
-        bikeEventTypes(offset: Int!, limit: Int!): [BikeEventType!]
+        persons(offset: Int, limit: Int): [Person!]
+        "If offset or limit is not provided, both values are ignored"
+        bikeEventTypes(offset: Int, limit: Int): [BikeEventType!]
         bikeEventTypeByd(id: ID!): BikeEventType
-        bikeEvents(offset: Int!, limit: Int!): [BikeEvent!]!
+        "If offset or limit is not provided, both values are ignored"
+        bikeEvents(offset: Int, limit: Int): [BikeEvent!]!
         bikeEventById(id:ID!): BikeEvent
         "actionLog for current user"
         actionLog: [ActionLog!]