wip ajout route organizations

Author: aurelie-crouillebois

api/db/database-builder/factory/build-client-application.js

@@ -11,6 +11,7 @@ export function buildClientApplication({
   clientId = 'client-id',
   clientSecret = 'super-secret',
   scopes = ['scope1', 'scope2'],
+  jurisdiction = { rules: [{ name: 'tags', value: ['MEDNUM'] }] },
 } = {}) {
   return databaseBuffer.pushInsertable({
     tableName: 'client_applications',
@@ -20,6 +21,7 @@ export function buildClientApplication({
       clientId,
       clientSecret: _getHashedSecret(clientSecret),
       scopes,
+      jurisdiction,
     },
   });
 }

api/server.maddo.js

@@ -6,6 +6,7 @@ import { setupErrorHandling } from './config/server-setup-error-handling.js';
 import { knex } from './db/knex-database-connection.js';
 import * as authenticationRoutes from './lib/application/authentication/index.js';
 import { authentication } from './lib/infrastructure/authentication.js';
+import * as organizationRoutes from './src/maddo/application/organizations-routes.js';
 import * as replicationRoutes from './src/maddo/application/replications-routes.js';
 import { Metrics } from './src/monitoring/infrastructure/metrics.js';
 import * as healthcheckRoutes from './src/shared/application/healthcheck/index.js';
@@ -179,7 +180,7 @@ const setupAuthentication = function (server) {
 };
 
 const setupRoutesAndPlugins = async function (server) {
-  await server.register([...plugins, healthcheckRoutes, authenticationRoutes, replicationRoutes]);
+  await server.register([...plugins, healthcheckRoutes, authenticationRoutes, replicationRoutes, organizationRoutes]);
 };
 
 const setupOpenApiSpecification = async function (server) {

api/src/identity-access-management/domain/models/ClientApplication.js

@@ -1,9 +1,10 @@
 export class ClientApplication {
-  constructor({ id, name, clientId, clientSecret, scopes }) {
+  constructor({ id, name, clientId, clientSecret, scopes, jurisdiction }) {
     this.id = id;
     this.name = name;
     this.clientId = clientId;
     this.clientSecret = clientSecret;
     this.scopes = scopes;
+    this.jurisdiction = jurisdiction;
   }
 }

api/src/maddo/application/organizations-controller.js

@@ -0,0 +1,3 @@
+export async function getOrganizations(request, h, dependencies = {}) {
+  return h.response().code(200);
+}

api/src/maddo/application/organizations-routes.js

@@ -0,0 +1,19 @@
+import { getOrganizations } from './organizations-controller.js';
+
+const register = async function (server) {
+  server.route([
+    {
+      method: 'GET',
+      path: '/api/organizations',
+      config: {
+        auth: { access: { scope: 'meta' } },
+        handler: getOrganizations,
+        notes: ["- Retourne la liste des organizations auxquelles l'application client a droit"],
+        tags: ['api', 'meta'],
+      },
+    },
+  ]);
+};
+
+const name = 'maddo-meta-api';
+export { name, register };

api/src/maddo/application/replications-routes.js

@@ -25,5 +25,5 @@ const register = async function (server) {
   ]);
 };
 
-const name = 'admin-campaign-participation-api';
+const name = 'maddo-replications-api';
 export { name, register };

api/src/maddo/infrastructure/repositories/organization-repositories.js

@@ -0,0 +1 @@
+export function findIdsByTagNames() {}

api/tests/maddo/application/acceptance/organizations-route_test.js

@@ -0,0 +1,50 @@
+import {
+  createMaddoServer,
+  databaseBuilder,
+  expect,
+  generateValidRequestAuthorizationHeaderForApplication,
+} from '../../../test-helper.js';
+
+describe('Acceptance | Maddo | Route | Organizations', function () {
+  let server;
+
+  beforeEach(async function () {
+    server = await createMaddoServer();
+  });
+
+  describe('GET /api/organizations', function () {
+    it('returns the list of all organizations of the client jurisdiction with an HTTP status code 200', async function () {
+      // given
+      const orgaInJurisdiction = databaseBuilder.factory.buildOrganization({ name: 'orga-in-jurisdiction' });
+      const orgaAlsoInJurisdiction = databaseBuilder.factory.buildOrganization({ name: 'orga-also-in-jurisdiction' });
+      databaseBuilder.factory.buildOrganization({ name: 'orga-not-in-jurisdiction' });
+
+      const tag = databaseBuilder.factory.buildTag();
+      databaseBuilder.factory.buildOrganizationTag({ organizationId: orgaInJurisdiction.id, tagId: tag.id });
+      databaseBuilder.factory.buildOrganizationTag({ organizationId: orgaAlsoInJurisdiction.id, tagId: tag.id });
+
+      const clientId = 'client';
+      databaseBuilder.factory.buildClientApplication({
+        clientId: 'client',
+        jurisdiction: { rules: [{ name: 'tags', value: [tag.name] }] },
+      });
+
+      await databaseBuilder.commit();
+
+      const options = {
+        method: 'GET',
+        url: '/api/organizations',
+        headers: {
+          authorization: generateValidRequestAuthorizationHeaderForApplication(clientId, 'pix-client', 'meta'),
+        },
+      };
+
+      // when
+      const response = await server.inject(options);
+
+      // then
+      expect(response.statusCode).to.equal(200);
+      expect(response.result).to.deep.equal();
+    });
+  });
+});

api/tests/maddo/application/acceptance/replications-routes_test.js

@@ -0,0 +1,62 @@
+import { replications } from '../../../../src/maddo/infrastructure/repositories/replication-repository.js';
+import {
+  createMaddoServer,
+  datamartKnex,
+  expect,
+  generateValidRequestAuthorizationHeaderForApplication,
+} from '../../../test-helper.js';
+
+describe('Maddo | Application | Acceptance | Replications', function () {
+  describe('POST /api/replications/{replication}', function () {
+    let server;
+
+    beforeEach(async function () {
+      const schema = (t) => {
+        t.string('firstName').notNullable();
+        t.string('lastName').notNullable();
+      };
+      await datamartKnex.schema.dropTableIfExists('to-replicate');
+      await datamartKnex.schema.createTable('to-replicate', schema);
+      await datamartKnex.schema.dropTableIfExists('replication');
+      await datamartKnex.schema.createTable('replication', schema);
+      server = await createMaddoServer();
+    });
+
+    it('should run given replication', async function () {
+      // given
+      const replication = 'my-replication';
+      await datamartKnex('to-replicate').insert([
+        { firstName: 'first1', lastName: 'last1' },
+        { firstName: 'first2', lastName: 'last2' },
+      ]);
+
+      replications.push({
+        name: 'my-replication',
+        from: ({ datawarehouseKnex }) => {
+          return datawarehouseKnex('to-replicate').select('*');
+        },
+        to: ({ datamartKnex }, chunk) => {
+          return datamartKnex('replication').insert(chunk);
+        },
+      });
+
+      // when
+      const response = await server.inject({
+        method: 'POST',
+        url: `/api/replications/${replication}?async=false`,
+        headers: {
+          authorization: generateValidRequestAuthorizationHeaderForApplication(
+            'pix-client',
+            'pix-client',
+            'replication',
+          ),
+        },
+      });
+
+      // then
+      expect(response.statusCode).to.equal(204);
+      const { count } = await datamartKnex('replication').count().first();
+      expect(count).to.equal(2);
+    });
+  });
+});

api/tests/tooling/domain-builder/factory/build-client-application.js

@@ -6,6 +6,12 @@ export function buildClientApplication({
   clientId = 'client-id',
   clientSecret = 'super-secret',
   scopes = ['scope1', 'scope2'],
+  jurisdiction = [
+    {
+      rule: 'tags',
+      value: ['MEDNUM'],
+    },
+  ],
 } = {}) {
-  return new ClientApplication({ id, name, clientId, clientSecret, scopes });
+  return new ClientApplication({ id, name, clientId, clientSecret, scopes, jurisdiction });
 }