DiunaBI/Frontend/src/app/models/dataSet.model.ts

import { Base } from './base.model';
import { UntypedFormBuilder, Validators, UntypedFormGroup } from '@angular/forms';
import { HttpClient } from '@angular/common/http';
import { environment } from 'src/environments/environment';
import { map } from 'rxjs';
import { DataRow } from './dataRow.model copy';

export class DataSet extends Base {
    number?: Number;
    source?: string; 
    name?: string;
    dataRows: DataRow[] = [];

    constructor(data: Partial<DataSet> = {}) {
        super();
        Object.assign(this, data);
    }
    override deserialize(input: any): this {     
        Object.assign(this, Object.assign(this, super.deserialize(input)));
        if (this.dataRows) { this.dataRows = this.dataRows.map(x => new DataRow().deserialize(x)); }
        return this;
    }
    override serialize() {
        this.number = 0; // will be overrided in backend
        return Object.assign({}, this);
    }
    static getForm(fb: UntypedFormBuilder) {
        return fb.group({
            id: [null],
            name: ['', Validators.required],
            source: ['', Validators.required],
            createdAt: '',
            modifiedAt: '',
            createdBy: '',
            modifiedBy: '',
          });
    }
    fillForm(form: UntypedFormGroup) {
        form.patchValue(this);
        form.patchValue({
            createdBy: this.createdBy?.userName,
            modifiedBy: this.modifiedBy?.userName
        });
    }
    loadForm(form: UntypedFormGroup) {
        for (let field of Object.keys(form.controls)) {
            this[field as keyof DataSet] = form.controls[field].value;
        }
        this.createdBy = undefined;
        this.modifiedBy = undefined;
    }
    //API Actions 
    static add(input: DataSet, _http: HttpClient): Promise<string> {
        return new Promise((resolve, reject) => {
            _http.post<string>(`${environment.api.url}/datasets`, {...input.serialize(), }).subscribe({
                next: (data) => resolve(data),
                error: (e) => reject(e) 
              }
            );
        });
    }
    static getList(_http: HttpClient): any {
        return new Promise((resolve, reject) => {
            _http.get<DataSet[]>(`${environment.api.url}/datasets`)
            .pipe(map(data => data.map(x => new DataSet().deserialize(x))))
            .subscribe({
                next: (data) => resolve(data),
                error: (e) => reject(e)
            })
        });
    }
    static getById(id: string, _http: HttpClient): Promise<DataSet> {
        return new Promise((resolve, reject) => {
            _http.get<DataSet>(`${environment.api.url}/datasets/${id}`).pipe(map(x => new DataSet().deserialize(x))).subscribe({
                next: (data) => resolve(data),
                error: (e) => reject(e)
            })
        });
    }
    static parseFile(file: any, _http: HttpClient): Promise<DataRow[]> {
        const formData = new FormData();
        formData.append(file.name, file);
        return new Promise((resolve, reject) => {
            _http.post<DataRow[]>(`${environment.api.url}/datasets/parseFile`, formData,
            ).pipe(map(data  => data.map(x => new DataRow().deserialize(x))))
            .subscribe({
                next: (data) => {
                    resolve(data);
                },
                error: (e) => reject(e)
            })
        })
    }
}