import UUID from "node-uuid"
import Lens from "paqmind.data-lens"
import TcLens from "paqmind.tcomb-lens"
import {merge, unflattenObject} from "common/helpers/common"
import api from "common/api/robot"
import {Robot} from "common/types"
import {formatTyped} from "common/formatters"
import {validateData} from "common/validation"
import state from "frontend/state"
import ajax from "frontend/ajax"
import * as alertActions from "frontend/actions/alert"
import addItem from "frontend/actions/add-item/robot"
let dataCursor = state.select(api.plural)
let itemsCursor = dataCursor.select("items")
// ProductData -> Promise Product
function updateAddForm(key, data) {
console.debug(api.plural + `.updateAddForm(${key}, ...)`)
let form = dataCursor.get("addForm")
let newForm = dataCursor.set("addForm", Lens(key).set(form, data))
return Promise.resolve(newForm)
}
function updateEditForm(key, data) {
console.debug(api.plural + `.updateEditForm(${key}, ...)`)
let form = dataCursor.get("editForm")
let newForm = dataCursor.set("editForm", Lens(key).set(form, data))
return Promise.resolve(newForm)
import {filter, map} from "ramda";
import {ALERT} from "shared/constants";
import state from "frontend/state";
let alertQueueCursor = state.select("alertQueue");
let alertTimeoutCursor = state.select("alertTimeout");
function processAlertQueue() {
if (!alertTimeoutCursor.get()) {
let alertQueue = alertQueueCursor.get();
let expirableAlerts = filter(m => m.expire, alertQueue);
if (expirableAlerts.length) {
let alert = expirableAlerts[0];
let timeout = setTimeout(() => {
alertQueueCursor.unset(0);
alertTimeoutCursor.unset();
setImmediate(processAlertQueue);
}, alert.expire);
alertTimeoutCursor.set(timeout);
} else {
setTimeout(processAlertQueue, ALERT.throttleTimeoutMs);
}
}
}
export default {
processAlertQueue
};
import {equals, filter} from "ramda";
import {UX} from "shared/constants";
import api from "shared/api/uxEng";
import state from "frontend/state";
import loadIndex from "frontend/actions/load-index/uxEng";
let urlCursor = state.select("url");
let urlQueryCursor = state.select("urlQuery");
let dataCursor = state.select(api.plural);
export default function establishIndex() {
console.debug(api.plural + `.establishIndex()`);
let urlQuery = urlQueryCursor.get();
let urlFilters = urlQuery.filters;
let urlSorts = urlQuery.sorts;
let urlOffset = urlQuery.offset;
let urlLimit = urlQuery.limit;
let {filters, sorts} = dataCursor.get();
if (!equals(urlFilters || UX.index.filters, filters)) {
dataCursor.set("filters", urlFilters || UX.index.filters);
if (true || !dataCursor.get("fullLoad")) {
/* TODO replace true with __newFilters_are_not_subset_of_oldFilters__ */
// Pagination is messed up, do reset
dataCursor.merge({
total: 0,
pagination: [],
});
}
import React from "react";
import ReactRouter from "react-router";
import state from "frontend/state";
import {merge} from "shared/helpers/common";
import {formatQuery} from "shared/helpers/jsonapi";
import {Component} from "./component";
let urlCursor = state.select("url");
export default class ItemLink extends Component {
render() {
let {params, ...props} = this.props;
params = merge(urlCursor.get("params"), params || {});
return (
<ReactRouter.Link params={params} {...props}>
{this.props.children}
</ReactRouter.Link>
);
}
}
import api from "common/api/robot"
import state from "frontend/state"
import loadItem from "frontend/actions/load-item/robot"
let urlCursor = state.select("url")
let dataCursor = state.select(api.plural)
export default function establishItem() {
console.debug(api.plural + `.establishItem()`)
dataCursor.set("id", urlCursor.get("params").id)
return loadItem()
}
import {assoc, reduce} from "ramda";
import api from "shared/api/robot";
import {inCache, getTotalPages, recommendOffset} from "frontend/helpers/pagination";
import state from "frontend/state";
import {indexRouter} from "frontend/router";
import fetchIndex from "frontend/actions/fetch-index/robot";
let dataCursor = state.select(api.plural);
let itemsCursor = state.select("items");
export default function loadIndex() {
console.debug(api.plural + ".loadIndex()");
let {filters, sorts, offset, limit, total, pagination} = dataCursor.get();
if (total) {
let recommendedOffset = recommendOffset(total, offset, limit);
if (offset > recommendedOffset) {
indexRouter.transitionTo(undefined, {offset: recommendedOffset});
return Promise.resolve([]); // TODO ?!
} else {
if (inCache(offset, limit, total, pagination)) {
// return cached items
return Promise.resolve(reduce(
(memo, id) => assoc(memo, id, itemsCursor.get(id)),
{}, pagination.slice(offset, offset + limit)
));
} else {
return fetchIndex(filters, sorts, offset, limit);
}
}
import {assoc} from "ramda"
import UUID from "node-uuid"
import {ALERT} from "common/constants"
import {Alert} from "common/types"
import {parseAs} from "common/parsers"
import state from "frontend/state"
let alertQueueCursor = state.select("alertQueue")
// Object -> Promise Alert
export default function addItem(data) {
data = assoc("id", data.id || UUID.v4(), data)
if (data.closable === undefined) {
data.closable = data.category === "error" ? false : true
}
if (data.expire === undefined) {
data.expire = data.category == "error" ? 0 : ALERT.expire
}
let item = parseAs(Alert, data)
alertQueueCursor.push(item)
return Promise.resolve(item)
}