x25 2.9.2 → 3.0.0

package/src/utility/validation/validate/cnp.js

@@ -0,0 +1,261 @@
+// @flow
+/* eslint-disable no-magic-numbers, max-statements */
+
+export const isValidCNP = (rawValue : string) : boolean => {
+
+  type CNP = Array<number>;
+
+  type PositionPropTypes = {
+    [key: string]: number;
+  };
+
+  const decimalSystem = 10,
+    position : PositionPropTypes = {
+      yearMillenium : 0,
+      sex           : 0,
+
+      yearDecades : 1,
+      yearUnits   : 2,
+
+      monthDecimals : 3,
+      monthUnits    : 4,
+
+      dayDecimals : 5,
+      dayUnits    : 6,
+
+      countyDecimals : 7,
+      countyUnits    : 8,
+
+      numberHundreds : 9,
+      numberDecimals : 10,
+      numberUnits    : 11,
+
+      controlDigit: 12,
+    },
+    getCNP = (raw : string) : CNP => {
+
+      let hashResult = 0;
+
+      const hashTable = [
+          2,
+          7,
+          9,
+          1,
+          4,
+          6,
+          3,
+          5,
+          8,
+          2,
+          7,
+          9,
+        ],
+        normalLength = 13,
+        cnp = [];
+
+      const reduceHash = (rawHash : number) : number => {
+        const
+          nrOfDigits = 11,
+          reduced = parseInt(rawHash % nrOfDigits,
+            decimalSystem);
+
+        if (reduced === 10) {
+          return 1;
+        }
+
+        return reduced;
+      };
+
+      if (raw.length !== normalLength) {
+        throw new Error(`The length [actual:${raw.length}]
+        should be ${normalLength} characters`);
+      }
+
+      if (raw[0] === "0") {
+        throw new Error("The sex can not be 0");
+      }
+
+      const controlDigit = parseInt(
+        raw.charAt(position.controlDigit),
+        decimalSystem,
+      );
+
+      if (isNaN(controlDigit)) {
+        throw new Error("The control digit should be number");
+      }
+
+      for (let index = 0; index < 12; index += 1) {
+
+        const rawChar = raw.charAt(index),
+          parsedValue = parseInt(rawChar,
+            decimalSystem),
+          correspondingHashNumber = hashTable[index];
+
+        if (isNaN(parsedValue)) {
+          throw new Error(`The char at position ${index} should be numeric`);
+        }
+
+        cnp[index] = parsedValue;
+        hashResult += (parsedValue * correspondingHashNumber);
+      }
+
+      if (controlDigit !== reduceHash(hashResult)) {
+        throw new Error(`
+          The control digit is not good
+          [${controlDigit} === ${reduceHash(hashResult)}]
+          `);
+      }
+
+      return cnp;
+    },
+    validate = (cnp : CNP) => {
+      const getCNPDigit = (currentPosition : number) : number => cnp[currentPosition],
+        isValidDate = () => {
+          const getYear = () : number => {
+            const computeYear = () : number => {
+                const {
+                  yearMillenium,
+                  yearDecades,
+                  yearUnits,
+                } = position;
+
+                let year = (
+                  (getCNPDigit(yearDecades) * 10) +
+                  getCNPDigit(yearUnits)
+                );
+
+                switch (getCNPDigit(yearMillenium)) {
+                  case 1:
+                  case 2:
+                    year += 1900;
+                    break;
+                  case 3:
+                  case 4:
+                    year += 1800;
+                    break;
+                  case 5:
+                  case 6:
+                    year += 2000;
+                    break;
+
+                    // 7,8,9
+                  default: {
+                    year += 2000;
+
+                    const today : any = new Date(),
+                      tempYear = parseInt(today.getYear(),
+                        10) - 14;
+
+                    if (year > tempYear) {
+                      year -= 100;
+                    }
+                  }
+                    break;
+                }
+
+                return year;
+              },
+              year : number = computeYear();
+
+            if (year < 1800 || year > 2099) {
+              throw new Error(`
+                Year [actual: ${String(year)}] is not valid.
+                It should be between 1800 and 2099
+                `);
+            }
+
+            return year;
+          };
+
+          const year : number = getYear();
+
+          const {
+              monthDecimals,
+              monthUnits,
+              dayDecimals,
+              dayUnits,
+            } = position,
+            month = (
+              (getCNPDigit(monthDecimals) * 10) +
+              getCNPDigit(monthUnits)
+            ),
+            day = (
+              (getCNPDigit(dayDecimals) * 10) +
+              getCNPDigit(dayUnits)
+            ),
+            // js months are starting from 0 -> 11
+            jsMonth = month - 1,
+            date = new Date(year,
+              jsMonth,
+              day,
+              0,
+              0,
+              0,
+              0);
+
+          if (
+            (date.getFullYear() !== year) ||
+              (date.getMonth() !== jsMonth) ||
+              (date.getDate() !== day)
+          ) {
+            throw new Error(`
+                The given date
+                [
+                  year -> ${String(year)}
+                  month -> ${String(month)}
+                  day -> ${String(day)}
+                ]`);
+          }
+        },
+        isValidCounty = () => {
+          const {
+              countyDecimals,
+              countyUnits,
+            } = position,
+            lowerLimit = 1,
+            upperLimit = 52,
+            code = (
+              (getCNPDigit(countyDecimals) * 10) +
+                getCNPDigit(countyUnits)
+            );
+
+          if (
+            code < lowerLimit ||
+                code > upperLimit
+          ) {
+            throw new Error(`
+                  The country code is invalid [actual: ${code}],
+                  should be between: ${lowerLimit} <= ${code} >= ${upperLimit}
+                  `);
+          }
+        },
+        isValidNumber = () => {
+          const {
+              numberHundreds,
+              numberDecimals,
+              numberUnits,
+            } = position,
+            number = (
+              (getCNPDigit(numberHundreds) * 100) +
+                  (getCNPDigit(numberDecimals) * 10) +
+                  getCNPDigit(numberUnits)
+            );
+
+          if (number === 0) {
+            throw new Error("The number should not be 0");
+          }
+        };
+
+      isValidDate();
+      isValidCounty();
+      isValidNumber();
+    };
+
+  try {
+    validate(getCNP(rawValue));
+
+    return true;
+  } catch (error) {
+    return false;
+  }
+};

package/{utility → src/utility}/validation/validate/date.js

@@ -1,61 +1,73 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-/* eslint-disable no-magic-numbers */
-
-var pattern = /^[0-9]{1,2}\.[0-9]{2}\.[0-9]{4}$/,
-    monthLength = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-
-// 2018-03-31T00:00:00.000Z
-// 2015-02-25T00:00:00Z
-var isValidDateStamp = exports.isValidDateStamp = function isValidDateStamp(raw) {
-
-  if (typeof raw !== "string" || raw.length < 20 || raw.length > 24) {
-    return false;
-  }
-
-  var value = new Date(raw);
-
-  if (Object.prototype.toString.call(value) === "[object Date]") {
-    if (isNaN(value.getTime())) {
-      return false;
-    }
-
-    return true;
-  }
-  return false;
-};
-
-// e.g. 25.08.2015
-var isValidDate = exports.isValidDate = function isValidDate(dateString) {
-
-  if (typeof dateString !== "string" || dateString.length !== 10) {
-    return false;
-  }
-
-  if (!pattern.test(dateString)) {
-    return false;
-  }
-
-  // Parse the date parts to integers
-  var parts = dateString.split("."),
-      day = parseInt(parts[0], 10),
-      month = parseInt(parts[1], 10),
-      year = parseInt(parts[2], 10);
-
-  // Check the ranges of month and year
-  if (year < 1000 || year > 3000 || month === 0 || month > 12) {
-    return false;
-  }
-
-  // Adjust for leap years
-  if (year % 400 === 0 || year % 100 !== 0 || year % 4 !== 0) {
-    monthLength[1] = 29;
-  }
-
-  // Check the range of the day
-  return day > 0 && day <= monthLength[month - 1];
-};
+// @flow
+/* eslint-disable no-magic-numbers */
+
+const
+  pattern = /^\d{1,2}\.\d{2}\.\d{4}$/u,
+  monthLength = [
+    31,
+    28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31,
+  ];
+
+// 2018-03-31T00:00:00.000Z
+// 2015-02-25T00:00:00Z
+export const isValidDateStamp = (raw: any) => {
+
+  if (typeof raw !== "string" || raw.length < 20 || raw.length > 24) {
+    return false;
+  }
+
+  const value = new Date(raw);
+
+  if (Object.prototype.toString.call(value) === "[object Date]") {
+    if (isNaN(value.getTime())) {
+      return false;
+    }
+
+    return true;
+  }
+  return false;
+};
+
+// e.g. 25.08.2015
+export const isValidDate = (dateString : string) : boolean => {
+
+  if (typeof dateString !== "string" || dateString.length !== 10) {
+    return false;
+  }
+
+  if (!pattern.test(dateString)) {
+    return false;
+  }
+
+  // Parse the date parts to integers
+  const parts = dateString.split("."),
+    day = parseInt(parts[0],
+      10),
+    month = parseInt(parts[1],
+      10),
+    year = parseInt(parts[2],
+      10);
+
+  // Check the ranges of month and year
+  if (year < 1000 || year > 3000 || month === 0 || month > 12) {
+    return false;
+  }
+
+  // Adjust for leap years
+  if ((year % 400 === 0) || (year % 100 !== 0) || (year % 4 !== 0)) {
+    monthLength[1] = 29;
+  }
+
+  // Check the range of the day
+  return day > 0 && day <= monthLength[month - 1];
+};

package/src/utility/validation/validate/email-test.js

@@ -0,0 +1,36 @@
+import { isValidEmail } from "./email";
+
+const valid = true,
+  notValid = false;
+
+describe("given an email without @ [email]",
+  () => {
+    it("should not be valid",
+      () => {
+        expect(isValidEmail("email")).toBe(notValid);
+      });
+  });
+
+describe("given an email without the user [email@]",
+  () => {
+    it("should not be valid",
+      () => {
+        expect(isValidEmail("email@")).toBe(notValid);
+      });
+  });
+
+describe("given an email without domain [email@email]",
+  () => {
+    it("should not be valid",
+      () => {
+        expect(isValidEmail("email@email")).toBe(notValid);
+      });
+  });
+
+describe("given a good email (email@email.ro)",
+  () => {
+    it("should be valid",
+      () => {
+        expect(isValidEmail("email@email.ro")).toBe(valid);
+      });
+  });

package/src/utility/validation/validate/email.js

@@ -0,0 +1,6 @@
+// @flow
+
+export const isValidEmail = (value : string) : boolean => (
+  /* eslint-disable-next-line */
+  new RegExp(/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/igm).test(value)
+);

package/src/utility/validation/validate/index.js

@@ -0,0 +1,7 @@
+// @flow
+
+export * from "./date";
+export * from "./email";
+export * from "./cif";
+export * from "./cnp";
+export * from "./bank";

package/webpack.config.js

@@ -0,0 +1,90 @@
+'use strict'
+
+var webpack = require('webpack')
+var env = process.env.NODE_ENV
+
+var config = {
+  module: {
+    loaders: [
+      {
+        test    : /\.jsx?$/u,
+        use     : ["babel-loader"],
+        exclude: /node_modules/
+      },
+      {
+        test : /\.scss$/u,
+        use  : [
+          "style-loader",
+          "css-loader",
+          "sass-loader",
+        ],
+      },
+      {
+        test : /\.css$/u,
+        use  : [
+          "style-loader",
+          "css-loader",
+        ],
+      },
+      {
+        test : /\.woff(2)?(\?v=[0-9]\.[0-9]\.[0-9])?$/u,
+        use  : "url-loader?limit=10000&minetype=application/font-woff",
+      },
+      {
+        test : /\.jpe?g$|\.gif$|\.png$/u,
+        use  : "url-loader",
+      },
+      {
+        test : /\.(ttf|eot|svg)(\?v=[0-9]\.[0-9]\.[0-9])?$/u,
+        use  : "file-loader",
+      }
+    ]
+  },
+  resolve: {
+    extensions: [
+      ".js",
+      ".jsx",
+    ],
+    modules: [
+      "client",
+      "node_modules",
+    ],
+  },
+  output: {
+    library: 'ReactPaginator',
+    libraryTarget: 'umd'
+  },
+  plugins: [
+    new webpack.DefinePlugin({
+      "process.env": {
+        "NODE_ENV": JSON.stringify("development"),
+      },
+    }),
+    new webpack.DefinePlugin({
+      "process.env": {
+        "BABEL_ENV": JSON.stringify("developmentTime"),
+      },
+    })
+  ]
+}
+
+if (env === 'production') {
+  config.plugins.push(
+    new webpack.DefinePlugin({
+      "process.env": {
+        "NODE_ENV": JSON.stringify("production"),
+      },
+    }),
+    new webpack.DefinePlugin({
+      "process.env": {
+        "BABEL_ENV": JSON.stringify("production"),
+      },
+    }),
+    new webpack.ContextReplacementPlugin(/moment[\/\\]locale$/, /ro/),
+    new webpack.optimize.UglifyJsPlugin({
+      mangle: false,
+    }),
+  )
+}
+
+module.exports = config

package/x25.wiki/Account.md

@@ -0,0 +1,41 @@
+Contains all information about the current account.
+
+The module `x25/Account` has: 
+- `<LoadAccount appName="auto" />`
+- `accountSelectors` 
+- `accountReducer`
+
+# LoadAccount
+
+It loads the account. The `appName` is the application for which is done the init-session
+
+Example:
+```jsx
+
+import { LoadAccount } from "x25/Account";
+
+<LoadAccount appName="auto">
+ <div />
+</LoadAccount>
+```
+
+It does not display `<div />` until the account is loaded
+
+
+# accountSelectors
+
+
+```jsx
+export const selectors = {
+  getCurrentAccount,
+  getCurrentAccountIsFetching,
+  getCurrentAccountShouldFetch,
+  getCurrentAccountIsFetched,
+  getCurrentAccountHasError,
+
+  getIsCurrentAccountAdministrator,
+
+  getCurrentAccountCompanies,
+};
+
+```

package/x25.wiki/Company.md

@@ -0,0 +1,39 @@
+Contains all information about the current company.
+
+The module `x25/Company` has: 
+- `<LoadCompany />`
+- `companySelectors` 
+- `companyReducer`
+
+# LoadCompany
+
+It loads the company
+
+Example:
+```jsx
+
+import { LoadCompany } from "x25/Company";
+
+<LoadCompany>
+ <div />
+</LoadCompany>
+```
+
+It does not display `<div />` until the company is loaded
+
+
+# companySelectors
+
+
+```jsx
+export const selectors = {
+  getCurrentCompany,
+  getCurrentCompanyIsFetched,
+  getCurrentCompanyIsFetching,
+  getCurrentCompanyHasError,
+  getCurrentCompanyShouldFetch,
+  getCompanyModules,
+  getCurrentCompanyID,
+};
+
+```

package/x25.wiki/Header.md

@@ -0,0 +1,21 @@
+The module `x25/Header` exports: 
+- `<SideworkLogo />`
+- `<Header ...props />`
+
+## `<Header ...props />`
+
+```jsx
+type HeaderPropTypes = {
+  brand : string;
+  accountName : string;
+  isAdmin: bool;
+  sidebarDocked: boolean;
+  ui: {
+    showNavbar: boolean;
+  };
+
+  toggleNavbar: () => void;
+
+  showSidebar: () => void;
+};
+```

package/x25.wiki/Home.md

@@ -0,0 +1 @@
+Welcome to the x25 wiki!

package/x25.wiki/Inputs.md

@@ -0,0 +1,33 @@
+The module `x25/Inputs` exports: 
+
+```jsx 
+export {
+  SimpleInput,
+  DelayInputChange,
+  FocusTemplate,
+  InputTemplate,
+  DateTemplate,
+  DateInput,
+  NumericInput,
+  NumericTemplate,
+  TextareaTemplate,
+  SimpleTextarea,
+  CaptchaBox,
+  LabelTemplate,
+  Tooltip,
+
+  // business
+  EmailInput,
+  PhoneInput,
+  BankAccountInput,
+  BankNameField,
+  CifFieldContainer,
+
+  // selects
+  SelectMonth,
+  SelectYear,
+  SelectCounty,
+  CustomSelect,
+  SimpleCustomSelect,
+};
+```

package/x25.wiki/Messages.md

@@ -0,0 +1,27 @@
+
+The module `x25/Messages` has: 
+- `<LoadingMessage ...props />`
+- `<ErrorMessage ...props />` 
+- `<LargeErrorMessage ...props />`
+
+## `<LoadingMessage ...props />`
+
+```jsx
+type LoadingMessagePropTypes = {
+  className? : string;
+  message? : string;
+  sm?: bool;
+};
+```
+
+## `<LargeErrorMessage ...props />`, `<ErrorMessage ...props />`
+
+```jsx
+type ErrorMessageProps = {
+  message: string;
+  details?: string;
+  itemNotFound?: boolean;
+
+  onRetry?: () => void;
+};
+```