All files / dist/src ContentReferences.js

0% Statements 0/73
0% Branches 0/46
0% Functions 0/28
0% Lines 0/69
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127                                                                                                                                                                                                                                                             
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Observable_1 = require("rxjs/Observable");
const Content_1 = require("./Content");
const Query_1 = require("./Query");
const SN_1 = require("./SN");
class ReferenceAbstract {
    constructor() {
        this._isDirty = false;
    }
    get IsDirty() {
        return this._isDirty;
    }
    Search(term, top = 10, skip = 0, odataParams = {}) {
        return new Query_1.FinializedQuery((q) => {
            let query = q.Equals('_Text', `*${term}*`);
            if (this.FieldSetting.SelectionRoots && this.FieldSetting.SelectionRoots.length) {
                query = query.And.Query((innerTree) => {
                    this.FieldSetting.SelectionRoots && this.FieldSetting.SelectionRoots.forEach((root, index, thisArray) => {
                        innerTree = innerTree.InTree(root);
                        if (index < thisArray.length - 1) {
                            innerTree = innerTree.Or;
                        }
                    });
                    return innerTree;
                });
            }
            if (this.FieldSetting.AllowedTypes && this.FieldSetting.AllowedTypes.length) {
                const foundTypes = this.FieldSetting.AllowedTypes.map((type) => SN_1.ContentTypes[type]).filter((a) => a !== undefined);
                if (foundTypes.length > 0) {
                    query = query.And.Query((innerTypes) => {
                        foundTypes.forEach((type, index, thisArray) => {
                            innerTypes = innerTypes.Type(type);
                            if (index < thisArray.length - 1) {
                                innerTypes = innerTypes.Or;
                            }
                        });
                        return innerTypes;
                    });
                }
            }
            return query.Top(top).Skip(skip);
        }, this.Repository, '/Root', odataParams);
    }
}
exports.ReferenceAbstract = ReferenceAbstract;
class ContentReferenceField extends ReferenceAbstract {
    constructor(fieldData, FieldSetting, Repository) {
        super();
        this.FieldSetting = FieldSetting;
        this.Repository = Repository;
        this.HandleLoaded(fieldData);
    }
    SetContent(content) {
        this._contentReference = content;
        this._isDirty = true;
    }
    GetContent(odataOptions) {
        if (this._contentReference !== undefined) {
            return Observable_1.Observable.of(this._contentReference);
        }
        const request = this.Repository.GetODataApi().Get({ path: this._referenceUrl, params: odataOptions })
            .map((r) => {
            return r && r.d && this.Repository.HandleLoadedContent(r.d);
        }).share();
        request.subscribe((c) => {
            this._contentReference = c || null;
        });
        return request;
    }
    GetValue() {
        return this._contentReference && this._contentReference.Path;
    }
    HandleLoaded(fieldData) {
        if (Content_1.isDeferred(fieldData)) {
            this._referenceUrl = fieldData.__deferred.uri.replace(this.Repository.Config.ODataToken, '');
        }
        else if (Content_1.isIContent(fieldData)) {
            this._contentReference = this.Repository.HandleLoadedContent(fieldData);
        }
        this._isDirty = false;
    }
}
exports.ContentReferenceField = ContentReferenceField;
class ContentListReferenceField extends ReferenceAbstract {
    constructor(fieldData, FieldSetting, Repository) {
        super();
        this.FieldSetting = FieldSetting;
        this.Repository = Repository;
        this.HandleLoaded(fieldData);
    }
    SetContent(content) {
        this._contentReferences = content;
        this._isDirty = true;
    }
    GetContent(odataOptions) {
        if (this._contentReferences) {
            return Observable_1.Observable.of(this._contentReferences);
        }
        const request = this.Repository.GetODataApi().Fetch({
            path: this._referenceUrl,
            params: odataOptions
        }).map((resp) => {
            return resp && resp.d && resp.d.results.map((c) => this.Repository.HandleLoadedContent(c)) || [];
        }).share();
        request.subscribe((c) => {
            this._contentReferences = c;
        });
        return request;
    }
    GetValue() {
        return this._contentReferences && this._contentReferences
            .filter((c) => c.Path && c.Path.length)
            .map((c) => c.Path);
    }
    HandleLoaded(fieldData) {
        if (Content_1.isDeferred(fieldData)) {
            this._referenceUrl = fieldData.__deferred.uri.replace(this.Repository.Config.ODataToken, '');
        }
        else if (SN_1.isIContentList(fieldData)) {
            this._contentReferences = fieldData.map((f) => this.Repository.HandleLoadedContent(f));
        }
        this._isDirty = false;
    }
}
exports.ContentListReferenceField = ContentListReferenceField;
//# sourceMappingURL=ContentReferences.js.map