Service gibt jetzt wieder ULRs zurück anstelle von Binaries.

.env.sample

@@ -4,3 +4,4 @@ ASSETS=assets
 CONFIG=config
 CERT_KEY_PATH=certs/server.key
 CERT_CRT_PATH=certs/server.crt
+FILESERVER=true

src/api/document.api.ts

@@ -4,14 +4,12 @@ import { Logger } from 'ts-log-debug';
 import * as asyncHandler from 'express-async-handler';
 import { isNullOrUndefined } from 'util';
 import { CommonService } from '../services/common.service';
-import { DocumentService } from '../services/document.service';
 import { ConfigurationService } from '../services/configuration.service';
 
 export function DocumentRouter(
-    log: Logger,
-    common: CommonService,
-    document: DocumentService,
-    config: ConfigurationService ): Router {
+  log: Logger,
+  common: CommonService,
+  config: ConfigurationService): Router {
   log.debug('Initialisiere Document API.');
   const api = express.Router();
 
@@ -41,71 +39,28 @@ export function DocumentRouter(
 
   api.get('/fragmente/:name', asyncHandler(async (req, res, next) => {
     try {
-        const name = req.params.name;
-        const toBase64 = req.query.base64;
-
-        if (isNullOrUndefined(name)) {
-          return res.json({ base64: '' });
-        }
-
-        if (!isNullOrUndefined(toBase64) && toBase64 === 'true') {
-          document.getFragment(name).then(base64String => {
-            return res.json({ base64: base64String });
-          }).catch(err => {
-            log.error(err);
-          });
-        } else {
-          document.getFragmentFilePath(name).then(filePath => {
-            return common.getAssetsFolder().then(assetsFolderPath => {
-              return res.sendFile(filePath, { root: assetsFolderPath }, (err): any => {
-                if (err) {
-                  log.error(err);
+      const name = req.params.name;
+      const p = `${common.getAssetsFolder()}/${config.getFragmentFilePath(name)}`;
 
-                  return res.status(err.status).end();
-                }
-              });
-            });
-          });
-        }
+      return res.json(p);
     } catch (err) {
       log.error(err);
       next(err);
     }
+
   }));
 
   api.get('/vorlagen/:name', asyncHandler(async (req, res, next) => {
     try {
       const name = req.params.name;
-      const toBase64 = req.query.base64;
-
-      if (isNullOrUndefined(name)) {
-        return res.json({ base64: '' });
-      }
-
-      if (!isNullOrUndefined(toBase64) && toBase64 === 'true') {
-        document.getTemplate(name).then(base64String => {
-          return res.json({ base64: base64String });
-        }).catch(err => {
-          log.error(err);
-        });
-      } else {
-        document.getTemplateFilePath(name).then(filePath => {
-          return common.getAssetsFolder().then(assetsFolderPath => {
-            return res.sendFile(filePath, { root: assetsFolderPath }, (err): any => {
-              if (err) {
-                log.error(err);
+      const p = `${common.getAssetsFolder()}/${config.getTemplateFilePath(name)}`;
 
-                return res.status(err.status).end();
-              }
-            });
-          });
-        });
-      }
-  } catch (err) {
-    log.error(err);
-    next(err);
-  }
-}));
+      return res.json(p);
+    } catch (err) {
+      log.error(err);
+      next(err);
+    }
+  }));
 
   return api;
 }

src/app/app.main.ts

@@ -47,6 +47,11 @@ export class AppMain {
     this.app.use(bodyParser.urlencoded({ extended: true }));
     this.app.use(morgan('combined'));
     this.app.use(cors({ optionsSuccessStatus: 200 }));
+
+    if (process.env.FILESERVER) {
+      this.app.use('/assets/fragmente', express.static(path.join(process.env.ASSETS, '/fragmente')));
+      this.app.use('/assets/vorlagen', express.static(path.join(process.env.ASSETS, '/vorlagen')));
+    }
   }
 
   setApiRoutes(): void {

src/index.ts

@@ -10,7 +10,6 @@ import { DocumentRouter } from './api/document.api';
 import { DatabaseRouter } from './api/database.api';
 import { AppMain } from './app/app.main';
 import { ConfigurationService } from './services/configuration.service';
-import { DocumentService } from './services/document.service';
 import { CommonService } from './services/common.service';
 import { StatusRouter } from './api/status.api';
 import { LDAPService } from './services/ldap.service';
@@ -23,15 +22,15 @@ const log = new Logger('FormBoxApi');
 
 log.appenders
   .set('stdout', {
-    levels: [ 'debug', 'info', 'trace' ],
+    levels: ['debug', 'info', 'trace'],
     type: 'stdout'
   })
   .set('stderr', {
     layout: {
       pattern: '%d %p %c %X{user} %m%n',
       type: 'pattern'
     },
-    levels: [ 'fatal', 'error', 'warn' ],
+    levels: ['fatal', 'error', 'warn'],
     type: 'stderr'
   });
 
@@ -42,14 +41,13 @@ log.debug(__dirname);
 const injector = ReflectiveInjector.resolveAndCreate([
   AppMain,
   ConfigurationService,
-  DocumentService,
   CommonService,
   LDAPService,
   { provide: 'Logger', useValue: log },
   { provide: 'Application', useValue: app },
-  { provide: 'DatabaseApi', useFactory: DatabaseRouter, deps: [ 'Logger', LDAPService ] },
-  { provide: 'DocumentApi', useFactory: DocumentRouter, deps: [ 'Logger', CommonService, DocumentService, ConfigurationService ] },
-  { provide: 'StatusApi', useFactory: StatusRouter, deps: [ 'Logger' ] }
+  { provide: 'DatabaseApi', useFactory: DatabaseRouter, deps: ['Logger', LDAPService] },
+  { provide: 'DocumentApi', useFactory: DocumentRouter, deps: ['Logger', CommonService, ConfigurationService] },
+  { provide: 'StatusApi', useFactory: StatusRouter, deps: ['Logger'] }
 ]);
 
 // Startet die Anwendung über Dependency Injection.

src/services/common.service.ts

@@ -5,7 +5,7 @@ import * as fs from 'fs';
 @Injectable()
 export class CommonService {
 
-  async getAssetsFolder(): Promise<string> {
+  getAssetsFolder(): string {
     return process.env.ASSETS;
   }
 

src/services/configuration.service.ts

@@ -18,7 +18,15 @@ export class ConfigurationService {
     return this.config.templates;
   }
 
+  getFragmentFilePath(name: string): string {
+    return `${this.config.fragments[name]}`;
+  }
+
+  getTemplateFilePath(name: string): string {
+    return `${this.config.templates[name]}`;
+  }
+
   getLDAP(name: string): any {
-    return this.config.ldap[ name ];
+    return this.config.ldap[name];
   }
 }

test/config/fragments.json

@@ -0,0 +1,3 @@
+{
+	"test": "fragmente/test.docx"
+}

test/config/ldap.json

@@ -0,0 +1,18 @@
+{
+  "config": {
+    "url": "ldap://formbox-ldap-test.de",
+    "base": "c=de",
+    "dn": "user",
+    "password": "password"
+  },
+  "attributes": [
+    "givenName",
+    "sn",
+    "uid"
+  ],
+  "mapping": {
+    "Vorname": "givenName",
+    "Nachname": "sn",
+    "uid": "uid"
+  }
+}

test/config/templates.json

@@ -0,0 +1,3 @@
+{
+	"test": "vorlagen/test.docx"
+}

test/helpers/init.spec.ts

@@ -10,10 +10,10 @@ import { DocumentRouter } from '../../src/api/document.api';
 import { DatabaseRouter } from '../../src/api/database.api';
 import { AppMain } from '../../src/app/app.main';
 import { ConfigurationService } from '../../src/services/configuration.service';
-import { DocumentService } from '../../src/services/document.service';
 import { CommonService } from '../../src/services/common.service';
 import { StatusRouter } from '../../src/api/status.api';
 import { LDAPService } from '../../src/services/ldap.service';
+import * as path from 'path';
 
 dotenv.config();
 
@@ -23,31 +23,30 @@ const log = new Logger('FormBoxApi');
 
 log.appenders
   .set('stdout', {
-    levels: [ 'debug', 'info', 'trace' ],
+    levels: ['debug', 'info', 'trace'],
     type: 'stdout'
   })
   .set('stderr', {
     layout: {
       pattern: '%d %p %c %X{user} %m%n',
       type: 'pattern'
     },
-    levels: [ 'fatal', 'error', 'warn' ],
+    levels: ['fatal', 'error', 'warn'],
     type: 'stderr'
   });
 
-log.debug(__dirname);
+process.env.CONFIG = path.join(__dirname, '../config');
 
 // Hier müssen alle Klassen eingetragen werden,
 // die injiziert werden sollen.
 export const injector = ReflectiveInjector.resolveAndCreate([
   AppMain,
   ConfigurationService,
-  DocumentService,
   CommonService,
   LDAPService,
   { provide: 'Logger', useValue: log },
   { provide: 'Application', useValue: app },
-  { provide: 'DatabaseApi', useFactory: DatabaseRouter, deps: [ 'Logger', LDAPService ] },
-  { provide: 'DocumentApi', useFactory: DocumentRouter, deps: [ 'Logger', CommonService, DocumentService, ConfigurationService ] },
-  { provide: 'StatusApi', useFactory: StatusRouter, deps: [ 'Logger' ] }
+  { provide: 'DatabaseApi', useFactory: DatabaseRouter, deps: ['Logger', LDAPService] },
+  { provide: 'DocumentApi', useFactory: DocumentRouter, deps: ['Logger', CommonService, ConfigurationService] },
+  { provide: 'StatusApi', useFactory: StatusRouter, deps: ['Logger'] }
 ]);

test/services/configuration.service.spec.ts

@@ -2,25 +2,35 @@ import { ConfigurationService } from '../../src/services/configuration.service';
 import { injector } from '../helpers/init.spec';
 
 describe('ConfigurationService', () => {
-    const config = injector.get(ConfigurationService);
+  const config: ConfigurationService = injector.get(ConfigurationService);
 
-    it('getFragments(): Promise<any> expects fragment list', function (done) {
-        config.getFragments().then(result => {
-            expect(result).toEqual(jasmine.objectContaining({ test: 'fragmente/test.docx' }));
-            done();
-        });
+  it('getFragments(): Promise<any> expects fragment list', function(done) {
+    config.getFragments().then(result => {
+      expect(result).toEqual(jasmine.objectContaining({ test: 'fragmente/test.docx' }));
+      done();
     });
+  });
 
-    it('getTemplates(): Promise<any> expects template list', function (done) {
-        config.getTemplates().then(result => {
-            expect(result).toEqual(jasmine.objectContaining({ test: 'vorlagen/test.docx' }));
-            done();
-        });
+  it('getTemplates(): Promise<any> expects template list', function(done) {
+    config.getTemplates().then(result => {
+      expect(result).toEqual(jasmine.objectContaining({ test: 'vorlagen/test.docx' }));
+      done();
     });
+  });
 
-    it('getLDAP()', () => {
-        expect(config.getLDAP('config').url).toBe('ldap://formbox-ldap-test.de');
-        expect(config.getLDAP('attributes')).toContain('givenName');
-        expect(config.getLDAP('mapping').Vorname).toBe('givenName');
-    })
+  it('getFragmentFilePath(name: string) valid parameter, expect relative file path', function() {
+    const result = config.getFragmentFilePath('test');
+    expect(result).toBe('fragmente/test.docx');
+  });
+
+  it('getTemplateFilePath(name: string) valid parameter, expect relative file path', function() {
+    const result = config.getTemplateFilePath('test');
+    expect(result).toBe('vorlagen/test.docx');
+  });
+
+  it('getLDAP()', () => {
+    expect(config.getLDAP('config').url).toBe('ldap://formbox-ldap-test.de');
+    expect(config.getLDAP('attributes')).toContain('givenName');
+    expect(config.getLDAP('mapping').Vorname).toBe('givenName');
+  })
 });