x25 2.9.2 → 3.0.0

package/src/Account/request.js

@@ -0,0 +1,36 @@
+// @flow
+
+import agent from "superagent";
+import * as Immutable from "immutable";
+
+import { noError, normalizeArrayByField, withPromiseCallback, normalizeArray } from "../utility";
+
+const normalizeInitialInformation = (info : any) => {
+
+  const
+    { Account, IsConnected, Counties, Companies } = info;
+
+  return {
+    Account  : Immutable.Map(Account || {}),
+    IsConnected,
+    Error    : IsConnected ? noError : "Not connected",
+    Counties : (typeof Counties === "undefined") ? [] : (
+      normalizeArrayByField(Counties,
+        "Short").entities
+    ),
+    Companies: (typeof Companies === "undefined") ? [] : (
+      normalizeArray(Companies).entities
+    ),
+  };
+};
+
+export const fetchInitialInformation = (app : string) => (
+  new Promise((resolve, reject) => (
+    agent.
+      get("/api/extern/get-initial-information").
+      type("form").
+      query({ app }).
+      end(withPromiseCallback((reponse) => resolve(normalizeInitialInformation(reponse)),
+        reject))
+  )) : Promise<any>
+);

package/src/Async/InitModule.jsx

@@ -0,0 +1,114 @@
+// @flow
+
+import type { RouteType, PaginatorType } from "./types";
+
+import type { Dispatch, State } from "src\\types";
+
+type Props = {
+  +ready: bool;
+  +props: any;
+  +route: RouteType;
+  +initModule: () => void;
+};
+
+type OwnProps = {
+  route: RouteType,
+  props: any;
+}
+
+import * as React from "react";
+
+import { LoadingMessage } from "../Messages/Loading";
+import { injectModals } from "../Modal/util";
+import { injectReducer } from "redux-injector";
+import { delay } from "../utility";
+
+const injectPaginator = ({ key, itemsReducer, pagesReducer } : PaginatorType) => {
+  injectReducer(`entities.${key}`, itemsReducer);
+  injectReducer(`paginations.${key}`, pagesReducer);
+};
+
+import { connect } from "react-redux";
+
+import { getIsModuleReady, moduleIsReadyAction } from "../reducer/module";
+
+const
+  mapStateToProps = (state : State, { route : { default : { module } } } : OwnProps) => ({
+    ready: getIsModuleReady(state, module),
+  }),
+  mapDispatchToProps = (dispatch : Dispatch, { route } : OwnProps) => ({
+    initModule () {
+      const { reducers, modals, paginators, module } = route.default;
+
+      delay().
+        then(() => {
+          if (reducers) {
+            if (Array.isArray(reducers)) {
+              for (const { key, func } of reducers) {
+                injectReducer(key, func);
+              }
+            } else {
+              const { key, func } = reducers;
+
+              injectReducer(key, func);
+            }
+          }
+        }).
+        then(() => {
+          if (modals) {
+            injectModals(modals);
+          }
+        }).
+        then(() => {
+          if (paginators) {
+            if (Array.isArray(paginators)) {
+              for (const paginator of paginators) {
+                injectPaginator(paginator);
+              }
+            } else {
+              injectPaginator(paginators);
+            }
+          }
+        }).
+        then(() => {
+          dispatch(moduleIsReadyAction(module));
+        });
+    },
+  });
+
+class InitModule extends React.Component<Props> {
+  componentDidMount () {
+    if (!this.props.ready) {
+      this.props.initModule();
+    }
+  }
+
+  shouldComponentUpdate () {
+    return (
+      true
+    );
+  }
+
+  render () {
+    const { route, ready, props } = this.props;
+    const { Component } = route.default;
+
+    if (ready) {
+      return <Component {...props} />;
+    }
+
+    return (
+      <div className="mt-3">
+        <LoadingMessage message="Așteaptă un pic..." />
+      </div>
+    );
+  }
+}
+
+const WrapInitModule = connect(mapStateToProps, mapDispatchToProps)(InitModule);
+
+const createWrap = (route : RouteType, props: any) => (
+  <WrapInitModule props={props} route={route} />
+);
+
+export default createWrap;

package/src/Async/RouteLoading.jsx

@@ -0,0 +1,52 @@
+// @flow
+
+type LoadingPropTypes = {
+  +error?: any;
+  +timedOut: bool;
+  +pastDelay: bool;
+  +retry: () => void;
+}
+
+type FireErrorPropTypes = {
+  error: any;
+}
+
+import React from "react";
+
+import { LoadingMessage } from "../Messages/Loading";
+import SimulatedException from "./SimulatedException";
+
+import { ErrorBoundary } from "./index";
+
+const IgnoreThisNode = ({ error : { message, stack } } : FireErrorPropTypes) => {
+  throw new SimulatedException(message, stack);
+};
+
+const RouteLoading = ({ error, retry, timedOut } : LoadingPropTypes) => {
+  if (error) {
+    return (
+      <ErrorBoundary>
+        <IgnoreThisNode error={error} />
+      </ErrorBoundary>
+    );
+  }
+
+  if (timedOut) {
+    return (
+      <div>{"Se pare că se încarcă mai greu ca de obicei "}
+        <button
+          className="btn btn-primary btn-block"
+          onClick={retry} type="button">{"Încearcă din nou"}
+        </button>
+      </div>
+    );
+  }
+
+  return (
+    <div className="mt-3">
+      <LoadingMessage message="Așteaptă un pic..." />
+    </div>
+  );
+};
+
+export default RouteLoading;

package/src/Async/SimulatedException.jsx

@@ -0,0 +1,19 @@
+// @flow
+/* eslint-disable max-classes-per-file */
+
+class CustomError<Message: string, Stack: string> extends Error {
+
+  constructor (message: Message, stack: Stack) {
+    super(message);
+    this.message = message;
+    this.name = message;
+    this.stack = stack;
+  }
+}
+
+type Message = string;
+type Stack = string;
+
+class SimulatedException extends CustomError<Message, Stack> {}
+
+export default SimulatedException;

package/src/Async/index.jsx

@@ -0,0 +1,75 @@
+// @flow
+/* eslint-disable new-cap, react/prefer-stateless-function, react/require-optimization */
+
+
+type LoaderType = (path : string) => void;
+
+import Loadable from "react-loadable";
+import * as React from "react";
+
+import RouteLoading from "./RouteLoading";
+import InitModule from "./InitModule";
+
+// type injectPaginatorTypes = {
+//   key: string,
+//   itemsReducer: any;
+//   pagesReducer: any;
+// };
+// import { injectReducer } from "redux-injector";
+// import { injectModals } from "../Modal/util";
+
+const
+  timeout = 15000;
+
+export let
+  ErrorBoundary = () => (
+    <div>{"No ErrorBoundary passed to x25"}</div>
+  );
+
+// const injectPaginator = ({ key, itemsReducer, pagesReducer } : injectPaginatorTypes) => {
+//   injectReducer(`entities.${key}`, itemsReducer);
+//   injectReducer(`paginations.${key}`, pagesReducer);
+// };
+
+// const renderWithReducer = (route, props) => {
+//   const { Component, reducers, modals, paginators } = route.default;
+//
+//   if (reducers) {
+//     if (Array.isArray(reducers)) {
+//       for (const { key, func } of reducers) {
+//         injectReducer(key, func);
+//       }
+//     } else {
+//       const { key, func } = reducers;
+//
+//       injectReducer(key, func);
+//     }
+//   }
+//
+//   if (modals) {
+//     injectModals(modals);
+//   }
+//
+//   if (paginators) {
+//     if (Array.isArray(paginators)) {
+//       for (const paginator of paginators) {
+//         injectPaginator(paginator);
+//       }
+//     } else {
+//       injectPaginator(paginators);
+//     }
+//   }
+//
+//   return <Component {...props} />;
+// };
+
+export const setErrorBoundary = (theError : React.Node) => {
+  ErrorBoundary = theError;
+};
+
+export const createAsyncRoute = (loader : LoaderType) => Loadable({
+  loader,
+  loading : RouteLoading,
+  render  : InitModule,
+  timeout,
+});

package/src/Async/types.js

@@ -0,0 +1,39 @@
+// @flow
+
+// import * as React from "react";
+
+import type { State } from "src\\types";
+import type { ModalsTypes } from "../Modal/types";
+
+type Reducer = (state : State, action : any) => void;
+
+type ReducerOptionsType = {
+  key: string,
+  func: Reducer,
+};
+
+type PaginatorType = {
+  key: string,
+  itemsReducer: Reducer;
+  pagesReducer: Reducer;
+};
+
+type ReducersTypes = Array<ReducerOptionsType> | ReducerOptionsType;
+type PaginatorsTypes = Array<PaginatorType> | PaginatorType;
+
+type RouteType = {
+  default: {
+    module: string,
+    Component: any,
+    reducers: ReducersTypes,
+    modals: ModalsTypes,
+    paginators: PaginatorsTypes,
+  },
+}
+
+export type {
+  ReducersTypes,
+  PaginatorsTypes,
+  PaginatorType,
+  RouteType,
+};

package/src/Company/Load.jsx

@@ -0,0 +1,84 @@
+// @flow
+/* eslint-disable react/require-optimization */
+
+import type { Dispatch, State } from "src\\types";
+
+type PropTypes = {
+  +isAdministrator: bool;
+  +isFetching: bool;
+  +hasError: bool;
+
+  +data: any;
+  +shouldFetch: any;
+  +children: any;
+
+  +fetchCurrentCompany: () => void;
+}
+
+import React from "react";
+
+import { withRouter } from "react-router-dom";
+// import moment from "moment";
+import { connect } from "react-redux";
+
+import { selectors } from "./reducer";
+import { accountSelectors } from "../Account";
+
+import { fetchCurrentCompany as fetchCurrentCompanyAction } from "./actions";
+
+import { LargeErrorMessage, LoadingMessage } from "../Messages";
+
+// import EstimatePrice from "../Payment/EstimatePrice";
+
+const
+  mapStateToProps = (state : State) => ({
+    isAdministrator : accountSelectors.getIsCurrentAccountAdministrator(state),
+    data            : selectors.getCurrentCompany(state),
+    hasError        : selectors.getCurrentCompanyHasError(state),
+    fetched         : selectors.getCurrentCompanyIsFetched(state),
+    isFetching      : selectors.getCurrentCompanyIsFetching(state),
+    shouldFetch     : selectors.getCurrentCompanyShouldFetch(state),
+  }),
+  mapDispatchToProps = (dispatch : Dispatch, { match : { params : { company } } }) => ({
+    fetchCurrentCompany () {
+      dispatch(fetchCurrentCompanyAction(company));
+    },
+  });
+
+
+const LoadCompany = (props : PropTypes) => {
+  const { children, data, isFetching, shouldFetch, hasError, fetchCurrentCompany } = props;
+
+  React.useEffect(() => {
+    if (shouldFetch) {
+      fetchCurrentCompany();
+    }
+  }, [
+    shouldFetch,
+    isFetching,
+    hasError,
+  ]);
+
+  if (isFetching) {
+    return (
+      <LoadingMessage message="Așteaptă..." />
+    );
+  }
+
+  if (hasError) {
+    return (
+      <LargeErrorMessage
+        message="Nu am putut stabili conexiunea cu server-ul"
+        onRetry={fetchCurrentCompany}
+      />
+    );
+  }
+
+  if (data.size === 0) {
+    return null;
+  }
+
+  return children;
+};
+
+export default withRouter(connect(mapStateToProps, mapDispatchToProps)(LoadCompany));

package/src/Company/actions.js

@@ -0,0 +1,10 @@
+// @flow
+
+import type { Action } from "src\\types";
+
+import { fetchCurrentCompany as fetchCurrentCompanyRequest } from "./request";
+
+export const fetchCurrentCompany = (rawID : string) : Action => ({
+  type    : "FETCH_CURRENT_COMPANY_INFO",
+  payload : fetchCurrentCompanyRequest(rawID),
+});

package/src/Company/index.js

@@ -0,0 +1,11 @@
+// @flow
+
+import companyReducer, { selectors as companySelectors } from "./reducer";
+
+import LoadCompany from "./Load";
+
+export {
+  companySelectors,
+  companyReducer,
+  LoadCompany,
+};

package/src/Company/reducer.js

@@ -0,0 +1,201 @@
+// @flow
+/* eslint-disable global-require */
+
+import * as Immutable from "immutable";
+
+import type { Action, State } from "src\\types";
+
+import { createSelector } from "reselect";
+
+import { noError } from "../utility";
+
+import { getIDFromURL } from "./util";
+
+const reducerKey = "companyInfo";
+
+type CurrentState = any;
+
+const initialState : CurrentState = Immutable.Map({
+  error    : noError,
+  fetched  : false,
+  fetching : false,
+
+  company: Immutable.Map(),
+});
+
+const
+  fetchCompanyPending = () => (
+    initialState.set("fetching",
+      true)
+  ),
+  fetchCompanyRejected = (state : any, { payload : { error } }) => (
+    state.merge({
+      error,
+      fetching: false,
+    })
+  ),
+  fetchCompanyFulfilled = (state : any, { payload }) => (
+    state.mergeDeep({
+      fetched  : true,
+      fetching : false,
+      company  : payload,
+    })
+  ),
+  modifyCompany = (state : any, { payload }) => (
+    state.set("company",
+      payload)
+  ),
+  clearInfoIfCurrentCompany = (state : any, { payload }) => {
+    const
+      companyID = String(state.getIn([
+        "company",
+        "ID",
+      ])),
+      fetched = state.get("fetched"),
+      dataID = String(payload.get("ID")),
+      theCurrentCompanyHasChanged = fetched && (dataID === companyID);
+
+    if (theCurrentCompanyHasChanged) {
+      return state.clear();
+    }
+
+    return state;
+  };
+
+const reducer = (state : any = initialState, action : Action) => {
+  switch (action.type) {
+    case "FETCH_CURRENT_COMPANY_INFO_PENDING":
+      return fetchCompanyPending();
+
+    case "FETCH_CURRENT_COMPANY_INFO_REJECTED":
+      return fetchCompanyRejected(state,
+        action);
+
+    case "FETCH_CURRENT_COMPANY_INFO_FULFILLED":
+      return fetchCompanyFulfilled(state,
+        action);
+
+    case "MODIFY_CURRENT_COMPANY_INFO":
+      return modifyCompany(state,
+        action);
+
+    case "TOGGLE_COMPANY_STATE":
+    case "DELETE_COMPANY":
+      return clearInfoIfCurrentCompany(state,
+        action);
+
+    default:
+      return state;
+  }
+};
+
+const
+  getFetching = (state : State) => state.getIn([
+    reducerKey,
+    "fetching",
+  ]) || false,
+  getFetched = (state : State) => state.getIn([
+    reducerKey,
+    "fetched",
+  ]) || false,
+  getError = (state : State) => state.getIn([
+    reducerKey,
+    "error",
+  ]) || noError,
+  getCurrentAccountFetched = (state : State) => state.getIn([
+    "account",
+    "fetched",
+  ]) || false;
+
+const checkForNoErrors = (error) => error !== noError;
+
+const
+  getCurrentCompany = (state : State) : any => (
+    state.getIn([
+      reducerKey,
+      "company",
+    ]) || Immutable.Map()
+  ),
+  getCurrentCompanyIsFetched = createSelector(
+    getFetching,
+    getFetched,
+    getError,
+    (isFetching, isFetched, error) => (
+      !isFetching && isFetched && error === noError
+    ),
+  ),
+  getCurrentCompanyIsFetching = createSelector(
+    getFetching,
+    getError,
+    (isFetching, error) => (
+      isFetching && error === noError
+    ),
+  ),
+  getCurrentCompanyHasError = createSelector(
+    getError,
+    checkForNoErrors,
+  ),
+  getCurrentCompanyShouldFetch = createSelector(
+    getCurrentAccountFetched,
+    getCurrentCompanyIsFetched,
+    getCurrentCompanyHasError,
+    getFetching,
+    getCurrentCompany,
+    (accountFetched, isFetched, hasError, isFetching, company) => (rawID : string) => {
+      const
+        hasIDChanged = () => {
+          const
+            id = company.get("ID"),
+            newID = Number(rawID);
+
+          return (
+            id === 0 ||
+          id !== newID ||
+          (id === newID && !isFetched)
+          );
+        };
+
+      return (
+        accountFetched && !hasError && !isFetching && hasIDChanged()
+      );
+    },
+  ),
+  getCompanyModules = createSelector(
+    getCurrentCompany,
+    (company) => company.get("Modules") || "",
+  ),
+
+  /*
+    This function is special, because it is called also in the
+    requests
+    In case the state is not ready, we take the id of the current company
+    from the URL
+
+    The url must have this pathname:
+
+    something/:companyID/something...
+  */
+  getCurrentCompanyID = (state : any) => {
+    if (typeof state === "undefined" || state === null) {
+      return getIDFromURL();
+    }
+
+    return state.getIn([
+      reducerKey,
+      "company",
+      "ID",
+    ]);
+  };
+
+
+export const selectors = {
+  getCurrentCompany,
+  getCurrentCompanyIsFetched,
+  getCurrentCompanyIsFetching,
+  getCurrentCompanyHasError,
+  getCurrentCompanyShouldFetch,
+  getCompanyModules,
+  getCurrentCompanyID,
+};
+
+export default reducer;

package/src/Company/request.js

@@ -0,0 +1,30 @@
+// @flow
+
+import agent from "superagent";
+import * as Immutable from "immutable";
+
+import { withPromiseCallback } from "../utility";
+import { selectors } from "./reducer";
+
+export const fetchCurrentCompany = (id : string) => (
+  new Promise((resolve, reject) => (
+    agent.
+      get(`/api/company/${id}/get-information`).
+      set("Accept",
+        "application/json").
+      end(withPromiseCallback((data) => resolve(Immutable.Map(data)),
+        reject))
+  )) : Promise<any>
+);
+
+export const modifyCurrentCompany = (data : any) => (
+  new Promise((resolve, reject) => (
+    agent.
+      post(`/api/company/${selectors.getCurrentCompanyID()}/modify-info`).
+      set("Accept",
+        "application/json").
+      send(data).
+      end(withPromiseCallback(resolve,
+        reject))
+  )) : Promise<any>
+);

package/src/Company/util.js

@@ -0,0 +1,7 @@
+// @flow
+
+export const getIDFromURL = () => {
+  const parts = String(window.location.pathname).split("/");
+
+  return parts[2];
+};