Added support for carriers:

- Model for carriers
- Model for transports
- Repositories & CRUD Controllers

README.md

@@ -30,10 +30,10 @@ Usage: `npm run consistency -- <action> [-f if we want to fix the issues]`
 
 ### Operations
 This script is used in server side to perform operations in the database. Now supported options are:
-- initialsubs: This option creates available subscription ids between min and max. Syntax: `npm run operations -- -o initialsubs "{"min": <int>, "max": <int> }"`
-- addipv4range: This option creates ipv4 ranges in the pool. Syntax: `npm run operations -- -o addipv4range "{"subnet": "<a.b.c.d/i>", "available": <boolean> }"`
-- migrateipv4: This option changes ipv4 from circuits and radius tables. Syntax: `npm run operations -- -o addipv4range "{"oldSubnet": "<a.b.c.d/i>", "newSubnet": "<a.b.c.d/i>", "available": <boolean>, "exceptions": {"<a.b.c.d>": true... } }"`
-- removeipv4range: This option removes ipv4 subnet from pool. Syntax: `npm run operations -- -o addipv4range "{"subnet": "<a.b.c.d/i>"}"`
+- initialsubs: This option creates available subscription ids between min and max. Syntax: `npm run operations -- initialsubs  -o "{"min": <int>, "max": <int> }"`
+- addipv4range: This option creates ipv4 ranges in the pool. Syntax: `npm run operations -- addipv4range -o "{"subnet": "<a.b.c.d/i>", "available": <boolean> }"`
+- migrateipv4: This option changes ipv4 from circuits and radius tables. Syntax: `npm run operations -- addipv4range -o "{"oldSubnet": "<a.b.c.d/i>", "newSubnet": "<a.b.c.d/i>", "available": <boolean>, "exceptions": {"<a.b.c.d>": true... } }"`
+- removeipv4range: This option removes ipv4 subnet from pool. Syntax: `npm run operations -- addipv4range -o "{"subnet": "<a.b.c.d/i>"}"`
 
 
 ## Contribute

src/__tests__/helpers/database.helpers.ts

@@ -9,7 +9,8 @@ import {
   RadpostauthRepository,
   RadreplyRepository,
   RadusergroupRepository,
-  UserinfoRepository
+  UserinfoRepository,
+  TransportRepository
 } from '../../repositories';
 import { testdb } from '../datasources/radius.datasource';
 import { testSimplexDb } from '../datasources/simplex.datasource';
@@ -19,9 +20,11 @@ import { SubscriptionIds, Circuit, Userinfo, Radcheck, Radusergroup, Radreply }
 export async function givenEmptyDatabase() {
   let subscriptionRepository: SubscriptionRepository;
   let circuitRepository: CircuitRepository;
+  let transportRepository: TransportRepository;
 
+  transportRepository = new TransportRepository(testSimplexDb, async () => circuitRepository);
   subscriptionRepository = new SubscriptionRepository(testSimplexDb, async () => circuitRepository);
-  circuitRepository = new CircuitRepository(testSimplexDb, async () => subscriptionRepository);
+  circuitRepository = new CircuitRepository(testSimplexDb, async () => subscriptionRepository, async () => transportRepository);
 
   const subscriptonIdsRepository = new SubscriptionIdsRepository(testSimplexDb);
   const ipv4PoolRepository = new IPv4PoolRepository(testSimplexDb);
@@ -52,8 +55,10 @@ export async function givenEmptyDatabase() {
 export async function givenSubscription(id: number, firstname: string, lastname: string) {
   let subscriptionRepository: SubscriptionRepository;
   let circuitRepository: CircuitRepository;
+  let transportRepository: TransportRepository;
+  transportRepository = new TransportRepository(testSimplexDb, async () => circuitRepository);
   subscriptionRepository = new SubscriptionRepository(testSimplexDb, async () => circuitRepository);
-  circuitRepository = new CircuitRepository(testSimplexDb, async () => subscriptionRepository);
+  circuitRepository = new CircuitRepository(testSimplexDb, async () => subscriptionRepository, async () => transportRepository);
 
   const subscriptionIdsRepository = new SubscriptionIdsRepository(testSimplexDb);
 
@@ -72,8 +77,10 @@ export async function givenSubscription(id: number, firstname: string, lastname:
 export async function givenCircuit(circuit: Partial<Circuit>) {
   let subscriptionRepository: SubscriptionRepository;
   let circuitRepository: CircuitRepository;
+  let transportRepository: TransportRepository;
+  transportRepository = new TransportRepository(testSimplexDb, async () => circuitRepository);
   subscriptionRepository = new SubscriptionRepository(testSimplexDb, async () => circuitRepository);
-  circuitRepository = new CircuitRepository(testSimplexDb, async () => subscriptionRepository);
+  circuitRepository = new CircuitRepository(testSimplexDb, async () => subscriptionRepository, async () => transportRepository);
 
   return circuitRepository.create(circuit);
 }
@@ -81,8 +88,10 @@ export async function givenCircuit(circuit: Partial<Circuit>) {
 export async function getSubscriptions() {
   let subscriptionRepository: SubscriptionRepository;
   let circuitRepository: CircuitRepository;
+  let transportRepository: TransportRepository;
+  transportRepository = new TransportRepository(testSimplexDb, async () => circuitRepository);
   subscriptionRepository = new SubscriptionRepository(testSimplexDb, async () => circuitRepository);
-  circuitRepository = new CircuitRepository(testSimplexDb, async () => subscriptionRepository);
+  circuitRepository = new CircuitRepository(testSimplexDb, async () => subscriptionRepository, async () => transportRepository);
 
   return subscriptionRepository.find();
 }
@@ -102,8 +111,10 @@ export async function getSubscriptionIdsPool() {
 export async function getSubscriptionFromId(id: number) {
   let subscriptionRepository: SubscriptionRepository;
   let circuitRepository: CircuitRepository;
+  let transportRepository: TransportRepository;
+  transportRepository = new TransportRepository(testSimplexDb, async () => circuitRepository);
   subscriptionRepository = new SubscriptionRepository(testSimplexDb, async () => circuitRepository);
-  circuitRepository = new CircuitRepository(testSimplexDb, async () => subscriptionRepository);
+  circuitRepository = new CircuitRepository(testSimplexDb, async () => subscriptionRepository, async () => transportRepository);
 
   return subscriptionRepository.findById(id);
 }

src/controllers/carrier.controller.ts

@@ -0,0 +1,175 @@
+import {
+  Count,
+  CountSchema,
+  Filter,
+  FilterExcludingWhere,
+  repository,
+  Where,
+} from '@loopback/repository';
+import {
+  post,
+  param,
+  get,
+  getFilterSchemaFor,
+  getModelSchemaRef,
+  getWhereSchemaFor,
+  patch,
+  put,
+  del,
+  requestBody,
+} from '@loopback/rest';
+import {Carrier} from '../models';
+import {CarrierRepository} from '../repositories';
+
+export class CarrierController {
+  constructor(
+    @repository(CarrierRepository)
+    public carrierRepository : CarrierRepository,
+  ) {}
+
+  @post('/carrier', {
+    responses: {
+      '200': {
+        description: 'Carrier model instance',
+        content: {'application/json': {schema: getModelSchemaRef(Carrier)}},
+      },
+    },
+  })
+  async create(
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(Carrier, {
+            title: 'NewCarrier',
+            exclude: ['id'],
+          }),
+        },
+      },
+    })
+    carrier: Omit<Carrier, 'id'>,
+  ): Promise<Carrier> {
+    return this.carrierRepository.create(carrier);
+  }
+
+  @get('/carrier/count', {
+    responses: {
+      '200': {
+        description: 'Carrier model count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async count(
+    @param.where(Carrier) where?: Where<Carrier>,
+  ): Promise<Count> {
+    return this.carrierRepository.count(where);
+  }
+
+  @get('/carrier', {
+    responses: {
+      '200': {
+        description: 'Array of Carrier model instances',
+        content: {
+          'application/json': {
+            schema: {
+              type: 'array',
+              items: getModelSchemaRef(Carrier, {includeRelations: true}),
+            },
+          },
+        },
+      },
+    },
+  })
+  async find(
+    @param.filter(Carrier) filter?: Filter<Carrier>,
+  ): Promise<Carrier[]> {
+    return this.carrierRepository.find(filter);
+  }
+
+  @patch('/carrier', {
+    responses: {
+      '200': {
+        description: 'Carrier PATCH success count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async updateAll(
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(Carrier, {partial: true}),
+        },
+      },
+    })
+    carrier: Carrier,
+    @param.where(Carrier) where?: Where<Carrier>,
+  ): Promise<Count> {
+    return this.carrierRepository.updateAll(carrier, where);
+  }
+
+  @get('/carrier/{id}', {
+    responses: {
+      '200': {
+        description: 'Carrier model instance',
+        content: {
+          'application/json': {
+            schema: getModelSchemaRef(Carrier, {includeRelations: true}),
+          },
+        },
+      },
+    },
+  })
+  async findById(
+    @param.path.number('id') id: number,
+    @param.filter(Carrier, {exclude: 'where'}) filter?: FilterExcludingWhere<Carrier>
+  ): Promise<Carrier> {
+    return this.carrierRepository.findById(id, filter);
+  }
+
+  @patch('/carrier/{id}', {
+    responses: {
+      '204': {
+        description: 'Carrier PATCH success',
+      },
+    },
+  })
+  async updateById(
+    @param.path.number('id') id: number,
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(Carrier, {partial: true}),
+        },
+      },
+    })
+    carrier: Carrier,
+  ): Promise<void> {
+    await this.carrierRepository.updateById(id, carrier);
+  }
+
+  @put('/carrier/{id}', {
+    responses: {
+      '204': {
+        description: 'Carrier PUT success',
+      },
+    },
+  })
+  async replaceById(
+    @param.path.number('id') id: number,
+    @requestBody() carrier: Carrier,
+  ): Promise<void> {
+    await this.carrierRepository.replaceById(id, carrier);
+  }
+
+  @del('/carrier/{id}', {
+    responses: {
+      '204': {
+        description: 'Carrier DELETE success',
+      },
+    },
+  })
+  async deleteById(@param.path.number('id') id: number): Promise<void> {
+    await this.carrierRepository.deleteById(id);
+  }
+}

src/controllers/index.ts

@@ -1,2 +1,4 @@
 export * from './ping.controller';
 export * from './radius.controller';
+export * from './transport.controller';
+export * from './carrier.controller';

src/controllers/radius.controller.ts

@@ -391,4 +391,47 @@ export class RadiusController {
   ) {
     return this.radiusManager.disconnectUser(circuit);
   }
+
+  @patch(baseControllerPath + '/subscription/{subscription}/circuit/{circuit}/transport/{transport}', {
+    summary: 'Attach transport to a circuit',
+    description: 'Attach one transport from the database to the given circuit',
+    responses: {
+      '200': {
+        description: 'Ok message',
+        content: {
+          'application/json': {
+            schema: specOkMsg,
+          },
+        },
+      },
+    },
+  })
+  async attachTransport(
+    @param.path.number('subscription') subscription: number,
+    @param.path.number('circuit') circuit: number,
+    @param.path.number('transport') transport: number,
+  ) {
+    return this.subscriptionsManager.attachCircuitTransport(circuit, transport);
+  }
+
+  @del(baseControllerPath + '/subscription/{subscription}/circuit/{circuit}/transport', {
+    summary: 'Detach transport from circuit',
+    description: 'Detach transport from the given circuit',
+    responses: {
+      '200': {
+        description: 'Ok message',
+        content: {
+          'application/json': {
+            schema: specOkMsg,
+          },
+        },
+      },
+    },
+  })
+  async detachTransport(
+    @param.path.number('subscription') subscription: number,
+    @param.path.number('circuit') circuit: number,
+  ) {
+    return this.subscriptionsManager.detachCircuitTransport(circuit);
+  }
 }

src/controllers/transport.controller.ts

@@ -0,0 +1,175 @@
+import {
+  Count,
+  CountSchema,
+  Filter,
+  FilterExcludingWhere,
+  repository,
+  Where,
+} from '@loopback/repository';
+import {
+  post,
+  param,
+  get,
+  getFilterSchemaFor,
+  getModelSchemaRef,
+  getWhereSchemaFor,
+  patch,
+  put,
+  del,
+  requestBody,
+} from '@loopback/rest';
+import { Transport } from '../models';
+import { TransportRepository } from '../repositories';
+
+export class TransportController {
+  constructor(
+    @repository(TransportRepository)
+    public transportRepository: TransportRepository,
+  ) { }
+
+  @post('/transport', {
+    responses: {
+      '200': {
+        description: 'Transport model instance',
+        content: { 'application/json': { schema: getModelSchemaRef(Transport) } },
+      },
+    },
+  })
+  async create(
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(Transport, {
+            title: 'NewTransport',
+            exclude: ['id'],
+          }),
+        },
+      },
+    })
+    transport: Omit<Transport, 'id'>,
+  ): Promise<Transport> {
+    return this.transportRepository.create(transport);
+  }
+
+  @get('/transport/count', {
+    responses: {
+      '200': {
+        description: 'Transport model count',
+        content: { 'application/json': { schema: CountSchema } },
+      },
+    },
+  })
+  async count(
+    @param.where(Transport) where?: Where<Transport>,
+  ): Promise<Count> {
+    return this.transportRepository.count(where);
+  }
+
+  @get('/transport', {
+    responses: {
+      '200': {
+        description: 'Array of Transport model instances',
+        content: {
+          'application/json': {
+            schema: {
+              type: 'array',
+              items: getModelSchemaRef(Transport, { includeRelations: true }),
+            },
+          },
+        },
+      },
+    },
+  })
+  async find(
+    @param.filter(Transport) filter?: Filter<Transport>,
+  ): Promise<Transport[]> {
+    return this.transportRepository.find(filter);
+  }
+
+  @patch('/transport', {
+    responses: {
+      '200': {
+        description: 'Transport PATCH success count',
+        content: { 'application/json': { schema: CountSchema } },
+      },
+    },
+  })
+  async updateAll(
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(Transport, { partial: true }),
+        },
+      },
+    })
+    transport: Transport,
+    @param.where(Transport) where?: Where<Transport>,
+  ): Promise<Count> {
+    return this.transportRepository.updateAll(transport, where);
+  }
+
+  @get('/transport/{id}', {
+    responses: {
+      '200': {
+        description: 'Transport model instance',
+        content: {
+          'application/json': {
+            schema: getModelSchemaRef(Transport, { includeRelations: true }),
+          },
+        },
+      },
+    },
+  })
+  async findById(
+    @param.path.number('id') id: number,
+    @param.filter(Transport, { exclude: 'where' }) filter?: FilterExcludingWhere<Transport>
+  ): Promise<Transport> {
+    return this.transportRepository.findById(id, filter);
+  }
+
+  @patch('/transport/{id}', {
+    responses: {
+      '204': {
+        description: 'Transport PATCH success',
+      },
+    },
+  })
+  async updateById(
+    @param.path.number('id') id: number,
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(Transport, { partial: true }),
+        },
+      },
+    })
+    transport: Transport,
+  ): Promise<void> {
+    await this.transportRepository.updateById(id, transport);
+  }
+
+  @put('/transport/{id}', {
+    responses: {
+      '204': {
+        description: 'Transport PUT success',
+      },
+    },
+  })
+  async replaceById(
+    @param.path.number('id') id: number,
+    @requestBody() transport: Transport,
+  ): Promise<void> {
+    await this.transportRepository.replaceById(id, transport);
+  }
+
+  @del('/transport/{id}', {
+    responses: {
+      '204': {
+        description: 'Transport DELETE success',
+      },
+    },
+  })
+  async deleteById(@param.path.number('id') id: number): Promise<void> {
+    await this.transportRepository.deleteById(id);
+  }
+}

src/models/carrier.model.ts

@@ -0,0 +1,40 @@
+import { Entity, model, property } from '@loopback/repository';
+
+@model()
+export class Carrier extends Entity {
+  @property({
+    type: 'number',
+    id: true,
+    generated: true,
+  })
+  id?: number;
+
+  @property({
+    type: 'string',
+    required: true,
+  })
+  name: string;
+
+  @property({
+    type: 'object',
+    postgresql: { "columnName": "data", "dataType": "json", "nullable": "Y" },
+  })
+  data?: object;
+
+  @property({
+    type: 'object',
+    postgresql: { "columnName": "structure", "dataType": "json", "nullable": "Y" },
+  })
+  structure?: object;
+
+
+  constructor(data?: Partial<Carrier>) {
+    super(data);
+  }
+}
+
+export interface CarrierRelations {
+  // describe navigational properties here
+}
+
+export type CarrierWithRelations = Carrier & CarrierRelations;

src/models/circuit.model.ts

@@ -1,5 +1,6 @@
 import { Entity, model, property, belongsTo } from '@loopback/repository';
 import { Subscription, SubscriptionWithRelations } from './subscription.model';
+import { Transport } from './transport.model';
 
 @model({
   settings: {
@@ -11,6 +12,12 @@ import { Subscription, SubscriptionWithRelations } from './subscription.model';
         entityKey: 'id',
         foreignKey: 'subscriptionid',
       },
+      fk_circuit_transportId: {
+        name: 'fk_circuit_transportId',
+        entity: 'Transport',
+        entityKey: 'id',
+        foreignKey: 'transportid',
+      },
     },
   }
 })
@@ -90,6 +97,9 @@ export class Circuit extends Entity {
   @belongsTo(() => Subscription)
   subscriptionId: number;
 
+  @belongsTo(() => Transport)
+  transportId?: number;
+
 
   constructor(data?: Partial<Circuit>) {
     super(data);

src/models/index.ts

@@ -15,3 +15,5 @@ export * from './subscription.model';
 export * from './circuit.model';
 export * from './i-pv-4-pool.model';
 export * from './i-pv-6-pool.model';
+export * from './transport.model';
+export * from './carrier.model';

src/models/transport.model.ts

@@ -0,0 +1,48 @@
+import { Entity, model, property, belongsTo, hasMany } from '@loopback/repository';
+import { Carrier } from './carrier.model';
+import { Circuit } from './circuit.model';
+
+@model({
+  settings: {
+    idInjection: false, postgresql: { table: 'transport' },
+    foreignKeys: {
+      fk_transport_carrierId: {
+        name: 'fk_transport_carrierId',
+        entity: 'Carrier',
+        entityKey: 'id',
+        foreignKey: 'carrierid',
+      },
+    },
+  }
+})
+export class Transport extends Entity {
+  @property({
+    type: 'number',
+    id: true,
+    generated: true,
+  })
+  id?: number;
+
+  @property({
+    type: 'object',
+    required: false,
+    postgresql: { "columnName": "data", "dataType": "json", "nullable": "Y" },
+  })
+  data?: any;
+
+  @belongsTo(() => Carrier)
+  carrierId?: number;
+
+  @hasMany(() => Circuit)
+  circuits: Circuit[];
+
+  constructor(data?: Partial<Transport>) {
+    super(data);
+  }
+}
+
+export interface TransportRelations {
+  // describe navigational properties here
+}
+
+export type TransportWithRelations = Transport & TransportRelations;

src/repositories/carrier.repository.ts

@@ -0,0 +1,16 @@
+import { DefaultTransactionalRepository } from '@loopback/repository';
+import { Carrier, CarrierRelations } from '../models';
+import { SimplexDataSource } from '../datasources';
+import { inject } from '@loopback/core';
+
+export class CarrierRepository extends DefaultTransactionalRepository<
+  Carrier,
+  typeof Carrier.prototype.id,
+  CarrierRelations
+  > {
+  constructor(
+    @inject('datasources.simplex') dataSource: SimplexDataSource,
+  ) {
+    super(Carrier, dataSource);
+  }
+}

src/repositories/circuit.repository.ts

@@ -1,8 +1,8 @@
 import { DefaultTransactionalRepository, BelongsToAccessor, repository } from '@loopback/repository';
-import { Circuit, CircuitRelations, Subscription } from '../models';
+import { Circuit, CircuitRelations, Subscription, Transport } from '../models';
 import { SimplexDataSource } from '../datasources';
 import { inject, Getter } from '@loopback/core';
-import { SubscriptionRepository } from '.';
+import { SubscriptionRepository, TransportRepository } from '.';
 
 export class CircuitRepository extends DefaultTransactionalRepository<
   Circuit,
@@ -13,17 +13,28 @@ export class CircuitRepository extends DefaultTransactionalRepository<
     Subscription,
     typeof Circuit.prototype.id
   >;
+  public readonly transport: BelongsToAccessor<
+    Transport,
+    typeof Circuit.prototype.id
+  >;
   constructor(
     @inject('datasources.simplex') dataSource: SimplexDataSource,
     @repository.getter('SubscriptionRepository')
     subscriptionRepositoryGetter: Getter<SubscriptionRepository>,
+    @repository.getter('TransportRepository')
+    transportRepositoryGetter: Getter<TransportRepository>,
   ) {
     super(Circuit, dataSource);
     this.subscription = this.createBelongsToAccessorFor(
       'subscription',
       subscriptionRepositoryGetter,
     );
+    this.transport = this.createBelongsToAccessorFor(
+      'transport',
+      transportRepositoryGetter,
+    );
 
     this.registerInclusionResolver('subscription', this.subscription.inclusionResolver);
+    this.registerInclusionResolver('transport', this.transport.inclusionResolver);
   }
 }

src/repositories/index.ts

@@ -15,3 +15,5 @@ export * from './circuit.repository';
 export * from './subscription.repository';
 export * from './i-pv-4-pool.repository';
 export * from './i-pv-6-pool.repository';
+export * from './transport.repository';
+export * from './carrier.repository';

src/repositories/transport.repository.ts

@@ -0,0 +1,30 @@
+import { DefaultTransactionalRepository, HasManyRepositoryFactory, repository } from '@loopback/repository';
+import { Transport, TransportRelations, Circuit } from '../models';
+import { SimplexDataSource } from '../datasources';
+import { inject, Getter } from '@loopback/core';
+import { CircuitRepository } from './circuit.repository';
+
+export class TransportRepository extends DefaultTransactionalRepository<
+  Transport,
+  typeof Transport.prototype.id,
+  TransportRelations
+  > {
+  public readonly circuits: HasManyRepositoryFactory<
+    Circuit,
+    typeof Transport.prototype.id
+  >;
+  constructor(
+    @inject('datasources.simplex') dataSource: SimplexDataSource,
+    @repository.getter('CircuitRepository')
+    getCircuitRepository: Getter<CircuitRepository>,
+  ) {
+    super(Transport, dataSource);
+
+    this.circuits = this.createHasManyRepositoryFactoryFor(
+      'circuits',
+      getCircuitRepository,
+    );
+
+    this.registerInclusionResolver('circuits', this.circuits.inclusionResolver);
+  }
+}

src/scripts/consistency.ts

@@ -15,7 +15,8 @@ import {
   RadpostauthRepository,
   RadreplyRepository,
   RadusergroupRepository,
-  UserinfoRepository
+  UserinfoRepository,
+  TransportRepository
 } from '../repositories';
 import { RadiusDataSource } from "../datasources/radius.datasource";
 
@@ -35,8 +36,13 @@ const userInfoRepository = new UserinfoRepository(db);
 
 let subscriptionRepository: SubscriptionRepository;
 let circuitRepository: CircuitRepository;
+let transportRepository: TransportRepository;
+
 subscriptionRepository = new SubscriptionRepository(simplexDb, async () => circuitRepository);
-circuitRepository = new CircuitRepository(simplexDb, async () => subscriptionRepository);
+circuitRepository = new CircuitRepository(simplexDb, async () => subscriptionRepository,
+  async () => transportRepository);
+
+transportRepository = new TransportRepository(simplexDb, async () => circuitRepository);
 
 // We attach simplex configuration file
 const simplexConfig: SimplexConfig = JSON.parse(

src/scripts/operations.ts

@@ -16,9 +16,11 @@ import {
   RadpostauthRepository,
   RadreplyRepository,
   RadusergroupRepository,
-  UserinfoRepository
+  UserinfoRepository,
+  TransportRepository
 } from '../repositories';
 import { RadiusDataSource } from "../datasources/radius.datasource";
+import { SimplexDataSource } from "../datasources/simplex.datasource";
 
 const db: RadiusDataSource = new RadiusDataSource();
 const simplexDb: SimplexDataSource = new SimplexDataSource();
@@ -36,8 +38,11 @@ const userInfoRepository = new UserinfoRepository(db);
 
 let subscriptionRepository: SubscriptionRepository;
 let circuitRepository: CircuitRepository;
+let transportRepository: TransportRepository;
 subscriptionRepository = new SubscriptionRepository(simplexDb, async () => circuitRepository);
-circuitRepository = new CircuitRepository(simplexDb, async () => subscriptionRepository);
+circuitRepository = new CircuitRepository(simplexDb, async () => subscriptionRepository,
+  async () => transportRepository);
+transportRepository = new TransportRepository(simplexDb, async () => circuitRepository);
 
 // We attach simplex configuration file
 const simplexConfig: SimplexConfig = JSON.parse(
@@ -58,7 +63,6 @@ import {
 import minimist from 'minimist';
 import { SimplexConfig } from '../application';
 import { IsolationLevel } from '@loopback/repository';
-import { SimplexDataSource } from '../datasources';
 
 interface InitialSubsConf {
   min: number;

src/services/subscriptions-manager.service.ts

@@ -1,5 +1,9 @@
 import { bind, BindingScope, inject } from '@loopback/core';
-import { RadreplyRepository, SubscriptionIdsRepository, UserinfoRepository, RadcheckRepository, RadusergroupRepository, SubscriptionRepository, CircuitRepository } from '../repositories';
+import {
+  RadreplyRepository, SubscriptionIdsRepository, UserinfoRepository,
+  RadcheckRepository, RadusergroupRepository, SubscriptionRepository, CircuitRepository,
+  TransportRepository
+} from '../repositories';
 import { Userinfo, Radcheck, Radusergroup, Radreply, Subscription, Circuit } from '../models';
 import { IsolationLevel, Transaction } from '@loopback/repository';
 import { BatchUser } from '../controllers/radius.controller';
@@ -19,6 +23,7 @@ export interface SubscriptionTransactions {
   circuitTx?: Transaction;
   ipv4PoolTx?: Transaction;
   ipv6PoolTx?: Transaction;
+  transportTx?: Transaction;
 }
 
 export interface SubscriptionData {
@@ -69,6 +74,8 @@ export class SubscriptionsManagerService {
     public ipv4PoolRepository: IPv4PoolRepository,
     @inject('repositories.IPv6PoolRepository')
     public ipv6PoolRepository: IPv6PoolRepository,
+    @inject('repositories.TransportRepository')
+    public transportRepository: TransportRepository,
     @inject('config.simplex')
     public simplexConfig: SimplexConfig, ) { }
 
@@ -397,7 +404,7 @@ export class SubscriptionsManagerService {
 
   public async getCircuit(id: number) {
     try {
-      return this.circuitRepository.findById(id, { include: [{ relation: 'subscription' }] });
+      return this.circuitRepository.findById(id, { include: [{ relation: 'subscription' }, { relation: 'transport' }] });
     } catch (err) {
       throw err;
     }
@@ -405,7 +412,7 @@ export class SubscriptionsManagerService {
 
   public async getCircuits(data: CircuitFilterData) {
     try {
-      return this.circuitRepository.find({ include: [{ relation: 'subscription' }], where: { ipv4: data.ipv4, nasId: data.nasId } });
+      return this.circuitRepository.find({ include: [{ relation: 'subscription' }, { relation: 'transport' }], where: { ipv4: data.ipv4, nasId: data.nasId } });
     } catch (err) {
       throw err;
     }
@@ -586,4 +593,30 @@ export class SubscriptionsManagerService {
       throw err;
     }
   }
+
+  public async attachCircuitTransport(id: number, transportId: number) {
+    try {
+      const transport = await this.transportRepository.findById(transportId);
+      const circuit = await this.circuitRepository.findById(id);
+      circuit.transportId = transport.id;
+
+      await this.circuitRepository.update(circuit);
+
+      return { msg: 'ok' };
+    } catch (err) {
+
+      throw err;
+    }
+  }
+
+  public async detachCircuitTransport(id: number) {
+    try {
+      const circuit = await this.circuitRepository.findById(id);
+      circuit.transportId = undefined;
+      await this.circuitRepository.update(circuit);
+      return { msg: 'ok' };
+    } catch (err) {
+      throw err;
+    }
+  }
 }