@ikas/storefront 4.0.0-alpha.59 → 4.0.0-alpha.6

package/src/models/ui/validator/rules/index.ts

@@ -0,0 +1,310 @@
+import { computed, makeObservable, reaction } from "mobx";
+import _get from "lodash/get";
+
+export enum ValidatorErrorType {
+  "REQUIRED_RULE" = "REQUIRED_RULE",
+  "EMAIl_RULE" = "EMAIl_RULE",
+  "MIN_RULE" = "MIN_RULE",
+}
+
+type ValueGetter<T> = (model: T) => any;
+type ValuePath<T> = string | ValueGetter<T>;
+
+export interface IValidationRuleParams<T = any> {
+  model?: T;
+  fieldKey: string;
+  fieldName?: string;
+  message?: ((model: T) => string) | string;
+  errorType?: ValidatorErrorType;
+  valuePath: ValuePath<T>;
+  onValueChange?: (rule: ValidationRule) => void;
+}
+
+export abstract class ValidationRule<T = any> {
+  model?: T;
+  fieldKey: string;
+  fieldName?: string;
+  message?: ((model: T) => string) | string;
+  errorType?: ValidatorErrorType;
+  valuePath: ValuePath<T>;
+  onValueChange?: (rule: ValidationRule) => void;
+  disposer?: () => void;
+
+  constructor(data: IValidationRuleParams<T>) {
+    this.model = data.model;
+    this.valuePath = data.valuePath;
+    this.fieldKey = data.fieldKey;
+    this.fieldName = data.fieldName;
+    this.onValueChange = data.onValueChange;
+    this.message = data.message;
+    this.errorType = data.errorType;
+
+    this.disposer = reaction(
+      () => this.value,
+      () => this.onValueChange && this.onValueChange(this)
+    );
+  }
+
+  get value() {
+    return this.getValue(this.valuePath);
+  }
+
+  protected getValue(valuePath: ValuePath<T>) {
+    if (typeof valuePath === "string") {
+      return _get(this.model, valuePath);
+    }
+    return valuePath(this.model!);
+  }
+
+  abstract run(): Promise<boolean>;
+
+  abstract get errorMessage(): string;
+}
+
+export interface IMinRuleParams<T> extends IValidationRuleParams<T> {
+  minValue: number;
+}
+
+export class MinRule<T> extends ValidationRule<T> {
+  minValue: number;
+  errorType = ValidatorErrorType.MIN_RULE;
+
+  constructor(data: IMinRuleParams<T>) {
+    super(data);
+    this.minValue = data.minValue;
+  }
+
+  get errorMessage() {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    if (typeof this.value === "string") {
+      return this.value.length >= this.minValue;
+    }
+    return this.value >= this.minValue;
+  }
+}
+
+export interface IMaxRuleParams extends IValidationRuleParams {
+  maxValue: number;
+}
+
+export class MaxRule<T> extends ValidationRule<T> {
+  maxValue: number;
+
+  constructor(data: IMaxRuleParams) {
+    super(data);
+    this.maxValue = data.maxValue;
+  }
+
+  get errorMessage() {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    return this.value <= this.maxValue;
+  }
+}
+
+export class RequiredRule<T> extends ValidationRule<T> {
+  constructor(data: IValidationRuleParams<T>) {
+    super(data);
+    this.errorType = ValidatorErrorType.REQUIRED_RULE;
+  }
+
+  get errorMessage() {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    if (typeof this.value === "string") return !!this.value.trim();
+    if (Array.isArray(this.value)) return !!this.value.length;
+
+    return this.value !== undefined && this.value !== null;
+  }
+}
+
+interface ILessThanRuleParams<T> extends IValidationRuleParams<T> {
+  otherFieldValuePath: ValuePath<T>;
+  otherFieldName?: string;
+}
+
+export class LessThanRule<T> extends ValidationRule<T> {
+  otherFieldName?: string;
+
+  otherFieldValuePath: ValuePath<T>;
+
+  constructor(data: ILessThanRuleParams<T>) {
+    super(data);
+    this.otherFieldName = data.otherFieldName;
+    this.otherFieldValuePath = data.otherFieldValuePath;
+  }
+
+  get otherValue() {
+    return this.getValue(this.otherFieldValuePath);
+  }
+
+  get errorMessage(): string {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    if (
+      this.value === undefined ||
+      this.value == null ||
+      this.otherValue === null ||
+      this.otherValue === undefined
+    )
+      return true;
+    return this.value < this.otherValue;
+  }
+}
+
+export class EmailRule<T> extends ValidationRule<T> {
+  errorType = ValidatorErrorType.EMAIl_RULE;
+
+  get errorMessage(): string {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(this.value);
+  }
+}
+
+export class PhoneRule<T> extends ValidationRule<T> {
+  get errorMessage() {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    if (!this.value) return true;
+
+    const result = this.value.match(/\d/g);
+    return (
+      (!!result && result.length <= 11) || !!/^\+(\d{12})$/gm.test(this.value)
+    );
+  }
+}
+
+export interface IEqualsRuleParams<T> extends IValidationRuleParams<T> {
+  equalsValuePath: ValuePath<T>;
+}
+
+export class EqualsRule<T> extends ValidationRule<T> {
+  equalsValuePath: ValuePath<T>;
+
+  constructor(data: IEqualsRuleParams<T>) {
+    super(data);
+    makeObservable(this, { equalsValue: computed });
+    this.equalsValuePath = data.equalsValuePath;
+  }
+
+  get equalsValue() {
+    return this.getValue(this.equalsValuePath);
+  }
+
+  get errorMessage() {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    return this.value === this.equalsValue;
+  }
+}
+
+export class IdentityNumberRule<T> extends ValidationRule<T> {
+  get errorMessage() {
+    if (!this.message) return "";
+    if (typeof this.message === "string") return this.message;
+    return this.message(this.model!);
+  }
+
+  async run(): Promise<boolean> {
+    const identityNumber = this.value;
+    if (!identityNumber) return false;
+    const tcknString = identityNumber.toString();
+
+    let odd = 0,
+      even = 0,
+      result = 0,
+      TCSum = 0;
+
+    const incorrect = [
+      11111111110,
+      22222222220,
+      33333333330,
+      44444444440,
+      55555555550,
+      66666666660,
+      7777777770,
+      88888888880,
+      99999999990,
+    ];
+
+    if (tcknString.length !== 11) return false;
+    if (isNaN(identityNumber)) return false;
+    if (tcknString[0] === "0") return false;
+
+    odd =
+      parseInt(tcknString[0]) +
+      parseInt(tcknString[2]) +
+      parseInt(tcknString[4]) +
+      parseInt(tcknString[6]) +
+      parseInt(tcknString[8]);
+    even =
+      parseInt(tcknString[1]) +
+      parseInt(tcknString[3]) +
+      parseInt(tcknString[5]) +
+      parseInt(tcknString[7]);
+
+    odd = odd * 7;
+    result = Math.abs(odd - even);
+    if (result % 10 !== parseInt(tcknString[9])) return false;
+
+    for (let i = 0; i < 10; i++) {
+      TCSum += parseInt(tcknString[i]);
+    }
+
+    if (TCSum % 10 !== parseInt(tcknString[10])) return false;
+
+    if (incorrect.toString().indexOf(tcknString) !== -1) return false;
+
+    return true;
+  }
+
+  //   const tcknString = identityNumber.toString();
+  //   var basamak = /^[0-9]{11}$/.test(tcknString);
+  //   var toplamX = 0;
+  //   for (var i = 0; i < 10; i++) {
+  //     toplamX += Number(tcknString.substr(i, 1));
+  //   }
+  //   var kuralX = toplamX % 10 === parseInt(tcknString.substr(10, 1));
+  //   var toplamY = 0;
+  //   var toplamY = 0;
+  //   for (var i = 0; i < 10; i += 2) {
+  //     toplamY += Number(tcknString.substr(i, 1));
+  //   }
+  //   for (var i = 1; i < 10; i += 2) {
+  //     toplamY += Number(tcknString.substr(i, 1));
+  //   }
+  //   var kuralY =
+  //     (toplamY * 7 - toplamY) % 10 === parseInt(tcknString.substr(9, 0));
+  //   return basamak && kuralX && kuralY;
+  // }
+}