x25 2.9.2 → 3.0.0

package/src/utility/normalize.js

@@ -0,0 +1,119 @@
+/* eslint-disable max-len, no-duplicate-imports */
+// @flow
+
+import type { NormalizedResult } from "src\\types";
+
+type Normalizr = (item : any) => any;
+
+type NormalizeBoolean = (input : "" | bool) => bool;
+type NormalizeArray = (raw : Array<any>) => NormalizedResult;
+type Normalize = (raw : Array<any>, field : string, normalizr : Normalizr) => NormalizedResult;
+type DefaultNormalize = (raw : Array<any>, field : string) => NormalizedResult;
+
+type Resolve = (data : any) => void;
+type Reject = (arg : any) => void;
+
+type Response = {
+  body: any;
+};
+
+type Error = {
+  status: any;
+}
+
+import * as Immutable from "immutable";
+
+const timeout = 500;
+
+const defaultNormalizr : Normalizr = (item) => Immutable.Map(item);
+
+const defaultValue = () => ({
+  entities : Immutable.Map(),
+  result   : Immutable.List(),
+});
+
+export const customNormalizeArrayByField : Normalize = (raw : Array<any>, field : string, normalizr : Normalizr) => (
+  raw === null ? defaultValue() : (
+    raw.reduce((previous, current) => {
+      const stringID = String(current[field]);
+
+      previous.entities = previous.entities.set(stringID,
+        normalizr(current));
+
+      previous.result = previous.result.push(stringID);
+
+      return previous;
+    }, defaultValue())
+  )
+);
+
+export const normalizeArrayByField : DefaultNormalize = (raw : Array<any>, field : string) => (
+  customNormalizeArrayByField(raw,
+    field,
+    defaultNormalizr)
+);
+
+export const withPromiseCallback = (resolve : Resolve, reject : Reject) => (error : Error, response : Response) => {
+  if (error) {
+    const StatusUnauthorized = 401;
+
+    if (error.status === StatusUnauthorized) {
+      document.location.href = "/";
+    } else {
+      // error.message
+      reject({ error: "Ceva nu a funcționat cum trebuia" });
+    }
+  } else {
+    resolve(response.body);
+  }
+};
+
+export const withHandlePDFCallback = (
+  { resolve, reject, title } : { resolve : Resolve, reject : Reject, title : string },
+) => (error : Error, response : Response) => {
+  // It is necessary to create a new blob object with mime-type explicitly set
+  // otherwise only Chrome works like it should
+  const newBlob = new Blob([response.body],
+    { type: "application/pdf" });
+
+  // IE doesn't allow using a blob object directly as link href
+  // instead it is necessary to use msSaveOrOpenBlob
+  if (window.navigator && window.navigator.msSaveOrOpenBlob) {
+    window.navigator.msSaveOrOpenBlob(newBlob);
+    return;
+  }
+
+  // For other browsers:
+  // Create a link pointing to the ObjectURL containing the blob.
+  const data = window.URL.createObjectURL(newBlob);
+  const link = document.createElement("a");
+
+  link.href = data;
+  link.download = `${title}.pdf`;
+  link.click();
+  setTimeout(() => {
+    // For Firefox it is necessary to delay revoking the ObjectURL
+    window.URL.revokeObjectURL(data);
+    withPromiseCallback(resolve,
+      reject)(error,
+      response);
+  }, timeout);
+};
+
+/*
+ * entities ---> Object { "1": Immutable.Map(), ... ]) }
+ * result ---> List([ "1", "2", "3" ])
+ */
+
+export const normalizeArray : NormalizeArray = (raw : Array<any>, normalizr?: Normalizr) => (
+  customNormalizeArrayByField(raw,
+    "ID",
+    typeof normalizr === "undefined" ? defaultNormalizr : normalizr)
+);
+
+export const normalizeBoolean : NormalizeBoolean = (value : boolean | "") => value || false;
+
+export const normalizeSelectNumeric = (raw : string) => (
+  (typeof raw === "string" && raw !== "") ? parseInt(raw,
+    10) : raw
+);

package/src/utility/numbers.js

@@ -0,0 +1,87 @@
+// @flow
+/* eslint-disable no-magic-numbers */
+
+declare var Intl:any
+
+const numberFormat : any = new Intl.NumberFormat("ro",
+  {
+    minimumFractionDigits: 2,
+  });
+
+const plainNumberFormat : any = new Intl.NumberFormat("ro");
+
+const replaceCharInString = ({ word, oldChar, newChar } : {
+  word: string,
+  oldChar: string,
+  newChar: string
+}) : string => {
+
+  const regex = new RegExp(oldChar,
+    "gu");
+
+  return word.replace(regex,
+    newChar);
+};
+
+// 127.99 ----> 127,99
+// 0 ----> ""
+export const formatZeroValue = (word : any, optional?: bool) : string => (
+  optional && word === ""
+) ? "" : replaceCharInString({
+    word    : String(word),
+    oldChar : "\\.",
+    newChar : ",",
+  });
+
+export const formatNumber = (word : any) : string => replaceCharInString({
+  word    : String(word),
+  oldChar : "\\.",
+  newChar : ",",
+});
+
+// 78,45 ---> 78.45
+export const normalizeNumber = (word : any) : string => replaceCharInString({
+  word    : String(word),
+  oldChar : ",",
+  newChar : ".",
+});
+
+export const numberToLocale = (value : number) : string => numberFormat.format(value);
+
+export const plainNumberToLocale = (value : number) : string => (
+  plainNumberFormat.format(value)
+);
+
+export const numberToLocaleForm = (value : number) : string => {
+  const upperLimit = 20,
+    formatted = plainNumberFormat.format(value);
+
+  if (value < upperLimit) {
+    return formatted;
+  }
+
+  return `${formatted} de`;
+};
+
+export const numericBehavior = {
+  normalize : normalizeNumber,
+  format    : formatNumber,
+};
+
+export const tryToParseNumber = (raw : string) => {
+  const result = Number(raw);
+
+  if (!isNaN(result) && raw !== "") {
+    return result;
+  }
+
+  return raw;
+};
+
+export const numberToLocaleHideBlank = (raw : any) => (
+  (typeof raw === "number" && raw !== 0) ? numberToLocale(raw) : ""
+);
+
+export const plainNumberToLocaleHideZero = (raw : any) => (
+  (typeof raw === "number" && raw !== 0) ? plainNumberToLocale(raw) : ""
+);

package/src/utility/numeric.js

@@ -0,0 +1,114 @@
+// @flow
+
+type This = any;
+
+import { normalizeNumber } from "./numbers";
+
+export const handleBlur = (that : This) => {
+  const { state, props } = that;
+
+  const
+    { input, normalizeValue, optional } = props,
+    { onBlur } = input,
+    { value: currentValue } = state;
+
+  const performBlur = (value : number | null, shouldRenderAgain : bool) => {
+
+    input.onChange(value);
+
+    /*
+     * Swallow the event to prevent Redux Form from
+     * extracting the form value
+     */
+    onBlur();
+
+    if (shouldRenderAgain) {
+      const setState = that.setState.bind(that);
+
+      return setState({
+        value,
+      });
+    }
+
+    return null;
+  };
+
+  const shouldNotChange = currentValue === "" && optional;
+
+  if (shouldNotChange) {
+    if (input.value === "") {
+      return null;
+    }
+
+    return performBlur(null,
+      true);
+  }
+
+  const
+    normalizedValue = normalizeValue(currentValue),
+    shouldRenderAgain = (
+      (!isNaN(normalizedValue)) &&
+      (currentValue !== normalizedValue)
+    );
+
+  return performBlur(normalizedValue,
+    shouldRenderAgain);
+};
+
+export const normalizeFloat = (raw : string) : number => {
+
+  /* eslint-disable no-magic-numbers */
+
+  const value = normalizeNumber(raw),
+    shouldNotNormalize = (
+      (value.trim() === "") ||
+    isNaN(Number(value))
+    );
+
+  if (shouldNotNormalize) {
+    return NaN;
+  }
+
+  const result = Number(value),
+    truncateTo = (unRouned : number, nrOfDecimals? : number = 2) : number => {
+      const parts = String(unRouned).split(".");
+
+      if (parts.length !== 2) {
+      // ex. 12
+        return unRouned;
+      }
+      const newDecimals = parts[1].slice(0,
+          nrOfDecimals),
+        newString = `${parts[0]}.${newDecimals}`;
+
+      return Number(newString);
+    },
+    normalized = truncateTo(result);
+
+  return normalized;
+};
+
+export const cwrp = (that : This, nextany : any) => {
+  const { state } = that;
+
+  const {
+    input: {
+      value: newValue,
+    },
+  } = nextany;
+
+  const { value: currentValue } = state;
+
+  const shouldRenderAgain = (
+    !isNaN(newValue) &&
+    (currentValue !== newValue)
+  );
+
+  const setState = that.setState.bind(that);
+
+  if (shouldRenderAgain) {
+    setState({
+      value: newValue,
+    });
+  }
+};

package/src/utility/others.jsx

@@ -0,0 +1,160 @@
+// @flow
+
+import type { List as ImmutableList, Map as ImmutableMap } from "immutable";
+
+type ReduxError = {
+  error: any;
+}
+
+import React from "react";
+import { SubmissionError } from "redux-form/immutable";
+
+export const getDateSortNumber = (item : string) => (
+  Number(new Date(item).getTime())
+);
+
+export const isAdministratorAccount = (current : number) => (
+  current === 0
+);
+
+export const createModal = (modalType : string, modalProps? : any) => ({
+  type    : "SHOW_MODAL",
+  payload : {
+    modalType,
+    modalProps,
+  },
+});
+
+export const
+  noError = "",
+  rowsPerLoad = 50,
+  nothingFetched = -1;
+
+export const removeID = (payload : ImmutableMap<string, any>) => (list : ImmutableList<string>) => (
+  // $FlowFixMe
+  list.delete(list.findIndex((current : string) => current === String(payload.get("ID"))))
+);
+
+export const addID = (payload : ImmutableMap<string, any>) => (list : ImmutableList<string>) => (
+  list.push(String(payload.get("ID")))
+);
+
+export const ReduxFormSubmissionError = (error? : ReduxError) => {
+  if (error) {
+    if (error instanceof SubmissionError) {
+      throw error;
+    }
+
+    const _error = typeof error.error === "string" ? error.error : "Am pierdut conexiunea cu server-ul";
+
+    throw new SubmissionError({
+      _error,
+    });
+  }
+};
+
+export const delay = () => (
+  new Promise((resolve) => {
+    setTimeout(resolve);
+  }) : Promise<any>
+);
+
+export const showCheck = (value : boolean) => (
+  value ? (
+    <i className="fa fa-check text-success" />
+  ) : null
+);
+
+export const userHasPressedCKeyAlone = (currentEvent : KeyboardEvent) : boolean => {
+  const {
+    ctrlKey,
+    keyCode,
+    srcElement: {
+      localName,
+    },
+  } = currentEvent;
+
+  const
+    createInvoiceKey = 67,
+    tag = localName.toLowerCase(),
+    isNotInputOrTextarea = (
+      tag !== "input" &&
+      tag !== "textarea"
+    );
+
+  return (
+    !ctrlKey &&
+    keyCode === createInvoiceKey &&
+    isNotInputOrTextarea
+  );
+};
+
+export const years = [
+  {
+    value : 2018,
+    name  : "2018",
+  },
+  {
+    value : 2019,
+    name  : "2019",
+  },
+  {
+    value : 2020,
+    name  : "2020",
+  },
+  {
+    value : 2021,
+    name  : "2021",
+  },
+];
+
+export const months = [
+  {
+    value : 0,
+    name  : "Ianuarie",
+  },
+  {
+    value : 1,
+    name  : "Februarie",
+  },
+  {
+    value : 2,
+    name  : "Martie",
+  },
+  {
+    value : 3,
+    name  : "Aprilie",
+  },
+  {
+    value : 4,
+    name  : "Mai",
+  },
+  {
+    value : 5,
+    name  : "Iunie",
+  },
+  {
+    value : 6,
+    name  : "Iulie",
+  },
+  {
+    value : 7,
+    name  : "August",
+  },
+  {
+    value : 8,
+    name  : "Septembrie",
+  },
+  {
+    value : 9,
+    name  : "Octombrie",
+  },
+  {
+    value : 10,
+    name  : "Noiembrie",
+  },
+  {
+    value : 11,
+    name  : "Decembrie",
+  },
+];

package/src/utility/strings-test.js

@@ -0,0 +1,136 @@
+import {
+  firstToUppercase,
+  toLower,
+  toTitle,
+  toUpper,
+} from "./strings";
+
+// toTitle
+(() => {
+  describe("Test toTitle",
+    () => {
+      const tests = [
+        {
+          input  : "",
+          output : "",
+        },
+        {
+          input  : "cosovei",
+          output : "Cosovei",
+        },
+        {
+          input  : "simona cosovei",
+          output : "Simona Cosovei",
+        },
+        {
+          input  : "ștefănică țepeș",
+          output : "Ștefănică Țepeș",
+        },
+        {
+          input  : "this is 4 long name 5",
+          output : "This Is 4 Long Name 5",
+        },
+      ];
+
+      for (const { input, output } of tests) {
+        describe(`Given the raw string "${input}"`,
+          () => {
+            it(`should be transformed to "${output}"`,
+              () => {
+                expect(toTitle(input)).toEqual(output);
+              });
+          });
+      }
+    });
+})();
+
+// firstToUppercase
+(() => {
+  describe("Test firstToUppercase",
+    () => {
+      const tests = [
+        {
+          input  : "",
+          output : "",
+        },
+        {
+          input  : "sima",
+          output : "Sima",
+        },
+        {
+          input  : "Simona Cosovei",
+          output : "Simona Cosovei",
+        },
+        {
+          input  : "this is 4 long name 5",
+          output : "This is 4 long name 5",
+        },
+      ];
+
+      for (const { input, output } of tests) {
+        describe(`given "${input}"`,
+          () => {
+            it(`should be transformed to "${output}"`,
+              () => {
+                expect(firstToUppercase(input)).toEqual(output);
+              });
+          });
+      }
+    });
+})();
+
+// toUpper
+(() => {
+  const tests = [
+    {
+      input  : "",
+      output : "",
+    },
+    {
+      input  : "sima",
+      output : "SIMA",
+    },
+    {
+      input  : "this is 4 long name 5",
+      output : "THIS IS 4 LONG NAME 5",
+    },
+  ];
+
+  for (const { input, output } of tests) {
+    describe(`given "${input}"`,
+      () => {
+        it(`should be transformed to "${output}"`,
+          () => {
+            expect(toUpper(input)).toEqual(output);
+          });
+      });
+  }
+})();
+
+// toLower
+(() => {
+  const tests = [
+    {
+      input  : "",
+      output : "",
+    },
+    {
+      input  : "siMa",
+      output : "sima",
+    },
+    {
+      input  : "This is 4 long Name 5",
+      output : "this is 4 long name 5",
+    },
+  ];
+
+  for (const { input, output } of tests) {
+    describe(`given "${input}"`,
+      () => {
+        it(`should be transformed to "${output}"`,
+          () => {
+            expect(toLower(input)).toEqual(output);
+          });
+      });
+  }
+})();

package/src/utility/strings.js

@@ -0,0 +1,80 @@
+/*
+ * @flow
+ * Simona Cosovei ---> Simona Cosovei
+ */
+export const toTitle = (str : string) : string => {
+  const transform = (txt : string) : string => {
+    const firstPart = txt.charAt(0).toUpperCase(),
+      secondPart = txt.substr(1).toLowerCase();
+
+    return `${firstPart}${secondPart}`;
+  };
+
+  return str.replace(/\S+/gu,
+    transform);
+};
+
+// this is an example ---> This is an example
+export const firstToUppercase = (str : string) : string => {
+  const firstPart = str.charAt(0).toUpperCase(),
+    secondPart = str.slice(1);
+
+  return `${firstPart}${secondPart}`;
+};
+
+export const normalizeDiacritics = (str: string) : string => {
+  const chars = {
+    "ă" : "a",
+    "â" : "a",
+    "î" : "i",
+    "ț" : "t",
+    "ș" : "s",
+
+    "Ă" : "A",
+    "Â" : "A",
+    "Î" : "I",
+    "Ț" : "T",
+    "Ș" : "S",
+  };
+
+  return str.replace(/ă|â|î|ț|ș|Ă|Â|Î|Ț|Ș/gui,
+    (matched) => chars[matched]);
+};
+
+// This is ---> THIS IS
+export const toUpper = (str : string) : string => str.toUpperCase();
+
+// This is ---> this is
+export const toLower = (str : string) : string => str.toLowerCase();
+
+export const formatBankAccount = (raw: string) : string => {
+
+  if (typeof raw === "undefined" || raw === "") {
+    return "";
+  }
+
+  let output = "";
+
+  const nrOfCharsPerGroup = 4,
+    withoutSpaces = raw.replace(/ /gu,
+      "");
+
+  for (let index = 0; index < withoutSpaces.length; index += 1) {
+    const currentChar = withoutSpaces.charAt(index);
+
+    if (output !== "" && index % nrOfCharsPerGroup === 0) {
+      output += " ";
+    }
+
+    output += currentChar;
+  }
+
+  return output;
+};
+
+export const normalizeCompanyName = (raw : string) : string => (
+  toTitle(raw).replace(/\ssrl/gui,
+    " S.R.L.").
+    replace(/\ss\.r\.l/gui,
+      " S.R.L")
+);