wip: ADDING post route

app/common/User.ts

@@ -10,6 +10,8 @@ export enum UserTypes {
   'service'
 }
 
+export type UserTypesStrings = keyof typeof UserTypes;
+
 /**
  * Information about a user, including any user attributes.
  */

app/gen-server/ApiServer.ts

@@ -582,6 +582,35 @@ export class ApiServer {
       if (data) { this._logDeleteUserEvents(req, data); }
       return sendReply(req, res, result);
     }));
+
+    // POST /service-accounts/
+    // Creates a new service account attached to the user making the api call.
+    this._app.post('/api/service-accounts', expressWrap(async (req, res) => {
+      const userId = getAuthorizedUserId(req);
+      const serviceAccount: any = await this._dbManager.createServiceAccount(req.body);
+      return sendOkReply(req, res, {
+        key:serviceAccount.key,
+      });
+      throw new ApiError(`${userId} post Not implemented yet ;)`, 501);
+    }));
+
+    // GET /service-accounts/
+    // Reads all service accounts attached to the user making the api call.
+    this._app.get('/api/service-accounts', expressWrap(async (req, res) => {
+      throw new ApiError('get Not implemented yet ;)', 501);
+    }));
+
+    // GET /service-accounts/:said
+    // Reads one particular service account of the user making the api call.
+    this._app.get('/api/service-accounts/:said', expressWrap(async (req, res) => {
+      throw new ApiError('get by id Not implemented yet ;)', 501);
+    }));
+
+    // DELETE /service-accounts/:said
+    // Deletes one particular service account of the user making the api call.
+    this._app.delete('/api/service-accounts/:said', expressWrap(async (req, res) => {
+      throw new ApiError('delete by id Not implemented yet ;)', 501);
+    }));
   }
 
   private async _getFullUser(req: Request, options: {includePrefs?: boolean} = {}): Promise<FullUser> {

app/gen-server/entity/ServiceAccount.ts

@@ -1,23 +1,20 @@
-import {BaseEntity, Column, Entity, JoinTable, ManyToOne, PrimaryGeneratedColumn} from "typeorm";
-import { User } from './User';
+import {BaseEntity, Column, Entity, PrimaryGeneratedColumn} from "typeorm";
 
 @Entity({name: 'service_accounts'})
 export class ServiceAccount extends BaseEntity {
 
   @PrimaryGeneratedColumn()
   public id: number;
 
+  @Column({type: Number})
+  public owner_id: number;
+
+  @Column({type: Number})
+  public service_user_id: number;
+
   @Column({type: String})
   public description: string;
 
   @Column({type: Date, nullable: false})
   public endOfLife: string;
-
-  @ManyToOne(type => User)
-  @JoinTable({
-    name: 'service_account_user',
-    joinColumn: {name: 'service_account_id'},
-    inverseJoinColumn: {name: 'user_id'}
-  })
-  public service_account_owner: User;
 }

app/gen-server/entity/User.ts

@@ -1,5 +1,5 @@
 import {UserOptions} from 'app/common/UserAPI';
-import {UserTypes} from 'app/common/User';
+import {UserTypesStrings} from 'app/common/User';
 import {nativeValues} from 'app/gen-server/lib/values';
 import {makeId} from 'app/server/lib/idUtils';
 import {BaseEntity, BeforeInsert, Column, Entity, JoinTable, ManyToMany, OneToMany, OneToOne,
@@ -74,7 +74,7 @@ export class User extends BaseEntity {
   public ref: string;
 
   @Column({name: 'type', type: String, default: 'login'})
-  public type: UserTypes | null;
+  public type: UserTypesStrings | null;
 
   @BeforeInsert()
   public async beforeInsert() {

app/gen-server/lib/homedb/HomeDBManager.ts

@@ -87,6 +87,7 @@ import {
   WhereExpressionBuilder
 } from "typeorm";
 import {v4 as uuidv4} from "uuid";
+import { ServiceAccountsManager } from './ServiceAccountsManager';
 
 // Support transactions in Sqlite in async code.  This is a monkey patch, affecting
 // the prototypes of various TypeORM classes.
@@ -258,6 +259,7 @@ export type BillingOptions = Partial<Pick<BillingAccount,
  */
 export class HomeDBManager extends EventEmitter {
   private _usersManager = new UsersManager(this, this._runInTransaction.bind(this));
+  private _serviceAccountsManager = new ServiceAccountsManager(this);
   private _connection: DataSource;
   private _exampleWorkspaceId: number;
   private _exampleOrgId: number;
@@ -3104,6 +3106,18 @@ export class HomeDBManager extends EventEmitter {
     return query.getOne();
   }
 
+  public async deleteAllServiceAccounts(){
+    return this._serviceAccountsManager.deleteAllServiceAccounts();
+  }
+
+  public async createServiceAccount(
+    ownerId: number,
+    description?: string,
+    endOfLife?: Date
+  ){
+  return this._serviceAccountsManager.createServiceAccount(ownerId, description, endOfLife);
+  }
+
   private _installConfig(
     key: ConfigKey,
     { manager }: { manager?: EntityManager }

app/gen-server/lib/homedb/ServiceAccountsManager.ts

@@ -0,0 +1,55 @@
+import { HomeDBManager } from 'app/gen-server/lib/homedb/HomeDBManager';
+//import { UsersManager } from 'app/gen-server/lib/homedb/UsersManager';
+import { EntityManager } from 'typeorm';
+import { User } from 'app/gen-server/entity/User';
+import {v4 as uuidv4} from 'uuid';
+//import { ServiceAccount } from 'app/gen-server/entity/ServiceAccount';
+
+export class ServiceAccountsManager {
+
+  private get _connection () {
+    return this._homeDb.connection;
+  }
+
+  public constructor(
+    private readonly _homeDb: HomeDBManager,
+    //private _runInTransaction: RunInTransaction
+  ) {}
+
+  // This method is implemented for test purpose only
+  // Using it outside of tests context will lead to partial db
+  // destruction
+  public async deleteAllServiceAccounts(optManager?: EntityManager){
+    const manager = optManager || new EntityManager(this._connection);
+    const queryBuilder = manager.createQueryBuilder()
+      .delete()
+      .from(User, 'users')
+      .where('users.type ="service"');
+    return await queryBuilder.execute();
+  }
+
+  public async createServiceAccount(
+    ownerId: number,
+    description?: string,
+    endOfLife?: Date,
+  ){
+    await this._connection.transaction(async manager => {
+      //TODO create new service user in order to have its
+      //id to insert
+      const uuid = uuidv4();
+      const email = `${uuid}@serviceaccounts.local`;
+      const serviceUser = await this._homeDb.getUserByLogin(email);
+      // FIXME use manager.save(entité);
+      return await manager.createQueryBuilder()
+        .insert()
+        .into('service_accounts')
+        .values({
+          ownerId,
+          serviceUserId: serviceUser.id,
+          description,
+          endOfLife,
+        })
+        .execute();
+    });
+  }
+}

app/gen-server/lib/homedb/UsersManager.ts

@@ -27,6 +27,8 @@ import { Pref } from 'app/gen-server/entity/Pref';
 import flatten from 'lodash/flatten';
 import { EntityManager } from 'typeorm';
 
+import { UserTypesStrings } from 'app/common/User';
+
 // A special user allowed to add/remove the EVERYONE_EMAIL to/from a resource.
 export const SUPPORT_EMAIL = appSettings.section('access').flag('supportEmail').requireString({
   envVar: 'GRIST_SUPPORT_EMAIL',
@@ -364,7 +366,7 @@ export class UsersManager {
    * unset/outdated fields of an existing record.
    *
    */
-  public async getUserByLogin(email: string, options: GetUserOptions = {}) {
+  public async getUserByLogin(email: string, options: GetUserOptions = {}, type?: UserTypesStrings) {
     const {manager: transaction, profile, userOptions} = options;
     const normalizedEmail = normalizeEmail(email);
     return await this._runInTransaction(transaction, async manager => {
@@ -382,6 +384,8 @@ export class UsersManager {
         // Special users do not have first time user set so that they don't get redirected to the
         // welcome page.
         user.isFirstTimeUser = !NON_LOGIN_EMAILS.includes(normalizedEmail);
+        // redémarrer lundi ici TODO
+        user.type = typeof type === 'undefined' ? 'login' : type;
         login = new Login();
         login.email = normalizedEmail;
         login.user = user;

app/gen-server/migration/1730215435023-ServiceAccounts.ts

@@ -23,62 +23,54 @@ export class ServiceAccounts1730215435023 implements MigrationInterface {
             isPrimary: true,
           },
           {
-            name: 'description',
-            type: 'varchar'
+            name: 'owner_id',
+            type: 'int',
           },
           {
-            name: 'endOfLife',
-            type: datetime,
-            isNullable: false,
+            name: 'service_user_id',
+            type: 'int',
           },
-        ],
-      })
-    );
-    await queryRunner.createTable(
-      new Table({
-        name: 'service_account_user',
-        columns: [
           {
-            name: 'service_account_id',
-            type: 'int',
+            name: 'description',
+            type: 'varchar',
           },
           {
-            name: 'user_id',
-            type: 'int'
+            name: 'endOfLife',
+            type: datetime,
+            isNullable: false,
           },
         ],
       })
     );
     await queryRunner.createForeignKey(
-      'service_account_user',
+      'service_accounts',
       new TableForeignKey({
-        columnNames: ['service_account_id'],
+        columnNames: ['service_user_id'],
         referencedColumnNames: ['id'],
-        referencedTableName: 'service_accounts',
+        referencedTableName: 'users',
         onDelete: 'CASCADE',
       })
     );
     await queryRunner.createForeignKey(
-      'service_account_user',
+      'service_accounts',
       new TableForeignKey({
-        columnNames: ['user_id'],
+        columnNames: ['owner_id'],
         referencedColumnNames: ['id'],
         referencedTableName: 'users',
         onDelete: 'CASCADE',
       })
     );
     await queryRunner.createIndex(
-      'service_account_user',
+      'service_accounts',
       new TableIndex({
-        name: 'service_account__user',
-        columnNames: ['service_account_id', 'user_id'],
+        name: 'service_account__owner',
+        columnNames: ['service_accounts_owner', 'user_id'],
       })
     );
   }
 
   public async down(queryRunner: QueryRunner): Promise<any> {
     await queryRunner.dropColumn('users', 'type');
     await queryRunner.dropTable('service_accounts');
-    await queryRunner.dropTable('service_account_user');
   }
 }

test/gen-server/ApiServer.ts

@@ -2350,9 +2350,7 @@ describe('ApiServer', function() {
 
     afterEach(async function() {
       oldEnv.restore();
-      // FIXME create the new method to delete services accounts
-      //const did = await dbManager.testGetId('Curiosity');
-      // await dbManager.deleteServices(did as string);
+      await dbManager.deleteAllServiceAccounts();
     });
 
     after(async function() {
@@ -2420,6 +2418,10 @@ describe('ApiServer', function() {
     // it('Endpoint UPDATE /api/service-accounts/{saId}/transfer-to/{userId}', async function() {
 
     // });
+
+    // it('MUSN'T connect as a login user, async function() {
+
+    //});
   });
 });