export const hiddenComponentDecorator = ({
modelName,
fields,
}: {
modelName: string;
fields: Fields;
}): { modelName; fields: Fields & WithHidden } => {
const TAG = '[hiddenComponentDecorator]';
logger.log(TAG, { fields });
let wrappedFields = R.omit([castModelKey('createdAt'), castModelKey('updatedAt')])(fields);
if (R.has('id', wrappedFields)) {
const hidden = R.isNil(wrappedFields.id.value);
wrappedFields = R.mergeDeepRight(wrappedFields, { id: { options: { hidden } } });
}
const positions = R.filter(R.pathEq(['options', 'type'], 'SortPosition'))(wrappedFields);
if (!R.isEmpty(positions)) {
const hiddenPositions = R.map(position => ({
...position,
options: { hidden: true },
}))(positions);
wrappedFields = R.mergeDeepRight(wrappedFields, { ...hiddenPositions });
}
logger.log(TAG, 'wrappedFields', { wrappedFields }, diff(fields, wrappedFields));
return { modelName, fields: wrappedFields };
};
export function findChildImages(parentName: string, imagesConfigMap: ImagesConfigMap): string[] {
const confPairs = toPairs(imagesConfigMap) as [string, ImageConfig][];
return pipe(
filter<[string, ImageConfig]>(pathEq(['1', 'baseimage'], parentName)),
map((arr: [string, ImageConfig]) => arr[0])
)(confPairs);
}
export const match = (modifier: string, props: MatchProps = {}) => {
if (modifier === SELF_MODIFIER_NAME) {
return true
}
const modifierPath = toPath(modifier)
const linearMatch = target => {
const value = path(modifierPath, target)
if (is(Boolean, value)) {
return value
}
if (isNil(value)) {
return false
}
return !isEmpty(value)
}
const matcher =
modifierPath.length > 1
? pathEq(init(modifierPath), last(modifierPath))
: linearMatch
return matcher(props)
}
[getType(bookmarkCreators.removeBookmarkTree)]: (
state: BookmarkState,
{payload}: ReturnType<typeof bookmarkCreators.removeBookmarkTree>
) => {
const removeFromIndex = state.trees.findIndex(R.pathEq(['parent', 'id'], payload.id))
if (removeFromIndex < 0) return state
return {
...state,
trees: state.trees.slice(0, removeFromIndex)
}
},
export const jsonDecorator = ({
modelName,
fields,
}: {
modelName: string;
fields: (Fields & WithHidden) | PositionsField;
}): { modelName; fields: (Fields & WithHidden) | PositionsField } => {
const TAG = '[jsonDecorator]';
logger.log(TAG, { fields });
const jsonFields = R.filter(R.pathEq(['options', 'json'], 'str'))(fields);
if (R.not(R.isEmpty(jsonFields))) {
logger.debug(TAG, { jsonFields });
const toJson = value => {
if (R.is(String, value) && value.length) {
try {
return JSON.parse(value);
} catch (e) {
logger.warn(TAG, e, { jsonFields });
return null;
}
}
if (R.is(Object, value)) {
return value;
}
return null;
};
const transformValue = R.over(R.lens(R.prop('value'), R.assoc('value')), toJson);
const transformedFields = R.map(transformValue)(jsonFields);
const wrappedFields = R.mergeDeepRight(fields, transformedFields);
logger.log(TAG, 'wrappedFields', { wrappedFields });
return { modelName, fields: wrappedFields };
}
return { modelName, fields };
};
export function isErrorResponse(error) {
const isError = R.pathEq(['response', 'data', 'name'], 'Error')(error);
const isAsuna = /^ASUNA__.+/.test(R.path(['response', 'data', 'code'])(error));
return isError || isAsuna;
}
export const enumDecorator = ({
modelName,
fields,
}: {
modelName: string;
fields: (Fields & WithHidden) | PositionsField | EnumField;
}): { modelName; fields: (Fields & WithHidden) | PositionsField | EnumField } => {
const TAG = '[enumDecorator]';
logger.log(TAG, { fields });
const enumFilterFields = R.filter(R.propEq('type', DynamicFormTypes.EnumFilter))(fields);
if (R.not(R.isEmpty(enumFilterFields))) {
const [, enumFilterField] = R.toPairs(enumFilterFields)[0];
logger.debug(TAG, { enumFilterField });
const enums = _.map(
_.keys(idx(enumFilterField as EnumField, _ => _.options.enumData)),
castModelName,
);
const current = castModelName(R.pathOr('', ['value'])(enumFilterField));
logger.debug(TAG, { enums, current });
// check if positions has value already
// save positions value if no value exists, update models' sequence for else
const positionsFieldPair = R.compose(
R.toPairs,
R.map(field => {
// raw is the original value, if exists, means it's update request
if (field.value && !field.raw) {
const value = R.is(String, field.value) ? JSON.parse(field.value) : field.value;
return { ...field, value, raw: field.value };
}
return { ...field, value: R.path([current, 'value'])(fields), raw: field.value };
}),
R.filter(R.pathEq(['options', 'type'], 'SortPosition')),
)(fields);
const filteredNames = R.without(current)(enums);
const filteredFields = R.omit(filteredNames)(fields);
const wrappedFields = current
? R.mergeDeepRight(filteredFields, {
[current]: {
isFilterField: true,
options: { filterType: R.path(['options', 'filterType'])(enumFilterField) },
value: R.isEmpty(positionsFieldPair)
? R.path([current, 'value'])(filteredFields)
: R.path([0, 1, 'value'])(positionsFieldPair),
},
...R.fromPairs(positionsFieldPair),
})
: filteredFields;
logger.debug(TAG, 'wrappedFields', {
current,
filteredNames,
filteredFields,
wrappedFields,
positionsFieldPair,
});
return { modelName, fields: wrappedFields };
}
return { modelName, fields };
};
const isAdmin = (ctx): boolean => pathEq(['state', 'user', 'userData'], true, ctx);
import * as R from 'ramda'
import {SagaIterator} from 'redux-saga'
import {all, call, put, select} from 'redux-saga/effects'
import {ActionType} from 'typesafe-actions'
import {BookmarkTree} from '../../../../types'
import {RootState} from '../../../rootReducer'
import * as bookmarkCreators from '../../actions'
import {getBookmarkTree} from '../utils/getters'
export const bookmarkTreesSelector = (state: RootState) => state.bookmark.trees
const treeIdEquals = R.pathEq(['parent', 'id'])
export function* openBookmarkTree({
payload
}: ActionType<typeof bookmarkCreators.openBookmarkTree>): SagaIterator {
try {
const [trees, bookmarkTree]: [Array<BookmarkTree>, BookmarkTree] = yield all([
select(bookmarkTreesSelector),
call(getBookmarkTree, payload.id)
])
// if tree is already in view, no need to re-render
if (trees.some(treeIdEquals(payload.id))) return
const parentIndex = trees.findIndex(treeIdEquals(payload.parentId))
// if parent doesn't exist, do not show this tree in the view
if (parentIndex < 0) return
yield put(bookmarkCreators.setBookmarkTrees([...trees.slice(0, parentIndex + 1), bookmarkTree]))
} catch (err) {