@dasch-swiss/dsp-js/src/models/v2/custom-converters/has-cardinality-for-property-converter.js

JavaScript library that handles API requests to Knora

var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
import { JsonConverter } from "json2typescript";
import { CustomConverterUtils } from "../../../util/utils";
import { Constants } from "../Constants";
import { Cardinality } from "../ontologies/class-definition";
/**
 * @category Internal
 */
var HasCardinalityForPropertyConverter = /** @class */ (function () {
    function HasCardinalityForPropertyConverter() {
    }
    HasCardinalityForPropertyConverter.prototype.serialize = function (cardinalities) {
        var subClassOf = cardinalities.map(function (card) {
            var cardEle = {};
            cardEle["@type"] = Constants.Restriction;
            cardEle[Constants.OnProperty] = {
                "@id": card.propertyIndex
            };
            if (card.cardinality === Cardinality._0_1) {
                cardEle[Constants.MaxCardinality] = 1;
            }
            else if (card.cardinality === Cardinality._0_n) {
                cardEle[Constants.MinCardinality] = 0;
            }
            else if (card.cardinality === Cardinality._1_n) {
                cardEle[Constants.MinCardinality] = 1;
            }
            else if (card.cardinality === Cardinality._1) {
                cardEle[Constants.Cardinality] = 1;
            }
            else {
                throw new Error("Invalid cardinality: " + card.cardinality);
            }
            if (card.guiOrder) {
                cardEle[Constants.GuiOrder] = card.guiOrder;
            }
            return cardEle;
        });
        if (subClassOf.length === 0) {
            // no cardinality, empty array
            return subClassOf;
        }
        else {
            // if one card is given, just return this card (single object, no array)
            return (subClassOf.length > 1 ? subClassOf : subClassOf[0]);
        }
    };
    HasCardinalityForPropertyConverter.prototype.deserialize = function (items) {
        var hasCardForProp = [];
        var addItem = function (ele) {
            if (ele.hasOwnProperty("@type") && (ele["@type"] === Constants.Restriction)) {
                var cardinality = Cardinality._0_n;
                if (ele.hasOwnProperty(Constants.MaxCardinality)) {
                    if (ele[Constants.MaxCardinality] === 1) {
                        cardinality = Cardinality._0_1;
                    }
                    else {
                        throw new Error("Inconsistent value for max cardinality: " + ele[Constants.MaxCardinality]);
                    }
                }
                else if (ele.hasOwnProperty(Constants.MinCardinality)) {
                    if (ele[Constants.MinCardinality] === 1) {
                        cardinality = Cardinality._1_n;
                    }
                    else if (ele[Constants.MinCardinality] === 0) {
                        cardinality = Cardinality._0_n;
                    }
                    else {
                        throw new Error("Inconsistent value for min cardinality " + ele[Constants.MinCardinality]);
                    }
                }
                else if (ele.hasOwnProperty(Constants.Cardinality)) {
                    if (ele[Constants.Cardinality] === 1) {
                        cardinality = Cardinality._1;
                    }
                    else {
                        throw new Error("Inconsistent value for cardinality " + ele[Constants.Cardinality]);
                    }
                }
                var propertyIndex = "";
                if (ele.hasOwnProperty(Constants.OnProperty)) {
                    var propstruct = ele[Constants.OnProperty];
                    if (propstruct.hasOwnProperty("@id") &&
                        CustomConverterUtils.isString(propstruct["@id"])) {
                        propertyIndex = propstruct["@id"];
                    }
                    else {
                        throw new Error("Missing property name in cardinality");
                    }
                }
                var isInherited = false;
                if (ele.hasOwnProperty(Constants.IsInherited) && ele[Constants.IsInherited] === true) {
                    isInherited = true;
                }
                var guiOrder = -1;
                if (ele.hasOwnProperty(Constants.GuiOrder)) {
                    guiOrder = ele[Constants.GuiOrder];
                    hasCardForProp.push({
                        propertyIndex: propertyIndex,
                        cardinality: cardinality,
                        guiOrder: guiOrder,
                        isInherited: isInherited
                    });
                }
                else {
                    hasCardForProp.push({
                        propertyIndex: propertyIndex,
                        cardinality: cardinality,
                        isInherited: isInherited
                    });
                }
            }
        };
        if (Array.isArray(items)) {
            items.forEach(function (item) { return addItem(item); });
        }
        else {
            addItem(items);
        }
        return hasCardForProp;
    };
    HasCardinalityForPropertyConverter = __decorate([
        JsonConverter
    ], HasCardinalityForPropertyConverter);
    return HasCardinalityForPropertyConverter;
}());
export { HasCardinalityForPropertyConverter };
//# sourceMappingURL=has-cardinality-for-property-converter.js.map