nope/modules/mod-Data-Writers/assembly/manual-assembly.ts

/**
 * @author Martin Karkowski
 * @email m.karkowski@zema.de
 * @create date 2018-05-22 11:14:22
 * @modify date 2018-05-22 11:14:22
 * @desc [description]
*/

/** Export for Inversify */
import { inject, injectable } from 'inversify';
import { IDescriptor } from '../../mod-Assembly-Builder/type/interfaces';
import * as CONVERTERS from '../../mod-Converters/assembly/manual-assembly';
import { ITSDBConfiguration } from '../../mod-Converters/type/interfaces';
import { BaseBuffer } from '../src/buffer';
import { Da3vidBufferedWriterRest, Da3vidWriterRest, Da3vidWriterWebsockets } from '../src/da3vid-writer';
import { FileWriter } from '../src/file-writer';
import { OpenTSDBRestWriter } from '../src/openTSDB-writer';
import { IBuffer, IWriter } from '../type/interfaces';
import * as BUFFER from '../type/types';





export const TYPES = {
    BufferedCsvFileWriter: Symbol.for('BufferedCsvFileWriter'),
    BufferedDa3vidWriter: Symbol.for('BufferedDa3vidWriter'),
    Da3vidWriter: Symbol.for('Da3vidWriter'),
    BufferedOpenTSDBWriter: Symbol.for('BufferedOpenTSDBWriter'),
    Buffer: BUFFER.TYPES.Buffer,
    Writer: BUFFER.TYPES.Writer
};

/**
 * A CSV Converter.
 *
 * @class BufferedCsvFileWriter
 * @extends {BaseBuffer<any, string>}
 */
@injectable()
export class BufferedCsvFileWriter extends BaseBuffer<any, string, any> {
    /**
     * Creates an instance of BufferedCsvFileWriter.
     * @param {LOGGING.Logger} _logger 
     * @param {CONVERTERS.ToCsvConverter} _converter 
     * @memberof BufferedCsvFileWriter
     */
    constructor(
        @inject(CONVERTERS.TYPES.ToCsvConverter) _converter: CONVERTERS.ToCsvConverter
    ) {
        super();

        this.storeableElements = 500;
        this.writer = new FileWriter();
        this.converter = _converter;
    }

    /**
     * Setter for the SPLITCHAR
     * 
     * @memberof BufferedCsvFileWriter
     */
    public set SPLITCHAR(value: string) {
        (this.converter as CONVERTERS.ToCsvConverter).SPLITCHAR = value;
    }

    /**
     * Getter for the SPLITCHAR
     * 
     * @type {string}
     * @memberof BufferedCsvFileWriter
     */
    public get SPLITCHAR(): string {
        return (this.converter as CONVERTERS.ToCsvConverter).SPLITCHAR;
    }

    /**
     * Registers a Converter the Writer
     * 
     * @param {string} _topic 
     * @param {number} _column 
     * @memberof BufferedCsvFileWriter
     */
    public register(_topic: string, _column: number): void {
        (this.converter as CONVERTERS.ToCsvConverter).register(_topic, _column);
    }

    /**
     * Writes the Head
     * 
     * @memberof BufferedCsvFileWriter
     */
    public writeHead(): void {
        if (this.writer !== null) {
            /** Simply Write the Head */
            this.writer.write(
                [
                    (this.converter as CONVERTERS.ToCsvConverter).generateHead()
                ]
            );
        } else {
            throw Error('writer is not Set')
        }
    }

    /**
     * Sets the Filename of the Converter
     * 
     * @memberof BufferedCsvFileWriter
     */
    public set fileName(value: string) {
        (this.writer as FileWriter).fileName = value;
    }

    /**
     * Sets the Filename of the Converter
     * 
     * @memberof BufferedCsvFileWriter
     */
    public get fileName() {
        return (this.writer as FileWriter).fileName;
    }
}

@injectable()
export class ExportedDa3vidWriterRest extends BaseBuffer<any, CONVERTERS.Da3vidData, CONVERTERS.Da3vidConfiguration> {
    /**
     * Creates an instance of ExportedDa3vidWriter.
     * @param {LOGGING.Logger} _logger 
     * @param {CONVERTERS.ToDa3vidConverter} _converter 
     * @memberof ExportedDa3vidWriter
     */
    constructor(
        @inject(CONVERTERS.TYPES.ToDa3vidConverter) _converter: CONVERTERS.ToDa3vidConverter
    ) {
        super();

        this.storeableElements = 0;
        this.writer = new Da3vidWriterRest();
        this.converter = _converter;
    }

    /**
     * Register an Element with a Tag
     *
     * @param {string} _topic
     * @param {ITSDBConfiguration} _config
     * @memberof ExportedOpenTSDBWriter
     */
    public register(_topic: string, _config: CONVERTERS.Da3vidConfiguration): void {
        (this.converter as CONVERTERS.ToDa3vidConverter).register(_topic, _config);
    }
}

@injectable()
export class ExportedBufferedDa3vidWriterRest extends BaseBuffer<any, CONVERTERS.Da3vidData, CONVERTERS.Da3vidConfiguration> {
    constructor(
        @inject(CONVERTERS.TYPES.ToDa3vidConverter) _converter: CONVERTERS.ToDa3vidConverter
    ) {
        super();

        this.storeableElements = 200;
        this.writer = new Da3vidBufferedWriterRest();
        this.converter = _converter;
    }

    /**
     * Register an Element with a Tag
     *
     * @param {string} _topic
     * @param {ITSDBConfiguration} _config
     * @memberof ExportedOpenTSDBWriter
     */
    public register(_topic: string, _config: CONVERTERS.Da3vidConfiguration): void {
        (this.converter as CONVERTERS.ToDa3vidConverter).register(_topic, _config);
    }
}

@injectable()
export class ExportedOpenTSDBWriter extends BaseBuffer<any, CONVERTERS.TSDBData, CONVERTERS.TSDBConfiguration> {
    constructor(
        @inject(CONVERTERS.TYPES.ToTSDBConverter) _converter: CONVERTERS.ToOpenTSDBConverter
    ) {
        super();
        this.storeableElements = 1000;
        this.writer = new OpenTSDBRestWriter();
        this.converter = _converter;
    }

    /**
     * Register an Element with a Tag
     *
     * @param {string} _topic
     * @param {ITSDBConfiguration} _config
     * @memberof ExportedOpenTSDBWriter
     */
    public register(_topic: string, _config: ITSDBConfiguration): void {
        (this.converter as CONVERTERS.ToOpenTSDBConverter).register(_topic, _config);
    }


    /**
     * Set the URI
     *
     * @memberof ExportedOpenTSDBWriter
     */
    public set uri(value: string) {
        (this.writer as OpenTSDBRestWriter).uri = value;
    }


    /**
     * Get the URI
     *
     * @type {string}
     * @memberof ExportedOpenTSDBWriter
     */
    public get uri(): string {
        return (this.writer as OpenTSDBRestWriter).uri;
    }
}


export const EXPORT: Array<IDescriptor> = [
    {
        selector: TYPES.BufferedCsvFileWriter,
        type: BufferedCsvFileWriter,
        options: {
            scope: 'inSingletonScope'
        }
    },
    {
        selector: TYPES.Da3vidWriter,
        type: ExportedDa3vidWriterRest,
        options: {
            scope: 'inSingletonScope'
        }
    },
    {
        selector: TYPES.BufferedDa3vidWriter,
        type: Da3vidWriterWebsockets,
        options: {
            scope: 'inSingletonScope'
        }
    },
    {
        selector: TYPES.BufferedOpenTSDBWriter,
        type: ExportedOpenTSDBWriter,
        options: {
            scope: 'inSingletonScope'
        }
    },

];

export const REQUIRE = ['LOGGER', 'CONVERTER']

export type Buffer<T> = IBuffer<T>;
export type Writer<K> = IWriter<K>;
export type Da3vidWriterWebsockets = Da3vidWriterWebsockets;

export const NAME = 'WRITER';