@christianriedl/media 1.0.285 → 1.0.286

package/dist/mediaService.js

@@ -0,0 +1,714 @@
+import { Helper } from '@christianriedl/utils';
+import { EState, EMediaType, EItemType } from "./iMedia";
+import { MediaHelper } from "./mediaHelper";
+import { LocationHelper } from "./locationHelper";
+export const getMediaSymbol = Symbol("get-media");
+export class MediaService {
+    rest;
+    mediaUrl;
+    log;
+    user;
+    mainRoot = {
+        name: "Root", dlnaid: "0", itemType: EItemType.MainRoot,
+        state: EState.FolderReal, childCount: 4, folders: [], files: [], rating: 63, creatorIdx: -1, genreIdx: -1,
+        year: -1, description: "", dlnaParentId: "", url: "", thumbnailUrl: "", date: new Date()
+    };
+    roots = {};
+    folders = {};
+    realPictureAlbums = {};
+    medialists = {};
+    pictureLocation = { name: "", values: [] };
+    listsInitialized = 0;
+    lastFolderId = "";
+    realFolderId = "";
+    referenceDict = new Set();
+    privateIdx = -100;
+    pictureParentLimit = 0;
+    statistics;
+    countFolders;
+    countFiles;
+    countList;
+    countReferences;
+    photoSelection = { rating: 1, criteria: 'ye' };
+    constructor(rest, user, statistics, pictureParentLimit, log) {
+        this.log = log;
+        this.user = user;
+        this.rest = rest;
+        this.pictureParentLimit = pictureParentLimit;
+        this.statistics = statistics;
+        this.countFolders = statistics.searchOrCreate(log.name, "CountFolders");
+        this.countFiles = statistics.searchOrCreate(log.name, "CountFiles");
+        this.countList = statistics.searchOrCreate(log.name, "CountList");
+        this.countReferences = statistics.searchOrCreate(log.name, "CountReferences");
+        this.mediaUrl = rest.serviceUrl;
+    }
+    prepareFolders(folder) {
+        this.folders[folder.dlnaid] = folder;
+        folder.childCount = Number(folder.childCount);
+        folder.itemType = Number(folder.itemType);
+        folder.title = folder.name;
+        folder.state = Number(folder.state);
+        folder.year = Number(folder.year);
+        folder.title = folder.name;
+        folder.subTitle = '';
+        switch (folder.itemType) {
+            case EItemType.PictureRoot:
+            case EItemType.PictureFolder:
+            case EItemType.PictureRating:
+            case EItemType.PictureGenreType:
+            case EItemType.PictureCategory:
+            case EItemType.PictureYear:
+            case EItemType.PictureAlbum:
+                if (folder.mustExpand)
+                    folder.info = folder.name;
+                else
+                    folder.info = `${folder.name} (${folder.childCount})`;
+                break;
+            case EItemType.AudioAlbum:
+                folder.subTitle = folder.year.toString() + ' - ' + this.folders[folder.dlnaParentId].name;
+                folder.thumbnailUrl = this.getAlbumArtUrl(folder.thumbnailUrl);
+                break;
+            case EItemType.VideoGenreType:
+                folder.folders = [];
+                return false; // Remove it
+        }
+        if (folder.folders) {
+            for (var i = 0; i < folder.folders.length;)
+                if (this.prepareFolders(folder.folders[i]))
+                    i++;
+                else
+                    folder.folders.splice(i, 1); // remove
+        }
+        return true;
+    }
+    async initialize(mediaType) {
+        const rc = await this.getLists(mediaType ? mediaType : EMediaType.Picture);
+        let folder;
+        const stars = this.photoSelection.rating ? (this.photoSelection.rating == 1 ? '*' : '**') : 'all';
+        if (rc) {
+            switch (mediaType) {
+                case EMediaType.Audio:
+                    folder = await this.initializeAudios();
+                    break;
+                case EMediaType.Picture:
+                    folder = await this.getPhotosByCriteria(stars, this.photoSelection.criteria);
+                    break;
+                case EMediaType.Video:
+                    folder = await this.initializeVideos();
+                    break;
+            }
+        }
+        return true;
+    }
+    getFolder(id) {
+        return this.folders[id];
+    }
+    prepare(folder) {
+    }
+    getRoot(mediaType) {
+        switch (mediaType) {
+            case EMediaType.Audio:
+                return this.audioRoot;
+            case EMediaType.Video:
+                return this.videoRoot;
+            case EMediaType.Picture:
+                return this.pictureRoot;
+            case EMediaType.Online:
+                return this.onlineRoot;
+        }
+        return undefined;
+    }
+    async getPhotosByCriteria(stars, criteria) {
+        const key = `${stars}.${criteria}`;
+        this.lastFolderId = this.realFolderId = "";
+        if (!this.roots[key]) {
+            this.log.trace("initializePhotos: " + key);
+            var critName = '';
+            switch (criteria) {
+                case 'ye':
+                    critName = 'Jahr';
+                    break;
+                case 'lo':
+                    critName = 'Orte';
+                    break;
+                case 'ev':
+                    critName = 'Ereignisse';
+                    break;
+                case 'pe':
+                    critName = 'Personen';
+                    break;
+            }
+            const root = await this.browse("0", 6, true, false, `Root;Fotos;${stars};${critName}`);
+            this.prepareFolders(root);
+            this.roots[key] = root;
+        }
+        if (criteria == 'lo' && this.pictureParentLimit > 0) {
+            let ratingMap = 0;
+            switch (stars) {
+                case "all":
+                    ratingMap = (1 << 2) | (1 << 1) | 1;
+                    break;
+                case "*":
+                    ratingMap = (1 << 2) | (1 << 1);
+                    break;
+                case "**":
+                    ratingMap = 1 << 2;
+                    break;
+            }
+            LocationHelper.addLocationParents(this, this.pictureLocation, stars, ratingMap);
+        }
+        if (criteria == 'ye') // ??
+            return this.folders[`ph.${stars}.${criteria}|`];
+        else
+            return this.folders[`ph.${stars}.${criteria}`];
+    }
+    async initializeAudios() {
+        if (!this.roots['mu']) {
+            this.log.trace("initializeAudios");
+            const root = await this.browse("0", 4, true, false, 'Root;Musik');
+            this.prepareFolders(root);
+            this.roots['mu'] = root.folders[0];
+        }
+        return this.folders['mu'];
+    }
+    async initializeVideos() {
+        if (!this.roots['vi']) {
+            this.log.trace("initializeVideos");
+            const root = await this.browse("0", 2, true, false, 'Root;Videos');
+            this.prepareFolders(root);
+            this.roots['vi'] = root.folders[0];
+        }
+        return this.folders['vi'];
+    }
+    async getRecordedTVs() {
+        this.log.trace("getRecordedTVs");
+        const root = await this.browse("0", 3, false, false, 'Root;Online;Rec TV');
+        this.prepareFolders(root);
+        this.roots['online'] = root;
+        const videos = this.folders['online.rectv'];
+        this.log.trace(`getRecordedTVs ${videos.childCount}`);
+        videos.childCount = Number(videos.childCount);
+        videos.itemType = Number(videos.itemType);
+        videos.state = Number(videos.state);
+        videos.title = videos.name;
+        videos.subTitle = this.folders[videos.dlnaParentId]?.name;
+        videos.thumbnailUrl = "";
+        if (videos.files) {
+            for (var i = 0; i < videos.files.length; i++) {
+                const video = videos.files[i];
+                video.itemType = Number(video.itemType);
+                video.state = Number(video.state);
+                video.duration = Number(video.duration);
+                video.title = video.name;
+                video.info = MediaHelper.durationString(video.duration);
+                video.thumbnailUrl = "";
+                video.subTitle = video.description;
+            }
+        }
+        return videos;
+    }
+    async getOnlineTVs() {
+        this.log.trace("getOnlineTVs");
+        const root = await this.browse("0", 3, false, false, 'Root;Online;TV');
+        this.prepareFolders(root);
+        this.roots['online'] = root;
+        const videos = this.folders['online.tv'];
+        this.log.trace(`getTVs ${videos.childCount}`);
+        videos.childCount = Number(videos.childCount);
+        videos.itemType = Number(videos.itemType);
+        videos.state = Number(videos.state);
+        videos.title = videos.name;
+        videos.subTitle = this.folders[videos.dlnaParentId]?.name;
+        if (videos.files) {
+            for (var i = 0; i < videos.files.length; i++) {
+                const video = videos.files[i];
+                video.itemType = Number(video.itemType);
+                video.state = Number(video.state);
+                video.duration = Number(video.duration);
+                video.title = video.name;
+                video.info = MediaHelper.durationString(video.duration);
+                if (videos.url && video.url)
+                    video.url = videos.url + video.url;
+                if (videos.thumbnailUrl && video.thumbnailUrl)
+                    video.thumbnailUrl = videos.thumbnailUrl + video.thumbnailUrl;
+                video.subTitle = video.description;
+            }
+        }
+        videos.thumbnailUrl = "";
+        return videos;
+    }
+    async getOnlineRadios() {
+        this.log.trace("getOnlineRadios");
+        const root = await this.browse("0", 3, false, false, 'Root;Online;Radio');
+        this.prepareFolders(root);
+        this.roots['online'] = root;
+        const audios = this.folders['online.radio'];
+        this.log.trace(`getRadios ${audios.childCount}`);
+        audios.childCount = Number(audios.childCount);
+        audios.itemType = Number(audios.itemType);
+        audios.state = Number(audios.state);
+        audios.title = audios.name;
+        audios.subTitle = this.folders[audios.dlnaParentId].name;
+        if (audios.files) {
+            for (var i = 0; i < audios.files.length; i++) {
+                const audio = audios.files[i];
+                audio.itemType = Number(audio.itemType);
+                audio.state = Number(audio.state);
+                audio.duration = Number(audio.duration);
+                audio.title = audio.name;
+                audio.info = MediaHelper.durationString(audio.duration);
+                audio.subTitle = audio.description;
+                if (audios.thumbnailUrl && audio.thumbnailUrl)
+                    audio.thumbnailUrl = audios.thumbnailUrl + audio.thumbnailUrl;
+                audio.url = audios.url + audio.url;
+            }
+        }
+        audios.thumbnailUrl = "";
+        return audios;
+    }
+    getListEntry(name, idx) {
+        var list = this.medialists[name];
+        if (list && idx < list.values.length)
+            return list.values[idx];
+        return `${name}.${idx}`;
+    }
+    async getPhotos(folder) {
+        let realPhotos;
+        const newFolder = this.lastFolderId !== folder.dlnaid;
+        this.lastFolderId = folder.dlnaid;
+        if (folder.state & EState.FolderVirtual) {
+            if (newFolder) {
+                const refs = await this.browseReferences(folder.dlnaid);
+                this.referenceDict.clear();
+                for (var i = 0; i < refs.files.length; i++) {
+                    this.referenceDict.add(refs.files[i]);
+                }
+                this.realFolderId = folder.dlnaid;
+                var idx = this.realFolderId.indexOf('|');
+                this.realFolderId = 'ph.all.ye' + this.realFolderId.substr(idx);
+                this.log.trace(`getPhotos virtual ${refs.files.length} ${this.realFolderId}`);
+            }
+            realPhotos = this.realPictureAlbums[this.realFolderId];
+            if (!realPhotos) {
+                realPhotos = await this.browse(this.realFolderId, 1, false, false);
+                this.log.trace(`getPhotos virtual getReal ${realPhotos.files.length}`);
+                this.processPhotos(realPhotos);
+                this.removePrivate(realPhotos);
+                this.realPictureAlbums[this.realFolderId] = realPhotos;
+            }
+            folder.url = realPhotos.url;
+            var virtualPhotos = {
+                itemType: folder.itemType,
+                state: folder.state,
+                name: folder.name,
+                description: folder.description,
+                childCount: 0,
+                dlnaid: folder.dlnaid,
+                dlnaParentId: folder.dlnaParentId,
+                rating: folder.rating,
+                url: realPhotos.url,
+                thumbnailUrl: folder.thumbnailUrl,
+                year: folder.year,
+                folders: [],
+                files: [],
+                genreIdx: folder.genreIdx,
+                creatorIdx: folder.creatorIdx,
+                date: folder.date,
+            };
+            for (var i = 0; i < realPhotos.files.length; i++) {
+                if (this.referenceDict.has(realPhotos.files[i].dlnaid)) {
+                    const photo = realPhotos.files[i];
+                    if (newFolder)
+                        photo.selected = false;
+                    virtualPhotos.files.push(photo);
+                    virtualPhotos.childCount++;
+                }
+            }
+            this.log.trace(`getPhotos virtual get ${virtualPhotos.files.length}`);
+            folder.childCount = virtualPhotos.childCount;
+            return virtualPhotos;
+        }
+        realPhotos = this.realPictureAlbums[folder.dlnaid];
+        if (!realPhotos) {
+            realPhotos = await this.browse(folder.dlnaid, 1, false, false);
+            this.realPictureAlbums[folder.dlnaid] = realPhotos;
+            this.processPhotos(realPhotos);
+            this.removePrivate(realPhotos);
+            this.log.trace(`getPhotos real get ${realPhotos.files.length}`);
+        }
+        if (newFolder) {
+            for (var i = 0; i < realPhotos.files.length; i++)
+                realPhotos.files[i].selected = false;
+        }
+        folder.childCount = realPhotos.childCount;
+        return realPhotos;
+    }
+    processPhotos(folder) {
+        if (folder.files) {
+            for (var i = 0; i < folder.files.length; i++) {
+                const photo = folder.files[i];
+                if (photo.orientation && typeof photo.orientation === 'string')
+                    photo.orientation = Number(photo.orientation);
+                if (photo.date) {
+                    if (typeof photo.date === 'string') {
+                        const date = new Date(Number(photo.year), 0, 1).getTime() + Number(photo.date) * 1000;
+                        photo.date = new Date(date);
+                    }
+                    else if (typeof photo.date === 'number')
+                        photo.date = Helper.fromMilliseconds1970(photo.date * 1000);
+                }
+                photo.title = MediaHelper.getPhotoDisplayName(folder, photo, this.pictureLocation, folder);
+            }
+        }
+    }
+    removePrivate(folder) {
+        if (this.privateIdx >= 0 && folder.files) {
+            for (var i = 0; i < folder.files.length;) {
+                if (folder.files[i].creatorIdx == this.privateIdx)
+                    folder.files.splice(i, 1);
+                else
+                    i++;
+            }
+            folder.childCount = folder.files.length;
+        }
+    }
+    async getAudios(folder) {
+        const audios = await this.browse(folder.dlnaid, 1, false, false);
+        this.prepareFolders(audios);
+        this.log.trace(`getAudios ${audios.childCount}`);
+        audios.childCount = Number(audios.childCount);
+        audios.itemType = Number(audios.itemType);
+        audios.state = Number(audios.state);
+        audios.title = audios.name;
+        audios.subTitle = this.folders[audios.dlnaParentId]?.name;
+        audios.thumbnailUrl = folder.thumbnailUrl;
+        if (audios.files) {
+            for (var i = 0; i < audios.files.length; i++) {
+                const audio = audios.files[i];
+                audio.itemType = Number(audio.itemType);
+                audio.state = Number(audio.state);
+                audio.duration = Number(audio.duration);
+                audio.title = `${audio.trackNo} ${audio.name}`;
+                audio.subTitle = MediaHelper.durationString(audio.duration);
+                audio.thumbnailUrl = "";
+            }
+        }
+        return audios;
+    }
+    async getVideos(folder) {
+        const videos = await this.browse(folder.dlnaid, 1, false, false);
+        this.prepareFolders(videos);
+        this.log.trace(`getVideos ${videos.childCount}`);
+        videos.childCount = Number(videos.childCount);
+        videos.itemType = Number(videos.itemType);
+        videos.state = Number(videos.state);
+        videos.title = videos.name;
+        videos.subTitle = this.folders[videos.dlnaParentId]?.name;
+        videos.thumbnailUrl = folder.thumbnailUrl;
+        if (videos.files) {
+            for (var i = 0; i < videos.files.length; i++) {
+                const video = videos.files[i];
+                video.itemType = Number(video.itemType);
+                video.state = Number(video.state);
+                video.duration = Number(video.duration);
+                if (typeof video.countryIdx === 'string')
+                    video.countryIdx = Number(video.countryIdx);
+                if (typeof video.creatorIdx === 'string')
+                    video.creatorIdx = Number(video.creatorIdx);
+                if (typeof video.genreIdx === 'string')
+                    video.genreIdx = Number(video.genreIdx);
+                video.title = video.name;
+                video.info = MediaHelper.durationString(video.duration);
+                video.thumbnailUrl = this.getAlbumArtUrl(video.thumbnailUrl);
+                video.subTitle = "";
+                if (video.year)
+                    video.subTitle = video.year.toString();
+                if (video.countryIdx && video.countryIdx >= 0) {
+                    const country = this.getListEntry('Video.Countries', video.countryIdx);
+                    if (country)
+                        video.subTitle += ' - ' + country;
+                }
+                if (video.creatorIdx && video.creatorIdx >= 0) {
+                    const reg = this.getListEntry('Video.Director', video.creatorIdx);
+                    if (reg)
+                        video.subTitle += ' - ' + reg;
+                }
+            }
+        }
+        return videos;
+    }
+    async getPhotoTitles() {
+        const result = await this.rest.getData('apimedia/phototitles');
+        return result.result;
+    }
+    getPhotoUrl(folderUrl, url, format) {
+        const picurl = `${this.mediaUrl}apiimage/Picture/${format}${folderUrl}${url}`;
+        return encodeURI(picurl);
+    }
+    getPhotoDisplayName(folder, picture, album) {
+        return MediaHelper.getPhotoDisplayName(folder, picture, this.pictureLocation, album);
+    }
+    getAudioUrl(item) {
+        const album = this.folders[item.dlnaParentId];
+        const audiourl = `${this.mediaUrl}apistream/Audio${album.url}${item.url}`;
+        return encodeURI(audiourl);
+    }
+    getVideoUrl(url) {
+        const videourl = `${this.mediaUrl}apistream/Video${url}`;
+        return encodeURI(videourl);
+    }
+    getAlbumArtUrl(folderUrl) {
+        const albumarturl = `${this.mediaUrl}apiimage/Picture/0x0${folderUrl}`;
+        return encodeURI(albumarturl);
+    }
+    getAlbumDownloadUrl(folderUrl, codec, param) {
+        var downloadurl = `${this.mediaUrl}apistream/AudioZipped?media=${folderUrl}`;
+        if (codec || param)
+            downloadurl += `&codec=${codec}& param=${param}`;
+        return encodeURI(downloadurl);
+    }
+    getPhotosDownloadUrl(folder, resy, quality, photoIds) {
+        var name = folder.name.replaceAll(' ', '_');
+        var downloadurl = `${this.mediaUrl}apimedia/PhotosZipped/${name}?id=${folder.dlnaid}`;
+        if (resy)
+            downloadurl += `&resy=${resy}`;
+        if (quality)
+            downloadurl += `&quality=${quality}`;
+        if (photoIds && photoIds.length > 0)
+            downloadurl += `&photoIds=${photoIds.join(',')}`;
+        return encodeURI(downloadurl);
+    }
+    async browse(id, depth, onlyFolder, onlyReal, selectFolder) {
+        const folder = await this.rest.getData('apimedia/browse', { id: id, depth: depth, onlyFolder: onlyFolder, onlyReal: onlyReal, selectFolder: selectFolder });
+        const mediaFolder = folder.result;
+        this.buildStatistics(mediaFolder);
+        return mediaFolder;
+    }
+    async browseRealFiles(dlnaid, listMediaType, realFolderPrefix) {
+        const query = { dlnaid: dlnaid, realFolderPrefix: realFolderPrefix, listMediaType: listMediaType };
+        const res = await this.rest.getData('apimedia/browserealfiles', query);
+        const result = res.result;
+        if (result.folder)
+            this.buildStatistics(result.folder);
+        if (listMediaType && result.lists) {
+            this.initializeLists(listMediaType, result.lists, result.privateCreatorIdx);
+        }
+        return result;
+    }
+    async getPhotoService(id) {
+        const res = await this.rest.getData('apimedia/photoservice', { id: id });
+        const result = res.result;
+        if (result.folder)
+            this.buildStatistics(result.folder);
+        if (result.lists) {
+            this.initializeLists(EMediaType.Picture, result.lists, result.privateCreatorIdx);
+        }
+        return result;
+    }
+    async addPhotoService(id, user, dlnaid, daysValid = 365, photoIds) {
+        const data = { id: id, user: user, dlnaid: dlnaid, daysValid: daysValid, photoIds: photoIds };
+        const res = await this.rest.postDataEx('apimedia/photoservice', data);
+        return res;
+    }
+    buildStatistics(folder) {
+        if (folder.folders) {
+            this.statistics.increment(this.countFolders, folder.folders.length);
+            for (let i = 0; i < folder.folders.length; i++)
+                this.buildStatistics(folder.folders[i]);
+        }
+        if (folder.files)
+            this.statistics.increment(this.countFiles, folder.files.length);
+    }
+    async browseReferences(id) {
+        const ref = await this.rest.getData('apimedia/browse', { id: id, depth: 1, onlyFolder: false, onlyReal: false });
+        const folders = ref.result;
+        if (folders.files)
+            this.statistics.increment(this.countReferences, folders.files.length);
+        return folders;
+    }
+    async getExifInfo(folderId, mediaId) {
+        const info = await this.rest.getData('apimedia/info/exif', { folderId: folderId, mediaId: mediaId });
+        return info.result;
+    }
+    async getSatIpProbe(channelName, urlOrFileName) {
+        const info = await this.rest.getData('apistream/satipprobe', { channelName: channelName, url: urlOrFileName });
+        return info.result;
+    }
+    stopSatIpStream(channelName, media) {
+        const url = `apistream/satipstream/stop?channelName=${encodeURIComponent(channelName)}&media=${encodeURIComponent(media)}`;
+        const res = this.rest.postData(url);
+        return this.rest.toData(res);
+    }
+    async ping() {
+        try {
+            const res = await this.rest.getData('apistream/ping', { request: 'test' });
+            return res.ok && res.result.result === 'test';
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    getImage(url) {
+        const res = this.rest.getBlob(url, "image/jpeg");
+        return this.rest.toData(res);
+    }
+    async getLists(mediaType) {
+        if (this.listsInitialized & (1 << mediaType))
+            return true;
+        const res = await this.rest.getData('apimedia/medialist', { mediaType: mediaType });
+        const list = res.result;
+        this.initializeLists(mediaType, list.lists, list.privateCreatorIdx);
+        this.log.trace(`getLists get ${list.lists.length}`);
+        return true;
+    }
+    initializeLists(mediaType, entries, privateCreator) {
+        for (var i = 0; i < entries.length; i++) {
+            const li = entries[i];
+            if (li.values)
+                this.statistics.increment(this.countList, li.values.length);
+            if (mediaType == EMediaType.Picture) {
+                // Handle private creator
+                if (li.name == 'Picture.Creator') {
+                    if (this.user != 'ric@rts.co.at' && this.user != 'rih@rts.co.at') {
+                        this.privateIdx = privateCreator;
+                        if (!this.privateIdx) {
+                            for (var j = 0; j < li.values.length; j++) {
+                                if (li.values[j] === "Christian Riedl Privat") {
+                                    this.privateIdx = j;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                if (li.name == 'Picture.Location') {
+                    this.pictureLocation = li;
+                    li.children = [];
+                    for (let i = 0; i < li.parents.length; i++) {
+                        li.children.push([]);
+                    }
+                    for (let i = 0; i < li.parents.length; i++) {
+                        const parentIdx = li.parents[i];
+                        if (parentIdx >= 0) {
+                            const childArray = li.children[parentIdx];
+                            childArray.push(i);
+                        }
+                    }
+                }
+            }
+            this.medialists[li.name] = li;
+        }
+        this.listsInitialized |= (1 << mediaType);
+    }
+    async upload(form) {
+        const res = await this.rest.postData('apistream/upload', form);
+        return res.ok && res.result.result;
+    }
+    async uploadBigFile(file, directory, progress) {
+        const guid = Helper.generateUUID();
+        if (!progress)
+            progress = (pos) => { }; // create dummy 
+        let url = `apistream/uploadbigfile?directory=${directory}&file=${file.name}&uniqueid=${guid}`;
+        let res = await this.rest.postDataEx(url);
+        if (!res.ok) {
+            progress(res.statusText);
+            return false;
+        }
+        let result = res.result;
+        if (result.result != 'OK') {
+            progress(result.result);
+            return false;
+        }
+        progress("Start Upload");
+        const chunkSize = 1000000;
+        for (let start = 0; start < file.size; start += chunkSize) {
+            const end = Math.min(start + chunkSize, file.size);
+            const blob = file.slice(start, end);
+            const close = end == file.size;
+            let url = `apistream/uploaddata?&position=${start}&uniqueid=${guid}&close=${close}`;
+            res = await this.rest.postBlob(url, blob);
+            if (!res.ok) {
+                progress(res.statusText);
+                return false;
+            }
+            let result = res.result;
+            if (close) {
+                progress(result.result);
+                return result.result == 'OK';
+            }
+            progress(result.result);
+            if (isNaN(parseInt(result.result)))
+                return false;
+        }
+        return true;
+    }
+    async getDirectories(path) {
+        const res = await this.rest.getData('apimedia/documents/directories', { path: path });
+        if (res && res.ok) {
+            return res.result;
+        }
+        return [];
+    }
+    async getFiles(path) {
+        const res = await this.rest.getData('apimedia/documents/files', { path: path });
+        if (res && res.ok)
+            return res.result;
+        return [];
+    }
+    async getDirectoriesFull(path) {
+        const res = await this.rest.getData('apimedia/documents/directories', { path: path, full: true });
+        if (res && res.ok) {
+            const infos = res.result;
+            for (let i = 0; i < infos.length; i++) {
+                infos[i].date = new Date(infos[i].date);
+            }
+            return infos;
+        }
+        return [];
+    }
+    async getFilesFull(path) {
+        const res = await this.rest.getData('apimedia/documents/files', { path: path, full: true });
+        if (res && res.ok) {
+            const infos = res.result;
+            for (let i = 0; i < infos.length; i++) {
+                infos[i].date = new Date(infos[i].date);
+            }
+            return infos;
+        }
+        return [];
+    }
+    async speedTest(blockSize, numBlocks) {
+        const res = await this.rest.getData(`apistream/speedtest?blockSize=${blockSize}&numBlocks=${numBlocks}`, undefined, undefined, "text/plain");
+        return res;
+        /*
+        const self = this;
+        const url = `${this.rest.serviceUrl}apistream/speedtest?blockSize=${blockSize}&numBlocks=${numBlocks}`
+        const promise = new Promise<IRestResult<string>>(function (resolve, reject) {
+            Rest.fetch<string>(url, "GET", "same-origin", undefined, undefined, resolve, reject, self.log, undefined, "text/plain");
+        });
+        return promise;
+        */
+    }
+    async getCloudUrl(folder, name) {
+        const res = await this.rest.getData('apimedia/onedriveurl', { folder: folder, name: name });
+        if (res && res.ok && res.result)
+            return res.result.result;
+        return "";
+    }
+    getFileUrl(path) {
+        return this.rest.serviceUrl + 'apimedia/document/' + encodeURI(path);
+    }
+    get audioRoot() {
+        return this.roots['mu'];
+    }
+    get videoRoot() {
+        return this.roots['vi'];
+    }
+    get pictureRoot() {
+        return this.roots['ph'];
+    }
+    get onlineRoot() {
+        return this.roots['online'];
+    }
+}
+//# sourceMappingURL=mediaService.js.map