Function bodies 124 total

export class Administrator implements IPerson {
  id?: string
  firstName?: string
  lastName?: string
  fullName?: string
  email?: string
}

export class Book extends Product {
    isbn?: string;
    author?: string;
    editor?: string;
    yearOfPublication?: number;
    numberOfPages?: number;
}

export class Equipe implements IEquipes {
  Id: string = "";
  nameFr?: string;
  nameEn?: string;
}

export class Member implements IPerson {
  id?: string
  created?: string
  active?: boolean
  firstName?: string
  lastName?: string
  fullName?: string
  email?: string
  phoneNumber?: string
  phoneExtension?: number
  apartment?: number
  street?: string
  city?: string
  zipCode?: string
  userId?: string
  roles?: string[]
}

export class Module implements IModules {
    Id: string = '';
    name?: string;
    content?: string;
    cardImage?: File;
    subject?: string;
}

export class Product implements IProduct {
    id?: string;
    nameFr?: string
    nameEn?: string
    descriptionFr?: string
    descriptionEn?: string

    price?: number
    cardImage?: File
    savedCardImage?: string
    membersOnly?: boolean
}

export class User {
  id?: string
  fullName?: string
  email?: string
  phoneNumber?: string
  phoneExtension?: number
  roles: Role[] = []
}

export class Guid {
  public static newGuid(): Guid {
    return new Guid(
      "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
        const r = (Math.random() * 16) | 0;
        const v = c == "x" ? r : (r & 0x3) | 0x8;
        return v.toString(16);
      })
    );
  }
  public static get empty(): string {
    return "00000000-0000-0000-0000-000000000000";
  }
  public get empty(): string {
    return Guid.empty;
  }
  public static isValid(str: string): boolean {
    const validRegex =
      /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
    return validRegex.test(str);
  }
  private value: string = this.empty;
  constructor(value?: string) {
    if (value) {
      if (Guid.isValid(value)) {
        this.value = value;
      }
    }
  }
  public toString() {
    return this.value;
  }

  public toJSON(): string {
    return this.value;
  }
}

  public static newGuid(): Guid {
    return new Guid(
      "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
        const r = (Math.random() * 16) | 0;
        const v = c == "x" ? r : (r & 0x3) | 0x8;
        return v.toString(16);
      })
    );
  }

  public static isValid(str: string): boolean {
    const validRegex =
      /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
    return validRegex.test(str);
  }

  constructor(value?: string) {
    if (value) {
      if (Guid.isValid(value)) {
        this.value = value;
      }
    }
  }

  public toString() {
    return this.value;
  }

  public toJSON(): string {
    return this.value;
  }

export class SucceededOrNotResponse {
    errors: Error[] = [];
    succeeded: boolean;

    constructor(succeeded: boolean, errors?: Error[]) {
        this.succeeded = succeeded
        if (errors)
            this.errors = errors
    }
    
    getErrorMessages(translationLocation: string, fallbackKey?: string): string[] {
        const errorMessages: string[] = [];
        this.errors.forEach(error => {
            const errorKey = error.errorType.makeFirstLetterLowercase()
            const errorMessage = i18n.t(`${translationLocation}.${errorKey}`)
            if (fallbackKey)
                errorMessages.push(errorMessage ? errorMessage : i18n.t(fallbackKey))
            else
                errorMessages.push(errorMessage ? errorMessage : i18n.t('validation.errorOccured'))
        })
        return errorMessages
    }
}

    constructor(succeeded: boolean, errors?: Error[]) {
        this.succeeded = succeeded
        if (errors)
            this.errors = errors
    }

export class TranslatableString {
  fr?: string
  en?: string

  constructor(fr?: string, en?: string) {
    this.fr = fr
    this.en = en
  }

  get getValueForLocale() {
    if (i18n.getLocale() === "fr")
      return this.fr ?? "";
    return this.en ?? "";
  }
}

  constructor(fr?: string, en?: string) {
    this.fr = fr
    this.en = en
  }

export function validate(value: string, rules: Rule[]): Status {
  for (const rule of rules) {
    const result = rule(value);
    if (!result.valid) {
      return result;
    }
  }

  return {
    valid: true,
  };
}

export function validateBoolean(value: boolean, rules: RuleBoolean[]): Status {
  for (const rule of rules) {
    const result = rule(value);
    if (!result.valid) {
      return result;
    }
  }

  return {
    valid: true,
  };
}

export function validateArray(value: any[], rules: RuleArray[]): Status {
  for (const rule of rules) {
    const result = rule(value);
    if (!result.valid) {
      return result;
    }
  }

  return {
    valid: true,
  };
}

export function minDate(min: string): Rule {
  return function (value: string): Status {
    const result = value > min;

    return {
      valid: result,
      message: result
        ? undefined
        : i18n.t('validation.min').replace("{min}", min.toString())
    };
  };
}

export function min(min: number): Rule {
  return function (value: string): Status {
    const result = Boolean(parseInt(value) >= min);

    return {
      valid: result,
      message: result
        ? undefined
        : i18n.t('validation.min').replace("{min}", min.toString()),
    };
  };
}

export function max(max: number): Rule {
  return function (value: string): Status {
    const result = Boolean(parseInt(value) <= max);

    return {
      valid: result,
      message: result
        ? undefined
        : i18n.t('validation.max').toString().replace("{max}", max.toString()),
    };
  };
}

function removeCrossorigin() {
  return {
    name: 'remove-crossorigin',
    transformIndexHtml(html: string) {
      return html.replace(/ crossorigin/g, '')
    }
  }
}