@seidor-cloud-produtos/tax-core 0.0.9-beta13 → 0.0.9-beta3

package/lib/taxReport/Block.ts

@@ -0,0 +1,58 @@
+import { EventEmitter } from "node:events";
+import RegisterPersist from "./interfaces/RegisterPersist";
+import { Register } from "./Register";
+import RegisterSubscriber from "./interfaces/RegisterSubscriber";
+import RegisterEventNotifier, {
+  Event,
+  newRegisterEventData,
+  RegisterEventData,
+} from "./interfaces/RegisterEventNotifier";
+
+export default abstract class Block
+  implements RegisterEventNotifier, RegisterSubscriber
+{
+  private readonly _name: string;
+  private eventEmitter: EventEmitter;
+  protected registersPersist: RegisterPersist;
+
+  protected constructor(name: string, regPersist: RegisterPersist) {
+    this._name = name;
+    this.eventEmitter = new EventEmitter();
+    this.registersPersist = regPersist;
+  }
+
+  abstract eventHandler(eventData: RegisterEventData): void;
+
+  public notifyEvent(eventData: RegisterEventData): void {
+    this.eventEmitter.emit(eventData.event, eventData);
+  }
+
+  get name() {
+    return this._name;
+  }
+
+  get registers() {
+    const sortApproach = (a: Register, b: Register) =>
+      a.reg.localeCompare(b.reg);
+    return this.registersPersist.all().sort(sortApproach);
+  }
+
+  public addSubscriber(subscriber: RegisterSubscriber) {
+    this.eventEmitter.on(Event.REGISTER_CREATED, function (data) {
+      return subscriber.eventHandler.call(subscriber, data);
+    });
+  }
+
+  public addRegister<T extends Register>(register: T) {
+    this.registersPersist.add(register);
+    this.notifyEvent(newRegisterEventData(register));
+  }
+
+  public hasContent(): boolean {
+    return this.registersPersist.hasRegisters();
+  }
+
+  public getRegisterByKey(registerKey: string): Register {
+    return this.registersPersist.getByKey(registerKey)!;
+  }
+}

package/lib/taxReport/CounterBlock.ts

@@ -0,0 +1,14 @@
+import Block from "./Block";
+import RegisterPersist from "./interfaces/RegisterPersist";
+import {RegisterEventData} from "./interfaces/RegisterEventNotifier";
+
+export default class CounterBlock extends Block {
+
+    constructor(regPersist: RegisterPersist, name: string = "9") {
+        super(name, regPersist);
+    }
+
+    eventHandler(eventData: RegisterEventData) {
+        // throw new Error("Method not implemented.");
+    }
+}

package/lib/taxReport/CounterRegister.ts

@@ -0,0 +1,20 @@
+import { Register } from "./Register";
+import { Alphanumeric, Key, Numeric } from "./Decorators";
+import RegisterEventNotifier from "./interfaces/RegisterEventNotifier";
+
+export default class CounterRegister extends Register {
+
+    // @ts-ignore
+    @Key()
+    // @ts-ignore
+    @Alphanumeric()
+    reg_blc: string = "";
+
+    // @ts-ignore
+    @Numeric()
+    qtd_reg_blc: number = 0;
+
+    constructor(qtd_reg_blc: number = 0, register: string = "9900") {
+        super(register, {} as RegisterEventNotifier);
+    }
+}

package/lib/taxReport/Decorators.ts

@@ -0,0 +1,242 @@
+import "reflect-metadata";
+
+export const keyCompositionMetadata = Symbol("key");
+
+export const maximumNumericLength = 19;
+export const defaultAlphanumericLength = 255;
+
+export enum FieldDataType {
+  alphanumeric,
+  numeric,
+}
+
+export enum valueProviderType {
+  property,
+  method,
+}
+
+export interface FieldFormat {
+  required: boolean;
+  dataType: FieldDataType;
+  maximumLength: number;
+  maximumDecimalsLength: number;
+  fillEntireLength: boolean;
+  valueProvider: valueProviderType;
+}
+
+function numericField(
+  required: boolean,
+  maximumLength: number,
+  valueProvider: valueProviderType,
+  fillEntireLength: boolean = false,
+  maximumDecimalsLength: number = 0,
+): FieldFormat {
+  return {
+    required: required,
+    dataType: FieldDataType.numeric,
+    maximumLength: maximumLength,
+    maximumDecimalsLength: maximumDecimalsLength,
+    fillEntireLength: fillEntireLength,
+    valueProvider: valueProvider,
+  } as FieldFormat;
+}
+
+function alphanumericField(
+  required: boolean,
+  maximumLength: number,
+  valueProvider: valueProviderType,
+  fillEntireLength: boolean = false,
+  maximumDecimalsLength: number = 0,
+): FieldFormat {
+  return {
+    required: required,
+    dataType: FieldDataType.alphanumeric,
+    maximumLength: maximumLength,
+    maximumDecimalsLength: maximumDecimalsLength,
+    fillEntireLength: fillEntireLength,
+    valueProvider: valueProvider,
+  } as FieldFormat;
+}
+
+export function Numeric(
+  required: boolean = false,
+  fillEntireLength: boolean = false,
+  maximumLength: number = maximumNumericLength,
+) {
+  return function (target: any, propertyKey: string, other?: any) {
+    Reflect.defineMetadata(
+      propertyKey,
+      numericField(
+        required,
+        maximumLength,
+        other ? valueProviderType.method : valueProviderType.property,
+        fillEntireLength,
+      ),
+      target,
+    );
+    return other;
+  };
+}
+
+//export function Numeric(
+//  required: boolean = false,
+//  fillEntireLength: boolean = false,
+//  maximumLength: number = maximumNumericLength,
+//): PropertyDecorator | MethodDecorator {
+//  return function (target: any, propertyKey: string, other: any) {
+//    Reflect.defineMetadata(
+//      propertyKey,
+//      numericField(
+//        required,
+//        maximumLength,
+//        other ? valueProviderType.method : valueProviderType.property,
+//        fillEntireLength,
+//      ),
+//      target,
+//    );
+//  };
+//}
+
+export function Decimal(
+  required: boolean = false,
+  fillEntireLength: boolean = false,
+  maximumLength: number = maximumNumericLength,
+  maximumDecimalsLength: number = 2,
+) {
+  return function (target: any, propertyKey: string, other?: any) {
+    Reflect.defineMetadata(
+      propertyKey,
+      numericField(
+        required,
+        maximumLength,
+        other ? valueProviderType.method : valueProviderType.property,
+        fillEntireLength,
+        maximumDecimalsLength,
+      ),
+      target,
+    );
+    return other;
+  };
+}
+
+//export function Decimal(
+//  required: boolean = false,
+//  fillEntireLength: boolean = false,
+//  maximumLength: number = maximumNumericLength,
+//  maximumDecimalsLength: number = 2,
+//): PropertyDecorator | MethodDecorator {
+//  return function (target: any, propertyKey: string, other: any) {
+//    Reflect.defineMetadata(
+//      propertyKey,
+//      numericField(
+//        required,
+//        maximumLength,
+//        other ? valueProviderType.method : valueProviderType.property,
+//        fillEntireLength,
+//        maximumDecimalsLength,
+//      ),
+//      target,
+//    );
+//  };
+//}
+
+export function Alphanumeric(
+    required: boolean = false,
+    fillEntireLength: boolean = false,
+    maximumLength: number = defaultAlphanumericLength
+  ) {
+  return function (target: any, propertyKey: string, other?: any) {
+    Reflect.defineMetadata(
+      propertyKey,
+      alphanumericField(
+        required,
+        maximumLength,
+        other ? valueProviderType.method : valueProviderType.property,
+        fillEntireLength,
+      ),
+      target,
+    );
+    return other;
+  };
+}
+
+//export function Alphanumeric(
+//  required: boolean = false,
+//  fillEntireLength: boolean = false,
+//  maximumLength: number = defaultAlphanumericLength,
+//): PropertyDecorator | MethodDecorator {
+//  return function (target: any, propertyKey: string, other: any) {
+//    Reflect.defineMetadata(
+//      propertyKey,
+//      alphanumericField(
+//        required,
+//        maximumLength,
+//        other ? valueProviderType.method : valueProviderType.property,
+//        fillEntireLength,
+//      ),
+//      target,
+//    );
+//  };
+//}
+
+export interface KeyComposition {
+  fields: KeyFieldDefinition[];
+}
+
+export interface KeyFieldDefinition {
+  fieldName: string;
+  valueProvider: valueProviderType;
+}
+
+function key() {
+  return {
+    fields: [],
+  } as KeyComposition;
+}
+
+function keyFieldDefinition(
+  fieldName: string,
+  valueProvider: valueProviderType,
+) {
+  return {
+    fieldName: fieldName,
+    valueProvider: valueProvider,
+  } as KeyFieldDefinition;
+}
+
+export function Key() {
+  return function (target: any, propertyKey: string, other?: any): void {
+    let keyComposition: KeyComposition;
+    keyComposition = Reflect.getMetadata(keyCompositionMetadata, target);
+    if (!keyComposition) {
+      keyComposition = key();
+    }
+    keyComposition.fields.push(
+      keyFieldDefinition(
+        propertyKey,
+        other ? valueProviderType.method : valueProviderType.property,
+      ),
+    );
+    Reflect.defineMetadata(keyCompositionMetadata, keyComposition, target);
+    return other;
+  };
+}
+
+//export function Key(): PropertyDecorator | MethodDecorator {
+//  return function (target: any, propertyKey: string, other?: any): void {
+//    let keyComposition: KeyComposition;
+//    keyComposition = Reflect.getMetadata(keyCompositionMetadata, target);
+//    if (!keyComposition) {
+//      keyComposition = key();
+//    }
+//    keyComposition.fields.push(
+//      keyFieldDefinition(
+//        propertyKey,
+//        other ? valueProviderType.method : valueProviderType.property,
+//      ),
+//    );
+//    Reflect.defineMetadata(keyCompositionMetadata, keyComposition, target);
+//  };
+//}
+
+//export {Numeric, Decimal, Alphanumeric, Key}

package/lib/taxReport/Register.ts

@@ -0,0 +1,42 @@
+import { Key, KeyComposition, keyCompositionMetadata } from "./Decorators";
+import RegisterEventNotifier, {
+  newRegisterEventData,
+} from "./interfaces/RegisterEventNotifier";
+
+export abstract class Register {
+  [key:string]:any;
+
+
+  private _registerNotifier: RegisterEventNotifier;
+  private readonly _children: Register[];
+
+  // @ts-ignore
+  @Key()
+  reg: string = "";
+  constructor(registerTag: string, notifier: RegisterEventNotifier) {
+    this._children = [];
+    this.reg = registerTag;
+    this._registerNotifier = notifier;
+  }
+
+  protected addChild(child: Register) {
+    this._children.push(child);
+    this._registerNotifier!!.notifyEvent(newRegisterEventData(child));
+  }
+
+  public getChildren(): Register[] {
+    return this._children;
+  }
+
+  public getKeyValue(): string {
+    const keyComposition: KeyComposition = Reflect.getMetadata(
+      keyCompositionMetadata,
+      this,
+    );
+    let result = "";
+    for (const keyFieldData of keyComposition.fields) {
+      result = result.concat(this[keyFieldData.fieldName]);
+    }
+    return result;
+  }
+}

package/lib/taxReport/ReportGenerator.ts

@@ -0,0 +1,178 @@
+import TaxReport from "./TaxReport";
+import Block from "./Block";
+import { Register } from "./Register";
+import { Alphanumeric, Numeric } from "./Decorators";
+import TagCounter from "./TagCounter";
+import CounterBlock from "./CounterBlock";
+import MemoryPersist from "./implementations/MemoryPersist";
+import CounterRegister from "./CounterRegister";
+import RegisterGenerator from "./interfaces/RegisterGenerator";
+import TaxRegisterGenerator from "./implementations/TaxRegisterGenerator";
+import RegisterEventNotifier from "./interfaces/RegisterEventNotifier";
+
+const tagCloseFileRegister = "9999";
+const openSuffix = "001";
+const closeSuffix = "990";
+
+export interface ReportGenerationOptions {
+  openSuffix: string;
+  closeSuffix: string;
+  openFileRegister: Register;
+  registerGenerator: RegisterGenerator;
+}
+
+enum IndicatorBlockContent {
+  hasContent = 0,
+  hasNoContent = 1,
+}
+
+export class CloseFile extends Register {
+  // @ts-ignore
+  @Numeric()
+  qtd_lin: number = 0;
+
+  constructor() {
+    super(tagCloseFileRegister, {} as RegisterEventNotifier);
+  }
+}
+
+export class OpenBlock extends Register {
+  constructor(tag: string) {
+    super(tag, {} as RegisterEventNotifier);
+  }
+  // @ts-ignore
+  @Alphanumeric(1)
+  ind_mov: number = IndicatorBlockContent.hasNoContent;
+}
+
+export class CloseBlock extends Register {
+  constructor(tag: string) {
+    super(tag, {} as RegisterEventNotifier);
+  }
+
+  qtd_lin: number = 0;
+}
+
+export default class ReportGenerator {
+  protected _options: ReportGenerationOptions;
+  protected _counters: TagCounter;
+
+  private constructor(options: ReportGenerationOptions) {
+    this._options = options;
+    this._counters = new TagCounter();
+  }
+
+  static defaultOptions(
+    openFileRegister: Register,
+    registerGenerator: RegisterGenerator,
+  ): ReportGenerationOptions {
+    return {
+      openSuffix: openSuffix,
+      closeSuffix: closeSuffix,
+      openFileRegister: openFileRegister,
+      registerGenerator: registerGenerator,
+    } as ReportGenerationOptions;
+  }
+
+  static newWithDefaultOptions(openFileRegister: Register): ReportGenerator {
+    return this.newWithOptions(
+      this.defaultOptions(
+        openFileRegister,
+        TaxRegisterGenerator.newWithDefaultOptions(),
+      ),
+    );
+  }
+
+  static newWithOptions(options: ReportGenerationOptions): ReportGenerator {
+    return new ReportGenerator(options);
+  }
+
+  private beforeGeneration(taxReport: TaxReport) {
+    this.addRegister(this._options.openFileRegister);
+  }
+
+  private generation(taxReport: TaxReport) {
+    const blocks = taxReport.Blocks;
+    for (const block of blocks) {
+      this.addBlock(block);
+    }
+  }
+
+  private afterGeneration(taxReport: TaxReport) {
+    const tagCounters = this._counters.getAllTagsCounters();
+    const counterBlock = new CounterBlock(MemoryPersist.createInstance());
+    const closeFileRegister = new CloseFile();
+    tagCounters.forEach((amount, tag) => {
+      const counterRegister = new CounterRegister();
+      counterRegister.reg_blc = tag;
+      counterRegister.qtd_reg_blc = amount;
+      closeFileRegister.qtd_lin += amount;
+      counterBlock.addRegister(counterRegister);
+    });
+    this.addBlock(counterBlock);
+    //This should register all lines of the taxReport
+    // To calculate this, we need to sum:
+    // total lines = registers lines (qtd_reg_blc) +
+    //               lines of counters (tagCounters.size) +
+    //               counters open and close line (2) +
+    //               close file line (1)
+    closeFileRegister.qtd_lin += tagCounters.size + 3;
+    this._options.registerGenerator.generate(closeFileRegister);
+  }
+
+  protected beforeBlockGeneration(block: Block): void {
+    const openBlock: OpenBlock = new OpenBlock(
+      `${block.name}${this._options.openSuffix}`,
+    );
+    openBlock.ind_mov = block.hasContent()
+      ? IndicatorBlockContent.hasContent
+      : IndicatorBlockContent.hasNoContent;
+    this.addRegister(openBlock);
+  }
+
+  protected blockGeneration(block: Block): void {
+    for (const register of block.registers) {
+      this.addRegister(register);
+    }
+  }
+
+  protected beforeRegisterGeneration(register: Register) {}
+
+  protected registerGeneration(register: Register) {
+    this._options.registerGenerator.generate(register);
+    for (const child of register.getChildren()) {
+      this.addRegister(child);
+    }
+  }
+
+  protected afterRegisterGeneration(register: Register) {
+    this._counters.countRegister(register);
+  }
+
+  protected afterBlockGeneration(block: Block) {
+    const closeBlock: CloseBlock = new CloseBlock(
+      `${block.name}${this._options.closeSuffix}`,
+    );
+    closeBlock.qtd_lin = this._counters.getBlockRegistersTotal(block.name) + 1;
+    this.addRegister(closeBlock);
+  }
+
+  private addBlock(block: Block) {
+    this.beforeBlockGeneration(block);
+    this.blockGeneration(block);
+    this.afterBlockGeneration(block);
+  }
+
+  private addRegister(register: Register) {
+    this.beforeRegisterGeneration(register);
+    this.registerGeneration(register);
+    this.afterRegisterGeneration(register);
+  }
+
+  public generateFile(taxReport: TaxReport): void {
+    this.beforeGeneration(taxReport);
+    this.generation(taxReport);
+    this.afterGeneration(taxReport);
+    this._options.registerGenerator.save();
+  }
+}

package/lib/taxReport/TagCounter.ts

@@ -0,0 +1,45 @@
+import {Register} from "./Register";
+
+export default class TagCounter {
+    private _blocksCounters: Map<string, Map<string, number>>;
+
+    public constructor() {
+        this._blocksCounters = new Map<string, Map<string, number>>();
+    }
+
+    public countRegister(register: Register) {
+        const blockLetter = register.reg[0];
+
+        let counters: Map<string, number>;
+        counters = !this._blocksCounters.has(blockLetter) ? new Map<string, number>() : this._blocksCounters.get(blockLetter)!
+        !counters.has(register.reg) ? counters.set(register.reg, 1) : counters.set(register.reg, (counters.get(register.reg)! + 1))
+        this._blocksCounters.set(blockLetter, counters);
+    }
+
+    public getBlockRegistersTotal(blockLetter: string): number {
+        let blockRegistersTotal = 0;
+        const blocksCounter = this._blocksCounters.get(blockLetter);
+        if (!blocksCounter) {
+            return blockRegistersTotal;
+        }
+        for (const value of blocksCounter.values()) {
+            blockRegistersTotal += value
+        }
+        return blockRegistersTotal
+    }
+
+    public getAllTagsCounters(): Map<string, number> {
+        const all = new Map<string, number>();
+
+        const blocksKeys = Array.from(this._blocksCounters.keys()).sort((a, b) => a.localeCompare(b));
+        blocksKeys.forEach((blockKey) => {
+            const block = this._blocksCounters.get(blockKey)!
+            const registerKeys = Array.from(block.keys()).sort((a, b) => a.localeCompare(b));
+            registerKeys.forEach((tag) => {
+                all.set(tag, block.get(tag)!)
+            })
+        })
+
+        return all;
+    }
+}

package/lib/taxReport/TaxReport.ts

@@ -0,0 +1,21 @@
+import Block from "./Block";
+
+export default abstract class TaxReport {
+    private readonly _blocks: Map<string, Block>;
+    protected constructor() {
+        this._blocks = new Map<string, Block>();
+    }
+
+    protected registerBlock(block: Block): TaxReport {
+        this._blocks.set(block.name, block);
+        return this
+    }
+
+    protected getBlock(name: string): Block | undefined {
+        return this._blocks.get(name)
+    }
+
+    get Blocks() {
+        return Array.from(this._blocks.values())
+    }
+}

package/lib/taxReport/implementations/ConsoleOutput.ts

@@ -0,0 +1,16 @@
+import { OutputWriter } from "../interfaces/OutputWriter";
+
+export default class ConsoleOutput implements OutputWriter {
+  private constructor() {}
+
+  static createInstance(): ConsoleOutput {
+    return new ConsoleOutput();
+  }
+
+  write(content: string): void {
+    console.log(content);
+  }
+  save(): void {
+    console.log("Saving content");
+  }
+}

package/lib/taxReport/implementations/MemoryPersist.ts

@@ -0,0 +1,63 @@
+import { Register } from "../Register";
+import RegisterPersist from "../interfaces/RegisterPersist";
+
+export default class MemoryPersist implements RegisterPersist {
+  private registers: Map<string, Array<Register>>;
+  private registersByKey: Map<string, Register>;
+
+  public static createInstance(): MemoryPersist {
+    return new MemoryPersist();
+  }
+
+  private constructor() {
+    this.registers = new Map<string, Array<Register>>();
+    this.registersByKey = new Map<string, Register>();
+  }
+
+  getByKey(registerKey: string): Register | undefined {
+    return this.registersByKey.get(registerKey);
+  }
+
+  set(regTag: string, registers: Register[]): void {
+    this.registers.set(regTag, registers);
+    for (const reg of registers) {
+      this.addRegisterKey(reg);
+    }
+  }
+  private addRegisterKey(reg: Register) {
+    if (this.registersByKey.has(reg.getKeyValue())) {
+      throw new Error(`duplicate register key: ${reg.getKeyValue()}`);
+    }
+    this.registersByKey.set(reg.getKeyValue(), reg);
+  }
+
+  hasRegisters(): boolean {
+    return this.registers.size !== 0;
+  }
+
+  all(): Register[] {
+    //TODO: Check the expected order of registers
+    //TODO: Check the performance + memory use of this implementation
+    let localRegisters: Register[] = new Array<Register>();
+    for (const [_regTag, values] of this.registers) {
+      localRegisters = [...localRegisters, ...values];
+    }
+    return localRegisters;
+  }
+
+  get(regTag: string) {
+    return this.registers.get(regTag);
+  }
+
+  has(regTag: string): boolean {
+    return this.registers.has(regTag);
+  }
+
+  add(register: Register): void {
+    if (!this.registers.has(register.reg)) {
+      this.registers.set(register.reg, []);
+    }
+    this.registers.get(register.reg)?.push(register);
+    this.addRegisterKey(register);
+  }
+}