@skbkontur/cassandra-distributed-task-queue-ui
Version:
.NET library implementing distributed task queue machinery using Apache Cassandra
300 lines • 10.8 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SetMapper = exports.StringMapper = exports.DateTimeRangeMapper = exports.StringArrayMapper = exports.IntegerMapper = exports.PlainValueMapper = void 0;
const tslib_1 = require("tslib");
const edi_ui_1 = require("@skbkontur/edi-ui");
const date_fns_1 = require("date-fns");
const difference_1 = tslib_1.__importDefault(require("lodash/difference"));
class PlainValueMapper {
constructor(queryStringParameterName) {
Object.defineProperty(this, "parameterName", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.parameterName = queryStringParameterName;
}
parseString(_parameterValue) {
throw new Error("Method should be implemented");
}
stringifyValue(_value) {
throw new Error("Method should be implemented");
}
parseEmpty() {
return null;
}
parse(parsedQueryString) {
const value = parsedQueryString[this.parameterName];
if (value === undefined) {
return this.parseEmpty();
}
if (typeof value !== "string") {
return null;
}
return this.parseString(value);
}
stringify(parsedQueryString, value) {
const result = this.stringifyValue(value);
if (result === undefined || result === null) {
return parsedQueryString;
}
return Object.assign(Object.assign({}, parsedQueryString), { [this.parameterName]: this.stringifyValue(value) });
}
}
exports.PlainValueMapper = PlainValueMapper;
class IntegerMapper extends PlainValueMapper {
constructor(queryStringParameterName, defaultValue) {
super(queryStringParameterName);
Object.defineProperty(this, "defaultValue", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
if (defaultValue !== undefined) {
this.defaultValue = defaultValue;
}
else {
this.defaultValue = null;
}
}
parseString(parameterValue) {
const result = parseInt(parameterValue, 10);
return isNaN(result) ? this.defaultValue : result;
}
parseEmpty() {
return this.defaultValue;
}
stringifyValue(value) {
if (value == null) {
return null;
}
if (this.defaultValue != null && value === this.defaultValue) {
return null;
}
return value.toString();
}
}
exports.IntegerMapper = IntegerMapper;
class StringArrayMapper extends PlainValueMapper {
constructor(queryStringParameterName, defaultValue) {
super(queryStringParameterName);
Object.defineProperty(this, "defaultValue", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.defaultValue = defaultValue || null;
}
parseEmpty() {
return this.defaultValue;
}
parseString(parameterValue) {
if (parameterValue == null || parameterValue === "") {
return this.defaultValue;
}
const values = parameterValue.split(" ");
return values;
}
stringifyValue(value) {
if (value == null || value.length === 0) {
return undefined;
}
const result = value.filter(x => x !== null).join(" ");
return result.length === 0 ? undefined : result;
}
}
exports.StringArrayMapper = StringArrayMapper;
class DateTimeRangeMapper {
constructor(queryStringParameterPrefix, defaultValue) {
Object.defineProperty(this, "parameterName", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "defaultValue", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.parameterName = queryStringParameterPrefix;
this.defaultValue = defaultValue || null;
}
parseDate(parameterValue) {
if (!parameterValue) {
return null;
}
const parsedValue = date_fns_1.parse(parameterValue, "yyyy-MM-dd", new Date());
return date_fns_1.isValid(parsedValue) ? edi_ui_1.DateUtils.fromLocalToUtc(parsedValue) : null;
}
stringifyDate(value) {
return value ? edi_ui_1.DateUtils.formatDate(value, "yyyy-MM-dd") : undefined;
}
parse(parsedQueryString) {
const fromString = parsedQueryString[this.parameterName + ".from"];
const toString = parsedQueryString[this.parameterName + ".to"];
if (this.defaultValue != null && fromString == undefined && toString == undefined) {
return this.defaultValue;
}
const lowerBound = this.parseDate(fromString);
const upperBound = this.parseDate(toString);
if (this.defaultValue != null && lowerBound == undefined && upperBound == undefined) {
return this.defaultValue;
}
return {
lowerBound: lowerBound && date_fns_1.startOfDay(lowerBound),
upperBound: upperBound && date_fns_1.endOfDay(upperBound),
};
}
stringify(parsedQueryString, value) {
if (value === null || value === undefined) {
return parsedQueryString;
}
if (this.isDefaultValue(value)) {
const _a = parsedQueryString, _b = this.parameterName + ".from", from = _a[_b], _c = this.parameterName + ".to", to = _a[_c], result = tslib_1.__rest(_a, [typeof _b === "symbol" ? _b : _b + "", typeof _c === "symbol" ? _c : _c + ""]);
return result;
}
let result = parsedQueryString;
if (value.lowerBound !== null && value.lowerBound !== undefined) {
result = Object.assign(Object.assign({}, result), { [this.parameterName + ".from"]: this.stringifyDate(value.lowerBound) });
}
if (value.upperBound !== null && value.upperBound !== undefined) {
result = Object.assign(Object.assign({}, result), { [this.parameterName + ".to"]: this.stringifyDate(value.upperBound) });
}
return result;
}
isDefaultValue(value) {
if (this.defaultValue == null) {
return false;
}
const defaultLower = this.defaultValue.lowerBound;
const valueLower = value.lowerBound;
if (defaultLower != null && valueLower != null && defaultLower.getTime() !== valueLower.getTime()) {
return false;
}
const defaultUpper = this.defaultValue.upperBound;
const valueUpper = value.upperBound;
if (defaultUpper != null && valueUpper != null && defaultUpper.getTime() !== valueUpper.getTime()) {
return false;
}
if (defaultLower == null && valueLower != null) {
return false;
}
if (defaultUpper == null && valueUpper != null) {
return false;
}
return true;
}
}
exports.DateTimeRangeMapper = DateTimeRangeMapper;
class StringMapper extends PlainValueMapper {
constructor(queryStringParameterName, defaultValue) {
super(queryStringParameterName);
Object.defineProperty(this, "defaultValue", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.defaultValue = defaultValue || null;
}
parseEmpty() {
return this.defaultValue;
}
parseString(parameterValue) {
return parameterValue;
}
stringifyValue(value) {
if (value === null || value === undefined || value === "") {
return null;
}
if (this.defaultValue != null && this.defaultValue === value) {
return null;
}
return value;
}
}
exports.StringMapper = StringMapper;
class SetMapper extends PlainValueMapper {
constructor(queryStringParameterName, enumValues, allowNegationOperator) {
super(queryStringParameterName);
Object.defineProperty(this, "enumValues", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "allowNegationOperator", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.allowNegationOperator = allowNegationOperator;
this.enumValues = enumValues;
}
parseString(parameterValue) {
if (parameterValue === null || parameterValue === undefined || parameterValue === "") {
return null;
}
let values;
if (this.allowNegationOperator && parameterValue[0] === "!") {
const negatedValues = parameterValue.replace(/^!/, "").split(" ");
values = difference_1.default(this.getKeys(), negatedValues);
}
else {
values = parameterValue.split(" ");
}
return values.filter(x => this.getKeys().includes(x)).map(x => this.getEnumValue(x));
}
buildPositiveValuesString(values) {
return values
.map(x => this.getString(x))
.filter(x => x !== null)
.join(" ");
}
buildNegativeValuesString(values) {
const positiveValues = values.map(x => this.getString(x)).filter(x => x !== null);
const negativeValues = difference_1.default(this.getKeys(), positiveValues);
return "!" + negativeValues.join(" ");
}
stringifyValue(value) {
if (value === null || value === undefined || value.length === 0) {
return undefined;
}
const positiveValues = this.buildPositiveValuesString(value);
if (this.allowNegationOperator) {
const negativeValues = this.buildNegativeValuesString(value);
if (positiveValues.length > negativeValues.length) {
return negativeValues;
}
}
return positiveValues.length === 0 ? undefined : positiveValues;
}
getString(value) {
for (const enumString in this.enumValues) {
if (this.enumValues[enumString] === value) {
return enumString;
}
}
return null;
}
getKeys() {
return Object.keys(this.enumValues);
}
getEnumValue(repr) {
return this.enumValues[repr];
}
}
exports.SetMapper = SetMapper;
Object.defineProperty(SetMapper, "nullValueString", {
enumerable: true,
configurable: true,
writable: true,
value: "Unknown"
});
//# sourceMappingURL=Mappers.js.map