Farmbot-Web-App/webpack/resources/reducer.ts

import { merge } from "lodash";
import { generateReducer } from "../redux/generate_reducer";
import { RestResources, ResourceIndex } from "./interfaces";
import {
  TaggedResource,
  ResourceName,
  sanityCheck,
  isTaggedResource,
  SpecialStatus
} from "./tagged_resources";
import { generateUuid, arrayWrap } from "./util";
import { EditResourceParams } from "../api/interfaces";
import {
  initialState as sequenceState,
  sequenceReducer as sequences,
} from "../sequences/reducer";
import {
  initialState as regimenState,
  regimensReducer as regimens
} from "../regimens/reducer";
import { combineReducers } from "redux";
import { ReduxAction } from "../redux/interfaces";
import {
  designer as farm_designer,
  initialState as designerState
} from "../farm_designer/reducer";
import { ResourceReadyPayl } from "../sync/actions";
import { OFCropResponse } from "../open_farm/index";
import {
  famrwareReducer as farmware,
  farmwareState
} from "../farmware/reducer";
import { Actions } from "../constants";
import { maybeTagSteps as dontTouchThis } from "./sequence_tagging";

const consumerReducer = combineReducers<RestResources["consumers"]>({
  regimens,
  sequences,
  farm_designer,
  farmware
} as any); // tslint:disable-line

export function emptyState(): RestResources {
  return {
    consumers: {
      sequences: sequenceState,
      regimens: regimenState,
      farm_designer: designerState,
      farmware: farmwareState
    },
    loaded: [],
    index: {
      all: [],
      byKind: {
        webcam_feed: [],
        device: [],
        farm_events: [],
        images: [],
        logs: [],
        peripherals: [],
        crops: [],
        points: [],
        regimens: [],
        sequences: [],
        tools: [],
        users: []
      },
      byKindAndId: {},
      references: {}
    }
  };
}

const initialState: RestResources = emptyState();

const afterEach = (state: RestResources, a: ReduxAction<object>) => {
  state.consumers = consumerReducer({
    sequences: state.consumers.sequences,
    regimens: state.consumers.regimens,
    farm_designer: state.consumers.farm_designer,
    farmware: state.consumers.farmware
  }, a);
  return state;
};

/** Responsible for all RESTful resources. */
export let resourceReducer = generateReducer
  <RestResources>(initialState, afterEach)
  .add<ResourceReadyPayl>(Actions.SAVE_SPECIAL_RESOURCE, (s, { payload }) => {
    const data = arrayWrap(payload);
    const kind = payload.name;
    data.map((body: ResourceReadyPayl) => {
      const crop = body.data as OFCropResponse;
      if (crop.data) {
        const cropInfo = crop.data.attributes;
        addToIndex(s.index, kind, cropInfo, generateUuid(undefined, kind));
      }
    });
    return s;
  })
  .add<TaggedResource>(Actions.SAVE_RESOURCE_OK, (s, { payload }) => {
    const resource = payload;
    resource.specialStatus = undefined;
    if (resource
      && resource.body) {
      switch (resource.kind) {
        case "crops":
        case "device":
        case "farm_events":
        case "logs":
        case "peripherals":
        case "points":
        case "regimens":
        case "sequences":
        case "tools":
        case "users":
        case "webcam_feed":
          reindexResource(s.index, resource);
          dontTouchThis(resource);
          s.index.references[resource.uuid] = resource;
          break;
        default:
          whoops(Actions.SAVE_RESOURCE_OK, payload.kind);
      }
    } else {
      throw new Error("Somehow, a resource was created without an ID?");
    }
    return s;
  })
  .add<TaggedResource>(Actions.DESTROY_RESOURCE_OK, (s, { payload }) => {
    const resource = payload;
    switch (resource.kind) {
      case "crops":
      case "device":
      case "farm_events":
      case "logs":
      case "peripherals":
      case "points":
      case "regimens":
      case "sequences":
      case "tools":
      case "users":
      case "webcam_feed":
      case "images":
        removeFromIndex(s.index, resource);
        break;
      default:
        whoops(Actions.DESTROY_RESOURCE_OK, payload.kind);
    }
    return s;
  })
  .add<TaggedResource>(Actions.UPDATE_RESOURCE_OK, (s, { payload }) => {
    const uuid = payload.uuid;
    s.index.references[uuid] = payload;
    const tr = s.index.references[uuid];
    if (tr) {
      tr.specialStatus = undefined;
      sanityCheck(tr);
      dontTouchThis(tr);
      reindexResource(s.index, tr);
      return s;
    } else {
      throw new Error("BAD UUID IN UPDATE_RESOURCE_OK");
    }
  })
  .add<TaggedResource>(Actions._RESOURCE_NO, (s, { payload }) => {
    const uuid = payload.uuid;
    const tr = merge(findByUuid(s.index, uuid), payload);
    tr.specialStatus = undefined;
    sanityCheck(tr);
    return s;
  })
  .add<EditResourceParams>(Actions.EDIT_RESOURCE, (s, { payload }) => {
    const uuid = payload.uuid;
    const { update } = payload;
    const source = merge<TaggedResource>(findByUuid(s.index, uuid),
      { body: update },
      { specialStatus: SpecialStatus.DIRTY });
    sanityCheck(source);
    payload && isTaggedResource(source);
    dontTouchThis(source);
    return s;
  })
  .add<EditResourceParams>(Actions.OVERWRITE_RESOURCE, (s, { payload }) => {
    const uuid = payload.uuid;
    const original = findByUuid(s.index, uuid);
    original.body = payload.update as typeof original.body;
    original.specialStatus = SpecialStatus.DIRTY;
    sanityCheck(original);
    payload && isTaggedResource(original);
    dontTouchThis(original);
    return s;
  })
  .add<TaggedResource>(Actions.INIT_RESOURCE, (s, { payload }) => {
    const tr = payload;
    const uuid = tr.uuid;
    reindexResource(s.index, tr);
    if (tr.kind === "logs") {
      // Since logs don't come from the API all the time, they are the only
      // resource (right now) that can have an id of `undefined` and not dirty.
      findByUuid(s.index, uuid).specialStatus = undefined;
    } else {
      findByUuid(s.index, uuid).specialStatus = SpecialStatus.DIRTY;
    }
    sanityCheck(tr);
    dontTouchThis(tr);
    return s;
  })
  .add<TaggedResource>(Actions.SAVE_RESOURCE_START, (s, { payload }) => {
    const resource = findByUuid(s.index, payload.uuid);
    resource.specialStatus = SpecialStatus.SAVING;
    if (!resource.body.id) { delete resource.body.id; }
    return s;
  })
  .add<ResourceReadyPayl>(Actions.RESOURCE_READY, (s, { payload }) => {
    const { name } = payload;
    /** Problem:  Most API resources are plural (array wrapped) resource.
     *            A small subset are singular (`device` and a few others),
     *            making `.map()` and friends unsafe.
     *  Solution: wrap everything in an array on the way in. */
    const unwrapped = payload.data;
    const data = arrayWrap(unwrapped);
    const { index } = s;
    s.loaded.push(name);
    index.byKind[name].map(x => {
      const resource = index.references[x];
      if (resource) {
        removeFromIndex(index, resource);
        dontTouchThis(resource);
      }
    });
    addAllToIndex(index, name, data);
    return s;
  });

interface HasID {
  id?: number | undefined;
}

function addAllToIndex<T extends HasID>(i: ResourceIndex,
  kind: ResourceName,
  all: T[]) {
  all.map(function (tr) {
    return addToIndex(i, kind, tr, generateUuid(tr.id, kind));
  });
}

function addToIndex<T>(index: ResourceIndex,
  kind: ResourceName,
  body: T,
  uuid: string) {
  const tr: TaggedResource =
    { kind, body, uuid, status: undefined } as any;
  sanityCheck(tr);
  index.all.push(tr.uuid);
  index.byKind[tr.kind].push(tr.uuid);
  if (tr.body.id) { index.byKindAndId[tr.kind + "." + tr.body.id] = tr.uuid; }
  dontTouchThis(tr);
  index.references[tr.uuid] = tr;
}

export function joinKindAndId(kind: ResourceName, id: number | undefined) {
  return `${kind}.${id || 0}`;
}

const filterOutUuid = (tr: TaggedResource) => (uuid: string) => uuid !== tr.uuid;
function removeFromIndex(index: ResourceIndex, tr: TaggedResource) {
  const { kind } = tr;
  const id = tr.body.id;
  index.all = index.all.filter(filterOutUuid(tr));
  index.byKind[tr.kind] = index.byKind[tr.kind].filter(filterOutUuid(tr));
  delete index.byKindAndId[joinKindAndId(kind, id)];
  delete index.byKindAndId[joinKindAndId(kind, 0)];
  delete index.references[tr.uuid];
}

function whoops(origin: string, kind: string) {
  const msg = `${origin}/${kind}: No handler written for this one yet.`;
  throw new Error(msg);
}

export function findByUuid(index: ResourceIndex, uuid: string): TaggedResource {
  const x = index.references[uuid];
  if (x && isTaggedResource(x)) {
    return x;
  } else {
    throw new Error("BAD UUID- CANT FIND RESOURCE: " + uuid);
  }
}

function reindexResource(i: ResourceIndex, r: TaggedResource) {
  removeFromIndex(i, r);
  addToIndex(i, r.kind, r.body, r.uuid);
}