refactor app using babel module-resolver

1 files changed, 194 insertions, 0 deletions

diff --git a/animism-align/frontend/app/api/crud.reducer.js b/animism-align/frontend/app/api/crud.reducer.js
new file mode 100644
index 0000000..3ee4974
--- /dev/null
+++ b/animism-align/frontend/app/api/crud.reducer.js
@@ -0,0 +1,194 @@
+import * as types from 'app/types'
+import { getOrderedIds, getOrderedIdsFromLookup } from 'app/utils'
+import { session } from 'app/session'
+
+export const crudState = (type, options) => ({
+  index: {},
+  show: {},
+  create: {},
+  update: {},
+  destroy: {},
+  lookup: [],
+  ...options,
+})
+
+export const crudReducer = (type) => {
+  const crud_type = types[type]
+  return (state, action) => {
+    switch (action.type) {
+      // index
+      case crud_type.index_loading:
+        return {
+          ...state,
+          index: action.load_more
+          ? { ...state.index, loading: true }
+          : { loading: true },
+        }
+      case crud_type.index:
+        if (action.data.res.length) {
+          return {
+            ...state,
+            index: {
+              lookup: action.data.res.reduce((a, b) => { a[b.id] = b; return a }, action.load_more ? state.index.lookup : {}),
+              order: getOrderedIds(action.data.res, state.options.sort, action.load_more ? state.index.order : []),
+            },
+          }
+        } else {
+          Object.keys(action.data.res).forEach(key => {
+            const el = action.data.res[key]
+            el.key = key
+            el.id = el.id || key
+          })
+          return {
+            ...state,
+            index: {
+              lookup: action.data.res,
+              order: getOrderedIdsFromLookup(action.data.res, state.options.sort),
+            },
+          }
+        }
+      case crud_type.index_error:
+        return {
+          ...state,
+          index: { loading: false, error: true },
+        }
+      case crud_type.index_sort:
+        return {
+          ...state,
+          index: {
+            ...state.index,
+            order: action.data.res.map(b => b.id),
+          },
+        }
+
+      // show
+      case crud_type.show_loading:
+        return {
+          ...state,
+          show: { loading: true },
+        }
+      case crud_type.show:
+        if (!action.data) {
+          return {
+            ...state,
+            show: { not_found: true },
+          }
+        }
+        return {
+          ...state,
+          show: action.data,
+        }
+      case crud_type.show_error:
+        return {
+          ...state,
+          show: { loading: false, error: true },
+        }
+
+      //
+      // create
+      case crud_type.create_loading:
+        return {
+          ...state,
+          create: { loading: true },
+        }
+      case crud_type.create:
+        return {
+          ...state,
+          create: action.data,
+          index: addToIndex(state.index, action.data.res, state.options.sort),
+        }
+      case crud_type.create_error:
+        return {
+          ...state,
+          create: action.data,
+        }
+
+      //
+      // update
+      case crud_type.update_loading:
+        return {
+          ...state,
+          update: { loading: true },
+        }
+      case crud_type.update:
+        return {
+          ...state,
+          update: action.data,
+          index: addToIndex(state.index, action.data.res, state.options.sort),
+          show: (state.show.res && state.show.res.id === action.data.res.id) ? {
+            ...state.show.res,
+            ...action.data.res,
+          } : state.show
+        }
+      case crud_type.index_error:
+        return {
+          ...state,
+          update: { loading: false, error: true },
+        }
+
+      //
+      // destroy
+      case crud_type.destroy_loading:
+        return {
+          ...state,
+          destroy: { loading: true },
+        }
+      case crud_type.destroy:
+        return {
+          ...state,
+          index: {
+            ...(() => {
+              if (!state.index.lookup) {
+                return {}
+              }
+              delete state.index.lookup[action.data.id]
+              const _id = parseInt(action.data.id)
+              state.index.order = state.index.order.filter(id => id !== _id)
+              return { ...state.index }
+            })()
+          },
+          destroy: { loading: false },
+        }
+      case crud_type.destroy_error:
+        return {
+          ...state,
+          destroy: { error: true },
+        }
+
+      //
+      // options
+      case crud_type.update_option:
+        session.set(type + "." + action.key, action.value)
+        return {
+          ...state,
+          options: {
+            ...state.options,
+            [action.key]: action.value,
+          }
+        }
+
+      case crud_type.update_options:
+        session.setAll(
+          Object.keys(action.opt).reduce((a,b) => { a[type + '.' + b] = action.opt[b]; return a }, {})
+        )
+        return {
+          ...state,
+          options: {
+            ...action.opt,
+          }
+        }
+
+      default:
+        return state
+    }
+  }
+}
+
+const addToIndex = (index, data, sort) => {
+  const lookup = (index && index.lookup) ? {
+    ...index.lookup,
+  } : {}
+  lookup[data.id] = data
+  const order = getOrderedIdsFromLookup(lookup, sort)
+  return { lookup, order }
+}