Code Review 1

README.md

@@ -155,3 +155,4 @@ This program is distributed in the hope that it will be useful, but WITHOUT ANY
 You should have received a copy of the GNU Affero General Public License along with this program. If not, see http://www.gnu.org/licenses/.
 
 SPDX-License-Identifier: AGPL-3.0-only
+

adapter/src/api/rest/adapterEndpoint.ts

@@ -0,0 +1,109 @@
+import express from 'express';
+import { AdapterConfigValidator } from '../../model/AdapterConfig';
+
+
+import { asyncHandler } from './utils';
+import {ProtocolConfigValidator} from "../../model/ProtocolConfig";
+import { Format } from '../../model/enum/Format';
+
+const adapterService = require( "../../services/AdapterService" );
+const APP_VERSION = "0.0.1"
+export class AdapterEndpoint {
+  constructor() {}
+
+  registerRoutes = (app: express.Application): void => {
+    app.post('/preview', asyncHandler(this.handleExecuteDataImport));
+    app.post('/preview/raw', asyncHandler(this.handleExecuteRawPreview));
+    app.get('/formats', asyncHandler(this.handleGetFormat));
+    app.get('/protocols', asyncHandler(this.handleGetProtocols));
+    app.get('/version', asyncHandler(this.handleGetApplicationVersion));
+  };
+
+  // Adapter Endpoint
+  /**
+     * @RestController
+  @AllArgsConstructor
+  public class AdapterEndpoint {
+    private final Adapter adapter;
+
+    @PostMapping(Mappings.IMPORT_PATH)
+    public DataImportResponse executeDataImport(@Valid @RequestBody AdapterConfig config)
+        throws ImporterParameterException, InterpreterParameterException, IOException {
+      return adapter.executeJob(config);
+    }
+
+    @PostMapping(Mappings.RAW_IMPORT_PATH)
+    public DataImportResponse executeRawPreview(@Valid @RequestBody ProtocolConfig config)
+        throws ImporterParameterException {
+      return adapter.executeRawImport(config);
+    }
+  }
+   */
+
+  handleExecuteDataImport = async (
+    req: express.Request,
+    res: express.Response,
+  ): Promise<void> => {
+    const validator = new AdapterConfigValidator();
+    if (!validator.validate(req.body)) {
+      res.status(400).json({ errors: validator.getErrors() });
+      return;
+    }
+
+    let adapterConfig = req.params.config
+    let returnDataImportResponse = adapterService.executeJob(adapterConfig);
+    res.status(200).send(returnDataImportResponse);
+  };
+
+  handleExecuteRawPreview = async (
+    req: express.Request,
+    res: express.Response,
+  ): Promise<void> => {
+    const validator = new ProtocolConfigValidator();
+    if (!validator.validate(req.body)) {
+      res.status(400).json({ errors: validator.getErrors() });
+      return;
+    }
+    let protocolConfig = req.params.config
+    let returnDataImportResponse = adapterService.executeRawImport(protocolConfig);
+    res.status(200).send(returnDataImportResponse);
+  };
+
+  /*
+    returns Collection of Importer
+  } */
+
+  handleGetFormat = async (
+    req: express.Request,
+    res: express.Response,
+  ): Promise<void> => {
+    try {
+      let interpreters = adapterService.getAllFormats();
+      res.status(200).json(interpreters);
+    } catch (e) {
+      res.status(500).send('Error finding formats');
+    }
+  };
+
+  /*
+    returns Collection of Importer
+  */
+  handleGetProtocols = async (
+    req: express.Request,
+    res: express.Response,
+  ): Promise<void> => {
+    try {
+          let protocols = adapterService.getAllProtocols();
+          res.status(200).json(protocols);
+        } catch (e) {
+          res.status(500).send('Error finding protocols');
+        }
+  };
+
+  handleGetApplicationVersion = async (
+    req: express.Request,
+    res: express.Response,
+  ): Promise<void> => {
+    res.status(200).send(APP_VERSION);
+  };
+};

adapter/src/api/rest/utils.ts

@@ -0,0 +1,19 @@
+import type { NextFunction, Request, RequestHandler, Response } from 'express';
+
+/**
+ * A wrapper for promise returning request handlers that passes the value of a
+ * rejected promise to express's `next` function.
+ * @param handler request handler to wrap
+ */
+export function asyncHandler(
+  handler: (
+    req: Request,
+    res: Response,
+    next?: NextFunction,
+  ) => void | Promise<void>,
+): RequestHandler {
+  return (req: Request, res: Response, next: NextFunction): void => {
+    const handlerResult = handler(req, res, next);
+    Promise.resolve(handlerResult).catch(next);
+  };
+}

adapter/src/importer/HttpImporter.ts

@@ -0,0 +1,63 @@
+import { Importer } from "./Importer";
+import { ImporterParameterDescription } from "./ImporterParameterDescription";
+
+export class HttpImporter extends Importer {
+    getAvailableParameters(): ImporterParameterDescription[] {
+        throw new Error("Method not implemented.");
+    }
+    doFetch(parameters: Record<string, unknown>): string {
+        throw new Error("Method not implemented.");
+    }
+    /**
+     * 
+     * private final List<ImporterParameterDescription> parameters = List.of(
+      new ImporterParameterDescription("location", "String of the URI for the HTTP call", String.class),
+      new ImporterParameterDescription("encoding",
+          "Encoding of the source. Available encodings: ISO-8859-1, US-ASCII, UTF-8", String.class),
+      new ImporterParameterDescription("defaultParameters", "Default values for open parameters in the URI", false,
+          RuntimeParameters.class));
+  private final RestTemplate restTemplate;
+
+  @Override
+  public String getType() {
+    return "HTTP";
+  }
+
+  @Override
+  public String getDescription() {
+    return "Plain HTTP";
+  }
+
+  @Override
+  protected void validateParameters(Map<String, Object> inputParameters) throws ImporterParameterException {
+    super.validateParameters(inputParameters);
+
+    String encoding = (String) inputParameters.get("encoding");
+    if (!encoding.equals(StandardCharsets.ISO_8859_1.name()) && !encoding.equals(StandardCharsets.US_ASCII.name()) && !encoding.equals(StandardCharsets.UTF_8.name())) {
+      throw new IllegalArgumentException(getType() + " interpreter requires parameter encoding to have value " +
+        StandardCharsets.ISO_8859_1 + ", " +
+        StandardCharsets.US_ASCII + ", " +
+        StandardCharsets.UTF_8
+        + ". Your given value " + encoding + " is invalid!");
+    }
+  }
+
+  @Override
+  public List<ImporterParameterDescription> getAvailableParameters() {
+    return parameters;
+  }
+
+  @Override
+  protected String doFetch(Map<String, Object> parameters) throws ImporterParameterException {
+    String location = parameters.get("location").toString();
+    try {
+      URI uri = URI.create(location);
+      byte[] rawResponse = restTemplate.getForEntity(uri, byte[].class).getBody();
+      return new String(rawResponse, Charset.forName((String) parameters.get("encoding")));
+    } catch (IllegalArgumentException e) {
+      throw new ImporterParameterException(e.getMessage());
+    }
+  }
+     */
+
+}