diff --git a/.github/workflows/beta.yml b/.github/workflows/beta.yml index 7a55c70..d6b7c07 100644 --- a/.github/workflows/beta.yml +++ b/.github/workflows/beta.yml @@ -12,6 +12,9 @@ jobs: contents: write outputs: new_version: ${{ steps.set-build-number.outputs.new_version }} + env: + PRIVATE_KEY: ${{ secrets.SIGNING_KEY }} + steps: - name: Check out code into the Go module directory uses: actions/checkout@v4 diff --git a/.github/workflows/manual.yml b/.github/workflows/manual.yml index 5393af7..4ffdb90 100644 --- a/.github/workflows/manual.yml +++ b/.github/workflows/manual.yml @@ -25,7 +25,11 @@ jobs: runs-on: ubuntu-latest permissions: contents: write + outputs: new_version: ${{ steps.set-build-number.outputs.new_version }} + env: + PRIVATE_KEY: ${{ secrets.SIGNING_KEY }} + steps: - name: Check out code into the Go module directory uses: actions/checkout@v4 @@ -59,6 +63,7 @@ jobs: - name: Build binaries run: | go mod tidy && go mod vendor + echo "$PRIVATE_KEY=${{ secrets.SIGNING_KEY }}" >> $GITHUB_ENV bash ${GITHUB_WORKSPACE}/Utility/create_binaries.sh beta - name: Create a Release diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 4a20886..6cc1c4a 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -12,6 +12,9 @@ jobs: contents: write outputs: new_version: ${{ steps.set-build-number.outputs.new_version }} + env: + PRIVATE_KEY: ${{ secrets.SIGNING_KEY }} + steps: - name: Check out code into the Go module directory uses: actions/checkout@v4 @@ -47,6 +50,7 @@ jobs: - name: Build binaries run: | go mod tidy && go mod vendor + echo "$PRIVATE_KEY=${{ secrets.SIGNING_KEY }}" >> $GITHUB_ENV bash ${GITHUB_WORKSPACE}/Utility/create_binaries.sh - name: Create a Release diff --git a/Dockerfile b/Dockerfile index 5f5229f..0d663a9 100644 --- a/Dockerfile +++ b/Dockerfile @@ -19,8 +19,8 @@ FROM base AS beta RUN go build -tags beta . FROM ${BUILD_FLAG} AS builder -ARG BRANCH -RUN echo "Build ${BRANCH} version" +ARG BUILD_FLAG +RUN echo "Build ${BUILD_FLAG} version" # Second stage. Creating an image # ----------------------------------------------------------------------------- diff --git a/Utility/create_binaries.sh b/Utility/create_binaries.sh index f64d1c9..ffd20d3 100644 --- a/Utility/create_binaries.sh +++ b/Utility/create_binaries.sh @@ -1,8 +1,46 @@ #!/bin/bash +set -e + +if [ -z "$PRIVATE_KEY" ]; then + echo "PRIVATE_KEY environment variable is not set. Exiting..." + exit 1 +fi + +function exitOnFailure { + echo "Build failed for ${1}/${2}. Exiting..." + rm threadfin_privkey.pem + exit 1 +} + +function verifySignature { + # Variables + binary_file="dist/${1}" + signature_file="signature.bin" + original_file="original_binary" + signature_size=256 + + # Extract the signature (assuming the signature is 256 bytes long) + tail -c $signature_size "$binary_file" > "$signature_file" + + # Extract the original binary content + head -c -$signature_size "$binary_file" > "$original_file" + + # Verify the signature + if ! openssl dgst -sha256 -verify threadfin_pubkey.pem -signature "$signature_file" "$original_file"; then + echo "Signature verification failed for ${1}. Exiting..." + exit 1 + fi + + # Clean up + rm "$signature_file" "$original_file" +} + os_list=("darwin" "freebsd" "linux" "windows") arch_list=("amd64" "arm64") +echo "$PRIVATE_KEY" > threadfin_privkey.pem + for os in "${os_list[@]}"; do export GOOS=$os for arch in "${arch_list[@]}"; do @@ -12,14 +50,31 @@ for os in "${os_list[@]}"; do bin_string="${bin_string}_beta" fi bin_string="${bin_string}_${os}_${arch}" + sha_string="${bin_string}" if [ "$os" = "windows" ]; then bin_string="${bin_string}.exe" fi echo "Building ${bin_string}" if [ "$1" = "beta" ]; then - go build -o "dist/${bin_string}" -tags beta + if ! go build -o "dist/${bin_string}" -tags beta; then + exitOnFailure "$os" "$arch" + fi else - go build -o "dist/${bin_string}" + if ! go build -o "dist/${bin_string}"; then + exitOnFailure "$os" "$arch" + fi fi + + echo "Signing the binary" + openssl dgst -sha256 -sign threadfin_privkey.pem -out signature.bin "dist/${bin_string}" + cat signature.bin >> "dist/${bin_string}" + + echo "Verify signature" + verifySignature "$bin_string" + + echo "Calculating sha256 for ${bin_string}" + sha256sum "dist/${bin_string}" > "dist/${sha_string}.sha256" done -done \ No newline at end of file +done + +rm threadfin_privkey.pem \ No newline at end of file diff --git a/src/buffer-interface.go b/src/buffer-interface.go new file mode 100644 index 0000000..99d7b63 --- /dev/null +++ b/src/buffer-interface.go @@ -0,0 +1,22 @@ +package src + +import "io" + +type BufferInterface interface { + StartBuffer(stream *Stream) error + StopBuffer() + CloseBuffer() + HandleByteOutput(stdOut io.ReadCloser) + PrepareBufferFolder(folder string) error + GetBufTmpFiles() []string + GetBufferedSize() int + addBufferedFilesToPipe() + DeleteOldestSegment() + CheckBufferFolder() (bool, error) + CheckBufferedFile(file string) (bool, error) + writeToPipe(file string) error + writeBytesToPipe(data []byte) error + GetPipeReader() *io.PipeReader + GetStopChan() chan struct{} + SetStopChan(chan struct{}) +} \ No newline at end of file diff --git a/src/buffer.go b/src/buffer.go index 85ccb11..0cd4dd1 100644 --- a/src/buffer.go +++ b/src/buffer.go @@ -5,114 +5,396 @@ import ( "fmt" "io" "os" + "path/filepath" + "sort" + "strconv" + "strings" + "time" "github.com/avfs/avfs" ) -func (b *Buffer) StartBuffer(stream *Stream,) { - b.Stream = stream - var err error = nil - if err = b.PrepareBufferFolder(stream.Folder); err != nil { +type StreamBuffer struct { + FileSystem avfs.VFS + Stream *Stream // Reference to the parents struct + StopChan chan struct{} + Stopped bool + CloseChan chan struct{} + Closed bool + LatestSegment int + OldSegments []string + PipeWriter *io.PipeWriter + PipeReader *io.PipeReader +} + +const ( + BufferFolderError = 4008 + SendFileError = 4009 + CreateFileError = 4010 + EndOfFileError = 4011 + ReadIntoBufferError = 4012 + WriteToBufferError = 4013 + OpenFileError = 4014 //errMsg = "Not able to open buffered file" + FileStatError = 4015 //errMsg = "Could not get file statics of buffered file" + ReadFileError = 4016 //errMsg = "Could not read buffered file before sending to clients" + FileDoesNotExistError = 4019 //errMsg = "Buffered file does not exist anymore" +) + +func (sb *StreamBuffer) StartBuffer(stream *Stream) error { + sb.Stream = stream + if err := sb.PrepareBufferFolder(filepath.Join(stream.Folder, "0.ts")); err != nil { // If something went wrong when setting up the buffer storage don't run at all stream.ReportError(err, BufferFolderError, "", true) - return + return err + } + return nil +} + +func (sb *StreamBuffer) StopBuffer() { + if !sb.Stopped { + sb.Stopped = true + close(sb.StopChan) } +} - switch Settings.Buffer { - case "ffmpeg", "vlc": - b.IsThirdPartyBuffer = true - err = StartThirdPartyBuffer(stream) - case "threadfin": - err = StartThreadfinBuffer(stream) - default: - return +func (sb *StreamBuffer) CloseBuffer() { + sb.StopBuffer() + if ! sb.Closed { + close(sb.CloseChan) + sb.Closed = true } - if err != nil { - b.Stream.handleBufferError(err) + if sb.Stream.Folder != "" { + sb.RemoveBufferedFiles(filepath.Join(sb.Stream.Folder, "0.ts")) } } +func (sb *StreamBuffer) GetPipeReader() *io.PipeReader{ + return sb.PipeReader +} + +func (sb *StreamBuffer) GetStopChan() chan struct{} { + return sb.StopChan +} + +func (sb *StreamBuffer) SetStopChan(stopChan chan struct{}) { + sb.StopChan = stopChan +} + /* HandleByteOutput save the byte ouptut of the command or http request as files */ -func (b *Buffer) HandleByteOutput(stdOut io.ReadCloser) { +func (sb *StreamBuffer) HandleByteOutput(stdOut io.ReadCloser) { TS_PACKAGE_MIN_SIZE := 188 bufferSize := Settings.BufferSize * 1024 // in bytes buffer := make([]byte, bufferSize) var fileSize int init := true - tmpFolder := b.Stream.Folder + string(os.PathSeparator) - tmpSegment := b.Stream.LatestSegment + tmpFolder := sb.Stream.Folder + string(os.PathSeparator) + tmpSegment := sb.LatestSegment - var bufferVFS = b.FileSystem + var bufferVFS = sb.FileSystem var f avfs.File var err error var tmpFile string reader := bufio.NewReader(stdOut) for { - if init { - tmpFile = fmt.Sprintf("%s%d.ts", tmpFolder, tmpSegment) - f, err = bufferVFS.Create(tmpFile) + select { + case <- sb.CloseChan: + // If the stream got stopped, stop the output + return + default: + if init { + tmpFile = fmt.Sprintf("%s%d.ts", tmpFolder, tmpSegment) + f, err = bufferVFS.Create(tmpFile) + if err != nil { + f.Close() + ShowError(err, CreateFileError) + sb.Stream.ReportError(err, CreateFileError, "", true) + return + } + init = false + } + n, err := reader.Read(buffer) + if n == 0 && err == nil { + continue + } + if err == io.EOF { + f.Close() + ShowDebug("Buffer reached EOF!", 3) + sb.Stream.ReportError(err, EndOfFileError, "", true) + return + } if err != nil { f.Close() - ShowError(err, CreateFileError) - b.Stream.ReportError(err, CreateFileError, "", true) + bufferVFS.Remove(tmpFile) + sb.Stream.ReportError(err, ReadIntoBufferError, "", true) return } - init = false + if _, err := f.Write(buffer[:n]); err != nil { + f.Close() + bufferVFS.Remove(tmpFile) + sb.Stream.ReportError(err, WriteToBufferError, "", true) + return + } + fileSize += n + // Check if the file size exceeds the threshold + if fileSize >= TS_PACKAGE_MIN_SIZE*1024 { + tmpSegment++ + tmpFile = fmt.Sprintf("%s%d.ts", tmpFolder, tmpSegment) + // Close the current file and create a new one + f.Close() + sb.LatestSegment = tmpSegment + f, err = bufferVFS.Create(tmpFile) + if err != nil { + f.Close() + sb.Stream.ReportError(err, CreateFileError, "", true) + return + } + fileSize = 0 + } } - n, err := reader.Read(buffer) - if n == 0 && err == nil { - continue + } +} + +func (sb *StreamBuffer) RemoveBufferedFiles(folder string) error { + test := filepath.Dir(folder) + if err := sb.FileSystem.RemoveAll(test); err != nil { + return fmt.Errorf("failed to remove buffer folder: %w", err) + } + return nil +} + +/* +PrepareBufferFolder will clean the buffer folder and check if the folder exists +*/ +func (sb *StreamBuffer) PrepareBufferFolder(folder string) error { + if err := sb.RemoveBufferedFiles(folder); err != nil { + return err + } + + if err := sb.createBufferFolder(filepath.Dir(folder)); err != nil { + return fmt.Errorf("failed to create buffer folder: %w", err) + } + + return nil +} + +func (sb *StreamBuffer) createBufferFolder(path string) (err error) { + + var debug string + _, err = sb.FileSystem.Stat(path) + + if fsIsNotExistErr(err) { + // Folder does not exist, will now be created + + // If we are on Windows and the cache location path is NOT on C:\ we need to create the volume it is located on + // Failure to do so here will result in a panic error and the stream not playing + if Settings.StoreBufferInRAM { + if sb.FileSystem.OSType() == avfs.OsWindows { + vm := sb.FileSystem.(avfs.VolumeManager) + pathIterator := avfs.NewPathIterator(sb.FileSystem, path) + if pathIterator.VolumeName() != "C:" { + vm.VolumeAdd(path) + } + } + + err = sb.FileSystem.MkdirAll(path, 0755) + if err == nil { + debug = fmt.Sprintf("Create virtual filesystem Folder: %s", path) + ShowDebug(debug, 1) + } else { + return err + } + + } else { + err = sb.FileSystem.MkdirAll(path, 0755) + if err == nil { + debug = fmt.Sprintf("Created folder on disk: %s", path) + ShowDebug(debug, 1) + } else { + return err + } } - if err == io.EOF { - f.Close() - ShowDebug("Buffer reached EOF!", 3) - b.Stream.ReportError(err, EndOfFileError, "", true) + + return nil + } + + return nil +} + +/* +GetBufTmpFiles retrieves the files within the buffer folder +and returns a sorted list with the file names +*/ +func (sb *StreamBuffer) GetBufTmpFiles() (tmpFiles []string) { + + var tmpFolder = sb.Stream.Folder + var fileIDs []float64 + + if _, err := sb.FileSystem.Stat(tmpFolder); !fsIsNotExistErr(err) { + files, err := sb.FileSystem.ReadDir(tmpFolder) + if err != nil { + ShowError(err, 000) return } + + // Check if more then one file is available + if len(files) >= 1 { + // Iterate over the files and collect the IDs + for _, file := range files { + if !file.IsDir() && filepath.Ext(file.Name()) == ".ts" { + fileID := strings.TrimSuffix(file.Name(), ".ts") + if f, err := strconv.ParseFloat(fileID, 64); err == nil { + fileIDs = append(fileIDs, f) + } + } + } + + sort.Float64s(fileIDs) + if len(fileIDs) > 0 { + fileIDs = fileIDs[:len(fileIDs)-1] + } + + // Create the return array with the sorted files + for _, file := range fileIDs { + fileName := fmt.Sprintf("%.0f.ts", file) + // Check if the file is already within old segments array + if !ContainsString(sb.OldSegments, fileName) { + tmpFiles = append(tmpFiles, fileName) + sb.OldSegments = append(sb.OldSegments, fileName) + } + } + } + } + return +} + +func (sb *StreamBuffer) GetBufferedSize() (size int) { + size = 0 + var tmpFolder = sb.Stream.Folder + if _, err := sb.FileSystem.Stat(tmpFolder); !fsIsNotExistErr(err) { + + files, err := sb.FileSystem.ReadDir(tmpFolder) if err != nil { - f.Close() - bufferVFS.Remove(tmpFile) - b.Stream.ReportError(err, ReadIntoBufferError, "", true) + ShowError(err, 000) return } - if _, err := f.Write(buffer[:n]); err != nil { - f.Close() - bufferVFS.Remove(tmpFile) - b.Stream.ReportError(err, WriteToBufferError, "", true) - return + for _, file := range files { + if !file.IsDir() && filepath.Ext(file.Name()) == ".ts" { + file_info, err := sb.FileSystem.Stat(filepath.Join(tmpFolder, file.Name())) + if err == nil { + size += int(file_info.Size()) + } + } } - fileSize += n - // Check if the file size exceeds the threshold - if fileSize >= TS_PACKAGE_MIN_SIZE * 1024 { - tmpSegment++ - tmpFile = fmt.Sprintf("%s%d.ts", tmpFolder, tmpSegment) - // Close the current file and create a new one - f.Close() - b.Stream.LatestSegment = tmpSegment - f, err = bufferVFS.Create(tmpFile) - if err != nil { - f.Close() - b.Stream.ReportError(err, CreateFileError, "", true) - return + } + return size +} + +func (sb *StreamBuffer) addBufferedFilesToPipe() { + for { + select { + case <-sb.StopChan: + return + default: + if sb.GetBufferedSize() < Settings.BufferSize * 1024 { + time.Sleep(25 * time.Millisecond) // Wait for new files + continue + } + tmpFiles := sb.GetBufTmpFiles() + for _, f := range tmpFiles { + if ok, err := sb.CheckBufferFolder(); !ok { + sb.Stream.ReportError(err, BufferFolderError, "", true) + return + } + ShowDebug(fmt.Sprintf("Streaming:Broadcasting file %s to clients", f), 1) + err := sb.writeToPipe(f) // Add file so it will be copied to the pipes + if err != nil { + sb.Stream.ReportError(err, 0, "", false) + } + sb.DeleteOldestSegment() } - fileSize = 0 } } } /* -PrepareBufferFolder will clean the buffer folder and check if the folder exists +DeleteOldesSegment will delete the file provided in the buffer */ -func (b *Buffer) PrepareBufferFolder(folder string) error { - if err := b.FileSystem.RemoveAll(getPlatformPath(folder)); err != nil { - return fmt.Errorf("failed to remove buffer folder: %w", err) +func (sb *StreamBuffer) DeleteOldestSegment() { + fileToRemove := filepath.Join(sb.Stream.Folder, sb.OldSegments[0]) + if err := sb.FileSystem.Remove(fileToRemove); err != nil { + ShowError(err, 4007) } + sb.OldSegments = sb.OldSegments[1:] +} - if err := checkVFSFolder(folder, b.FileSystem); err != nil { - return fmt.Errorf("failed to check buffer folder: %w", err) +/* +CheckBufferFolder reports whether the buffer folder exists. +*/ +func (sb *StreamBuffer) CheckBufferFolder() (bool, error) { + if _, err := sb.FileSystem.Stat(sb.Stream.Folder); fsIsNotExistErr(err) { + return false, err } + return true, nil +} - return nil +// CheckBufferedFile check for the existance of the given file (file path is needed) +func (sb *StreamBuffer) CheckBufferedFile(file string) (bool, error) { + if _, err := sb.FileSystem.Stat(file); fsIsNotExistErr(err) { + return false, err + } + return true, nil } + +func (sb *StreamBuffer) writeToPipe(file string) error { + f, err := sb.FileSystem.Open(filepath.Join(sb.Stream.Folder, file)) + if err != nil { + return err + } + defer f.Close() + + + buf := make([]byte, 4096) // 4KB buffer + for { + select { + case <- sb.StopChan: + // Pipe was closed quit writing to it + return nil + default: + n, err := f.Read(buf) + if err != nil && err != io.EOF { + sb.Stream.ReportError(err, 0, "", true) // TODO: Add error code + return err + } else if err == io.EOF { + return nil + } + if n == 0 { + break + } + + _, err = sb.PipeWriter.Write(buf[:n]) + if err != nil { + sb.Stream.ReportError(err, 0, "", true) // TODO: Add error code + return err + } + } + } +} + +func (sb *StreamBuffer) writeBytesToPipe(data []byte) error { + for { + select { + case <- sb.StopChan: + // Pipe was closed quit writing to it + return nil + default: + _, err := sb.PipeWriter.Write(data) + if err != nil { + sb.Stream.ReportError(err, 0, "", true) // TODO: Add error code + return err + } + time.Sleep(800 * time.Millisecond) + } + } +} \ No newline at end of file diff --git a/src/config.go b/src/config.go index d074787..f000fd0 100644 --- a/src/config.go +++ b/src/config.go @@ -136,12 +136,7 @@ func Init() (err error) { ShowError(err, 1071) return } - - err = conditionalUpdateChanges() - if err != nil { - return - } - + // Einstellungen laden (settings.json) ShowInfo(fmt.Sprintf("Load Settings:%s", System.File.Settings)) diff --git a/src/data.go b/src/data.go index 72cf638..4aa24b5 100644 --- a/src/data.go +++ b/src/data.go @@ -15,7 +15,7 @@ import ( ) // Einstellungen ändern (WebUI) -func updateServerSettings(request RequestStruct) (settings SettingsStruct, err error) { +func updateServerSettings(request RequestStruct) (settings *SettingsStruct, err error) { oldSettings, err := jsonToMap(mapToJSON(Settings)) if err != nil { @@ -27,6 +27,11 @@ func updateServerSettings(request RequestStruct) (settings SettingsStruct, err e ShowError(err, 0 ) //TODO: Define error code return } + + if len(newSettings) == 0 { + return nil, nil + } + var reloadData = false var cacheImages = false var createXEPGFiles = false @@ -57,7 +62,7 @@ func updateServerSettings(request RequestStruct) (settings SettingsStruct, err e _, err := time.Parse("1504", v.(string)) if err != nil { ShowError(err, 1012) - return Settings, err + return &Settings, err } newUpdateTimes = append(newUpdateTimes, v.(string)) @@ -219,7 +224,7 @@ func updateServerSettings(request RequestStruct) (settings SettingsStruct, err e err = saveSettings(Settings) if err == nil { - settings = Settings + settings = &Settings if reloadData { @@ -447,7 +452,7 @@ func deleteLocalProviderFiles(dataID, fileType string) { } // Filtereinstellungen speichern (WebUI) -func saveFilter(request RequestStruct) (settings SettingsStruct, err error) { +func saveFilter(request RequestStruct) (settings *SettingsStruct, err error) { var filterMap = make(map[int64]interface{}) var newData = make(map[int64]interface{}) @@ -522,7 +527,7 @@ func saveFilter(request RequestStruct) (settings SettingsStruct, err error) { return } - settings = Settings + settings = &Settings err = buildDatabaseDVR() if err != nil { diff --git a/src/internal/up2date/client/client.go b/src/internal/up2date/client/client.go deleted file mode 100755 index 4bd0728..0000000 --- a/src/internal/up2date/client/client.go +++ /dev/null @@ -1,135 +0,0 @@ -package up2date - -import ( - "bytes" - "encoding/json" - "errors" - "fmt" - "io" - "net" - "net/http" - "net/url" - "runtime" - "time" -) - -// ClientInfo : Information about the key (NAME OS, ARCH, UUID, KEY) -type ClientInfo struct { - Arch string `json:"arch"` - Branch string `json:"branch"` - CMD string `json:"cmd,omitempty"` - Name string `json:"name"` - OS string `json:"os"` - URL string `json:"url"` - - Response ServerResponse `json:"response,omitempty"` -} - -//ServerResponse : Response from server after client request -type ServerResponse struct { - Status bool `json:"status,omitempty"` - Reason string `json:"reason,omitempty"` - Version string `json:"version,omitempty"` - UpdateBIN string `json:"update.url.bin,omitempty"` - UpdateZIP string `json:"update.url.zip,omitempty"` - Filename string `json:"filename.bin,omitempty"` - UpdatedAt string - Assets []AssetsStruct -} - -type AssetsStruct struct { - DownloadUrl string - UpdatetAt string -} - -// Updater : Client infos -var Updater ClientInfo - -// UpdateURL : URL for the new binary -var UpdateURL string - -// Init : Init -func Init() { - Updater.OS = runtime.GOOS - Updater.Arch = runtime.GOARCH -} - -// GetVersion : Information about the latest version -func GetVersion() (err error) { - - Updater.CMD = "getVersion" - err = serverRequest() - return -} - -func serverRequest() (err error) { - - var serverResponse ServerResponse - jsonByte, err := json.MarshalIndent(Updater, "", " ") - if err == nil { - - // Serververbindung prüfen - u, err := url.Parse(Updater.URL) - if err != nil { - return err - } - var server = u.Host - - timeout := time.Duration(1 * time.Second) - _, err = net.DialTimeout("tcp", server, timeout) - if err != nil { - return err - } - - // Check redirect 301 <---> 308 - redirect, _ := http.NewRequest("POST", Updater.URL, nil) - - client := &http.Client{} - client.CheckRedirect = func(redirect *http.Request, via []*http.Request) error { - return errors.New("Redirect") - } - - resp, err := client.Do(redirect) - - if err != nil { - // Redirect - if resp.StatusCode >= 301 && resp.StatusCode <= 308 { //status code 301 <---> 308 - Updater.URL = resp.Header.Get("Location") - } else { - return err - } - } - // --- - - req, _ := http.NewRequest("POST", Updater.URL, bytes.NewBuffer(jsonByte)) - req.Header.Set("Content-Type", "application/json") - - client = &http.Client{} - resp, err = client.Do(req) - - if err != nil { - return err - } - - if resp.StatusCode != http.StatusOK { - //fmt.Println(resp.StatusCode, Updater.URL, Updater.CMD) - return fmt.Errorf("%d: %s (%s)", resp.StatusCode, http.StatusText(resp.StatusCode), Updater.URL) - } - - Updater.CMD = "" - defer resp.Body.Close() - - body, _ := io.ReadAll(resp.Body) - - err = json.Unmarshal(body, &serverResponse) - - if err != nil { - return err - } - - Updater.Response = serverResponse - - } - - return -} diff --git a/src/internal/up2date/client/update.go b/src/internal/up2date/client/update.go deleted file mode 100755 index 2327cbc..0000000 --- a/src/internal/up2date/client/update.go +++ /dev/null @@ -1,258 +0,0 @@ -package up2date - -import ( - "archive/zip" - "fmt" - "io" - "log" - "net/http" - "os" - "os/exec" - "path/filepath" - "runtime" - "strings" - "syscall" -) - -// DoUpdate : Update binary -func DoUpdate(fileType, filenameBIN string) (err error) { - - var url string - switch fileType { - case "bin": - url = Updater.Response.UpdateBIN - case "zip": - url = Updater.Response.UpdateZIP - } - - if len(url) > 0 { - log.Println("["+strings.ToUpper(fileType)+"]", "New version ("+Updater.Name+"):", Updater.Response.Version) - - // Download new binary - log.Println("DEBUG: ", url) - resp, err := http.Get(url) - if err != nil { - return err - } - defer resp.Body.Close() - log.Println("["+strings.ToUpper(fileType)+"]", "Download new version...") - - if resp.StatusCode != http.StatusOK { - log.Println("["+strings.ToUpper(fileType)+"]", "Download new version...NOK") - return fmt.Errorf("bad status: %s", resp.Status) - } - - // Change binary filename to .filename - binary, _ := os.Executable() - var filename = getFilenameFromPath(binary) - var path = getPlatformPath(binary) - var oldBinary = path + "_old_" + filename - var newBinary = binary - - // ZIP - var tmpFolder = path + "tmp" - var tmpFile = tmpFolder + string(os.PathSeparator) + filenameBIN - - //fmt.Println(binary, path+"."+filename) - os.Rename(newBinary, oldBinary) - - // Save the new binary with the old file name - out, err := os.Create(binary) - if err != nil { - restorOldBinary(oldBinary, newBinary) - return err - } - defer out.Close() - - // Write the body to file - - _, err = io.Copy(out, resp.Body) - if err != nil { - restorOldBinary(oldBinary, newBinary) - return err - } - - // Update as a ZIP file - if fileType == "zip" { - - log.Println("["+strings.ToUpper(fileType)+"]", "Update file:", filenameBIN) - log.Println("["+strings.ToUpper(fileType)+"]", "Unzip ZIP file...") - err = extractZIP(binary, tmpFolder) - - binary = newBinary - - if err != nil { - - log.Println("["+strings.ToUpper(fileType)+"]", "Unzip ZIP file...ERROR") - - restorOldBinary(oldBinary, newBinary) - - return err - } else { - - log.Println("["+strings.ToUpper(fileType)+"]", "Unzip ZIP file...OK") - log.Println("["+strings.ToUpper(fileType)+"]", "Copy binary file...") - - err = copyFile(tmpFile, binary) - if err == nil { - log.Println("["+strings.ToUpper(fileType)+"]", "Copy binary file...OK") - } else { - - log.Println("["+strings.ToUpper(fileType)+"]", "Copy binary file...ERROR") - restorOldBinary(oldBinary, newBinary) - - return err - } - - os.RemoveAll(tmpFolder) - } - - } - - // Set the permission - os.Chmod(binary, 0755) - - // Close the new file !Windows - out.Close() - - log.Println("["+strings.ToUpper(fileType)+"]", "Update Successful") - - // Restart binary (Windows) - if runtime.GOOS == "windows" { - - bin, err := os.Executable() - - if err != nil { - restorOldBinary(oldBinary, newBinary) - return err - } - - var pid = os.Getpid() - var process, _ = os.FindProcess(pid) - - if proc, err := start(bin); err == nil { - - os.RemoveAll(oldBinary) - process.Kill() - proc.Wait() - - } else { - restorOldBinary(oldBinary, newBinary) - } - - } else { - - // Restart binary (Linux and UNIX) - file, _ := os.Executable() - err = os.RemoveAll(oldBinary) - if err != nil { - fmt.Println(err) - } - err = syscall.Exec(file, os.Args, os.Environ()) - if err != nil { - restorOldBinary(oldBinary, newBinary) - log.Fatal(err) - return err - } - - } - - } - - return -} - -func start(args ...string) (p *os.Process, err error) { - - if args[0], err = exec.LookPath(args[0]); err == nil { - //fmt.Println(args[0]) - var procAttr os.ProcAttr - procAttr.Files = []*os.File{os.Stdin, os.Stdout, os.Stderr} - p, err := os.StartProcess(args[0], args, &procAttr) - - if err == nil { - return p, nil - } - - } - - return nil, err -} - -func restorOldBinary(oldBinary, newBinary string) { - os.RemoveAll(newBinary) - os.Rename(oldBinary, newBinary) -} - -func getFilenameFromPath(path string) string { - - file := filepath.Base(path) - - return file -} - -func getPlatformPath(path string) string { - - var newPath = filepath.Dir(path) - return newPath -} - -func copyFile(src, dst string) (err error) { - in, err := os.Open(src) - if err != nil { - return err - } - defer in.Close() - - out, err := os.Create(dst) - if err != nil { - return err - } - defer out.Close() - - _, err = io.Copy(out, in) - if err != nil { - return err - } - return out.Close() -} - -func extractZIP(archive, target string) (err error) { - - reader, err := zip.OpenReader(archive) - if err != nil { - return err - } - - if err := os.MkdirAll(target, 0755); err != nil { - return err - } - - for _, file := range reader.File { - - path := filepath.Join(target, file.Name) - if file.FileInfo().IsDir() { - os.MkdirAll(path, file.Mode()) - continue - } - - fileReader, err := file.Open() - if err != nil { - return err - } - defer fileReader.Close() - - targetFile, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode()) - if err != nil { - return err - } - defer targetFile.Close() - - if _, err := io.Copy(targetFile, fileReader); err != nil { - return err - } - - } - - return -} diff --git a/src/internal/updater/checkSigning.go b/src/internal/updater/checkSigning.go new file mode 100644 index 0000000..bf31808 --- /dev/null +++ b/src/internal/updater/checkSigning.go @@ -0,0 +1,92 @@ +package up2date + +import ( + "crypto" + "crypto/rsa" + "crypto/sha256" + "crypto/x509" + "encoding/pem" + "fmt" + "io" + "os" +) + +const pubkey = `-----BEGIN PUBLIC KEY----- +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2ZkUyr5n1c1iSO8fMtFl +ZV1zncySavnEOOADT+1jHAJVASipxYbm+gZ9welcAl5iYZSXd0FV7uGBbU1HogIL +pl3zfRJ4xY+TmVDRGdKfnc2KMn/7aY3JdSUfSCZ+smZVvHNRWlnzVsRoYNHMe6gm +dHg50I1IgFuhdtYY4p3e4FS4SdZVNV3BJuJTaAG8viUpsoy30DnaWIBsDpX+CPjp +7ntWZPGxDxCRl011ri+DWd3dgcClDmt6YXJAzkiSnfuNqXwENu2nhFV7wCqwMmFU +nfkRuBOYqTJ3GAsAJK+HNthxWV09p9O1n1pgLpaBNcp8UosBWXH+JEJU7UKSp2u3 +bwIDAQAB +-----END PUBLIC KEY-----` + +func checkSignature(filePath string) (bool, error) { + file, err := os.Open("threadfin") + if err != nil { + return false, err + } + // Gehe zum Ende der Datei und extrahiere die letzten 256 Bytes (Signatur)# + fileInfo, err := file.Stat() + if err != nil { + fmt.Println("Fehler beim Abrufen der Dateiinformationen:", err) + return false, err + } + signatureSize := 256 // Größe der RSA Signatur in Bytes + fileSize := fileInfo.Size() + if fileSize < int64(signatureSize) { + fmt.Println("Dateigröße zu klein für Signatur") + return false, err + } + // Extrahiere die Signatur + _, err = file.Seek(-int64(signatureSize), io.SeekEnd) + if err != nil { + fmt.Println("Fehler beim Suchen der Signatur:", err) + return false, err + } + signature := make([]byte, signatureSize) + _, err = file.Read(signature) + if err != nil { + fmt.Println("Fehler beim Lesen der Signatur:", err) + return false, err + } + // Gehe zum Anfang der Datei und lese den Inhalt ohne die Signatur + _, err = file.Seek(0, io.SeekStart) + if err != nil { + fmt.Println("Fehler beim Suchen des Datei-Anfangs:", err) + return false, err + } + content := make([]byte, fileSize-int64(signatureSize)) + _, err = file.Read(content) + if err != nil { + fmt.Println("Fehler beim Lesen des Datei-Inhalts:", err) + return false, err + } + // Lade den öffentlichen Schlüssel (aus einer PEM-Datei) + block, _ := pem.Decode([]byte(pubkey)) + if block == nil || block.Type != "PUBLIC KEY" { + fmt.Println("Fehler beim Dekodieren des öffentlichen Schlüssels") + return false, err + } + pubKey, err := x509.ParsePKIXPublicKey(block.Bytes) + if err != nil { + fmt.Println("Fehler beim Parsen des öffentlichen Schlüssels:", err) + return false, err + } + rsaPubKey, ok := pubKey.(*rsa.PublicKey) + if !ok { + fmt.Println("Öffentlicher Schlüssel ist kein RSA-Schlüssel") + return false, err + } + // Berechne den SHA-256 Hash des Inhalts ohne die Signatur + hash := sha256.Sum256(content) + // Überprüfe die Signatur + err = rsa.VerifyPKCS1v15(rsaPubKey, crypto.SHA256, hash[:], signature) + if err != nil { + fmt.Println("Signaturüberprüfung fehlgeschlagen:", err) + return false, err + } else { + fmt.Println("Signaturüberprüfung erfolgreich!") + return true, nil + } +} \ No newline at end of file diff --git a/src/internal/updater/updater.go b/src/internal/updater/updater.go new file mode 100755 index 0000000..4706e62 --- /dev/null +++ b/src/internal/updater/updater.go @@ -0,0 +1,352 @@ +package up2date + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "io" + "net/http" + "os" + "os/exec" + "runtime" + "strings" + "time" + + "github.com/hashicorp/go-version" +) + +// ClientInfo : Information about the key (NAME OS, ARCH, UUID, KEY) +type ClientInfo struct { + Arch string `json:"arch"` + Branch string `json:"branch"` + CMD string `json:"cmd,omitempty"` + Name string `json:"name"` + OS string `json:"os"` + URL string `json:"url"` + + Filename string `json:"filename,omitempty"` + BinaryDownloadURL string `json:"binaryDownloadURL,omitempty"` + SHA256DownloadURL string `json:"sha256DownloadURL,omitempty"` + + Response ServerResponse `json:"response,omitempty"` + + Server *http.Server +} + +// ServerResponse : Response from server after client request +type ServerResponse struct { + Status bool `json:"status,omitempty"` + Reason string `json:"reason,omitempty"` + Version string `json:"version,omitempty"` + UpdateBIN string `json:"update.url.bin,omitempty"` + UpdateZIP string `json:"update.url.zip,omitempty"` + UpdatedAt string + Assets []AssetsStruct +} + +type GithubReleaseInfo struct { + TagName string `json:"tag_name"` + Prerelease bool `json:"prerelease"` + Assets []AssetsStruct `json:"assets"` +} + +type AssetsStruct struct { + Name string `json:"name"` + DownloadUrl string `json:"browser_download_url"` + UpdatetAt string `json:"updated_at"` + ContentType string `json:"content_type"` +} + +// Init : Init +func Init(branch, name, url string) *ClientInfo { + return &ClientInfo{ + Arch: runtime.GOARCH, + Branch: branch, + Name: name, + OS: runtime.GOOS, + URL: url, + } +} + +func (c *ClientInfo) GetBinaryDownloadURL(releasesURL string) error { + //var latest string + //var bin_name string + var body []byte + + var git []*GithubReleaseInfo + + resp, err := http.Get(releasesURL) + if err != nil { + return err + } + + body, _ = io.ReadAll(resp.Body) + + err = json.Unmarshal(body, &git) + if err != nil { + return err + } + + // Get latest prerelease tag name + if c.Branch == "beta" { + for _, release := range git { + if release.Prerelease { + if c.Response.Version == "" { + c.Response.Version = release.TagName + } + c.Response.Assets = append(c.Response.Assets, release.Assets...) + } + } + } + + // Latest main tag name + if c.Branch == "master" { + for _, release := range git { + if !release.Prerelease { + if c.Response.Version == "" { + c.Response.Version = release.TagName + } + c.Response.Assets = append(c.Response.Assets, release.Assets...) + } + } + } + + // Find the download link corresponding to the OS + foundBinaryURL := false + foundSHA256URL := false + for _, asset := range c.Response.Assets { + if strings.Contains(asset.Name, c.OS) && strings.Contains(asset.Name, c.Arch) { + if strings.Contains(asset.Name, "sha256") { + c.SHA256DownloadURL = asset.DownloadUrl + foundSHA256URL = true + } else { + c.BinaryDownloadURL = asset.DownloadUrl + foundBinaryURL = true + } + if foundBinaryURL && foundSHA256URL { + c.Filename = asset.Name + c.Response.Status = true + break + } + } + } + return nil +} + +func (c *ClientInfo) ExistsNewerVersion(Version, Build string) bool { + var currentVersion = Version + "." + Build + current_version, _ := version.NewVersion(currentVersion) + response_version, _ := version.NewVersion(c.Response.Version) + if response_version == nil { + current_date := getBinaryTime() + layout := time.RFC3339 + response_date, err := time.Parse(layout, c.Response.UpdatedAt) + if err != nil { + return false + } + if current_date.Before(response_date) { + return true + } + } else if response_version.GreaterThan(current_version) && c.Response.Status { + return true + } + return false +} + +func getBinaryTime() time.Time { + executablePath, err := os.Executable() + if err != nil { + return time.Now() + } + binaryInfo, err := os.Stat(executablePath) + if err != nil { + return time.Now() + } + return binaryInfo.ModTime() +} + +func (c *ClientInfo) DoUpdateNew() error { + client := &http.Client{ + CheckRedirect: func(req *http.Request, via []*http.Request) error { + // Allow up to 10 redirects + if len(via) >= 10 { + return http.ErrUseLastResponse + } + return nil + }, + } + + resp, err := client.Get(c.BinaryDownloadURL) + if err != nil { + return err + } + defer resp.Body.Close() + + // Create a temporary file to save the new binary + tmpBinary, err := os.CreateTemp("", c.Filename) + if err != nil { + return err + } + + buf := make ([]byte, 128 * 1024) + for { + n , err := resp.Body.Read(buf) + if err != nil && err != io.EOF { + return err + } + if n == 0 { + break + } + + if _, err := tmpBinary.Write(buf[:n]); err != nil { + return err + } + } + + // Close the file explicitly + tmpBinary.Close() + + if err := c.verifyChecksum(tmpBinary.Name()); err != nil { + os.Remove(tmpBinary.Name()) + return err + } + + // Check the signature + if ok, err := checkSignature(tmpBinary.Name()); !ok { + return err + } + + // Get the current executable + exePath, err := os.Executable() + if err != nil { + os.Remove(tmpBinary.Name()) + return err + } + + // Get the stat from the current executable + oldExeInfo, err := os.Stat(exePath) + if err != nil { + os.Remove(tmpBinary.Name()) + return err + } + + // Set attributes of the new executable + if err := os.Chmod(tmpBinary.Name(), oldExeInfo.Mode()); err != nil { + os.Remove(tmpBinary.Name()) + return err + } + + // Backup the old executable + backupPath := os.TempDir() + string(os.PathSeparator) + c.Filename + ".old" + _ = os.Remove(backupPath) + + // Move the existing executable + err = os.Rename(exePath, backupPath) + if err != nil { + os.Remove(tmpBinary.Name()) + return err + } + + // Move the new executable + if err := os.Rename(tmpBinary.Name(), exePath); err != nil { + copyFile(backupPath, exePath) + return err + } + + // Stop the webserver + if err = shutdownWebserver(c.Server); err != nil { + return err + } + + // Restart the application + restartApplication(exePath, os.Args, os.Environ()) + + return nil +} + +func shutdownWebserver(server *http.Server) error { + if server != nil { + ctx, cancel := context.WithTimeout(context.Background(), 25*time.Second) + defer cancel() + err := server.Shutdown(ctx) + if err != nil { + return err + } + } + return nil +} + +func restartApplication(exePath string, args []string, env []string) error { + + cmd := exec.Command(exePath, args[1:]...) // Pass all arguments except the first one (which is the executable path) + cmd.Env = env + err := cmd.Start() // Start the new executable + if err != nil { + return err + } + + if runtime.GOOS == "windows" { + + var pid = os.Getpid() + var process, _ = os.FindProcess(pid) + + process.Kill() // Kill this instance of the application + process.Wait() + } else { + os.Exit(0) // Stop this instance of the application + } + return nil +} + +func copyFile(src, dst string) error { + sourceFile, err := os.Open(src) + if err != nil { + return err + } + defer sourceFile.Close() + + destinationFile, err := os.Create(dst) + if err != nil { + return err + } + defer destinationFile.Close() + + _, err = io.Copy(destinationFile, sourceFile) + return err +} + +func (c *ClientInfo) verifyChecksum(filePath string) error { + // Download the expected checksum + if c.SHA256DownloadURL == "" { + return fmt.Errorf("no URL for the checksum") + } + resp, err := http.Get(c.SHA256DownloadURL) + if err != nil { + return err + } + defer resp.Body.Close() + + var expectedChecksum string + if _, err := fmt.Fscan(resp.Body, &expectedChecksum); err != nil { + return err + } + + file, err := os.Open(filePath) + if err != nil { + return err + } + defer file.Close() + + hash := sha256.New() + if _, err := io.Copy(hash, file); err != nil { + return err + } + calculatedChecksum := hex.EncodeToString(hash.Sum(nil)) + + if calculatedChecksum != expectedChecksum { + return fmt.Errorf("checksum verification failed: expected %s, got %s", expectedChecksum, calculatedChecksum) + } + return nil +} \ No newline at end of file diff --git a/src/provider.go b/src/provider.go index 2e3bc0f..b567cc0 100644 --- a/src/provider.go +++ b/src/provider.go @@ -305,7 +305,16 @@ func downloadFileFromServer(providerURL string, proxyUrl string) (filename strin return } - httpClient := &http.Client{} + httpClient := &http.Client{ + Timeout: 30 * time.Second, + CheckRedirect: func(req *http.Request, via []*http.Request) error { + // Allow up to 10 redirects + if len(via) >= 10 { + return http.ErrUseLastResponse + } + return nil + }, + } if proxyUrl != "" { proxyURL, err := url.Parse(proxyUrl) @@ -320,15 +329,23 @@ func downloadFileFromServer(providerURL string, proxyUrl string) (filename strin } } - resp, err := httpClient.Get(providerURL) + // Create a Request to set headers + req, err := http.NewRequest("GET", providerURL, nil) + if err != nil { + return + } + + req.Header.Set("User-Agent", Settings.UserAgent) + req.Header.Set("Accept", "*/*") + req.Header.Set("Accept-Encoding", "gzip,deflate") + + resp, err := httpClient.Do(req) if err != nil { return } defer resp.Body.Close() - resp.Header.Set("User-Agent", Settings.UserAgent) - if resp.StatusCode != http.StatusOK { err = fmt.Errorf("%d: %s %s", resp.StatusCode, providerURL, http.StatusText(resp.StatusCode)) return diff --git a/src/serveStream.go b/src/serveStream.go deleted file mode 100644 index a3fbb35..0000000 --- a/src/serveStream.go +++ /dev/null @@ -1,723 +0,0 @@ -package src - -import ( - "context" - "fmt" - "io/fs" - "net/http" - "os" - "os/exec" - "path/filepath" - "sort" - "strconv" - "strings" - "syscall" - "time" - - "github.com/google/uuid" - "github.com/avfs/avfs" - "github.com/avfs/avfs/vfs/memfs" - "github.com/avfs/avfs/vfs/osfs" -) - -/* -NewStreamManager creates and returns a new StreamManager struct and will check permanently the errorChan of the struct -*/ -func NewStreamManager() *StreamManager { - sm := &StreamManager{ - Playlists: map[string]*Playlist{}, - errorChan: make(chan ErrorInfo), - stopChan: make(chan bool), - FileSystem: nil, - } - - // Start a go routine that will check for the error channel - go func() { - for { - select { - case errorInfo := <-sm.errorChan: - stream := errorInfo.Stream - if errorInfo.BufferClosed && !stream.DoAutoReconnect { - ShowError(errorInfo.Error, errorInfo.ErrorCode) - } else { - ShowDebug(errorInfo.Error.Error(), 3) - } - _, streamID := sm.GetPlaylistIDandStreamID(stream) - if errorInfo.ClientID != "" { - // Client specifc errors - errorInfo.Stream.RemoveClientFromStream(streamID, errorInfo.ClientID) - } else { - // Buffer disconnect error - clients := stream.Clients - if len(clients) > 0 && errorInfo.BufferClosed { - if stream.DoAutoReconnect && stream.Buffer.IsThirdPartyBuffer { - stream.Buffer.StartBuffer(stream) - } else { - stream.StopStream(streamID) - } - } - } - case <-sm.stopChan: - return - } - } - }() - return sm -} - -/* -StartStream starts the ffmpeg process for buffering a stream -It will check if the stream already exists -*/ -func (sm *StreamManager) StartStream(streamInfo StreamInfo, w http.ResponseWriter) (clientID string, playlistID string) { - sm.mu.Lock() - defer sm.mu.Unlock() - - // get the playlist ID from stream info - playlistID = streamInfo.PlaylistID - // generate new client ID - clientID = uuid.New().String() - // set URL ID as stream ID - streamID := streamInfo.URLid - - // check if playlist already exists - _, exists := sm.Playlists[playlistID] - if !exists { - // create a new one - playlist := &Playlist{ - Name: getProviderParameter(playlistID, GetPlaylistType(playlistID), "name"), - Streams: make(map[string]*Stream), - } - // add the playlist to the map - sm.Playlists[playlistID] = playlist - - // check if a new stream is possible - if IsNewStreamPossible(sm, streamInfo, w) { - // create a new buffer and add the stream to the map within the new playlist - sm.Playlists[playlistID].Streams[streamID] = CreateStream(streamInfo, sm.FileSystem, sm.errorChan) - if sm.Playlists[playlistID].Streams[streamID] == nil { - return "", "" - } - ShowInfo(fmt.Sprintf("Streaming:Started streaming for %s", streamID)) - } else { - return "", "" - } - } else { - // check if the stream already exists - stream, exists := sm.Playlists[playlistID].Streams[streamID] - if !exists { - // check if a new stream is possible - if IsNewStreamPossible(sm, streamInfo, w) { - // create a new buffer and add the stream to the map within the existing playlist - sm.Playlists[playlistID].Streams[streamID] = CreateStream(streamInfo, sm.FileSystem, sm.errorChan) - ShowInfo(fmt.Sprintf("Streaming:Started streaming for %s", streamID)) - } else { - return "", "" - } - } else { - // Here we can check if multiple clients for one stream is allowed! - ShowInfo(fmt.Sprintf("Streaming:Client joined %s, total: %d", streamID, len(stream.Clients)+1)) - } - } - return -} - -func InitBufferVFS(virtual bool) avfs.VFS { - if virtual { - return memfs.New() - } else { - return osfs.New() - } -} - -/* -CreateStream will create and return a new Stream struct, it will also start the new buffer. -*/ -func CreateStream(streamInfo StreamInfo, fileSystem avfs.VFS, errorChan chan ErrorInfo) *Stream { - ctx, cancel := context.WithCancel(context.Background()) - folder := System.Folder.Temp + streamInfo.PlaylistID + string(os.PathSeparator) + streamInfo.URLid - stream := &Stream{ - Name: streamInfo.Name, - Buffer: &Buffer{Config: &BufferConfig{}, FileSystem: fileSystem}, - ErrorChan: errorChan, - Ctx: ctx, - Cancel: cancel, - URL: streamInfo.URL, - BackupChannel1URL: streamInfo.BackupChannel1URL, - BackupChannel2URL: streamInfo.BackupChannel2URL, - BackupChannel3URL: streamInfo.BackupChannel3URL, - Folder: folder, - Clients: make(map[string]Client), - BackupNumber: 0, - UseBackup: false, - DoAutoReconnect: Settings.BufferAutoReconnect, - } - stream.Buffer.StartBuffer(stream) - if stream.Buffer == nil { - return nil - } - return stream -} - -/* -IsNewStreamPossible reports whether there is a new connection allowed -*/ -func IsNewStreamPossible(sm *StreamManager, streamInfo StreamInfo, w http.ResponseWriter) bool { - playlistID := streamInfo.PlaylistID - if len(sm.Playlists[playlistID].Streams) < GetTuner(playlistID, GetPlaylistType(playlistID)) { - return true - } else { - HandleStreamLimit(w) - return false - } -} - -/* -GetStreamLimitContent will check if there is already a custuom video that will be provided to client. - -Otherwise it will check if there has been uploaded a image that will be converted into an video. -Finally it will provide either the default content or the new content. -*/ -func GetStreamLimitContent() ([]byte, bool) { - var content []byte - var contentOk bool - imageFileList, err := os.ReadDir(System.Folder.Custom) - if err != nil { - ShowError(err, 0) - } - fileList, err := os.ReadDir(System.Folder.Video) - if err == nil { - createContent := ShouldCreateContent(fileList) - if createContent && len(imageFileList) > 0 { - err := CreateAlternativNoMoreStreamsVideo(System.Folder.Custom + imageFileList[0].Name()) - if err == nil { - contentOk = true - } else { - ShowError(err, 0) - return nil, false - } - content, err = os.ReadFile(System.Folder.Video + fileList[0].Name()) - if err != nil { - ShowError(err, 0) - } - contentOk = true - } - } - if !contentOk { - if value, ok := webUI["html/video/stream-limit.ts"]; ok && !contentOk { - contentOk = true - content = GetHTMLString(value.(string)) - } - } - return content, contentOk -} - -/* -HandleStreamLimit sends an info to the client that the stream limit has been reached. -The content that will provided to client will be fetched with GetStreamLimitContent() function -*/ -func HandleStreamLimit(w http.ResponseWriter) { - ShowInfo("Streaming Status: No new connections available. Tuner limit reached.") - content, contentOk := GetStreamLimitContent() - if contentOk { - w.Header().Set("Content-type", "video/mpeg") - w.WriteHeader(http.StatusOK) - for i := 0; i < 600; i++ { - if _, err := w.Write(content); err != nil { - ShowError(err, 0) - return - } - time.Sleep(100 * time.Millisecond) - } - } -} - -/* -ShouldCreateContent reports whether a new video file shall be created. -It removes existing files if necessary. -*/ -func ShouldCreateContent(fileList []fs.DirEntry) bool { - switch len(fileList) { - case 0: - return true - case 1: - return false - default: - for _, file := range fileList { - os.Remove(System.Folder.Video + file.Name()) - } - return true - } -} - -/* -GetTuner returns the maximum number of connections for a playlist. -It will check if the buffer type is matching the third party buffers -*/ -func GetTuner(id, playlistType string) (tuner int) { - switch Settings.Buffer { - case "-": - tuner = Settings.Tuner - - case "ffmpeg", "vlc", "threadfin": - i, err := strconv.Atoi(getProviderParameter(id, playlistType, "tuner")) - if err == nil { - tuner = i - } else { - ShowError(err, 0) - tuner = 1 - } - } - return -} - -/* -GetPlaylistType returns the type of the playlist based on the playlist ID -*/ -func GetPlaylistType(playlistID string) string { - switch playlistID[0:1] { - case "M": - return "m3u" - case "H": - return "hdhr" - default: - return "" - } -} - -/* -CreateAlternativNoMoreStreamsVideo generates a new video file based on the image provided as path to it. -It will use the third party tool defined in the settings and starts a process for generating the video file -*/ -func CreateAlternativNoMoreStreamsVideo(pathToFile string) error { - cmd := new(exec.Cmd) - path, arguments := prepareArguments(pathToFile) - if len(arguments) == 0 { - if _, err := os.Stat(Settings.FFmpegPath); err != nil { - return fmt.Errorf("ffmpeg path is not valid. Can not convert custom image to video") - } - } - - cmd = exec.Command(path, arguments...) - - if len(cmd.Args) > 0 && path != "" { - ShowInfo("Streaming Status:Creating video from uploaded image for a customized no more stream video") - err := cmd.Run() - if err != nil { - return err - } - ShowInfo("Streaming Status:Successfully created video from custom image") - return nil - } else { - return fmt.Errorf("path for third party tool ") - } -} - -// TODO: Add description -func prepareArguments(pathToFile string) (string, []string) { - switch Settings.Buffer { - case "ffmpeg", "threadfin", "-": - return Settings.FFmpegPath, []string{"--no-audio", "--loop", "--sout", fmt.Sprintf("'#transcode{vcodec=h264,vb=1024,scale=1,width=1920,height=1080,acodec=none,venc=x264{preset=ultrafast}}:standard{access=file,mux=ts,dst=%sstream-limit.ts}'", System.Folder.Video), System.Folder.Video, pathToFile} - case "vlc": - return Settings.VLCPath, []string{"-loop", "1", "-i", pathToFile, "-c:v", "libx264", "-t", "1", "-pix_fmt", "yuv420p", "-vf", "scale=1920:1080", fmt.Sprintf("%sstream-limit.ts", System.Folder.Video)} - default: - return "", []string{} - } -} - -/* -StopStream stops the third party tool process when there are no more clients receiving the stream -*/ -func (sm *StreamManager) StopStream(playlistID string, streamID string, clientID string) { - sm.mu.Lock() - defer sm.mu.Unlock() - - playlist, exists := sm.Playlists[playlistID] - if exists { - if stream, exists := playlist.Streams[streamID]; exists { - if client, exists := stream.Clients[clientID]; exists { - CloseClientConnection(client.w) - delete(stream.Clients, clientID) - ShowInfo(fmt.Sprintf("Streaming:Client left %s, total: %d", streamID, len(stream.Clients))) - if len(stream.Clients) == 0 { - stream.Cancel() // Tell everyone about the ending of the stream - if stream.Buffer.IsThirdPartyBuffer { - stream.Buffer.Cmd.Process.Signal(syscall.SIGKILL) // Kill the third party tool process - stream.Buffer.Cmd.Wait() - DeletPIDfromDisc(fmt.Sprintf("%d", stream.Buffer.Cmd.Process.Pid)) // Delete the PID since the process has been terminated - } else { - close(stream.Buffer.StopChan) - } - - ShowInfo(fmt.Sprintf("Streaming:Stopped streaming for %s", streamID)) - var debug = fmt.Sprintf("Streaming:Remove temporary files (%s)", stream.Folder) - ShowDebug(debug, 1) - - debug = fmt.Sprintf("Streaming:Remove tmp folder %s", stream.Folder) - ShowDebug(debug, 1) - - if err := sm.FileSystem.RemoveAll(stream.Folder); err != nil { - ShowError(err, 4005) - } - delete(sm.Playlists[playlistID].Streams, streamID) - } - } - } - if len(sm.Playlists[playlistID].Streams) == 0 { - delete(sm.Playlists, playlistID) - } - } -} - -func CloseClientConnection(w http.ResponseWriter) { - // Set the header - w.Header().Set("Connection", "close") - // Close the connection explicitly - if flusher, ok := w.(http.Flusher); ok { - flusher.Flush() - } - if hijacker, ok := w.(http.Hijacker); ok { - conn, _, err := hijacker.Hijack() - if err == nil { - conn.Close() - } - } -} - -func (sm *StreamManager) StopAllStreams() { - for _, playlist := range sm.Playlists { - for streamID, stream := range playlist.Streams { - stream.StopStream(streamID) - } - } -} - -/* -ServeStream will ensure that the clients is getting the stream requested -*/ -func (sm *StreamManager) ServeStream(streamInfo StreamInfo, w http.ResponseWriter, r *http.Request) { - - if sm.LockAgainstNewStreams { - return - } - - // Initialize buffer file system - if sm.FileSystem == nil { - sm.FileSystem = InitBufferVFS(Settings.StoreBufferInRAM) - } - - clientID, playlistID := sm.StartStream(streamInfo, w) - if clientID == "" || playlistID == "" { - if sm.Playlists[streamInfo.PlaylistID].Streams[streamInfo.URLid] == nil { - delete(sm.Playlists, streamInfo.PlaylistID) - } - return - } - defer sm.StopStream(playlistID, streamInfo.URLid, clientID) - - // Add a new client to the client map - client := &Client{ - r: r, - w: w, - } - stream := sm.Playlists[playlistID].Streams[streamInfo.URLid] - stream.Clients[clientID] = *client - - // If it was the first client start t - if len(stream.Clients) == 1 { - // Send Data to the clients, this should run only once per stream - go stream.SendData() - } - - // Wait for the client context to get closed - <-r.Context().Done() -} - -/* -GetPlaylistIDandStreamID retrieves the playlist ID and the stream ID from the given stream -*/ -func (sm *StreamManager) GetPlaylistIDandStreamID(stream *Stream) (string, string) { - for playlistID, playlist := range sm.Playlists { - for streamID, tmpStream := range playlist.Streams { - if tmpStream.Name == stream.Name { - return playlistID, streamID - } - } - } - ShowDebug("Streaming:Could not get playlist ID and stream ID", 3) - return "", "" -} - -/* -SendData sends Data to the clients connected to the stream -With errorChan it reports occuring errors to the StreamManager instance -*/ -func (s *Stream) SendData() { - var oldSegments []string - - for { - select { - case <- s.Ctx.Done(): - return - default: - tmpFiles := s.GetBufTmpFiles() - for _, f := range tmpFiles { - if ok, err := s.CheckBufferFolder(); !ok { - s.ReportError(err, BufferFolderError, "", true) - return - } - oldSegments = append(oldSegments, f) - ShowDebug(fmt.Sprintf("Streaming:Sending file %s to clients", f), 1) - s.SendFileToClients(f) - if s.GetBufferedSize() > Settings.BufferSize * 1024 { - s.DeleteOldestSegment(oldSegments[0]) - oldSegments = oldSegments[1:] - } - } - if len(tmpFiles) == 0 { - time.Sleep(5 * time.Millisecond) // This will ensure that streams will synchronize over the time - } - } - } -} - -func (s *Stream) GetBufferedSize() (size int) { - size = 0 - var tmpFolder = s.Folder + string(os.PathSeparator) - if _, err := s.Buffer.FileSystem.Stat(tmpFolder); !fsIsNotExistErr(err) { - - files, err := s.Buffer.FileSystem.ReadDir(getPlatformPath(tmpFolder)) - if err != nil { - ShowError(err, 000) - return - } - for _, file := range files { - if !file.IsDir() && filepath.Ext(file.Name()) == ".ts" { - file_info, err := s.Buffer.FileSystem.Stat(getPlatformFile(tmpFolder + file.Name())) - if err == nil { - size += int(file_info.Size()) - } - } - } - } - return size -} - -/* -GetBufTmpFiles retrieves the files within the buffer folder -and returns a sorted list with the file names -*/ -func (s *Stream) GetBufTmpFiles() (tmpFiles []string) { - - var tmpFolder = s.Folder + string(os.PathSeparator) - var fileIDs []float64 - - if _, err := s.Buffer.FileSystem.Stat(tmpFolder); !fsIsNotExistErr(err) { - - files, err := s.Buffer.FileSystem.ReadDir(getPlatformPath(tmpFolder)) - if err != nil { - ShowError(err, 000) - return - } - - // Check if more then one file is available - if len(files) > 1 { - // Iterate over the files and collect the IDs - for _, file := range files { - if !file.IsDir() && filepath.Ext(file.Name()) == ".ts" { - fileID := strings.TrimSuffix(file.Name(), ".ts") - if f, err := strconv.ParseFloat(fileID, 64); err == nil { - fileIDs = append(fileIDs, f) - } - } - } - - sort.Float64s(fileIDs) - if len(fileIDs) > 0 { - fileIDs = fileIDs[:len(fileIDs)-1] - } - - // Create the return array with the sorted files - for _, file := range fileIDs { - fileName := fmt.Sprintf("%.0f.ts", file) - // Check if the file is already within old segments array - if !ContainsString(s.OldSegments, fileName) { - tmpFiles = append(tmpFiles, fileName) - s.OldSegments = append(s.OldSegments, fileName) - } - } - } - } - return -} - -/* -DeleteOldesSegment will delete the file provided in the buffer -*/ -func (s *Stream) DeleteOldestSegment(oldSegment string) { - fileToRemove := s.Folder + string(os.PathSeparator) + oldSegment - if err := s.Buffer.FileSystem.RemoveAll(getPlatformFile(fileToRemove)); err != nil { - ShowError(err, 4007) - } -} - -/* -CheckBufferFolder reports whether the buffer folder exists. -*/ -func (s *Stream) CheckBufferFolder() (bool, error) { - if _, err := s.Buffer.FileSystem.Stat(s.Folder); fsIsNotExistErr(err) { - return false, err - } - return true, nil -} - -// CheckBufferedFile check for the existance of the given file (file path is needed) -func (s *Stream) CheckBufferedFile(file string) (bool, error) { - if _, err := s.Buffer.FileSystem.Stat(file); fsIsNotExistErr(err) { - return false, err - } - return true, nil -} - -/* -SendFileToClients reports whether sending the File to the clients was successful -It will also use the errorChan to report to the StreamManager if there is an error sending the file to a specifc client -*/ -func (s *Stream) SendFileToClients(fileName string) { - var filePath string = fmt.Sprint(s.Folder + string(os.PathSeparator) + fileName) - if ok, err := s.CheckBufferedFile(filePath); !ok { - s.ReportError(err, 4019, "", false) - return - } - file, err := s.Buffer.FileSystem.Open(filePath) - if err != nil { - s.ReportError(err, OpenFileError, "", false) - return - } - defer file.Close() - l, err := file.Stat() - if err != nil { - s.ReportError(err, FileStatError, "", false) - return - } - buffer := make([]byte, l.Size()) - if _, err := file.Read(buffer); err != nil { - s.ReportError(err, ReadFileError, "", false) - return - } - for clientID, client := range s.Clients { - ShowDebug(fmt.Sprintf("Streaming:Sending file %s to client %s", fileName, clientID), 3) - if _, err := client.w.Write(buffer); err != nil { - s.ReportError(fmt.Errorf("Streaming:Error when trying to send file to client %s", clientID), SendFileError, clientID, false) - } - } -} - -func (s *Stream) ReportError(err error, errCode int, clientID string, closed bool) { - s.ErrorChan <- ErrorInfo{err, errCode, s, clientID, closed} -} - -func (s *Stream) StopStream(streamID string) { - for clientID, client := range s.Clients { - CloseClientConnection(client.w) - delete(s.Clients, clientID) - ShowInfo(fmt.Sprintf("Streaming:Client kicked %s, total: %d", streamID, len(s.Clients))) - if len(s.Clients) == 0 { - s.Cancel() // Tell everyone about the ending of the stream - if s.Buffer.IsThirdPartyBuffer { - s.Buffer.Cmd.Process.Signal(syscall.SIGKILL) // Kill the third party tool process - s.Buffer.Cmd.Wait() - DeletPIDfromDisc(fmt.Sprintf("%d", s.Buffer.Cmd.Process.Pid)) // Delete the PID since the process has been terminated - } else { - close(s.Buffer.StopChan) - } - } - } -} - -func (s *Stream) RemoveClientFromStream(streamID, clientID string) { - if client, exists := s.Clients[clientID]; exists { - CloseClientConnection(client.w) - delete(s.Clients, clientID) - ShowInfo(fmt.Sprintf("Streaming:Removed client from %s, total: %d", streamID, len(s.Clients))) - } -} - -/* -UpdateStreamURLForBackup will set the ther stream url when a backup will be used -*/ -func (s *Stream) UpdateStreamURLForBackup() { - switch s.BackupNumber { - case 1: - s.URL = s.BackupChannel1URL - ShowHighlight("START OF BACKUP 1 STREAM") - ShowInfo("Backup Channel 1 URL: " + s.URL) - case 2: - s.URL = s.BackupChannel2URL - ShowHighlight("START OF BACKUP 2 STREAM") - ShowInfo("Backup Channel 2 URL: " + s.URL) - case 3: - s.URL = s.BackupChannel3URL - ShowHighlight("START OF BACKUP 3 STREAM") - ShowInfo("Backup Channel 3 URL: " + s.URL) - } -} - -/* -HandleBufferError will retry running the Buffer function with the next backup number -*/ -func (s *Stream) handleBufferError(err error) { - ShowError(err, 4011) - if !s.UseBackup || (s.UseBackup && s.BackupNumber >= 0 && s.BackupNumber <= 3) { - s.BackupNumber++ - if s.BackupChannel1URL != "" || s.BackupChannel2URL != "" || s.BackupChannel3URL != "" { - s.UseBackup = true - s.UpdateStreamURLForBackup() - s.Buffer.StartBuffer(s) - } - } -} - -/* -GetCurrentlyUsedChannels will extract and fill the data into the response struct about the currently active playlists and channels -*/ -func GetCurrentlyUsedChannels(sm *StreamManager, response *APIResponseStruct) error { - // should be nil but its always better to check - if response.ActiveStreams == nil { - response.ActiveStreams = &ActiveStreamsStruct{ - Playlists: make(map[string]*PlaylistStruct), - } - } else if response.ActiveStreams.Playlists == nil { - response.ActiveStreams.Playlists = make(map[string]*PlaylistStruct) - } - // iterate over the playlists within the StreamManager and extract the data - for playlistID, playlist := range sm.Playlists { - // create a new ActiveStreams struct if it doesn't exist right now - if response.ActiveStreams == nil { - response.ActiveStreams = &ActiveStreamsStruct{ - Playlists: make(map[string]*PlaylistStruct), - } - } - // for every Playlist found Create a new Playlist struct and add it to the map - response.ActiveStreams.Playlists[playlistID] = CreatePlaylistStruct(playlist.Name, sm.Playlists[playlistID].Streams) - } - return nil -} - -/* -CreatePlaylistSruct will extract the info from the given Stream struct -*/ -func CreatePlaylistStruct(name string, streams map[string]*Stream) *PlaylistStruct { - var playlist = &PlaylistStruct{ - PlaylistName: name, - ActiveChannels: &[]string{}, - ClientConnections: 0, - } - - // Iterate over every stream within the map - for _, stream := range streams { - *playlist.ActiveChannels = append(*playlist.ActiveChannels, stream.Name) - playlist.ClientConnections += len(stream.Clients) - } - return playlist -} diff --git a/src/stream.go b/src/stream.go new file mode 100644 index 0000000..d8cc08e --- /dev/null +++ b/src/stream.go @@ -0,0 +1,260 @@ +package src + +import ( + "bytes" + "context" + "fmt" + "io" + "net/http" + "os" + "sync" + "time" + + "github.com/avfs/avfs" +) + +// Stream repräsentiert einen einzelnen Stream +type Stream struct { + mu sync.Mutex + Name string + Clients map[string]*Client + Buffer BufferInterface + ErrorChan chan ErrorInfo + Ctx context.Context + Cancel context.CancelFunc + + Folder string + URL string + BackupChannel1URL string + BackupChannel2URL string + BackupChannel3URL string + UseBackup bool + BackupNumber int + DoAutoReconnect bool + + StopTimer *time.Timer + TimerCancel context.CancelFunc +} + +type Client struct { + w http.ResponseWriter + r *http.Request + buffer *bytes.Buffer + flushChannel chan struct{} + doneChannel chan struct{} +} + +type ErrorInfo struct { + Error error + ErrorCode int + Stream *Stream + ClientID string + BufferClosed bool +} + +/* +CreateStream will create and return a new Stream struct, it will also start the new buffer. +*/ +func CreateStream(streamInfo *StreamInfo, fileSystem avfs.VFS, errorChan chan ErrorInfo) *Stream { + ctx, cancel := context.WithCancel(context.Background()) + folder := System.Folder.Temp + streamInfo.PlaylistID + string(os.PathSeparator) + streamInfo.URLid + pipeReader, pipeWriter := io.Pipe() + streamBuffer := StreamBuffer{ + FileSystem: fileSystem, + PipeWriter: pipeWriter, + PipeReader: pipeReader, + StopChan: make(chan struct{}), + CloseChan: make(chan struct{}), + } + var buffer BufferInterface + switch Settings.Buffer { + case "vlc", "ffmpeg": + buffer = &ThirdPartyBuffer{ + StreamBuffer: streamBuffer, + } + case "threadfin": + buffer = &ThreadfinBuffer{ + StreamBuffer: streamBuffer, + } + default: + cancel() + return nil + } + + stream := &Stream{ + Name: streamInfo.Name, + Buffer: buffer, + ErrorChan: errorChan, + Ctx: ctx, + Cancel: cancel, + URL: streamInfo.URL, + BackupChannel1URL: streamInfo.BackupChannel1URL, + BackupChannel2URL: streamInfo.BackupChannel2URL, + BackupChannel3URL: streamInfo.BackupChannel3URL, + Folder: folder, + Clients: make(map[string]*Client), + BackupNumber: 0, + UseBackup: false, + DoAutoReconnect: Settings.BufferAutoReconnect, + } + if err := buffer.StartBuffer(stream); err != nil { + return nil + } + go buffer.addBufferedFilesToPipe() + return stream +} + +func CreateTunerLimitReachedStream() *Stream { + ctx, cancel := context.WithCancel(context.Background()) + // Create a minimal Stream object + pipeReader, pipeWriter := io.Pipe() + streamBuffer := &StreamBuffer{ + PipeWriter: pipeWriter, + PipeReader: pipeReader, + StopChan: make(chan struct{}), + CloseChan: make(chan struct{}), + } + var buffer BufferInterface = streamBuffer + stream := &Stream{ + Clients: make(map[string]*Client), + Buffer: buffer, + Name: "Tuner limit reached", + Ctx: ctx, + Cancel: cancel, + DoAutoReconnect: false, + Folder: "", + } + streamBuffer.Stream = stream + + return stream +} + +func CloseClientConnection(w http.ResponseWriter) { + // Set the header + w.Header().Set("Connection", "close") + // Close the connection explicitly + if flusher, ok := w.(http.Flusher); ok { + flusher.Flush() + } + if hijacker, ok := w.(http.Hijacker); ok { + conn, _, err := hijacker.Hijack() + if err == nil { + conn.Close() + } + } +} + +func (s *Stream) Broadcast() { + buffer := make([]byte, 4096) + var stopChan chan struct{} = s.Buffer.GetStopChan() + var pipeReader *io.PipeReader = s.Buffer.GetPipeReader() + for { + select { + case <- stopChan: + // Pipe was closed stop reading from it! + return + default: + n, err := pipeReader.Read(buffer) + if err != nil { + if err != io.EOF { + fmt.Printf("Streaming:Error when reading from pipe: %v\n", err) + } + break + } + + s.mu.Lock() + for clientID, client := range s.Clients { + client.buffer.Write(buffer[:n]) + select { + case client.flushChannel <- struct{}{}: + <-client.doneChannel + default: + // Skip sending if the channel is full + ShowDebug(fmt.Sprintf("Skipped sending data to client: %s", clientID), 3) + } + } + s.mu.Unlock() + } + } +} + +func (s *Stream) handleClientWrites(client *Client) { + for { + select { + case <-client.flushChannel: + client.buffer.WriteTo(client.w) + if flusher, ok := client.w.(http.Flusher); ok { + flusher.Flush() + } + client.doneChannel <- struct{}{} + case <-client.r.Context().Done(): + return + } + } +} + +func (s *Stream) ReportError(err error, errCode int, clientID string, closed bool) { + s.ErrorChan <- ErrorInfo{err, errCode, s, clientID, closed} +} + +func (s *Stream) StopStream(streamID string) { + var pipeWriter *io.PipeWriter + switch buffer := s.Buffer.(type) { + case *ThirdPartyBuffer: + pipeWriter = buffer.PipeWriter + } + pipeWriter.Close() + for clientID, client := range s.Clients { + CloseClientConnection(client.w) + delete(s.Clients, clientID) + ShowInfo(fmt.Sprintf("Streaming:Client kicked %s, total: %d", streamID, len(s.Clients))) + if len(s.Clients) == 0 { + s.Cancel() // Tell everyone about the ending of the stream + s.Buffer.CloseBuffer() + } + } +} + +func (s *Stream) RemoveClientFromStream(streamID, clientID string) { + s.Buffer.(*StreamBuffer).PipeWriter.Close() + if client, exists := s.Clients[clientID]; exists { + CloseClientConnection(client.w) + delete(s.Clients, clientID) + ShowInfo(fmt.Sprintf("Streaming:Removed client from %s, total: %d", streamID, len(s.Clients))) + } +} + +/* +UpdateStreamURLForBackup will set the ther stream url when a backup will be used +*/ +func (s *Stream) UpdateStreamURLForBackup() { + switch s.BackupNumber { + case 1: + s.URL = s.BackupChannel1URL + ShowHighlight("START OF BACKUP 1 STREAM") + ShowInfo("Backup Channel 1 URL: " + s.URL) + case 2: + s.URL = s.BackupChannel2URL + ShowHighlight("START OF BACKUP 2 STREAM") + ShowInfo("Backup Channel 2 URL: " + s.URL) + case 3: + s.URL = s.BackupChannel3URL + ShowHighlight("START OF BACKUP 3 STREAM") + ShowInfo("Backup Channel 3 URL: " + s.URL) + } +} + +/* +HandleBufferError will retry running the Buffer function with the next backup number +*/ +func (s *Stream) handleBufferError(err error) { + ShowError(err, 4011) + if !s.UseBackup || (s.UseBackup && s.BackupNumber >= 0 && s.BackupNumber <= 3) { + s.BackupNumber++ + if s.BackupChannel1URL != "" || s.BackupChannel2URL != "" || s.BackupChannel3URL != "" { + s.UseBackup = true + s.UpdateStreamURLForBackup() + s.Buffer.StartBuffer(s) + } + } +} diff --git a/src/streamManager.go b/src/streamManager.go new file mode 100644 index 0000000..3924f07 --- /dev/null +++ b/src/streamManager.go @@ -0,0 +1,490 @@ +package src + +import ( + "bytes" + "fmt" + "io/fs" + "net/http" + "os" + "os/exec" + "strconv" + "sync" + "time" + + "github.com/avfs/avfs" + "github.com/avfs/avfs/vfs/memfs" + "github.com/avfs/avfs/vfs/osfs" + "github.com/google/uuid" +) + +// StreamManager verwaltet die Streams und ffmpeg-Prozesse +type StreamManager struct { + Playlists map[string]*Playlist + errorChan chan ErrorInfo + stopChan chan bool + LockAgainstNewStreams bool + FileSystem avfs.VFS + mu sync.Mutex +} + +type Playlist struct { + Name string + Streams map[string]*Stream +} + +/* +NewStreamManager creates and returns a new StreamManager struct and will check permanently the errorChan of the struct +*/ +func NewStreamManager() *StreamManager { + sm := &StreamManager{ + Playlists: map[string]*Playlist{}, + errorChan: make(chan ErrorInfo), + stopChan: make(chan bool), + FileSystem: nil, + } + + // Start a go routine that will check for the error channel + go func() { + for { + select { + case errorInfo := <-sm.errorChan: + stream := errorInfo.Stream + if errorInfo.BufferClosed && !stream.DoAutoReconnect { + ShowError(errorInfo.Error, errorInfo.ErrorCode) + } else { + ShowDebug(errorInfo.Error.Error(), 3) + } + _, streamID := sm.GetPlaylistIDandStreamID(stream) + if errorInfo.ClientID != "" { + // Client specifc errors + errorInfo.Stream.RemoveClientFromStream(streamID, errorInfo.ClientID) + } else { + // Buffer disconnect error + clients := stream.Clients + if len(clients) > 0 && errorInfo.BufferClosed { + if stream.DoAutoReconnect{ + if buffer, ok := stream.Buffer.(*ThirdPartyBuffer); ok { + buffer.StartBuffer(stream) + continue + } + } + stream.StopStream(streamID) + } + } + case <-sm.stopChan: + return + } + } + }() + return sm +} + +/* +StartStream starts the ffmpeg process for buffering a stream +It will check if the stream already exists +*/ +func (sm *StreamManager) StartStream(streamInfo *StreamInfo) (clientID string, playlistID string) { + sm.mu.Lock() + defer sm.mu.Unlock() + + // get the playlist ID from stream info + playlistID = streamInfo.PlaylistID + // generate new client ID + clientID = uuid.New().String() + // set URL ID as stream ID + streamID := streamInfo.URLid + + // check if playlist already exists + _, exists := sm.Playlists[playlistID] + if !exists { + // create a new one + playlist := &Playlist{ + Name: getProviderParameter(playlistID, GetPlaylistType(playlistID), "name"), + Streams: make(map[string]*Stream), + } + // add the playlist to the map + sm.Playlists[playlistID] = playlist + + // check if a new stream is possible + if sm.IsNewStreamPossible(streamInfo) { + // create a new buffer and add the stream to the map within the new playlist + sm.Playlists[playlistID].Streams[streamID] = CreateStream(streamInfo, sm.FileSystem, sm.errorChan) + if sm.Playlists[playlistID].Streams[streamID] == nil { + return "", "" + } + ShowInfo(fmt.Sprintf("Streaming:Started streaming for %s", streamID)) + } else { + streamInfo.URLid = "TunerLimitReached" + if _, exists := sm.Playlists[playlistID].Streams["TunerLimitReached"]; !exists { + stream := CreateTunerLimitReachedStream() + sm.Playlists[playlistID].Streams["TunerLimitReached"] = stream + HandleStreamLimit(stream) + } + } + } else { + // check if the stream already exists + stream, exists := sm.Playlists[playlistID].Streams[streamID] + if !exists { + // check if a new stream is possible + if sm.IsNewStreamPossible(streamInfo) { + // create a new buffer and add the stream to the map within the existing playlist + sm.Playlists[playlistID].Streams[streamID] = CreateStream(streamInfo, sm.FileSystem, sm.errorChan) + ShowInfo(fmt.Sprintf("Streaming:Started streaming for %s", streamID)) + } else { + streamInfo.URLid = "TunerLimitReached" + if _, exists := sm.Playlists[playlistID].Streams["TunerLimitReached"]; !exists { + stream := CreateTunerLimitReachedStream() + sm.Playlists[playlistID].Streams["TunerLimitReached"] = stream + HandleStreamLimit(stream) + } + } + } else { + if len(stream.Clients) == 0 { + if stream.StopTimer != nil { + stream.StopTimer.Stop() + stream.StopTimer = nil + stream.TimerCancel = nil + } + stream.Buffer.SetStopChan(make(chan struct{})) + go stream.Buffer.addBufferedFilesToPipe() + } + // Here we can check if multiple clients for one stream is allowed! + ShowInfo(fmt.Sprintf("Streaming:Client joined %s, total: %d", streamID, len(stream.Clients)+1)) + } + } + return +} + +func InitBufferVFS(virtual bool) avfs.VFS { + if virtual { + return memfs.New() + } else { + return osfs.New() + } +} + +/* +IsNewStreamPossible reports whether there is a new connection allowed +*/ +func (sm *StreamManager) IsNewStreamPossible(streamInfo *StreamInfo) bool { + playlistID := streamInfo.PlaylistID + if len(sm.Playlists[playlistID].Streams) < GetTuner(playlistID, GetPlaylistType(playlistID)) { + return true + } else { + return false + } +} + +/* +StopStream stops the third party tool process when there are no more clients receiving the stream +*/ +func (sm *StreamManager) StopStream(playlistID string, streamID string, clientID string) { + sm.mu.Lock() + defer sm.mu.Unlock() + + playlist, exists := sm.Playlists[playlistID] + if exists { + if stream, exists := playlist.Streams[streamID]; exists { + if client, exists := stream.Clients[clientID]; exists { + CloseClientConnection(client.w) + delete(stream.Clients, clientID) + ShowInfo(fmt.Sprintf("Streaming:Client left %s, total: %d", streamID, len(stream.Clients))) + if len(stream.Clients) == 0 { + stream.Buffer.StopBuffer() + // Start a timer to stop the stream after a delay + cancel := func() { + sm.mu.Lock() + defer sm.mu.Unlock() + stream.Cancel() // Tell everyone about the ending of the stream + stream.Buffer.CloseBuffer() + + ShowInfo(fmt.Sprintf("Streaming:Stopped streaming for %s", streamID)) + var debug = fmt.Sprintf("Streaming:Remove temporary files (%s)", stream.Folder) + ShowDebug(debug, 1) + + debug = fmt.Sprintf("Streaming:Remove tmp folder %s", stream.Folder) + ShowDebug(debug, 1) + + if err := sm.FileSystem.RemoveAll(stream.Folder); err != nil { + ShowError(err, 4005) + } + delete(sm.Playlists[playlistID].Streams, streamID) + if len(sm.Playlists[playlistID].Streams) == 0 { + delete(sm.Playlists, playlistID) + } + } + stream.TimerCancel = cancel + stream.StopTimer = time.AfterFunc(time.Duration(Settings.BufferTerminationTimeout) * time.Second, cancel) + } + } + } + } +} + +func (sm *StreamManager) StopAllStreams() { + for _, playlist := range sm.Playlists { + for streamID, stream := range playlist.Streams { + stream.StopStream(streamID) + } + } +} + +/* +ServeStream will ensure that the clients is getting the stream requested +*/ +func (sm *StreamManager) ServeStream(streamInfo StreamInfo, w http.ResponseWriter, r *http.Request) { + + if sm.LockAgainstNewStreams { + return + } + + // Initialize buffer file system + if sm.FileSystem == nil { + sm.FileSystem = InitBufferVFS(Settings.StoreBufferInRAM) + } + + clientID, playlistID := sm.StartStream(&streamInfo) + if clientID == "" || playlistID == "" { + return + } + defer sm.StopStream(playlistID, streamInfo.URLid, clientID) + + // Add a new client to the client map + client := &Client{ + r: r, + w: w, + buffer: new(bytes.Buffer), + flushChannel: make(chan struct{}, 1), + doneChannel: make(chan struct{}, 1), + } + stream := sm.Playlists[playlistID].Streams[streamInfo.URLid] + stream.Clients[clientID] = client + + // Start a goroutine to handle writing to the client + go stream.handleClientWrites(client) + + // Make sure Broadcast is running only once + if len(stream.Clients) == 1 { + w.WriteHeader(http.StatusOK) + w.Header().Set("Content-type", "video/mpeg2ts") + go stream.Broadcast() + } + + // Wait for the client context to get closed + <-r.Context().Done() +} + +/* +GetPlaylistIDandStreamID retrieves the playlist ID and the stream ID from the given stream +*/ +func (sm *StreamManager) GetPlaylistIDandStreamID(stream *Stream) (string, string) { + for playlistID, playlist := range sm.Playlists { + for streamID, tmpStream := range playlist.Streams { + if tmpStream.Name == stream.Name { + return playlistID, streamID + } + } + } + ShowDebug("Streaming:Could not get playlist ID and stream ID", 3) + return "", "" +} + +/* +GetCurrentlyUsedChannels will extract and fill the data into the response struct about the currently active playlists and channels +*/ +func GetCurrentlyUsedChannels(sm *StreamManager, response *APIResponseStruct) error { + // should be nil but its always better to check + if response.ActiveStreams == nil { + response.ActiveStreams = &ActiveStreamsStruct{ + Playlists: make(map[string]*PlaylistStruct), + } + } else if response.ActiveStreams.Playlists == nil { + response.ActiveStreams.Playlists = make(map[string]*PlaylistStruct) + } + // iterate over the playlists within the StreamManager and extract the data + for playlistID, playlist := range sm.Playlists { + // create a new ActiveStreams struct if it doesn't exist right now + if response.ActiveStreams == nil { + response.ActiveStreams = &ActiveStreamsStruct{ + Playlists: make(map[string]*PlaylistStruct), + } + } + // for every Playlist found Create a new Playlist struct and add it to the map + response.ActiveStreams.Playlists[playlistID] = CreatePlaylistStruct(playlist.Name, sm.Playlists[playlistID].Streams) + } + return nil +} + +/* +CreatePlaylistSruct will extract the info from the given Stream struct +*/ +func CreatePlaylistStruct(name string, streams map[string]*Stream) *PlaylistStruct { + var playlist = &PlaylistStruct{ + PlaylistName: name, + ActiveChannels: &[]string{}, + ClientConnections: 0, + } + + // Iterate over every stream within the map + for _, stream := range streams { + *playlist.ActiveChannels = append(*playlist.ActiveChannels, stream.Name) + playlist.ClientConnections += len(stream.Clients) + } + return playlist +} + +/* +GetStreamLimitContent will check if there is already a custuom video that will be provided to client. + +Otherwise it will check if there has been uploaded a image that will be converted into an video. +Finally it will provide either the default content or the new content. +*/ +func GetStreamLimitContent() ([]byte, bool) { + var content []byte + var contentOk bool + imageFileList, err := os.ReadDir(System.Folder.Custom) + if err != nil { + ShowError(err, 0) + } + fileList, err := os.ReadDir(System.Folder.Video) + if err == nil { + createContent := ShouldCreateContent(fileList) + if createContent && len(imageFileList) > 0 { + err := CreateAlternativNoMoreStreamsVideo(System.Folder.Custom + imageFileList[0].Name()) + if err != nil { + ShowError(err, 0) + } + } + content, err = os.ReadFile(System.Folder.Video + fileList[0].Name()) + if err != nil { + ShowError(err, 0) + } else { + contentOk = true + } + } + if !contentOk { + if value, ok := webUI["web/public/video/stream-limit.ts"]; ok && !contentOk { + contentOk = true + content = GetHTMLString(value.(string)) + } + } + return content, contentOk +} + +/* +HandleStreamLimit sends an info to the client that the stream limit has been reached. +The content that will provided to client will be fetched with GetStreamLimitContent() function +*/ +func HandleStreamLimit(stream *Stream) { + ShowInfo("Streaming Status:No new connections available. Tuner limit reached.") + ShowInfo("Streaming limit reached content instead") + content, contentOk := GetStreamLimitContent() + var stopChannel = stream.Buffer.GetStopChan() + if contentOk { + // Write content to the pipe in a loop + go func() { + for { + select { + case <- stopChannel: + return + default: + stream.Buffer.writeBytesToPipe(content) + time.Sleep(750 * time.Millisecond) + } + } + }() + } +} + +/* +ShouldCreateContent reports whether a new video file shall be created. +It removes existing files if necessary. +*/ +func ShouldCreateContent(fileList []fs.DirEntry) bool { + switch len(fileList) { + case 0: + return true + case 1: + return false + default: + for _, file := range fileList { + os.Remove(System.Folder.Video + file.Name()) + } + return true + } +} + +/* +GetTuner returns the maximum number of connections for a playlist. +It will check if the buffer type is matching the third party buffers +*/ +func GetTuner(id, playlistType string) (tuner int) { + switch Settings.Buffer { + case "-": + tuner = Settings.Tuner + + case "ffmpeg", "vlc", "threadfin": + i, err := strconv.Atoi(getProviderParameter(id, playlistType, "tuner")) + if err == nil { + tuner = i + } else { + ShowError(err, 0) + tuner = 1 + } + } + return +} + +/* +GetPlaylistType returns the type of the playlist based on the playlist ID +*/ +func GetPlaylistType(playlistID string) string { + switch playlistID[0:1] { + case "M": + return "m3u" + case "H": + return "hdhr" + default: + return "" + } +} + +/* +CreateAlternativNoMoreStreamsVideo generates a new video file based on the image provided as path to it. +It will use the third party tool defined in the settings and starts a process for generating the video file +*/ +func CreateAlternativNoMoreStreamsVideo(pathToFile string) error { + cmd := new(exec.Cmd) + path, arguments := prepareArguments(pathToFile) + if len(arguments) == 0 { + if _, err := os.Stat(Settings.FFmpegPath); err != nil { + return fmt.Errorf("ffmpeg path is not valid. Can not convert custom image to video") + } + } + + cmd = exec.Command(path, arguments...) + + if len(cmd.Args) > 0 && path != "" { + ShowInfo("Streaming Status:Creating video from uploaded image for a customized no more stream video") + err := cmd.Run() + if err != nil { + return err + } + ShowInfo("Streaming Status:Successfully created video from custom image") + return nil + } else { + return fmt.Errorf("path for third party tool ") + } +} + +// TODO: Add description +func prepareArguments(pathToFile string) (string, []string) { + switch Settings.Buffer { + case "ffmpeg", "threadfin", "-": + return Settings.FFmpegPath, []string{"-loop", "1", "-i", pathToFile, "-c:v", "libx264", "-t", "1", "-pix_fmt", "yuv420p", "-vf", "scale=1920:1080", fmt.Sprintf("%sstream-limit.ts", System.Folder.Video)} + case "vlc": + return Settings.VLCPath, []string{"--no-audio", "--loop", "--sout", fmt.Sprintf("'#transcode{vcodec=h264,vb=1024,scale=1,width=1920,height=1080,acodec=none,venc=x264{preset=ultrafast}}:standard{access=file,mux=ts,dst=%sstream-limit.ts}'", System.Folder.Video), System.Folder.Video, pathToFile} + default: + return "", []string{} + } +} diff --git a/src/struct-buffer.go b/src/struct-buffer.go deleted file mode 100644 index a0b5ce0..0000000 --- a/src/struct-buffer.go +++ /dev/null @@ -1,87 +0,0 @@ -package src - -import ( - "context" - "net/http" - "os/exec" - "sync" - - "github.com/avfs/avfs" -) - -// StreamManager verwaltet die Streams und ffmpeg-Prozesse -type StreamManager struct { - Playlists map[string]*Playlist - errorChan chan ErrorInfo - stopChan chan bool - LockAgainstNewStreams bool - FileSystem avfs.VFS - mu sync.Mutex -} - -type Playlist struct { - Name string - Streams map[string]*Stream -} - -// Stream repräsentiert einen einzelnen Stream -type Stream struct { - Name string - Clients map[string]Client - Buffer *Buffer - ErrorChan chan ErrorInfo - Ctx context.Context - Cancel context.CancelFunc - - Folder string - LatestSegment int - OldSegments []string - URL string - BackupChannel1URL string - BackupChannel2URL string - BackupChannel3URL string - UseBackup bool - BackupNumber int - DoAutoReconnect bool -} - -type Buffer struct { - FileSystem avfs.VFS - IsThirdPartyBuffer bool - Cmd *exec.Cmd - Config *BufferConfig - Stream *Stream // Reference to the parents struct - StopChan chan struct{} -} - -type BufferConfig struct { - BufferType string - Path string - Options string -} - -type Client struct { - w http.ResponseWriter - r *http.Request -} - -type ErrorInfo struct { - Error error - ErrorCode int - Stream *Stream - ClientID string - BufferClosed bool -} - -const ( - BufferFolderError = 4008 - SendFileError = 4009 - CreateFileError = 4010 - EndOfFileError = 4011 - ReadIntoBufferError = 4012 - WriteToBufferError = 4013 - OpenFileError = 4014 //errMsg = "Not able to open buffered file" - FileStatError = 4015 //errMsg = "Could not get file statics of buffered file" - ReadFileError = 4016 //errMsg = "Could not read buffered file before sending to clients" - FileDoesNotExistError = 4019 //errMsg = "Buffered file does not exist anymore" -) diff --git a/src/struct-system.go b/src/struct-system.go index 003e9ce..0d591c6 100644 --- a/src/struct-system.go +++ b/src/struct-system.go @@ -95,11 +95,7 @@ type SystemStruct struct { TagName string } - Update struct { - Git string - Name string - Github string - } + Update Update URLBase string UDPxy string @@ -109,22 +105,19 @@ type SystemStruct struct { } } +type Update struct { + Git string + Name string + Github string +} + // GitStruct : Updateinformationen von GitHub type GitStruct struct { Filename string `json:"filename"` Version string `json:"version"` } -type GithubReleaseInfo struct { - TagName string `json:"tag_name"` - Prerelease bool `json:"prerelease"` - Assets []AssetsStruct `json:"assets"` -} -type AssetsStruct struct { - DownloadUrl string `json:"browser_download_url"` - UpdatetAt string `json:"updated_at"` -} // DataStruct : Alle Daten werden hier abgelegt. (Lineup, XMLTV) type DataStruct struct { @@ -278,28 +271,29 @@ type Notification struct { // SettingsStruct : Inhalt der settings.json type SettingsStruct struct { - API bool `json:"api"` - AuthenticationAPI bool `json:"authentication.api"` - AuthenticationM3U bool `json:"authentication.m3u"` - AuthenticationPMS bool `json:"authentication.pms"` - AuthenticationWEB bool `json:"authentication.web"` - AuthenticationXML bool `json:"authentication.xml"` - BackupKeep int `json:"backup.keep"` - BackupPath string `json:"backup.path"` - Branch string `json:"git.branch,omitempty"` - Buffer string `json:"buffer"` - BufferSize int `json:"buffer.size.kb"` - BufferTimeout float64 `json:"buffer.timeout"` - BufferAutoReconnect bool `json:"buffer.autoReconnect"` - CacheImages bool `json:"cache.images"` - ChangeVersion bool `json:"changeVersion"` - EpgSource string `json:"epgSource"` - FFmpegOptions string `json:"ffmpeg.options"` - FFmpegPath string `json:"ffmpeg.path"` - VLCOptions string `json:"vlc.options"` - VLCPath string `json:"vlc.path"` - FileM3U []string `json:"file,omitempty"` // Beim Wizard wird die M3U in ein Slice gespeichert - FileXMLTV []string `json:"xmltv,omitempty"` // Altes Speichersystem der Provider XML Datei Slice (Wird für die Umwandlung auf das neue benötigt) + API bool `json:"api"` + AuthenticationAPI bool `json:"authentication.api"` + AuthenticationM3U bool `json:"authentication.m3u"` + AuthenticationPMS bool `json:"authentication.pms"` + AuthenticationWEB bool `json:"authentication.web"` + AuthenticationXML bool `json:"authentication.xml"` + BackupKeep int `json:"backup.keep"` + BackupPath string `json:"backup.path"` + Branch string `json:"git.branch,omitempty"` + Buffer string `json:"buffer"` + BufferSize int `json:"buffer.size.kb"` + BufferTimeout float64 `json:"buffer.timeout"` + BufferAutoReconnect bool `json:"buffer.autoReconnect"` + BufferTerminationTimeout int `json:"buffer.terminationTimeout"` + CacheImages bool `json:"cache.images"` + ChangeVersion bool `json:"changeVersion"` + EpgSource string `json:"epgSource"` + FFmpegOptions string `json:"ffmpeg.options"` + FFmpegPath string `json:"ffmpeg.path"` + VLCOptions string `json:"vlc.options"` + VLCPath string `json:"vlc.path"` + FileM3U []string `json:"file,omitempty"` // Beim Wizard wird die M3U in ein Slice gespeichert + FileXMLTV []string `json:"xmltv,omitempty"` // Altes Speichersystem der Provider XML Datei Slice (Wird für die Umwandlung auf das neue benötigt) Files struct { HDHR map[string]interface{} `json:"hdhr"` diff --git a/src/struct-webserver.go b/src/struct-webserver.go index 7c11af8..306f7c3 100644 --- a/src/struct-webserver.go +++ b/src/struct-webserver.go @@ -36,6 +36,7 @@ type RequestStruct struct { Buffer *string `json:"buffer,omitempty"` BufferSize *int `json:"buffer.size.kb,omitempty"` BufferTimeout *float64 `json:"buffer.timeout,omitempty"` + BufferTerminationTimeout *int `json:"buffer.terminationTimeout,omitempty"` BufferAutoReconnect *bool `json:"buffer.autoReconnect,omitempty"` CacheImages *bool `json:"cache.images,omitempty"` EpgSource *string `json:"epgSource,omitempty"` @@ -59,7 +60,7 @@ type RequestStruct struct { BindingIPs *string `json:"bindingIPs,omitempty"` ForceHttpsToUpstream *bool `json:"forceHttps,omitempty"` UseHttps *bool `json:"useHttps,omitempty"` - ForceClientHttps *bool `json:"forceClientHttps"` + ForceClientHttps *bool `json:"forceClientHttps,omitempty"` ThreadfinDomain *string `json:"threadfinDomain,omitempty"` EnableNonAscii *bool `json:"enableNonAscii,omitempty"` EpgCategories *string `json:"epgCategories,omitempty"` @@ -135,7 +136,7 @@ type ResponseStruct struct { OpenLink string `json:"openLink,omitempty"` OpenMenu string `json:"openMenu,omitempty"` Reload bool `json:"reload,omitempty"` - Settings SettingsStruct `json:"settings"` + Settings *SettingsStruct `json:"settings"` Status bool `json:"status"` Token string `json:"token,omitempty"` Users map[string]interface{} `json:"users,omitempty"` diff --git a/src/system.go b/src/system.go index 3a3fbf8..98143d6 100644 --- a/src/system.go +++ b/src/system.go @@ -133,6 +133,7 @@ func loadSettings() (settings SettingsStruct, err error) { defaults["buffer.size.kb"] = 1024 defaults["buffer.timeout"] = 500 defaults["buffer.autoReconnect"] = false + defaults["buffer.terminationTimeout"] = 5 defaults["cache.images"] = false defaults["epgSource"] = "PMS" defaults["ffmpeg.options"] = System.FFmpeg.DefaultOptions diff --git a/src/thirdPartyBuffer.go b/src/thirdPartyBuffer.go index 819898d..c7908dc 100644 --- a/src/thirdPartyBuffer.go +++ b/src/thirdPartyBuffer.go @@ -7,42 +7,70 @@ import ( "net/url" "os" "os/exec" + "path/filepath" "strings" + "syscall" ) +type ThirdPartyBuffer struct { + StreamBuffer + Cmd *exec.Cmd + BufferType string + Path string + Options string +} + + // StartThirdPartyBuffer starts the third party tool and capture its output for the given stream. -func StartThirdPartyBuffer(stream *Stream) error { - - SetBufferConfig(stream.Buffer.Config) - bufferConfig := stream.Buffer.Config - if bufferConfig.BufferType == "" { +func (sb *ThirdPartyBuffer) StartBuffer(stream *Stream) error { + if err := sb.StreamBuffer.StartBuffer(stream); err != nil { + return err + } + + sb.SetBufferConfig() + if sb.BufferType == "" { return fmt.Errorf("could not set buffer config") } - ShowInfo(fmt.Sprintf("Streaming: Buffer:%s path:%s", bufferConfig.BufferType, bufferConfig.Path)) + ShowInfo(fmt.Sprintf("Streaming: Buffer:%s path:%s", sb.BufferType, sb.Path)) ShowInfo("Streaming URL:" + stream.URL) - err := RunBufferCommand(stream) + err := sb.RunBufferCommand(stream) if err != nil { stream.handleBufferError(err) } return nil } +func (sb *ThirdPartyBuffer) StopBuffer() { + close(sb.StopChan) +} + +func (sb *ThirdPartyBuffer) CloseBuffer() { + if !sb.Closed{ + sb.Closed = true + close(sb.CloseChan) + sb.Cmd.Process.Signal(syscall.SIGKILL) // Kill the third party tool process + sb.Cmd.Wait() + DeletPIDfromDisc(fmt.Sprintf("%d", sb.Cmd.Process.Pid)) // Delete the PID since the process has been terminated + sb.RemoveBufferedFiles(filepath.Join(sb.Stream.Folder, "0.ts")) + } +} + // SetBufferConfig returns the the arguments from the buffer settings in the config file -func SetBufferConfig(config *BufferConfig) { - config.BufferType = strings.ToUpper(Settings.Buffer) - switch config.BufferType { +func (sb *ThirdPartyBuffer) SetBufferConfig() { + sb.BufferType = strings.ToUpper(Settings.Buffer) + switch sb.BufferType { case "FFMPEG": - config.Options = Settings.FFmpegOptions - config.Path = Settings.FFmpegPath + sb.Options = Settings.FFmpegOptions + sb.Path = Settings.FFmpegPath case "VLC": - config.Options = Settings.VLCOptions - config.Path = Settings.VLCPath + sb.Options = Settings.VLCOptions + sb.Path = Settings.VLCPath default: - config.BufferType = "" - config.Options = "" - config.Path = "" + sb.BufferType = "" + sb.Options = "" + sb.Path = "" } } @@ -58,12 +86,12 @@ func SetBufferConfig(config *BufferConfig) { // Returns: // - *Buffer: A pointer to a Buffer struct representing the buffer process. // - error: An error object if an error occurs, otherwise nil. -func RunBufferCommand(stream *Stream) error { - bufferConfig := stream.Buffer.Config - args := PrepareBufferArguments(bufferConfig.Options, stream.URL) +func (sb *ThirdPartyBuffer) RunBufferCommand(stream *Stream) error { + sb.Stream = stream + args := PrepareBufferArguments(sb.Options, stream.URL) - cmd := exec.Command(bufferConfig.Path, args...) - debug := fmt.Sprintf("%s:%s %s", strings.ToUpper(Settings.Buffer), bufferConfig.Path, args) + cmd := exec.Command(sb.Path, args...) + debug := fmt.Sprintf("%s:%s %s", strings.ToUpper(Settings.Buffer), sb.Path, args) ShowDebug(debug, 1) stdOut, stdErr, err := GetCommandPipes(cmd) @@ -76,12 +104,10 @@ func RunBufferCommand(stream *Stream) error { } WritePIDtoDisk(fmt.Sprintf("%d", cmd.Process.Pid)) - go ShowCommandStdErrInConsole(bufferConfig.BufferType, stdErr) - go stream.Buffer.HandleByteOutput(stdOut) - - stream.Buffer.IsThirdPartyBuffer = true - stream.Buffer.Cmd = cmd + go ShowCommandStdErrInConsole(sb.BufferType, stdErr) + go sb.HandleByteOutput(stdOut) + sb.Cmd = cmd return nil } diff --git a/src/threadfinBuffer.go b/src/threadfinBuffer.go index ff5bee1..1508645 100644 --- a/src/threadfinBuffer.go +++ b/src/threadfinBuffer.go @@ -6,12 +6,20 @@ import ( "io" "mime" "net/http" + "path/filepath" "strings" "time" ) -func StartThreadfinBuffer(stream *Stream) error { - stopChan := make(chan struct{}) +type ThreadfinBuffer struct{ + StreamBuffer +} + +func (sb *ThreadfinBuffer) StartBuffer(stream *Stream) error { + if err := sb.StreamBuffer.StartBuffer(stream); err != nil { + return err + } + ShowInfo(fmt.Sprintf("Streaming:Buffer:%s", "Threadfin")) ShowInfo("Streaming URL:" + stream.URL) @@ -55,7 +63,7 @@ func StartThreadfinBuffer(stream *Stream) error { for { select { - case <-stopChan: + case <-sb.StopChan: resp.Body.Close() time.Sleep(200 * time.Millisecond) // Let the buffer stop before going on return @@ -64,10 +72,17 @@ func StartThreadfinBuffer(stream *Stream) error { } } }() - stream.Buffer.StopChan = stopChan return nil } +func (sb *ThreadfinBuffer) CloseBuffer() { + if !sb.Closed { + sb.Closed = true + close(sb.CloseChan) + sb.RemoveBufferedFiles(filepath.Join(sb.Stream.Folder, "0.ts")) + } +} + func selectStreamFromMaster(resp io.ReadCloser) (string, string, error) { defer resp.Close() diff --git a/src/update.go b/src/update.go index 2b919b7..387591c 100644 --- a/src/update.go +++ b/src/update.go @@ -1,41 +1,26 @@ package src import ( - "encoding/json" - "errors" "fmt" - "io" - "net/http" - "os" - "strings" - up2date "threadfin/src/internal/up2date/client" - "time" - - "github.com/hashicorp/go-version" - - "reflect" + updater "threadfin/src/internal/updater" ) // BinaryUpdate : Binary Update Prozess. Git Branch master und beta wird von GitHub geladen. -func BinaryUpdate(forceUpdate bool) (err error) { +func BinaryUpdate(forceUpdate bool) bool { if !System.GitHub.Update { ShowWarning(2099) - return + return false } if !forceUpdate { if !Settings.ThreadfinAutoUpdate { ShowWarning(2098) - return + return false } } - var updater = &up2date.Updater - updater.Name = System.Update.Name - updater.Branch = System.Branch - - up2date.Init() + var updater = updater.Init(System.Branch, System.Update.Name, System.Update.Git) if System.Beta { updater.Branch = "beta" @@ -44,303 +29,36 @@ func BinaryUpdate(forceUpdate bool) (err error) { } ShowInfo("Update Version:" + updater.Branch) - var releaseInfo = fmt.Sprintf("%s/releases", System.Update.Github) - //var latest string - //var bin_name string - var body []byte + var releaseInfoURL = fmt.Sprintf("%s/releases", System.Update.Github) - var git []*GithubReleaseInfo - - resp, err := http.Get(releaseInfo) - if err != nil { - ShowError(err, 6003) - return nil + if updater.GetBinaryDownloadURL(releaseInfoURL) != nil { + return false } - body, _ = io.ReadAll(resp.Body) - - err = json.Unmarshal(body, &git) - if err != nil { - return err - } - - // Get latest prerelease tag name - if updater.Branch == "beta" { - for _, release := range git { - if release.Prerelease { - updater.Response.Version = release.TagName - updater.Response.UpdatedAt = release.Assets[0].UpdatetAt - for _, asset := range release.Assets { - new_asset := up2date.AssetsStruct{DownloadUrl: asset.DownloadUrl, UpdatetAt: asset.UpdatetAt} - updater.Response.Assets = append(updater.Response.Assets, new_asset) - } - break - } - } - } - - // Latest main tag name - if updater.Branch == "master" { - for _, release := range git { - if !release.Prerelease { - updater.Response.Version = release.TagName - for _, asset := range release.Assets { - new_asset := up2date.AssetsStruct{DownloadUrl: asset.DownloadUrl, UpdatetAt: asset.UpdatetAt} - updater.Response.Assets = append(updater.Response.Assets, new_asset) - } - break - } - } + if !updater.Response.Status { + return false } ShowInfo("LATEST VERSION:" + updater.Response.Version) + ShowInfo("FILE:" + updater.BinaryDownloadURL) - for _, asset := range updater.Response.Assets { - if strings.Contains(asset.DownloadUrl, System.OS) && strings.Contains(asset.DownloadUrl, System.ARCH) { - updater.Response.Status = true - updater.Response.UpdateBIN = asset.DownloadUrl - break - } - } - - ShowInfo("FILE:" + updater.Response.UpdateBIN) - - var path_to_file string do_upgrade := false if !forceUpdate { - do_upgrade = existsNewerVersion(updater.Response) + do_upgrade = updater.ExistsNewerVersion(System.Version, System.Build) } else { do_upgrade = true } // Versionsnummer überprüfen if do_upgrade { - // Update durchführen - var fileType, url string - - ShowInfo(fmt.Sprintf("Update Available:Version: %s", updater.Response.Version)) - - switch System.Branch { - - // Update von GitHub - case "master", "beta", "development": - ShowInfo("Update Server:GitHub") - - // Update vom eigenen Server - default: - ShowInfo(fmt.Sprintf("Update Server:%s", Settings.UpdateURL)) - - } - - ShowInfo(fmt.Sprintf("Start Update:Branch: %s", updater.Branch)) - - // Neue Version als BIN Datei herunterladen - if len(updater.Response.UpdateBIN) > 0 { - url = updater.Response.UpdateBIN - fileType = "bin" - } - - // Neue Version als ZIP Datei herunterladen - if len(updater.Response.UpdateZIP) > 0 { - url = updater.Response.UpdateZIP - fileType = "zip" - } - - if len(url) > 0 { - - err = up2date.DoUpdate(fileType, updater.Response.Filename) - if err != nil { - ShowError(err, 6002) - } - if System.Branch == "beta" { - if err := os.WriteFile(path_to_file, []byte(updater.Response.UpdatedAt), 0666); err != nil { - ShowError(err, 6005) - } - } - } - } else { - ShowInfo("BIN:Update omitted") - } - - return nil -} - -func existsNewerVersion(response up2date.ServerResponse) bool { - var currentVersion = System.Version + "." + System.Build - current_version, _ := version.NewVersion(currentVersion) - response_version, _ := version.NewVersion(response.Version) - if response_version == nil { - current_date := getBinaryTime() - layout := time.RFC3339 - response_date, err := time.Parse(layout ,response.UpdatedAt) + err := updater.DoUpdateNew() if err != nil { + ShowError(err, 6002) return false } - if current_date.Before(response_date) { - return true - } - } else if response_version.GreaterThan(current_version) && response.Status { return true - } - return false -} - -func getBinaryTime() time.Time { - executablePath, err := os.Executable() - if err != nil { - return time.Now() - } - binaryInfo, err := os.Stat(executablePath) - if err != nil { - return time.Now() - } - return binaryInfo.ModTime() -} - -func conditionalUpdateChanges() (err error) { - -checkVersion: - settingsMap, err := loadJSONFileToMap(System.File.Settings) - if err != nil || len(settingsMap) == 0 { - return - } - - if settingsVersion, ok := settingsMap["version"].(string); ok { - - if settingsVersion > System.DBVersion { - ShowInfo("Settings DB Version:" + settingsVersion) - ShowInfo("System DB Version:" + System.DBVersion) - err = errors.New(getErrMsg(1031)) - return - } - - // Letzte Kompatible Version (1.4.4) - if settingsVersion < System.Compatibility { - err = errors.New(getErrMsg(1013)) - return - } - - switch settingsVersion { - - case "1.4.4": - // UUID Wert in xepg.json setzen - err = setValueForUUID() - if err != nil { - return - } - - // Neuer Filter (WebUI). Alte Filtereinstellungen werden konvertiert - if oldFilter, ok := settingsMap["filter"].([]interface{}); ok { - var newFilterMap = convertToNewFilter(oldFilter) - settingsMap["filter"] = newFilterMap - - settingsMap["version"] = "2.0.0" - - err = saveMapToJSONFile(System.File.Settings, settingsMap) - if err != nil { - return - } - - goto checkVersion - - } else { - err = errors.New(getErrMsg(1030)) - return - } - - case "2.0.0": - - if oldBuffer, ok := settingsMap["buffer"].(bool); ok { - - var newBuffer string - switch oldBuffer { - case true: - newBuffer = "threadfin" - case false: - newBuffer = "-" - } - - settingsMap["buffer"] = newBuffer - - settingsMap["version"] = "2.1.0" - - err = saveMapToJSONFile(System.File.Settings, settingsMap) - if err != nil { - return - } - - goto checkVersion - - } else { - err = errors.New(getErrMsg(1030)) - return - } - - case "2.1.0": - // Falls es in einem späteren Update Änderungen an der Datenbank gibt, geht es hier weiter - - break - } - } else { - // settings.json ist zu alt (älter als Version 1.4.4) - err = errors.New(getErrMsg(1013)) - } - - return -} - -func convertToNewFilter(oldFilter []interface{}) (newFilterMap map[int]interface{}) { - - newFilterMap = make(map[int]interface{}) - - switch reflect.TypeOf(oldFilter).Kind() { - - case reflect.Slice: - s := reflect.ValueOf(oldFilter) - - for i := 0; i < s.Len(); i++ { - - var newFilter FilterStruct - newFilter.Active = true - newFilter.Name = fmt.Sprintf("Custom filter %d", i+1) - newFilter.Filter = s.Index(i).Interface().(string) - newFilter.Type = "custom-filter" - newFilter.CaseSensitive = false - - newFilterMap[i] = newFilter - - } - - } - - return -} - -func setValueForUUID() (err error) { - - xepg, err := loadJSONFileToMap(System.File.XEPG) - if err == nil { - - for _, c := range xepg { - - var xepgChannel = c.(map[string]interface{}) - - if uuidKey, ok := xepgChannel["_uuid.key"].(string); ok { - - if value, ok := xepgChannel[uuidKey].(string); ok { - - if len(value) > 0 { - xepgChannel["_uuid.value"] = value - } - - } - - } - - } + ShowInfo("BIN:Update omitted") + return false } - err = saveMapToJSONFile(System.File.XEPG, xepg) - - return } diff --git a/src/webUI.go b/src/webUI.go index bb3cbc7..18d15f0 100644 --- a/src/webUI.go +++ b/src/webUI.go @@ -6,12 +6,12 @@ func loadHTMLMap() { webUI["web/public/configuration.html"] = "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" webUI["web/public/create-first-user.html"] = "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" - webUI["web/public/index.html"] = "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" + webUI["web/public/index.html"] = "PCFET0NUWVBFIGh0bWw+DQo8aHRtbCBsYW5nPSJlbiI+DQo8aGVhZD4NCiAgPG1ldGEgY2hhcnNldD0idXRmLTgiPg0KICA8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ZGV2aWNlLXdpZHRoLCBpbml0aWFsLXNjYWxlPTEuMCI+DQogIA0KICA8dGl0bGU+VGhyZWFkZmluPC90aXRsZT4NCiAgPCEtLSBmb250LWF3ZXNvbWUgLS0+DQogIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iaHR0cHM6Ly9jZG5qcy5jbG91ZGZsYXJlLmNvbS9hamF4L2xpYnMvZm9udC1hd2Vzb21lLzYuNy4yL2Nzcy9hbGwubWluLmNzcyIgaW50ZWdyaXR5PSJzaGE1MTItRXZ2ODRNcjRrcVZHUk5TZ0lHTC9GL2FJRHFRYjd4UTJ2Y3JkSXd4ZmpUaFNIOENTUjdQQkVha0NyNTFDayt3Ky9VNnN3VTJJbTF2VlgwU1ZrOUFCaGc9PSIgY3Jvc3NvcmlnaW49ImFub255bW91cyIgcmVmZXJyZXJwb2xpY3k9Im5vLXJlZmVycmVyIiAvPg0KICA8bGluayBocmVmPSJodHRwczovL2Nkbi5qc2RlbGl2ci5uZXQvbnBtL2Jvb3RzdHJhcEA1LjMuMy9kaXN0L2Nzcy9ib290c3RyYXAubWluLmNzcyIgcmVsPSJzdHlsZXNoZWV0IiBpbnRlZ3JpdHk9InNoYTM4NC1RV1RLWnlqcFBFaklTdjVXYVJVOU9GZVJwb2s2WWN0blltRHI1cE5seVQyYlJqWGgwSk1oalk2aFcrQUxFd0lIIiBjcm9zc29yaWdpbj0iYW5vbnltb3VzIj4NCiAgPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJjc3Mvc2NyZWVuLmNzcyIgdHlwZT0idGV4dC9jc3MiPg0KICA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImNzcy9iYXNlLmNzcyIgdHlwZT0idGV4dC9jc3MiPg0KICA8bGluayByZWw9Imljb24iIGhyZWY9ImltZy90aHJlYWRmaW4uaWNvIj4NCjwvaGVhZD4NCg0KPGJvZHkgb25sb2FkPSJqYXZhc2NyaXB0OiBQYWdlUmVhZHkoKTsiPg0KDQogIDxkaXYgaWQ9ImxvYWRpbmciIGNsYXNzPSJtb2RhbCBmYWRlIj4NCiAgICA8ZGl2IGNsYXNzPSJtb2RhbC1kaWFsb2cgbG9hZGVyIj48L2Rpdj4NCiAgPC9kaXY+DQoNCiAgPGRpdiBpZD0icG9wdXAiIGNsYXNzPSJtb2RhbCBmYWRlIj4NCiAgICA8ZGl2IGNsYXNzPSJtb2RhbC1kaWFsb2cgbW9kYWwteGwiPg0KICAgICAgPGRpdiBjbGFzcz0ibW9kYWwtY29udGVudCIgaWQ9InBvcHVwTW9kYWxDb250ZW50Ij4NCiAgICAgICAgPGRpdiBjbGFzcz0ibW9kYWwtaGVhZGVyIiBpZD0icG9wdXBIZWFkZXIiPjwvZGl2Pg0KICAgICAgICAgIDxkaXYgY2xhc3M9Im1vZGFsLWJvZHkiIGlkPSJwb3B1cEJvZHkiPg0KICAgICAgICAgICAgPGRpdiBjbGFzcz0iY29udGFpbmVyLWZsdWlkIiBpZD0icG9wdXBCb2R5Q29udGFpbmVyIj4NCiAgICAgICAgICAgICAgPGRpdiBjbGFzcz0icm93IiBpZD0icG9wdXBSb3ciPg0KICAgICAgICAgICAgICAgIDxkaXYgaWQ9InBvcHVwQ3VzdG9tIj4NCiAgICAgICAgICAgICAgICA8L2Rpdj4NCiAgICAgICAgICAgICAgPC9kaXY+DQogICAgICAgICAgICA8L2Rpdj4NCiAgICAgICAgICA8L2Rpdj4NCiAgICAgIDwvZGl2Pg0KICAgIDwvZGl2Pg0KICA8L2Rpdj4NCg0KICA8ZGl2IGNsYXNzPSJtb2RhbCBmYWRlIiBpZD0ic2VydmVyX2luZm9ybWF0aW9uIj48L2Rpdj4NCiAgDQogIDxuYXYgY2xhc3M9Im5hdmJhciBuYXZiYXItZXhwYW5kLWxnIHN0aWNreS10b3AgbmF2YmFyLWRhcmsgYmctYmxhY2siPg0KICAgIDxkaXYgY2xhc3M9ImNvbnRhaW5lci1mbHVpZCI+DQogICAgICA8YSBjbGFzcz0ibmF2YmFyLWJyYW5kIiBocmVmPSIvd2ViIiB0aXRsZT0ibG9nbyI+DQogICAgICAgIDxzcGFuIGlkPSJsb2dvIj48L3NwYW4+DQogICAgICA8L2E+DQogICAgICA8YnV0dG9uIGNsYXNzPSJuYXZiYXItdG9nZ2xlciIgdHlwZT0iYnV0dG9uIiBkYXRhLWJzLXRvZ2dsZT0iY29sbGFwc2UiIGRhdGEtYnMtdGFyZ2V0PSIjbmF2YmFyU3VwcG9ydGVkQ29udGVudCIgYXJpYS1jb250cm9scz0ibmF2YmFyU3VwcG9ydGVkQ29udGVudCIgYXJpYS1leHBhbmRlZD0iZmFsc2UiIGFyaWEtbGFiZWw9IlRvZ2dsZSBuYXZpZ2F0aW9uIj4NCiAgICAgICAgPHNwYW4gY2xhc3M9Im5hdmJhci10b2dnbGVyLWljb24iPjwvc3Bhbj4NCiAgICAgIDwvYnV0dG9uPg0KICAgICAgPGRpdiBjbGFzcz0iY29sbGFwc2UgbmF2YmFyLWNvbGxhcHNlIiBpZD0ibmF2YmFyU3VwcG9ydGVkQ29udGVudCI+DQogICAgICAgIDx1bCBjbGFzcz0ibmF2YmFyLW5hdiBteC1hdXRvIG1iLTIgbWItbGctMCIgaWQ9Im1haW4tbWVudSI+DQogICAgICAgIDwvdWw+DQogICAgICAgIDx1bD4NCiAgICAgICAgICA8bGkgY2xhc3M9Im5hdi1saW5rIiBkYXRhLWJzLXRvZ2dsZT0ibW9kYWwiIGRhdGEtYnMtdGFyZ2V0PSIjc2VydmVyX2luZm9ybWF0aW9uIiBpZD0ic2VydmVyX2luZm9ybWF0aW9uX2J1dHRvbiI+PGkgY2xhc3M9ImZhcyBmYS1pbmZvLWNpcmNsZSI+PC9pPiBTZXJ2ZXIgSW5mb3JtYXRpb248L2xpPg0KICAgICAgICA8L3VsPg0KICAgICAgPC9kaXY+DQogICAgPC9kaXY+DQogIDwvbmF2Pg0KICA8ZGl2IGNsYXNzPSJjb250YWluZXItZmxleCI+DQogICAgPGRpdiBjbGFzcz0icm93Ij4NCiAgICAgIDxkaXYgY2xhc3M9ImNvbC1tZC0xMiBjb2wtc20tMTIiPg0KICAgICAgICA8ZGl2IGlkPSJjb250ZW50IiBjbGFzcz0idGFibGUtcmVzcG9uc2l2ZSI+PC9kaXY+DQogICAgICA8L2Rpdj4NCiAgICA8L2Rpdj4NCiAgICA8ZGl2IGNsYXNzPSJyb3ciIGlkPSJteVN0cmVhbXNCb3giPg0KICAgICAgPGRpdiBjbGFzcz0iY29sLW1kLTUgY29sLXNtLTEyIHRhYmxlLXJlc3BvbnNpdmUgZmxvYXQtc3RhcnQiPg0KICAgICAgICA8dGFibGUgY2xhc3M9InRhYmxlIHRhYmxlLWRhcmsgdGFibGUtYm9yZGVyZWQgY2FwdGlvbi10b3AiIGlkPSJhY3RpdmVTdHJlYW1zIj48L3RhYmxlPg0KICAgICAgPC9kaXY+DQogICAgICA8ZGl2IGNsYXNzPSJjb2wtbWQtNSBjb2wtc20tMTIgdGFibGUtcmVzcG9uc2l2ZSBmbG9hdC1lbmQiPg0KICAgICAgICA8dGFibGUgY2xhc3M9InRhYmxlIHRhYmxlLWRhcmsgdGFibGUtYm9yZGVyZWQgY2FwdGlvbi10b3AiIGlkPSJpbmFjdGl2ZVN0cmVhbXMiPjwvdGFibGU+DQogICAgICA8L2Rpdj4NCiAgICA8L2Rpdj4NCiAgPC9kaXY+DQoNCiAgPGRpdiBpZD0ibm90aWZpY2F0aW9uX2NvbnRhaW50ZXIiIGNsYXNzPSJub3RpZmljYXRpb24iPg0KICAgIDxkaXYgY2xhc3M9ImNvbnRlbnQiPg0KICAgICAgPGRpdiBjbGFzcz0iaGVhZGVyIGQtZmxleCBqdXN0aWZ5LWNvbnRlbnQtYmV0d2VlbiBhbGlnbi1pdGVtcy1jZW50ZXIiPg0KICAgICAgICA8aDUgY2xhc3M9InRpdGxlIiBpZD0ibm90aWZpY2F0aW9uX3RpdGxlIj48L2g1Pg0KICAgICAgICA8YnV0dG9uIHR5cGU9ImJ1dHRvbiIgY2xhc3M9ImJ0bi1jbG9zZSBidG4tY2xvc2Utd2hpdGUiIGlkPSJjbG9zZU5vdGlmaWNhdGlvbiI+PC9idXR0b24+DQogICAgICA8L2Rpdj4NCiAgICAgIDxkaXYgY2xhc3M9Im1vZGFsLWJvZHkgbm90aWZpY2F0aW9uQ29udGVudCI+DQogICAgICAgICAgPHAgaWQ9Im5vdGlmaWNhdGlvbl90ZXh0Ij48L3A+DQogICAgICAgICAgPGlucHV0IHR5cGU9ImJ1dHRvbiIgY2xhc3M9InVwZGF0ZU5vdyIgaWQ9InVwZGF0ZU5vd0J1dHRvbiI+DQogICAgICA8L2Rpdj4NCiAgICA8L2Rpdj4NCiAgPC9kaXY+DQoNCiAgPGJ1dHRvbiB0eXBlPSJidXR0b24iIG9uY2xpY2s9InRvcEZ1bmN0aW9uKCkiIGlkPSJiYWNrVG9Ub3AiPg0KICAgIDxpbWcgc3JjPSJpY29ucy9jaGV2cm9uLWRvdWJsZS11cC5zdmciIGFsdD0iR28gdG8gdG9wIj4NCiAgPC9idXR0b24+DQoNCiAgPHNjcmlwdCBzcmM9Imh0dHBzOi8vY2RuLmpzZGVsaXZyLm5ldC9ucG0vYm9vdHN0cmFwQDUuMy4zL2Rpc3QvanMvYm9vdHN0cmFwLmJ1bmRsZS5taW4uanMiIGludGVncml0eT0ic2hhMzg0LVl2cGNyWWYwdFkzbEhCNjBOTmttWGM1czlmRFZaTEVTYUFBNTVORHpPeGh5OUdrY0lkc2xLMWVON042akllSHoiIGNyb3Nzb3JpZ2luPSJhbm9ueW1vdXMiPjwvc2NyaXB0Pg0KICA8c2NyaXB0IHNyYz0iaHR0cHM6Ly9jZG5qcy5jbG91ZGZsYXJlLmNvbS9hamF4L2xpYnMvY2xpcGJvYXJkLmpzLzIuMC4xMS9jbGlwYm9hcmQubWluLmpzIiBpbnRlZ3JpdHk9InNoYTUxMi03TzVwWHBjMG9DUnJ4azhSVWZEWUZnbjBuTzF0K2pMdUlPUWRPTVJwNEFQQjd1WjR2U2pzcHpwNXk2WUR0RHM0VnpVU1RiV3pCRlovTEtKaG55Rk9Ldz09IiBjcm9zc29yaWdpbj0iYW5vbnltb3VzIiByZWZlcnJlcnBvbGljeT0ibm8tcmVmZXJyZXIiPjwvc2NyaXB0Pg0KICA8c2NyaXB0IGxhbmd1YWdlPSJqYXZhc2NyaXB0IiB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0ianMvc2VydmVyX2luZm9ybWF0aW9uLmpzIj48L3NjcmlwdD4NCiAgPHNjcmlwdCBsYW5ndWFnZT0iamF2YXNjcmlwdCIgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9ImpzL25ldHdvcmsuanMiPjwvc2NyaXB0Pg0KICA8c2NyaXB0IGxhbmd1YWdlPSJqYXZhc2NyaXB0IiB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0ianMvb3B0aW9uX2RpYWxvZ3VlLmpzIj48L3NjcmlwdD4NCiAgPHNjcmlwdCBsYW5ndWFnZT0iamF2YXNjcmlwdCIgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9ImpzL21lbnUuanMiPjwvc2NyaXB0Pg0KICA8c2NyaXB0IGxhbmd1YWdlPSJqYXZhc2NyaXB0IiB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0ianMvc2V0dGluZ3MuanMiPjwvc2NyaXB0Pg0KICA8c2NyaXB0IGxhbmd1YWdlPSJqYXZhc2NyaXB0IiB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0ianMvbG9ncy5qcyI+PC9zY3JpcHQ+DQogIDxzY3JpcHQgbGFuZ3VhZ2U9ImphdmFzY3JpcHQiIHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJqcy9iYXNlLmpzIj48L3NjcmlwdD4NCiAgPHNjcmlwdCBsYW5ndWFnZT0iamF2YXNjcmlwdCIgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9ImpzL3ZlcnNpb25fY2hlY2suanMiPjwvc2NyaXB0Pg0KDQo8L2JvZHk+PC9odG1sPg==" webUI["web/public/login.html"] = "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" webUI["web/public/maintenance.html"] = "PCFkb2N0eXBlIGh0bWw+DQo8aHRtbD4NCg0KPGhlYWQ+DQogIDxtZXRhIGNoYXJzZXQ9InV0Zi04Ij4NCiAgPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPWRldmljZS13aWR0aCwgaW5pdGlhbC1zY2FsZT0xLjAiIC8+DQogIDx0aXRsZT5UaHJlYWRmaW48L3RpdGxlPg0KICA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImNzcy9zY3JlZW4uY3NzIiB0eXBlPSJ0ZXh0L2NzcyI+DQogIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iY3NzL2Jhc2UuY3NzIiB0eXBlPSJ0ZXh0L2NzcyI+DQo8L2hlYWQ+DQoNCjxib2R5Pg0KDQogIDxkaXYgaWQ9ImhlYWRlciIgY2xhc3M9ImltZ0NlbnRlciI+PC9kaXY+DQoNCiAgPGRpdiBpZD0iYm94Ij4NCg0KICAgIDxkaXYgaWQ9ImhlYWRsaW5lIj4NCiAgICAgIDxoMSBpZD0iaGVhZC10ZXh0IiBjbGFzcz0iY2VudGVyIj5NYWludGVuYW5jZTwvaDE+DQogICAgPC9kaXY+DQoNCiAgICA8ZGl2IGlkPSJjb250ZW50Ij4NCiAgICAgIFRocmVhZGZpbiBpcyB1cGRhdGluZyB0aGUgZGF0YWJhc2UsIHBsZWFzZSB0cnkgYWdhaW4gbGF0ZXIuDQogICAgPC9kaXY+DQoNCiAgICA8ZGl2IGlkPSJib3gtZm9vdGVyIj48L2Rpdj4NCg0KICA8L2Rpdj4NCg0KPC9ib2R5Pg0KDQo8L2h0bWw+" - webUI["web/public/css/base.css"] = "*{
  -webkit-appearance: none;
  -moz-appearance: none;
  -ms-appearance: none;
  font-family: "Arial", sans-serif;
  letter-spacing: 2px;
}

/*
::-webkit-scrollbar { 
    display: none; 
}
*/

::-webkit-scrollbar {
  width: 12px;
  height: 12px;
}


::-webkit-scrollbar-track {
  -webkit-box-shadow: inset 0 0 6px rgba(0, 0, 0, 0.3);
  border-radius: 5px;

}

::-webkit-scrollbar-thumb {
  border-radius: 5px;
  -webkit-box-shadow: inset 0 0 6px rgba(0, 0, 0, 0.6);
  background-color: #444;
}

::-webkit-scrollbar-thumb:hover {
  background: #333;
}

::-webkit-scrollbar-corner {
  background: transparent;
}

a {
  color: #00E6FF;
}

html,
body {
  color: #fff;
  margin: 0px auto;
  height: 100%;
  font-size: 14px;
}

h2 {
  font-size: 24px;
  letter-spacing: 2px;
}

h3 {
  font-size: 22px;
  letter-spacing: 1px;
}

h4 {
  font-size: 20px;
  letter-spacing: 1px;
  line-height: 1.5em;

}

h5 {
  font-size: 16px;
  letter-spacing: 1px;
  line-height: 1.2em;
  margin: 0px auto;
  margin-left: 10px;
}

hr {
  border: 0;
  height: 1px;
  background: #333;
  margin: 10px 0px;
}

p {
  margin: 2px;
  padding: 2px 5px;
}

pre {
  margin: 0px 0px 5px 0px;
  font-size: 12px;
  color: #ddd;
  letter-spacing: 1px;
  white-space: pre-wrap;
  font-family: monospace;
  font-size: 12px;
  font-style: normal;
  font-variant: normal;
  line-height: 1.6em;
}

label {
  margin-bottom: 20px;
  display: block;
}

li {
  list-style-type: none;
  cursor: pointer;
  transition: all 0.3;
}

li:hover {
  border-color: #00E6FF
}

select {
  cursor: pointer;
  width: calc(100% + 2px);
  height: auto;
  border: solid 0px #00E6FF;
  border-radius: 0px;
  box-sizing: border-box;
  outline: none;
  color: #fff;
  padding: 9px 10px;
  display: block;
  background-color: #333;
  font-size: 14px;
  margin: 5px 0px 5px 0px;
}

select:focus {
  outline: none;
}

input {
  -webkit-appearance: unset;
  margin: 0px;
  padding: 2.5px 10px;
  outline: none;
  font-size: 14px;
}

input[type=button],
input[type=submit] {
  cursor: pointer;
  background-color: #000;
  margin: 10px 10px;
  padding: 10px 25px;
  border: solid 0px;
  border-color: #000;
  border-radius: 3px;
  outline: none;
  color: #fff;
}

input[type=button]:focus {
  outline: none;
}

input[type=button]:hover {
  background-color: #00E6FF;
  color: #000;
}

input[type=button]:hover.delete {
  background-color: red;
  color: #fff;
}

input[type=text],
input[type=search],
input[type=password] {
  color: #fff;
  width: -webkit-calc(100% - 0px);
  width: -moz-calc(100% - 0px);
  width: calc(100% - 0px);
  outline: none;
  border: solid 1px transparent;
  background-color: transparent;
  border-bottom-color: #555;
  border-radius: 0px;
  padding: 8px 10px;
}

input[type="checkbox"] {
  border: solid 1px #00E6FF;
  background-color: #333;
  height: 25px;
  width: 25px;
  cursor: pointer;
  /*
  -webkit-appearance: checkbox;
  */
}

input[type="checkbox"]:checked {
  color: #fff;
  background-color: #00E6FF;
  /*display: inline-block;*/
}

input[type="checkbox"]:before {
  position: initial;
  left: 0px;
  margin-left: -4px;
  content: " ";
}

input[type="checkbox"]:checked:before {
  position: initial;
  left: 0px;
  margin-left: -3px;
  content: "✓";
  color: #000;
}

input[type="checkbox"].bulk:checked:before {
  position: relative;
  left: 0px;
  top: -11px;
  margin-left: -3px;
  content: "✓";
  font-size: 1.5em;
  color: #000;
}


input[type=button].cancel {

  background-color: transparent;
  border-color: red;
}

input[type=button].save {
  background-color: #111;
  float: right;
}


input[type=button].black,
input[type=submit].black {
  background-color: #000;
  border-color: #000;
}

input[type=button].center {
  margin-right: auto;
  margin-left: auto;
  background-color: #000;
  border-color: #000;
}

.pointer {
  cursor: pointer;
}

.pointer:hover {
  color: #00E6FF;
  cursor: pointer;
}

.sortThis {
  color: #00E6FF;
}

.w40px {
  max-width: 40px;
}

.w50px {
  max-width: 50px;
}

.w80px {
  max-width: 80px;
}

.w150px {
  max-width: 150px;
}

.w200px {
  max-width: 200px;
  min-width: 100px;
  width: 200px;
  overflow-x: hidden;
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
}

.w300px {
  max-width: 300px;
}

.w220px {
  max-width: 220px;
  cursor: alias;
}

.footer {
  font-size: 10px;
}

.center {
  text-align: center;
}

.screenLogHidden {
  transform: translate(0px, -110px);
}

.borderSpace {
  margin-bottom: 30px;
}

.none {
  display: none;
}


.notVisible {
  height: 0px;
  display: none;
  opacity: 0;
  border-bottom: #000 solid 0px;

}

.visible {
  opacity: 1;
  display: block;
  border-bottom: #444 solid 1px;
  padding: 10px;
}

.floatRight {
  float: right;
}

.floatLeft {
  float: left;
}

.menu-active {
  background-color: #00E6FF;
}

table {
  width: 100%
}

#branch {
  color: red;
}

#interaction {
  margin-bottom: 100px;
  text-align: center;
  border-bottom: solid 0px #777;
}


.half {
  display: block;
  width: 45%;
}

.menu {
  border: solid 1px #00E6FF;
}

.infoMsg {
  color: #aaa;
}

.errorMsg {
  color: red;
}

.warningMsg {
  color: yellow;
}

.debugMsg {
  color: magenta;
}


.category {
  border-left: solid 2px
}

.news {
  border-color: tomato
}

.movie {
  border-color: royalblue;
}

.series {
  border-color: gold;
}

.sports {
  border-color: yellowgreen;
}

.kids {
  border-color: mediumpurple;
}

/* Loading */
#loading {
  left: 0px;
  top: 0px;
  z-index: 10000;
  position: absolute;
  background-color: rgba(0, 0, 0, 0.8);
  margin: auto;
  width: 100%;
  height: 100%;
}


.loader {
  border: 5px solid transparent;
  border-radius: 50%;
  border-top: 5px solid #00E6FF;
  border-bottom: 5px solid #00E6FF;
  width: 50px;
  height: 50px;
  -webkit-animation: spin 1.2s linear infinite;
  animation: spin 1.2s linear infinite;

  position: fixed;
  margin: auto;

  top: 0;
  right: 0;
  bottom: 0;
  left: 0;

}

.notification {
  background-color: #333;
  color: #fff;
  text-align: center;
  padding: 10px; /* Adjust padding as needed */
  position: fixed;
  bottom: 20px; /* Adjust position as needed */
  right: 20px; /* Adjust position as needed */
  z-index: 1000;
  display: none; /* Initially hidden */
  width: 300px; /* Adjust width as needed */
  max-height: calc(80vh - 10px); /* Adjust height as needed */
  border-radius: 10px; /* Optional: rounded corners */
  box-shadow: 0 0 10px rgba(0, 0, 0, 0.5); /* Optional: add shadow for better visibility */
}

.notification .header {
  display: flex;
  justify-content: space-between;
  align-items: center;
}

.notification .content {
  flex-grow: 1; /* Allow content to grow and take available space */
  overflow-y: auto; /* Enable vertical scrolling if content overflows */
  margin-bottom: 10px; /* Ensure there's a gap to the bottom */
}

.fa-style {
  color: #FFF;
  font-size: 25px;
}

.fa-style:hover {
  transform: scale(1.2);
}

.notificationContent {
  border-radius: 10px;
}

.updateNow {
  margin-bottom: 5px;
}

#backToTop {
  display: none; /* Hidden by default */
  position: fixed; /* Fixed/sticky position */
  bottom: 50px; /* Place the button at the bottom of the page */
  right: 50px; /* Place the button 30px from the right */
  z-index: 99; /* Make sure it does not overlap */
  border: none; /* Remove borders */
  outline: none; /* Remove outline */
  background-color: #000;
  cursor: pointer; /* Add a mouse pointer on hover */
  padding: 5px 10px 10px 10px; /* Some padding */
  border-radius: 5px; /* Rounded corners */
}

#backToTop:hover {
  background-color: #00E6FF; /* Add a dark-grey background on hover */
}

@-webkit-keyframes spin {
  0% {
    -webkit-transform: rotate(0deg);
  }

  100% {
    -webkit-transform: rotate(360deg);
  }
}

@keyframes spin {
  0% {
    transform: rotate(0deg);
  }

  100% {
    transform: rotate(360deg);
  }
}" - webUI["web/public/css/screen.css"] = "nav img {
  display: block;
  max-height: 20px;
  max-width: 20px;
  float: left;
}

nav p {
  text-align: left;
  padding: 0px 30px;
}

#layout {
  display: block;
  height: 100%;
}
/*
.form-control {
  background-color: #444;
  color: #FFF;
  pointer-events: none;
}*/

.form-control:disabled {
  background-color: transparent;
}

.layout-left {
  display: block;
  min-width: 150px;
  max-width: 20%;
  background-color: #111;
  height: inherit;
  float: left;
}

.layout-right {
  display: block;
  background-color: #444;
}

#menu-wrapper {
  height: 100%;
}


#logo {
  display: block;
  min-width: 180px;
  width: 100%;
  height: 100px;
  background: url("../img/threadfin.png");
  background-repeat: no-repeat;
  background-position: center;
  background-size: 100%;
}


#page {
  max-width: 950px;
  margin: auto;
  background-color: #444;

  /*
  height: -webkit-calc(100% - 130px);
  height: -moz-calc(100% - 130px);
  height: calc(100% - 130px);
  */

  min-height: -webkit-calc(100% - 120px);
  min-height: -moz-calc(100% - 120px);
  min-height: calc(100% - 120px);


  box-shadow: 0px 5px 5px #222;

}

#uiSetting {
  float: right;
  margin-right: 25px;
}

#box input[type=text],
#box input[type=password] {
  width: -webkit-calc(100% - 20px);
  width: -moz-calc(100% - 20px);
  width: calc(100% - 20px);
}

#box input[type=submit] {
  margin: 50px auto;
}

#settings {
  display: block;
  padding: 10px 10px;
}

#settings h5 {
  margin: 50px 0px 10px 0px;
}

#content-interaction .search {
  width: 200px;
  border: 1px solid #000;
  padding: 9px;
  background-color: #333;
  margin: 10px;
  float: right;
  border-radius: 3px;

}

#myStreams {
  position: fixed;
  bottom: 0px;
  background-color: #111;
  width: 100%;
  max-width: 950px;

  /*
  max-height: 100px;
  */
  margin-bottom: 0px;
}

#myStreams img {
  width: 4%;
  padding: 2px 5px;
  cursor: pointer;
  float: right;
}

/* Wizard*/
#box {
  background-color: #444;
  min-height: 400px;

  display: flex;
  flex-direction: column;
  justify-content: space-between;
}

#box p {
  padding: 10px 0px;
}

#box-footer {
  margin-top: auto;
}

#box-footer {
  margin: auto;
  padding: 10px;
}

#headline {
  background-color: #222;
  border-bottom: solid 2px #222;
  transition: all 0.5s;
  padding: 10px 0px;
  display: block;
}

#content {
  display: block;
  overflow: auto;
  padding: 10px;
}

/* --- */


#clientInfo,
#activeStreams,
#inactiveStreams {
  font-family: monospace;
  display: block;
  font-size: 12px;
  color: #00E6FF;
  padding: 0px;
}

#activeStreams thead,
#inactiveStreams thead {
  font-size: 2em;
}

#openStreams {
  width: 20px;
  height: 200px;
  cursor: pointer;
  float: right;
  position: absolute;
  right: 0px;
  bottom: 0px;
  background: url("../img/touch.png");
  background-color: #111;

  background-position: bottom right;
}

#allStreams {
  padding: 2px;
}

#activeStreams .tdKey,
#inactiveStreams .tdKey {
  width: 115px;
  letter-spacing: 0px;
}

caption {
  color: #FFF;
  font-size: 2em;
}

.tdKey {
  text-align: left;
}

.tdVal {
  text-align: left;
}

.modal-header {
  background-color: #212529;
}
.modal-body {
  background-color: #444;
}

#inactiveStreams .tdKey {
  color: red;
}

#clientInfo .tdVal,
#logInfo .tdVal,
#activeStreams .tdVal,
#inactiveStreams .tdVal,
#mappingInfo .tdVal {
  color: #aaa;
  white-space: inherit;
}

#box-wrapper {
  display: inline-block;
  width: 100%;

  overflow-y: scroll;
}

#contentTable,
#inactiveContentTable,
#mapping-detail-table,
#contentTable {
  display: table;
  --bs-table-color: none;
  border-collapse: collapse;
  overflow-y: scroll;
}

#inactiveContentTable {
  margin-top: 2%;
}


#contentTable .contentTableHeader,
#inactiveContentTable .inactiveContentTableHeader {
  background-color: #333;
  height: 50px;
  border-bottom: solid 1px #111;
  border-left: solid 3px #333;
  cursor: auto;

}


tbody {
  width: 100%;
}


.tableEllipsis {
  width: 150px;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}

#contentTable img,
#inactiveContentTable img {
  display: block;
  margin-left: auto;
  margin-right: auto;
  max-width: 60px;
}

#contentTable tr,
#inactiveContentTable tr {
  border-left: solid 3px 444;
  border-bottom: solid 1px #333;
  cursor: pointer;
}

#contentTable tr:hover,
#inactiveContentTable tr:hover {
  background-color: #333;
}

#contentTable td,
#inactiveContentTable td {

  padding: 0px 2px;
}

#contentTable input[type=text],
#inactiveContentTable input[type=text] {
  width: 80%;
  min-width: 35px;
  max-width: 60px;
  border: 0px;
  background-color: #333;
  margin-left: 5px;
  text-align: left;
}

#contentTable input[type=checkbox],
#inactiveContentTable input[type=checkbox] {
  max-width: 25px;
  margin: auto;
}


.showBulk {
  display: block;
}

.hideBulk {
  display: none;
}

#contentTable tr.activeEPG,
#inactiveContentTable tr.activeEPG {
  border-left: solid 3px lawngreen;
}

#contentTable tr.notActiveEPG,
#inactiveContentTable tr.notActiveEPG {
  border-left: solid 3px red;
}


#logScreen p {
  white-space: pre;
  font-size: 10px;
  /*
  line-height: 1.6em;
  font-family: "Arial", sans-serif;
  */
  letter-spacing: 1px;
  font-family: monospace;
  font-size: 12px;
  font-style: normal;
  font-variant: normal;
  line-height: 1.6em;
}

#mapping-detail,
#user-detail,
#file-detail {
  box-shadow: 0px 5px 40px #000;
  margin-top: 20px;
  margin-left: auto;
  margin-right: auto;

  max-width: 600px;
  background-color: #222;
  padding: 10px;
  overflow: auto;
}

#file-detail input[type=text] {
  width: -webkit-calc(100% - 20px);
  width: -moz-calc(100% - 20px);
  width: calc(100% - 20px);
}

#mapping-detail img {
  display: block;
  max-height: 30px;
  margin-bottom: 20px;
  margin-left: auto;
  margin-right: auto;
}

#mapping-detail input[type=text],
#content_settings input[type=text],
#content_settings input[type=password] {
  border: solid 1px;
  border-color: transparent;
  background-color: #333;
  text-align: left;
  width: -webkit-calc(100% - 20px);
  width: -moz-calc(100% - 20px);
  width: calc(100% - 20px);
}

#mapping-detail-table,
#user-detail-table {
  display: inline-table;
  width: 100%;
}

#content_settings table {
  display: inline-table;
  table-layout: fixed;
  width: 100%;
}


#mapping-detail-table td,
#user-detail-table td {
  padding: 10px 0px;

}

#mapping-detail-table td.left,
#user-detail-table td.left {
  width: 38%;
}

.interaction,
#interaction {
  margin-top: 20px;
  display: inline-flex;
  float: right;
}

.interaction input[type=button],
.interaction input[type=submit] {
  background-color: #000;
  min-width: 100px;
  margin: 0px 10px;
  text-align: center;
}

#notification {
  display: block;
  position: fixed;
  right: 0px;
  height: 100%;
  width: 250px;

  background-color: #222;
  box-shadow: 0px 0px 20px #000;
}

#notification h5 {
  background-color: #121212;
  padding: 5px 10px 5px 10px;
}

#notification pre {
  padding: 0px 10px 0px 10px;
}

#notification p {
  font-size: 10 px;
  margin: 0px;
  padding: 0px 10px 5px 10px;
}

#notification .element {
  /*padding: 0px 5px;*/
  margin: 5px 5px;
  border-radius: 5px;
  background-color: #181818;
  border-left: 10px solid green;
}


@media only screen and (min-width: 620px) {
  body {
    width: 100%;
    background-color: #444;
  }

  h1 {
    font-size: 26px;
    letter-spacing: 3px;
  }

  nav p {
    display: block;
  }



  #header_config {
    display: block;
    height: 100px;
    background: url("../img/logo_w_600x200.png");
    background-repeat: no-repeat;

    background-size: 300px 100px;
  }

  #screenLog {
    margin-left: 300px;

    transition: none;
    background-color: transparent;
    border-bottom: solid 1px transparent;
    box-shadow: 0px 0px 0px #222;
  }

  #settings {
    /*
    height: -webkit-calc(100% - 100px);
    height: -moz-calc(100% - 100px);
    height: calc(100% - 100px);
    */
    position: relative;
    overflow: auto;
  }


  .screenLogHidden {
    transform: translate(0px, 0px);
  }


  #box {
    display: block;
    min-height: 500px;
    max-width: 500px;
    margin: 10px auto;
    background-color: #444;
    box-shadow: 0px 5px 5px #222;

    display: flex;
    flex-direction: column;
  }
}

@media only screen and (max-width: 620px) {
  body {
    background-color: #444; /* Ensure the background color is consistent */
  }

  /* Add any other styles specific to small devices here */
}


/*
=============== 
Sidebar
===============
*/
:root {
  /* dark shades of primary color*/
  --clr-primary-1: hsl(205, 86%, 17%);
  --clr-primary-2: hsl(205, 77%, 27%);
  --clr-primary-3: hsl(205, 72%, 37%);
  --clr-primary-4: hsl(205, 63%, 48%);
  /* primary/main color */
  --clr-primary-5: hsl(205, 78%, 60%);
  /* lighter shades of primary color */
  --clr-primary-6: hsl(205, 89%, 70%);
  --clr-primary-7: hsl(205, 90%, 76%);
  --clr-primary-8: hsl(205, 86%, 81%);
  --clr-primary-9: hsl(205, 90%, 88%);
  --clr-primary-10: hsl(205, 100%, 96%);
  /* darkest grey - used for headings */
  --clr-grey-1: hsl(209, 61%, 16%);
  --clr-grey-2: hsl(211, 39%, 23%);
  --clr-grey-3: hsl(209, 34%, 30%);
  --clr-grey-4: hsl(209, 28%, 39%);
  /* grey used for paragraphs */
  --clr-grey-5: hsl(210, 22%, 49%);
  --clr-grey-6: hsl(209, 23%, 60%);
  --clr-grey-7: hsl(211, 27%, 70%);
  --clr-grey-8: hsl(210, 31%, 80%);
  --clr-grey-9: hsl(212, 33%, 89%);
  --clr-grey-10: hsl(210, 36%, 96%);
  --clr-white: #fff;
  --clr-red-dark: hsl(360, 67%, 44%);
  --clr-red-light: hsl(360, 71%, 66%);
  --clr-green-dark: hsl(125, 67%, 44%);
  --clr-green-light: hsl(125, 71%, 66%);
  --clr-orange: hsl(14,93%,53%);
  --clr-black: #222;
  --ff-primary: 'Roboto', sans-serif;
  --ff-secondary: 'Open Sans', sans-serif;
  --transition: all 0.3s linear;
  --spacing: 0.1rem;
  --radius: 0.25rem;
  --light-shadow: 0 5px 15px rgba(0, 0, 0, 0.1);
  --dark-shadow: 0 5px 15px rgba(0, 0, 0, 0.2);
  --max-width: 1170px;
  --fixed-width: 620px;
}

.sidebar-toggle {
  position: fixed;
  top: 44rem;
  left: 11rem;
  font-size: 2rem;
  background: transparent;
  border-color: transparent;
  color: var(--clr-orange);
  transition: var(--transition);
  cursor: pointer;
  /* animation: bounce 10s ease-in-out infinite; */
}
.sidebar-toggle:hover {
  color: var(--clr-orange);
  animation: expand .5s ease-in forwards;
}
.sidebar-toggle:not(:hover) {
  color: var(--clr-orange);
  animation: collapse .5s ease-out forwards;
}
@keyframes expand {
  0% {
    transform: scale(1);
  }
  50% {
    transform: scale(1.5);
  }
  100% {
    transform: scale(1.25);
  }
}
@keyframes collapse {
  0% {
    transform: scale(1.25);
  }
  100% {
    transform: scale(1);
  }
}

.sidebar-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 1rem 1.5rem;
}
.close-btn {
  position: fixed;
  top: 44rem;
  left: 70rem;
  font-size: 2rem;
  background: transparent;
  border-color: transparent;
  color: var(--clr-orange);
  transition: var(--transition);
  cursor: pointer;
  display: none;
}
.close-btn:hover {
  color: var(--clr-orange);
  animation: expand .5s ease-in forwards;
}
.close-btn:not(:hover) {
  color: var(--clr-orange);
  animation: collapse .5s ease-out forwards;
}
.logo {
  justify-self: center;
  height: 40px;
}

.links a {
  display: block;
  font-size: 1.5rem;
  text-transform: capitalize;
  padding: 1rem 1.5rem;
  color: var(--clr-grey-5);
  transition: var(--transition);
}
.links a:hover {
  background: var(--clr-primary-8);
  color: var(--clr-primary-5);
  padding-left: 1.75rem;
}
.social-icons {
  justify-self: center;
  display: flex;
  padding-bottom: 2rem;
}
.social-icons a {
  font-size: 1.5rem;
  margin: 0 0.5rem;
  color: var(--clr-primary-5);
  transition: var(--transition);
}
.social-icons a:hover {
  color: var(--clr-primary-1);
}

.sidebar {
  position: fixed;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  background: var(--clr-black);
  display: grid;
  grid-template-rows: auto 1fr auto;
  row-gap: 1rem;
  box-shadow: var(--clr-red-dark);
  transition: var(--transition);
  transform: translate(-100%);
}
.show-sidebar {
  transform: translate(0);
}
.show-sidebar .close-btn {
  display: block;
}

.sidebar .card {
  width: 44em;
  margin: 3em;
}
.card {
  /* color: var(--clr-black); */
  border: 5px solid var(--clr-orange);
}
/* .card input[type=text] {
  color: var(--clr-black);
  outline: var(--clr-black);
  border: solid 1px var(--clr-black);
} */
.card label {
  margin-top: 2em;
}
.card label:first-of-type {
  margin-top: 1em;
}" - webUI["web/public/icons/chevron-double-up.svg"] = "PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiIgZmlsbD0id2hpdGUiIGNsYXNzPSJiaSBiaS1jaGV2cm9uLWRvdWJsZS11cCIgdmlld0JveD0iMCAwIDE2IDE2Ij4KICA8cGF0aCBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik03LjY0NiAyLjY0NmEuNS41IDAgMCAxIC43MDggMGw2IDZhLjUuNSAwIDAgMS0uNzA4LjcwOEw4IDMuNzA3IDIuMzU0IDkuMzU0YS41LjUgMCAxIDEtLjcwOC0uNzA4eiIvPgogIDxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgZD0iTTcuNjQ2IDYuNjQ2YS41LjUgMCAwIDEgLjcwOCAwbDYgNmEuNS41IDAgMCAxLS43MDguNzA4TDggNy43MDdsLTUuNjQ2IDUuNjQ3YS41LjUgMCAwIDEtLjcwOC0uNzA4eiIvPgo8L3N2Zz4=" + webUI["web/public/css/base.css"] = "*{
  /*
  -webkit-appearance: none;
  -moz-appearance: none;
  -ms-appearance: none;*/
  font-family: "Arial", sans-serif;
  letter-spacing: 2px;
}

/*
::-webkit-scrollbar { 
    display: none; 
}
*/

::-webkit-scrollbar {
  width: 12px;
  height: 12px;
}


::-webkit-scrollbar-track {
  -webkit-box-shadow: inset 0 0 6px rgba(0, 0, 0, 0.3);
  border-radius: 5px;

}

::-webkit-scrollbar-thumb {
  border-radius: 5px;
  -webkit-box-shadow: inset 0 0 6px rgba(0, 0, 0, 0.6);
  background-color: #444;
}

::-webkit-scrollbar-thumb:hover {
  background: #333;
}

::-webkit-scrollbar-corner {
  background: transparent;
}

a {
  color: #00E6FF;
}

html,
body {
  color: #fff;
  margin: 0px auto;
  height: 100%;
  font-size: 14px;
}

h2 {
  font-size: 24px;
  letter-spacing: 2px;
}

h3 {
  font-size: 22px;
  letter-spacing: 1px;
}

h4 {
  font-size: 20px;
  letter-spacing: 1px;
  line-height: 1.5em;

}

h5 {
  font-size: 16px;
  letter-spacing: 1px;
  line-height: 1.2em;
  margin: 0px auto;
  margin-left: 10px;
}

hr {
  border: 0;
  height: 1px;
  background: #333;
  margin: 10px 0px;
}

p {
  margin: 2px;
  padding: 2px 5px;
}

pre {
  margin: 0px 0px 5px 0px;
  font-size: 12px;
  color: #ddd;
  letter-spacing: 1px;
  white-space: pre-wrap;
  font-family: monospace;
  font-size: 12px;
  font-style: normal;
  font-variant: normal;
  line-height: 1.6em;
}

label {
  margin-bottom: 20px;
  display: block;
}

li {
  list-style-type: none;
  cursor: pointer;
  transition: all 0.3;
}

li:hover {
  border-color: #00E6FF
}

select {
  cursor: pointer;
  width: calc(100% + 2px);
  height: auto;
  border: solid 0px #00E6FF;
  border-radius: 0px;
  box-sizing: border-box;
  outline: none;
  color: #fff;
  padding: 9px 10px;
  display: block;
  background-color: #333;
  font-size: 14px;
  margin: 5px 0px 5px 0px;
}

select:focus {
  outline: none;
}

input {
  -webkit-appearance: unset;
  margin: 0px;
  padding: 2.5px 10px;
  outline: none;
  font-size: 14px;
}

input[type=button],
input[type=submit] {
  cursor: pointer;
  background-color: #000;
  margin: 10px 10px;
  padding: 10px 25px;
  border: solid 0px;
  border-color: #000;
  border-radius: 3px;
  outline: none;
  color: #fff;
}

input[type=button]:focus {
  outline: none;
}

input[type=button]:hover {
  background-color: #00E6FF;
  color: #000;
}

input[type=button]:hover.delete {
  background-color: red;
  color: #fff;
}

input[type=text],
input[type=search],
input[type=password] {
  color: #fff;
  width: -webkit-calc(100% - 0px);
  width: -moz-calc(100% - 0px);
  width: calc(100% - 0px);
  outline: none;
  border: solid 1px transparent;
  background-color: transparent;
  border-bottom-color: #555;
  border-radius: 0px;
  padding: 8px 10px;
}

input[type=checkbox] {
  border: solid 1px #00E6FF;
  background-color: #333;
  height: 25px;
  width: 25px;
  cursor: pointer;
}

input[type=checkbox]:checked {
  color: #fff;
  background-color: #00E6FF !important;
  /*display: inline-block;*/
}

input[type=checkbox]:before {
  position: initial;
  left: 0px;
  margin-left: -4px;
  content: " ";
}

input[type=checkbox]:checked:before {
  position: initial;
  left: 0px;
  margin-left: -3px;
  content: "✓";
  color: #000;
}

input[type=checkbox].bulk:checked:before {
  position: initial;
  left: 0px;
  margin-left: -3px;
  content: "✓";
  color: #000;
}

input[type=button].cancel {

  background-color: transparent;
  border-color: red;
}

input[type=button].save {
  background-color: #111;
  float: right;
}


input[type=button].black,
input[type=submit].black {
  background-color: #000;
  border-color: #000;
}

input[type=button].center {
  margin-right: auto;
  margin-left: auto;
  background-color: #000;
  border-color: #000;
}

.pointer {
  cursor: pointer;
}

.pointer:hover {
  color: #00E6FF;
  cursor: pointer;
}

.sortThis {
  color: #00E6FF;
}

.w40px {
  max-width: 40px;
}

.w50px {
  max-width: 50px;
}

.w80px {
  max-width: 80px;
}

.w150px {
  max-width: 150px;
}

.w200px {
  max-width: 200px;
  min-width: 100px;
  width: 200px;
  overflow-x: hidden;
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
}

.w300px {
  max-width: 300px;
}

.w220px {
  max-width: 220px;
  cursor: alias;
}

.footer {
  font-size: 10px;
}

.center {
  text-align: center;
}

.screenLogHidden {
  transform: translate(0px, -110px);
}

.borderSpace {
  margin-bottom: 30px;
}

.none {
  display: none;
}


.notVisible {
  height: 0px;
  display: none;
  opacity: 0;
  border-bottom: #000 solid 0px;

}

.visible {
  opacity: 1;
  display: block;
  border-bottom: #444 solid 1px;
  padding: 10px;
}

.floatRight {
  float: right;
}

.floatLeft {
  float: left;
}

.menu-active {
  background-color: #00E6FF;
}

table {
  width: 100%
}

#branch {
  color: red;
}

#interaction {
  margin-bottom: 100px;
  text-align: center;
  border-bottom: solid 0px #777;
}


.half {
  display: block;
  width: 45%;
}

.menu {
  border: solid 1px #00E6FF;
}

.infoMsg {
  color: #aaa;
}

.errorMsg {
  color: red;
}

.warningMsg {
  color: yellow;
}

.debugMsg {
  color: magenta;
}


.category {
  border-left: solid 2px
}

.news {
  border-color: tomato
}

.movie {
  border-color: royalblue;
}

.series {
  border-color: gold;
}

.sports {
  border-color: yellowgreen;
}

.kids {
  border-color: mediumpurple;
}

/* Loading */
#loading {
  left: 0px;
  top: 0px;
  z-index: 10000;
  position: absolute;
  background-color: rgba(0, 0, 0, 0.8);
  margin: auto;
  width: 100%;
  height: 100%;
}


.loader {
  border: 5px solid transparent;
  border-radius: 50%;
  border-top: 5px solid #00E6FF;
  border-bottom: 5px solid #00E6FF;
  width: 50px;
  height: 50px;
  -webkit-animation: spin 1.2s linear infinite;
  animation: spin 1.2s linear infinite;

  position: fixed;
  margin: auto;

  top: 0;
  right: 0;
  bottom: 0;
  left: 0;

}

.notification {
  background-color: #333;
  color: #fff;
  text-align: center;
  padding: 10px; /* Adjust padding as needed */
  position: fixed;
  bottom: 20px; /* Adjust position as needed */
  right: 20px; /* Adjust position as needed */
  z-index: 1000;
  display: none; /* Initially hidden */
  width: 300px; /* Adjust width as needed */
  max-height: calc(80vh - 10px); /* Adjust height as needed */
  border-radius: 10px; /* Optional: rounded corners */
  box-shadow: 0 0 10px rgba(0, 0, 0, 0.5); /* Optional: add shadow for better visibility */
}

.notification .header {
  display: flex;
  justify-content: space-between;
  align-items: center;
}

.notification .content {
  flex-grow: 1; /* Allow content to grow and take available space */
  overflow-y: auto; /* Enable vertical scrolling if content overflows */
  margin-bottom: 10px; /* Ensure there's a gap to the bottom */
}

.fa-style {
  color: #FFF;
  font-size: 25px;
}

.fa-style:hover {
  transform: scale(1.2);
}

.notificationContent {
  border-radius: 10px;
}

.updateNow {
  margin-bottom: 5px;
}

#backToTop {
  display: none; /* Hidden by default */
  position: fixed; /* Fixed/sticky position */
  bottom: 50px; /* Place the button at the bottom of the page */
  right: 50px; /* Place the button 30px from the right */
  z-index: 99; /* Make sure it does not overlap */
  border: none; /* Remove borders */
  outline: none; /* Remove outline */
  background-color: #000;
  cursor: pointer; /* Add a mouse pointer on hover */
  padding: 5px 10px 10px 10px; /* Some padding */
  border-radius: 5px; /* Rounded corners */
}

#backToTop:hover {
  background-color: #00E6FF; /* Add a dark-grey background on hover */
}

@-webkit-keyframes spin {
  0% {
    -webkit-transform: rotate(0deg);
  }

  100% {
    -webkit-transform: rotate(360deg);
  }
}

@keyframes spin {
  0% {
    transform: rotate(0deg);
  }

  100% {
    transform: rotate(360deg);
  }
}" + webUI["web/public/css/screen.css"] = "nav img {
  display: block;
  max-height: 20px;
  max-width: 20px;
  float: left;
}

nav p {
  text-align: left;
  padding: 0px 30px;
}

#layout {
  display: block;
  height: 100%;
}
/*
.form-control {
  background-color: #444;
  color: #FFF;
  pointer-events: none;
}*/

.form-control:disabled {
  background-color: transparent;
}

.layout-left {
  display: block;
  min-width: 150px;
  max-width: 20%;
  background-color: #111;
  height: inherit;
  float: left;
}

.layout-right {
  display: block;
  background-color: #444;
}

#menu-wrapper {
  height: 100%;
}


#logo {
  display: block;
  min-width: 180px;
  width: 100%;
  height: 100px;
  background: url("../img/threadfin.png");
  background-repeat: no-repeat;
  background-position: center;
  background-size: 100%;
}


#page {
  max-width: 950px;
  margin: auto;
  background-color: #444;

  /*
  height: -webkit-calc(100% - 130px);
  height: -moz-calc(100% - 130px);
  height: calc(100% - 130px);
  */

  min-height: -webkit-calc(100% - 120px);
  min-height: -moz-calc(100% - 120px);
  min-height: calc(100% - 120px);


  box-shadow: 0px 5px 5px #222;

}

#uiSetting {
  float: right;
  margin-right: 25px;
}

#box input[type=text],
#box input[type=password] {
  width: -webkit-calc(100% - 20px);
  width: -moz-calc(100% - 20px);
  width: calc(100% - 20px);
}

#box input[type=submit] {
  margin: 50px auto;
}

#settings {
  display: block;
  padding: 10px 10px;
}

#settings h5 {
  margin: 50px 0px 10px 0px;
}

#content-interaction .search {
  width: 200px;
  border: 1px solid #000;
  padding: 9px;
  background-color: #333;
  margin: 10px;
  float: right;
  border-radius: 3px;

}

#myStreams {
  position: fixed;
  bottom: 0px;
  background-color: #111;
  width: 100%;
  max-width: 950px;

  /*
  max-height: 100px;
  */
  margin-bottom: 0px;
}

#myStreams img {
  width: 4%;
  padding: 2px 5px;
  cursor: pointer;
  float: right;
}

/* Wizard*/
#box {
  background-color: #444;
  min-height: 400px;

  display: flex;
  flex-direction: column;
  justify-content: space-between;
}

#box p {
  padding: 10px 0px;
}

#box-footer {
  margin-top: auto;
}

#box-footer {
  margin: auto;
  padding: 10px;
}

#headline {
  background-color: #222;
  border-bottom: solid 2px #222;
  transition: all 0.5s;
  padding: 10px 0px;
  display: block;
}

#content {
  display: block;
  overflow: auto;
  padding: 10px;
}

/* --- */


#clientInfo,
#activeStreams,
#inactiveStreams {
  font-family: monospace;
  display: block;
  font-size: 12px;
  color: #00E6FF;
  padding: 0px;
}

#activeStreams thead,
#inactiveStreams thead {
  font-size: 2em;
}

#openStreams {
  width: 20px;
  height: 200px;
  cursor: pointer;
  float: right;
  position: absolute;
  right: 0px;
  bottom: 0px;
  background: url("../img/touch.png");
  background-color: #111;

  background-position: bottom right;
}

#allStreams {
  padding: 2px;
}

#activeStreams .tdKey,
#inactiveStreams .tdKey {
  width: 115px;
  letter-spacing: 0px;
}

caption {
  color: #FFF;
  font-size: 2em;
}

.tdKey {
  text-align: left;
}

.tdVal {
  text-align: left;
}

.modal-header {
  background-color: #212529;
}
.modal-body {
  background-color: #444;
}

#inactiveStreams .tdKey {
  color: red;
}

#clientInfo .tdVal,
#logInfo .tdVal,
#activeStreams .tdVal,
#inactiveStreams .tdVal,
#mappingInfo .tdVal {
  color: #aaa;
  white-space: inherit;
}

#box-wrapper {
  display: inline-block;
  width: 100%;

  overflow-y: scroll;
}

#contentTable,
#inactiveContentTable,
#mapping-detail-table,
#contentTable {
  display: table;
  --bs-table-color: none;
  border-collapse: collapse;
  overflow-y: scroll;
}

#inactiveContentTable {
  margin-top: 2%;
}


#contentTable .contentTableHeader,
#inactiveContentTable .inactiveContentTableHeader {
  background-color: #333;
  height: 50px;
  border-bottom: solid 1px #111;
  border-left: solid 3px #333;
  cursor: auto;

}


tbody {
  width: 100%;
}


.tableEllipsis {
  width: 150px;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}

#contentTable img,
#inactiveContentTable img {
  display: block;
  margin-left: auto;
  margin-right: auto;
  max-width: 60px;
}

#contentTable tr,
#inactiveContentTable tr {
  border-left: solid 3px 444;
  border-bottom: solid 1px #333;
  cursor: pointer;
}

#contentTable tr:hover,
#inactiveContentTable tr:hover {
  background-color: #333;
}

#contentTable td,
#inactiveContentTable td {

  padding: 0px 2px;
}

#contentTable input[type=text],
#inactiveContentTable input[type=text] {
  width: 80%;
  min-width: 35px;
  max-width: 60px;
  border: 0px;
  background-color: #333;
  margin-left: 5px;
  text-align: left;
}

/*
#contentTable input[type=checkbox],
#inactiveContentTable input[type=checkbox] {
  max-width: 25px;
  margin: auto;
}
*/


.showBulk {
  display: block;
}

.hideBulk {
  display: none;
}

#contentTable tr.activeEPG,
#inactiveContentTable tr.activeEPG {
  border-left: solid 3px lawngreen;
}

#contentTable tr.notActiveEPG,
#inactiveContentTable tr.notActiveEPG {
  border-left: solid 3px red;
}


#logScreen p {
  white-space: pre;
  font-size: 10px;
  /*
  line-height: 1.6em;
  font-family: "Arial", sans-serif;
  */
  letter-spacing: 1px;
  font-family: monospace;
  font-size: 12px;
  font-style: normal;
  font-variant: normal;
  line-height: 1.6em;
}

#mapping-detail,
#user-detail,
#file-detail {
  box-shadow: 0px 5px 40px #000;
  margin-top: 20px;
  margin-left: auto;
  margin-right: auto;

  max-width: 600px;
  background-color: #222;
  padding: 10px;
  overflow: auto;
}

#file-detail input[type=text] {
  width: -webkit-calc(100% - 20px);
  width: -moz-calc(100% - 20px);
  width: calc(100% - 20px);
}

#mapping-detail img {
  display: block;
  max-height: 30px;
  margin-bottom: 20px;
  margin-left: auto;
  margin-right: auto;
}

#mapping-detail input[type=text],
#content_settings input[type=text],
#content_settings input[type=password] {
  border: solid 1px;
  border-color: transparent;
  background-color: #333;
  text-align: left;
  width: -webkit-calc(100% - 20px);
  width: -moz-calc(100% - 20px);
  width: calc(100% - 20px);
}

#mapping-detail-table,
#user-detail-table {
  display: inline-table;
  width: 100%;
}

#content_settings table {
  display: inline-table;
  table-layout: fixed;
  width: 100%;
}


#mapping-detail-table td,
#user-detail-table td {
  padding: 10px 0px;

}

#mapping-detail-table td.left,
#user-detail-table td.left {
  width: 38%;
}

.interaction,
#interaction {
  margin-top: 20px;
  display: inline-flex;
  float: right;
}

.interaction input[type=button],
.interaction input[type=submit] {
  background-color: #000;
  min-width: 100px;
  margin: 0px 10px;
  text-align: center;
}

#notification {
  display: block;
  position: fixed;
  right: 0px;
  height: 100%;
  width: 250px;

  background-color: #222;
  box-shadow: 0px 0px 20px #000;
}

#notification h5 {
  background-color: #121212;
  padding: 5px 10px 5px 10px;
}

#notification pre {
  padding: 0px 10px 0px 10px;
}

#notification p {
  font-size: 10 px;
  margin: 0px;
  padding: 0px 10px 5px 10px;
}

#notification .element {
  /*padding: 0px 5px;*/
  margin: 5px 5px;
  border-radius: 5px;
  background-color: #181818;
  border-left: 10px solid green;
}


@media only screen and (min-width: 620px) {
  body {
    width: 100%;
    background-color: #444;
  }

  h1 {
    font-size: 26px;
    letter-spacing: 3px;
  }

  nav p {
    display: block;
  }



  #header_config {
    display: block;
    height: 100px;
    background: url("../img/logo_w_600x200.png");
    background-repeat: no-repeat;

    background-size: 300px 100px;
  }

  #screenLog {
    margin-left: 300px;

    transition: none;
    background-color: transparent;
    border-bottom: solid 1px transparent;
    box-shadow: 0px 0px 0px #222;
  }

  #settings {
    /*
    height: -webkit-calc(100% - 100px);
    height: -moz-calc(100% - 100px);
    height: calc(100% - 100px);
    */
    position: relative;
    overflow: auto;
  }


  .screenLogHidden {
    transform: translate(0px, 0px);
  }


  #box {
    display: block;
    min-height: 500px;
    max-width: 500px;
    margin: 10px auto;
    background-color: #444;
    box-shadow: 0px 5px 5px #222;

    display: flex;
    flex-direction: column;
  }
}

@media only screen and (max-width: 620px) {
  body {
    background-color: #444; /* Ensure the background color is consistent */
  }

  /* Add any other styles specific to small devices here */
}


/*
=============== 
Sidebar
===============
*/
:root {
  /* dark shades of primary color*/
  --clr-primary-1: hsl(205, 86%, 17%);
  --clr-primary-2: hsl(205, 77%, 27%);
  --clr-primary-3: hsl(205, 72%, 37%);
  --clr-primary-4: hsl(205, 63%, 48%);
  /* primary/main color */
  --clr-primary-5: hsl(205, 78%, 60%);
  /* lighter shades of primary color */
  --clr-primary-6: hsl(205, 89%, 70%);
  --clr-primary-7: hsl(205, 90%, 76%);
  --clr-primary-8: hsl(205, 86%, 81%);
  --clr-primary-9: hsl(205, 90%, 88%);
  --clr-primary-10: hsl(205, 100%, 96%);
  /* darkest grey - used for headings */
  --clr-grey-1: hsl(209, 61%, 16%);
  --clr-grey-2: hsl(211, 39%, 23%);
  --clr-grey-3: hsl(209, 34%, 30%);
  --clr-grey-4: hsl(209, 28%, 39%);
  /* grey used for paragraphs */
  --clr-grey-5: hsl(210, 22%, 49%);
  --clr-grey-6: hsl(209, 23%, 60%);
  --clr-grey-7: hsl(211, 27%, 70%);
  --clr-grey-8: hsl(210, 31%, 80%);
  --clr-grey-9: hsl(212, 33%, 89%);
  --clr-grey-10: hsl(210, 36%, 96%);
  --clr-white: #fff;
  --clr-red-dark: hsl(360, 67%, 44%);
  --clr-red-light: hsl(360, 71%, 66%);
  --clr-green-dark: hsl(125, 67%, 44%);
  --clr-green-light: hsl(125, 71%, 66%);
  --clr-orange: hsl(14,93%,53%);
  --clr-black: #222;
  --ff-primary: 'Roboto', sans-serif;
  --ff-secondary: 'Open Sans', sans-serif;
  --transition: all 0.3s linear;
  --spacing: 0.1rem;
  --radius: 0.25rem;
  --light-shadow: 0 5px 15px rgba(0, 0, 0, 0.1);
  --dark-shadow: 0 5px 15px rgba(0, 0, 0, 0.2);
  --max-width: 1170px;
  --fixed-width: 620px;
}

.sidebar-toggle {
  position: fixed;
  top: 44rem;
  left: 11rem;
  font-size: 2rem;
  background: transparent;
  border-color: transparent;
  color: var(--clr-orange);
  transition: var(--transition);
  cursor: pointer;
  /* animation: bounce 10s ease-in-out infinite; */
}
.sidebar-toggle:hover {
  color: var(--clr-orange);
  animation: expand .5s ease-in forwards;
}
.sidebar-toggle:not(:hover) {
  color: var(--clr-orange);
  animation: collapse .5s ease-out forwards;
}
@keyframes expand {
  0% {
    transform: scale(1);
  }
  50% {
    transform: scale(1.5);
  }
  100% {
    transform: scale(1.25);
  }
}
@keyframes collapse {
  0% {
    transform: scale(1.25);
  }
  100% {
    transform: scale(1);
  }
}

.sidebar-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 1rem 1.5rem;
}
.close-btn {
  position: fixed;
  top: 44rem;
  left: 70rem;
  font-size: 2rem;
  background: transparent;
  border-color: transparent;
  color: var(--clr-orange);
  transition: var(--transition);
  cursor: pointer;
  display: none;
}
.close-btn:hover {
  color: var(--clr-orange);
  animation: expand .5s ease-in forwards;
}
.close-btn:not(:hover) {
  color: var(--clr-orange);
  animation: collapse .5s ease-out forwards;
}
.logo {
  justify-self: center;
  height: 40px;
}

.links a {
  display: block;
  font-size: 1.5rem;
  text-transform: capitalize;
  padding: 1rem 1.5rem;
  color: var(--clr-grey-5);
  transition: var(--transition);
}
.links a:hover {
  background: var(--clr-primary-8);
  color: var(--clr-primary-5);
  padding-left: 1.75rem;
}
.social-icons {
  justify-self: center;
  display: flex;
  padding-bottom: 2rem;
}
.social-icons a {
  font-size: 1.5rem;
  margin: 0 0.5rem;
  color: var(--clr-primary-5);
  transition: var(--transition);
}
.social-icons a:hover {
  color: var(--clr-primary-1);
}

.sidebar {
  position: fixed;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  background: var(--clr-black);
  display: grid;
  grid-template-rows: auto 1fr auto;
  row-gap: 1rem;
  box-shadow: var(--clr-red-dark);
  transition: var(--transition);
  transform: translate(-100%);
}
.show-sidebar {
  transform: translate(0);
}
.show-sidebar .close-btn {
  display: block;
}

.sidebar .card {
  width: 44em;
  margin: 3em;
}
.card {
  /* color: var(--clr-black); */
  border: 5px solid var(--clr-orange);
}
/* .card input[type=text] {
  color: var(--clr-black);
  outline: var(--clr-black);
  border: solid 1px var(--clr-black);
} */
.card label {
  margin-top: 2em;
}
.card label:first-of-type {
  margin-top: 1em;
}" + webUI["web/public/icons/chevron-double-up.svg"] = "PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiIgZmlsbD0id2hpdGUiIGNsYXNzPSJiaSBiaS1jaGV2cm9uLWRvdWJsZS11cCIgdmlld0JveD0iMCAwIDE2IDE2Ij4NCiAgPHBhdGggZmlsbC1ydWxlPSJldmVub2RkIiBkPSJNNy42NDYgMi42NDZhLjUuNSAwIDAgMSAuNzA4IDBsNiA2YS41LjUgMCAwIDEtLjcwOC43MDhMOCAzLjcwNyAyLjM1NCA5LjM1NGEuNS41IDAgMSAxLS43MDgtLjcwOHoiLz4NCiAgPHBhdGggZmlsbC1ydWxlPSJldmVub2RkIiBkPSJNNy42NDYgNi42NDZhLjUuNSAwIDAgMSAuNzA4IDBsNiA2YS41LjUgMCAwIDEtLjcwOC43MDhMOCA3LjcwN2wtNS42NDYgNS42NDdhLjUuNSAwIDAgMS0uNzA4LS43MDh6Ii8+DQo8L3N2Zz4=" webUI["web/public/img/filter.png"] = "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" webUI["web/public/img/log.png"] = "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" webUI["web/public/img/logout.png"] = "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" @@ -26,26 +26,26 @@ func loadHTMLMap() { webUI["web/public/img/xmltv.png"] = "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" webUI["web/public/js/authentication.js"] = "ZnVuY3Rpb24gbG9naW4oKSB7CiAgICB2YXIgZXJyID0gZmFsc2U7CiAgICB2YXIgZGF0YSA9IG5ldyBPYmplY3QoKTsKICAgIHZhciBkaXYgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29udGVudCIpOwogICAgdmFyIGZvcm0gPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiYXV0aGVudGljYXRpb24iKTsKICAgIHZhciBpbnB1dHMgPSBkaXYuZ2V0RWxlbWVudHNCeVRhZ05hbWUoIklOUFVUIik7CiAgICBjb25zb2xlLmxvZyhpbnB1dHMpOwogICAgZm9yICh2YXIgaSA9IGlucHV0cy5sZW5ndGggLSAxOyBpID49IDA7IGktLSkgewogICAgICAgIHZhciBrZXkgPSBpbnB1dHNbaV0ubmFtZTsKICAgICAgICB2YXIgdmFsdWUgPSBpbnB1dHNbaV0udmFsdWU7CiAgICAgICAgaWYgKHZhbHVlLmxlbmd0aCA9PSAwKSB7CiAgICAgICAgICAgIGlucHV0c1tpXS5zdHlsZS5ib3JkZXJDb2xvciA9ICJyZWQiOwogICAgICAgICAgICBlcnIgPSB0cnVlOwogICAgICAgIH0KICAgICAgICBkYXRhW2tleV0gPSB2YWx1ZTsKICAgIH0KICAgIGlmIChlcnIgPT0gdHJ1ZSkgewogICAgICAgIGRhdGEgPSBuZXcgT2JqZWN0KCk7CiAgICAgICAgcmV0dXJuOwogICAgfQogICAgaWYgKGRhdGEuaGFzT3duUHJvcGVydHkoImNvbmZpcm0iKSkgewogICAgICAgIGlmIChkYXRhWyJjb25maXJtIl0gIT0gZGF0YVsicGFzc3dvcmQiXSkgewogICAgICAgICAgICBhbGVydCgic2RhZnNkIik7CiAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdwYXNzd29yZCcpLnN0eWxlLmJvcmRlckNvbG9yID0gInJlZCI7CiAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25maXJtJykuc3R5bGUuYm9yZGVyQ29sb3IgPSAicmVkIjsKICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImVyciIpLmlubmVySFRNTCA9ICJ7ey5hY2NvdW50LmZhaWxlZH19IjsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIH0KICAgIH0KICAgIGNvbnNvbGUubG9nKGRhdGEpOwogICAgZm9ybS5zdWJtaXQoKTsKfQovLyMgc291cmNlTWFwcGluZ1VSTD1hdXRoZW50aWNhdGlvbi5qcy5tYXA=" webUI["web/public/js/authentication.js.map"] = "eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aGVudGljYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHMvYXV0aGVudGljYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsU0FBUyxLQUFLO0lBQ1osSUFBSSxHQUFHLEdBQVcsS0FBSyxDQUFBO0lBQ3ZCLElBQUksSUFBSSxHQUFHLElBQUksTUFBTSxFQUFFLENBQUE7SUFDdkIsSUFBSSxHQUFHLEdBQU8sUUFBUSxDQUFDLGNBQWMsQ0FBQyxTQUFTLENBQUMsQ0FBQTtJQUNoRCxJQUFJLElBQUksR0FBTyxRQUFRLENBQUMsY0FBYyxDQUFDLGdCQUFnQixDQUFDLENBQUE7SUFFeEQsSUFBSSxNQUFNLEdBQU8sR0FBRyxDQUFDLG9CQUFvQixDQUFDLE9BQU8sQ0FBQyxDQUFBO0lBRWxELE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUE7SUFFbkIsS0FBSyxJQUFJLENBQUMsR0FBRyxNQUFNLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUM7UUFFNUMsSUFBSSxHQUFHLEdBQVcsTUFBTSxDQUFDLENBQUMsQ0FBc0IsQ0FBQyxJQUFJLENBQUE7UUFDckQsSUFBSSxLQUFLLEdBQVcsTUFBTSxDQUFDLENBQUMsQ0FBc0IsQ0FBQyxLQUFLLENBQUE7UUFFeEQsSUFBSSxLQUFLLENBQUMsTUFBTSxJQUFJLENBQUMsRUFBRSxDQUFDO1lBQ3RCLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsV0FBVyxHQUFHLEtBQUssQ0FBQTtZQUNuQyxHQUFHLEdBQUcsSUFBSSxDQUFBO1FBQ1osQ0FBQztRQUVELElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxLQUFLLENBQUE7SUFFbkIsQ0FBQztJQUVELElBQUksR0FBRyxJQUFJLElBQUksRUFBRSxDQUFDO1FBQ2hCLElBQUksR0FBRyxJQUFJLE1BQU0sRUFBRSxDQUFBO1FBQ25CLE9BQU07SUFDUixDQUFDO0lBRUQsSUFBSSxJQUFJLENBQUMsY0FBYyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUM7UUFFbkMsSUFBSSxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksSUFBSSxDQUFDLFVBQVUsQ0FBQyxFQUFFLENBQUM7WUFDeEMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUFBO1lBQ2YsUUFBUSxDQUFDLGNBQWMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxLQUFLLENBQUMsV0FBVyxHQUFHLEtBQUssQ0FBQTtZQUM3RCxRQUFRLENBQUMsY0FBYyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxXQUFXLEdBQUcsS0FBSyxDQUFBO1lBRTVELFFBQVEsQ0FBQyxjQUFjLENBQUMsS0FBSyxDQUFDLENBQUMsU0FBUyxHQUFHLHFCQUFxQixDQUFBO1lBQ2hFLE9BQU07UUFDUixDQUFDO0lBRUgsQ0FBQztJQUVELE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUE7SUFFakIsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO0FBRWhCLENBQUMifQ==" - webUI["web/public/js/base.js"] = "var SERVER;
var BULK_EDIT = false;
var COLUMN_TO_SORT;
var INACTIVE_COLUMN_TO_SORT;
var SEARCH_MAPPING = new Object();
var UNDO = new Object();
var SERVER_CONNECTION = false;
var WS_AVAILABLE = false;
var tooltipTriggerList;
var tooltipList;
const clipboard = new ClipboardJS('.copy-btn');
clipboard.on('success', function (e) {
    const tooltip = bootstrap.Tooltip.getInstance(e.trigger);
    if (tooltip) {
        const prevContent = tooltip._config.title;
        tooltip.setContent({ '.tooltip-inner': 'Copied!' });
        tooltip.show();
        setTimeout(() => {
            tooltip.setContent({ '.tooltip-inner': prevContent });
        }, 3000);
    }
    else {
        console.error('Tooltip instance not found for element:', e.trigger);
    }
});
clipboard.on('error', function (e) {
    console.log(e);
});
var popupModal = new bootstrap.Modal(document.getElementById("popup"), {
    keyboard: true,
    focus: true,
    backdrop: 'static'
});
var loadingModal = new bootstrap.Modal(document.getElementById("loading"), {
    keyboard: true,
    focus: true
});
// Menü
var menuItems = new Array();
menuItems.push(new MainMenuItem("playlist", "{{.mainMenu.item.playlist}}", "m3u.png", "{{.mainMenu.headline.playlist}}"));
menuItems.push(new MainMenuItem("xmltv", "{{.mainMenu.item.xmltv}}", "xmltv.png", "{{.mainMenu.headline.xmltv}}"));
menuItems.push(new MainMenuItem("filter", "{{.mainMenu.item.filter}}", "filter.png", "{{.mainMenu.headline.filter}}"));
menuItems.push(new MainMenuItem("mapping", "{{.mainMenu.item.mapping}}", "mapping.png", "{{.mainMenu.headline.mapping}}"));
menuItems.push(new MainMenuItem("users", "{{.mainMenu.item.users}}", "users.png", "{{.mainMenu.headline.users}}"));
menuItems.push(new MainMenuItem("settings", "{{.mainMenu.item.settings}}", "settings.png", "{{.mainMenu.headline.settings}}"));
menuItems.push(new MainMenuItem("log", "{{.mainMenu.item.log}}", "log.png", "{{.mainMenu.headline.log}}"));
menuItems.push(new MainMenuItem("logout", "{{.mainMenu.item.logout}}", "logout.png", "{{.mainMenu.headline.logout}}"));
// Kategorien für die Einstellungen
var settingsCategory = new Array();
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.general}}", "ThreadfinAutoUpdate,ssdp,tuner,epgSource,epgCategories,epgCategoriesColors,dummy,dummyChannel,ignoreFilters,api"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.customization}}", "uploadCustomImage"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.webclient}}", "webclient.language"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.files}}", "update,files.update,temp.path,cache.images,omitPorts,xepg.replace.missing.images,xepg.replace.channel.title,enableNonAscii"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.network}}", "bindingIPs,threadfinDomain,useHttps,forceClientHttps,forceHttps"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.streaming}}", "buffer,udpxy,buffer.size.kb,storeBufferInRAM,buffer.timeout,buffer.autoReconnect,user.agent,ffmpeg.path,ffmpeg.options,vlc.path,vlc.options"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.backup}}", "backup.path,backup.keep"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.authentication}}", "authentication.web,authentication.pms,authentication.m3u,authentication.xml,authentication.api"));
var serverInformation = new Array();
serverInformation.push(new ServerInformationItem("{{.serverInfo.header.serverInfo}}", "version,errors,warnings"));
serverInformation.push(new ServerInformationItem("{{.serverInfo.header.streamInfo}}", "dvr,m3uUrl,xepgUrl,streams,xepg"));
serverInformation.push(new ServerInformationItem("{{.serverInfo.header.changeVersion}}", "changeVersion"));
function showElement(elmID, show) {
    if (elmID == "popupCustom" || elmID == "popup") {
        switch (show) {
            case true:
                popupModal.show();
                break;
            case false:
                popupModal.hide();
                break;
        }
    }
    if (elmID == "loading") {
        switch (show) {
            case true:
                loadingModal.show();
                break;
            case false:
                loadingModal.hide();
                break;
        }
    }
}
function changeButtonAction(element, buttonID, attribute) {
    var value = element.options[element.selectedIndex].value;
    document.getElementById(buttonID).setAttribute(attribute, value);
}
function getLocalData(dataType, id) {
    var data = new Object();
    switch (dataType) {
        case "m3u":
            data = SERVER["settings"]["files"][dataType][id];
            break;
        case "hdhr":
            data = SERVER["settings"]["files"][dataType][id];
            break;
        case "filter":
        case "custom-filter":
        case "group-title":
            if (id == -1) {
                data["active"] = true;
                data["caseSensitive"] = false;
                data["description"] = "";
                data["exclude"] = "";
                data["filter"] = "";
                data["include"] = "";
                data["name"] = "";
                data["type"] = "group-title";
                data["x-category"] = "";
                SERVER["settings"]["filter"][id] = data;
            }
            data = SERVER["settings"]["filter"][id];
            break;
        case "xmltv":
            data = SERVER["settings"]["files"][dataType][id];
            break;
        case "users":
            data = SERVER["users"][id]["data"];
            break;
        case "mapping":
            data = SERVER["xepg"]["epgMapping"][id];
            break;
        case "m3uGroups":
            data = SERVER["data"]["playlist"]["m3u"]["groups"];
            break;
    }
    return data;
}
function getObjKeys(obj) {
    var keys = new Array();
    for (var i in obj) {
        if (obj.hasOwnProperty(i)) {
            keys.push(i);
        }
    }
    return keys;
}
function getOwnObjProps(object) {
    return object ? Object.getOwnPropertyNames(object) : [];
}
function getAllSelectedChannels() {
    var channels = new Array();
    if (BULK_EDIT == false) {
        return channels;
    }
    var trs = document.getElementById("contentTable").getElementsByTagName("TR");
    for (var i = 1; i < trs.length; i++) {
        if (trs[i].style.display != "none") {
            if (trs[i].firstChild.firstChild.checked == true) {
                channels.push(trs[i].id);
            }
        }
    }
    var trs_inactive = document.getElementById("inactiveContentTable").getElementsByTagName("TR");
    for (var i = 1; i < trs_inactive.length; i++) {
        if (trs_inactive[i].style.display != "none") {
            if (trs_inactive[i].firstChild.firstChild.checked == true) {
                channels.push(trs_inactive[i].id);
            }
        }
    }
    return channels;
}
function selectAllChannels(table_name = "contentTable") {
    var bulk = false;
    var trs = document.getElementById(table_name).getElementsByTagName("TR");
    if (trs[0].firstChild.firstChild.checked == true) {
        bulk = true;
    }
    for (var i = 1; i < trs.length; i++) {
        if (trs[i].style.display != "none") {
            switch (bulk) {
                case true:
                    trs[i].firstChild.firstChild.checked = true;
                    break;
                case false:
                    trs[i].firstChild.firstChild.checked = false;
                    break;
            }
        }
    }
    return;
}
function bulkEdit() {
    BULK_EDIT = !BULK_EDIT;
    var className;
    var rows = document.getElementsByClassName("bulk");
    switch (BULK_EDIT) {
        case true:
            className = "bulk showBulk";
            break;
        case false:
            className = "bulk hideBulk";
            break;
    }
    for (var i = 0; i < rows.length; i++) {
        rows[i].className = className;
        rows[i].checked = false;
    }
    return;
}
function sortTable(column, table_name = "contentTable") {
    // console.log("COLUMN: " + column);
    if ((column == COLUMN_TO_SORT && table_name == "contentTable") || (column == INACTIVE_COLUMN_TO_SORT && table_name == "inactiveContentTable")) {
        return;
    }
    var table = document.getElementById(table_name);
    var tableHead = table.getElementsByTagName("TR")[0];
    var tableItems = tableHead.getElementsByTagName("TD");
    var sortObj = new Object();
    var x, xValue;
    var tableHeader;
    var sortByString = false;
    if (column > 0 && COLUMN_TO_SORT > 0 && table_name == "contentTable") {
        tableItems[COLUMN_TO_SORT].className = "pointer";
        tableItems[column].className = "sortThis";
    }
    else if (column > 0 && INACTIVE_COLUMN_TO_SORT > 0 && table_name == "inactiveContentTable") {
        tableItems[INACTIVE_COLUMN_TO_SORT].className = "pointer";
        tableItems[column].className = "sortThis";
    }
    if (table_name == "contentTable") {
        COLUMN_TO_SORT = column;
    }
    else if (table_name == "inactiveContentTable") {
        INACTIVE_COLUMN_TO_SORT = column;
    }
    var rows = table.rows;
    if (rows[1] != undefined) {
        tableHeader = rows[0];
        x = rows[1].getElementsByTagName("TD")[column];
        for (i = 1; i < rows.length; i++) {
            x = rows[i].getElementsByTagName("TD")[column];
            switch (x.childNodes[0].tagName.toLowerCase()) {
                case "input":
                    xValue = x.getElementsByTagName("INPUT")[0].value.toLowerCase();
                    break;
                case "p":
                    xValue = x.getElementsByTagName("P")[0].innerText.toLowerCase();
                    break;
                default: console.log(x.childNodes[0].tagName);
            }
            if (xValue == "") {
                xValue = i;
                sortObj[i] = rows[i];
            }
            else {
                switch (isNaN(xValue)) {
                    case false:
                        xValue = parseFloat(xValue);
                        sortObj[xValue] = rows[i];
                        break;
                    case true:
                        sortByString = true;
                        sortObj[xValue.toLowerCase() + i] = rows[i];
                        break;
                }
            }
        }
        while (table.firstChild) {
            table.removeChild(table.firstChild);
        }
        var sortValues = getObjKeys(sortObj);
        if (sortByString == true) {
            if (column == 3) {
                var collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
                sortValues.sort(collator.compare);
            }
            else {
                sortValues.sort();
            }
        }
        else {
            function sortFloat(a, b) {
                return a - b;
            }
            sortValues.sort(sortFloat);
        }
        table.appendChild(tableHeader);
        for (var i = 0; i < sortValues.length; i++) {
            table.appendChild(sortObj[sortValues[i]]);
        }
    }
    return;
}
function createSearchObj() {
    SEARCH_MAPPING = new Object();
    var data = SERVER["xepg"]["epgMapping"];
    var channels = getObjKeys(data);
    var channelKeys = ["x-active", "x-channelID", "x-name", "_file.m3u.name", "x-group-title", "x-xmltv-file"];
    channels.forEach(id => {
        channelKeys.forEach(key => {
            if (key == "x-active") {
                switch (data[id][key]) {
                    case true:
                        SEARCH_MAPPING[id] = "online ";
                        break;
                    case false:
                        SEARCH_MAPPING[id] = "offline ";
                        break;
                }
            }
            else {
                if (key == "x-xmltv-file") {
                    var xmltvFile = getValueFromProviderFile(data[id][key], "xmltv", "name");
                    if (xmltvFile != undefined) {
                        SEARCH_MAPPING[id] = SEARCH_MAPPING[id] + xmltvFile + " ";
                    }
                }
                else {
                    SEARCH_MAPPING[id] = SEARCH_MAPPING[id] + data[id][key] + " ";
                }
            }
        });
    });
    return;
}
function enableGroupSelection(selector) {
    var lastcheck = null; // no checkboxes clicked yet
    // get desired checkboxes
    var checkboxes = document.querySelectorAll(selector);
    // loop over checkboxes to add event listener
    Array.prototype.forEach.call(checkboxes, function (cbx, idx) {
        cbx.addEventListener('click', function (evt) {
            // test for shift key, not first checkbox, and not same checkbox
            if (evt.shiftKey && null !== lastcheck && idx !== lastcheck) {
                // get range of checks between last-checkbox and shift-checkbox
                // Math.min/max does our sorting for us
                Array.prototype.slice.call(checkboxes, Math.min(lastcheck, idx), Math.max(lastcheck, idx))
                    // and loop over each
                    .forEach(function (ccbx) {
                    ccbx.checked = true;
                });
            }
            lastcheck = idx; // set this checkbox as last-checked for later
        });
    });
}
function searchInMapping() {
    var searchValue = document.getElementById("searchMapping").value;
    var trs = document.getElementById("contentTable").getElementsByTagName("TR");
    for (var i = 1; i < trs.length; ++i) {
        var id = trs[i].getAttribute("id");
        var element = SEARCH_MAPPING[id];
        switch (element.toLowerCase().includes(searchValue.toLowerCase())) {
            case true:
                document.getElementById(id).style.display = "";
                break;
            case false:
                document.getElementById(id).style.display = "none";
                break;
        }
    }
    return;
}
function changeChannelNumbers(elements) {
    var starting_number_element = document.getElementsByName("x-channels-start")[0];
    var elems = elements.split(",");
    var starting_number = parseFloat(starting_number_element.value);
    var data = SERVER["xepg"]["epgMapping"];
    elems.forEach(element => {
        var elem = document.getElementById(element);
        var input = elem.childNodes[1].firstChild;
        input.value = starting_number.toString();
        data[element]["x-channelID"] = starting_number.toString();
        starting_number++;
    });
    if (COLUMN_TO_SORT == 1) {
        COLUMN_TO_SORT = -1;
        sortTable(1);
    }
    if (INACTIVE_COLUMN_TO_SORT == 1) {
        INACTIVE_COLUMN_TO_SORT = -1;
        sortTable(1, "inactive_content_page");
    }
}
function changeChannelNumber(element) {
    var dbID = element.parentNode.parentNode.id;
    var newNumber = parseFloat(element.value);
    var channelNumbers = [];
    var data = SERVER["xepg"]["epgMapping"];
    var channels = getObjKeys(data);
    if (isNaN(newNumber)) {
        alert("{{.alert.invalidChannelNumber}}");
        return;
    }
    channels.forEach(id => {
        var channelNumber = parseFloat(data[id]["x-channelID"]);
        channelNumbers.push(channelNumber);
    });
    for (var i = 0; i < channelNumbers.length; i++) {
        if (channelNumbers.indexOf(newNumber) == -1) {
            break;
        }
        if (Math.floor(newNumber) == newNumber) {
            newNumber = newNumber + 1;
        }
        else {
            newNumber = newNumber + 0.1;
            newNumber.toFixed(1);
            newNumber = Math.round(newNumber * 10) / 10;
        }
    }
    data[dbID]["x-channelID"] = newNumber.toString();
    element.value = newNumber;
    if (COLUMN_TO_SORT == 1) {
        COLUMN_TO_SORT = -1;
        sortTable(1);
    }
    if (INACTIVE_COLUMN_TO_SORT == 1) {
        INACTIVE_COLUMN_TO_SORT = -1;
        sortTable(1, "inactive_content_page");
    }
    return;
}
function backup() {
    var data = new Object();
    console.log("Backup data");
    var cmd = "ThreadfinBackup";
    console.log("SEND TO SERVER");
    console.log(data);
    var server = new Server(cmd);
    server.request(data);
    return;
}
function toggleChannelStatus(id) {
    var element;
    var status;
    if (document.getElementById("active")) {
        var checkbox = document.getElementById("active");
        status = (checkbox).checked;
    }
    var ids = getAllSelectedChannels();
    if (ids.length == 0) {
        ids.push(id);
    }
    ids.forEach(id => {
        var channel = SERVER["xepg"]["epgMapping"][id];
        channel["x-active"] = status;
        switch (channel["x-active"]) {
            case true:
                if (channel["x-xmltv-file"] == "-" || channel["x-mapping"] == "-") {
                    if (BULK_EDIT == false) {
                        // alert(channel["x-name"] + ": Missing XMLTV file / channel")
                        checkbox.checked = true;
                    }
                    channel["x-active"] = true;
                }
                break;
            case false:
                // code...
                break;
        }
        if (channel["x-active"] == false) {
            document.getElementById(id).className = "notActiveEPG";
        }
        else {
            document.getElementById(id).className = "activeEPG";
        }
    });
}
function restore() {
    if (document.getElementById('upload')) {
        document.getElementById('upload').remove();
    }
    var restore = document.createElement("INPUT");
    restore.setAttribute("type", "file");
    restore.setAttribute("class", "notVisible");
    restore.setAttribute("name", "");
    restore.id = "upload";
    document.body.appendChild(restore);
    restore.click();
    restore.onchange = function () {
        var filename = restore.files[0].name;
        var check = confirm("File: " + filename + "\n{{.confirm.restore}}");
        if (check == true) {
            var reader = new FileReader();
            var file = document.querySelector('input[type=file]').files[0];
            if (file) {
                reader.readAsDataURL(file);
                reader.onload = function () {
                    console.log(reader.result);
                    var data = new Object();
                    var cmd = "ThreadfinRestore";
                    data["base64"] = reader.result;
                    var server = new Server(cmd);
                    server.request(data);
                };
            }
            else {
                alert("File could not be loaded");
            }
            restore.remove();
            return;
        }
    };
    return;
}
function uploadLogo() {
    if (document.getElementById('upload')) {
        document.getElementById('upload').remove();
    }
    var upload = document.createElement("INPUT");
    upload.setAttribute("type", "file");
    upload.setAttribute("class", "notVisible");
    upload.setAttribute("name", "");
    upload.id = "upload";
    document.body.appendChild(upload);
    upload.click();
    upload.onblur = function () {
        alert();
    };
    upload.onchange = function () {
        var filename = upload.files[0].name;
        var reader = new FileReader();
        var file = document.querySelector('input[type=file]').files[0];
        if (file) {
            reader.readAsDataURL(file);
            reader.onload = function () {
                console.log(reader.result);
                var data = new Object();
                var cmd = "uploadLogo";
                data["base64"] = reader.result;
                data["filename"] = file.name;
                var server = new Server(cmd);
                server.request(data);
                var updateLogo = document.getElementById('update-icon');
                updateLogo.checked = false;
                updateLogo.className = "changed";
            };
        }
        else {
            alert("File could not be loaded");
        }
        upload.remove();
        return;
    };
}
function checkUndo(key) {
    switch (key) {
        case "epgMapping":
            if (UNDO.hasOwnProperty(key)) {
                SERVER["xepg"][key] = JSON.parse(JSON.stringify(UNDO[key]));
            }
            else {
                UNDO[key] = JSON.parse(JSON.stringify(SERVER["xepg"][key]));
            }
            break;
        default:
            break;
    }
    return;
}
function sortSelect(elem) {
    var tmpAry = [];
    var selectedValue = elem[elem.selectedIndex].value;
    for (var i = 0; i < elem.options.length; i++)
        tmpAry.push(elem.options[i]);
    tmpAry.sort(function (a, b) { return (a.text < b.text) ? -1 : 1; });
    while (elem.options.length > 0)
        elem.options[0] = null;
    var newSelectedIndex = 0;
    for (var i = 0; i < tmpAry.length; i++) {
        elem.options[i] = tmpAry[i];
        if (elem.options[i].value == selectedValue)
            newSelectedIndex = i;
    }
    elem.selectedIndex = newSelectedIndex; // Set new selected index after sorting
    return;
}
function updateLog() {
    console.log("TOKEN");
    var server = new Server("updateLog");
    server.request(new Object());
}
// Get the button:
let backToTop = document.getElementById("backToTop");
backToTop.setAttribute("title", "{{.button.backToTop}}");
// When the user scrolls down 20px from the top of the document, show the button
window.onscroll = function () { scrollFunction(); };
function scrollFunction() {
    if (document.body.scrollTop > 20 || document.documentElement.scrollTop > 20) {
        backToTop.style.display = "block";
    }
    else {
        backToTop.style.display = "none";
    }
}
// When the user clicks on the button, scroll to the top of the document
function topFunction() {
    document.body.scrollTop = 0; // For Safari
    document.documentElement.scrollTop = 0; // For Chrome, Firefox, IE and Opera
}
//# sourceMappingURL=base.js.map" - webUI["web/public/js/base.js.map"] = "{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/ts/base.ts"],"names":[],"mappings":"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"}" + webUI["web/public/js/base.js"] = "var SERVER;
var BULK_EDIT = false;
var COLUMN_TO_SORT;
var INACTIVE_COLUMN_TO_SORT;
var SEARCH_MAPPING = new Object();
var UNDO = new Object();
var SERVER_CONNECTION = false;
var WS_AVAILABLE = false;
var tooltipTriggerList;
var tooltipList;
const clipboard = new ClipboardJS('.copy-btn');
clipboard.on('success', function (e) {
    const tooltip = bootstrap.Tooltip.getInstance(e.trigger);
    if (tooltip) {
        const prevContent = tooltip._config.title;
        tooltip.setContent({ '.tooltip-inner': 'Copied!' });
        tooltip.show();
        setTimeout(() => {
            tooltip.setContent({ '.tooltip-inner': prevContent });
        }, 3000);
    }
    else {
        console.error('Tooltip instance not found for element:', e.trigger);
    }
});
clipboard.on('error', function (e) {
    console.log(e);
});
var popupModal = new bootstrap.Modal(document.getElementById("popup"), {
    keyboard: true,
    focus: true,
    backdrop: 'static'
});
var loadingModal = new bootstrap.Modal(document.getElementById("loading"), {
    keyboard: true,
    focus: true
});
// Menü
var menuItems = new Array();
menuItems.push(new MainMenuItem("playlist", "{{.mainMenu.item.playlist}}", "m3u.png", "{{.mainMenu.headline.playlist}}"));
menuItems.push(new MainMenuItem("xmltv", "{{.mainMenu.item.xmltv}}", "xmltv.png", "{{.mainMenu.headline.xmltv}}"));
menuItems.push(new MainMenuItem("filter", "{{.mainMenu.item.filter}}", "filter.png", "{{.mainMenu.headline.filter}}"));
menuItems.push(new MainMenuItem("mapping", "{{.mainMenu.item.mapping}}", "mapping.png", "{{.mainMenu.headline.mapping}}"));
menuItems.push(new MainMenuItem("users", "{{.mainMenu.item.users}}", "users.png", "{{.mainMenu.headline.users}}"));
menuItems.push(new MainMenuItem("settings", "{{.mainMenu.item.settings}}", "settings.png", "{{.mainMenu.headline.settings}}"));
menuItems.push(new MainMenuItem("log", "{{.mainMenu.item.log}}", "log.png", "{{.mainMenu.headline.log}}"));
menuItems.push(new MainMenuItem("logout", "{{.mainMenu.item.logout}}", "logout.png", "{{.mainMenu.headline.logout}}"));
// Kategorien für die Einstellungen
var settingsCategory = new Array();
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.general}}", "ThreadfinAutoUpdate,ssdp,tuner,epgSource,epgCategories,epgCategoriesColors,dummy,dummyChannel,ignoreFilters,api"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.customization}}", "uploadCustomImage"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.webclient}}", "webclient.language"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.files}}", "update,files.update,temp.path,cache.images,omitPorts,xepg.replace.missing.images,xepg.replace.channel.title,enableNonAscii"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.network}}", "bindingIPs,threadfinDomain,useHttps,forceClientHttps,forceHttps"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.streaming}}", "buffer,udpxy,buffer.size.kb,storeBufferInRAM,buffer.terminationTimeout,buffer.timeout,buffer.autoReconnect,user.agent,ffmpeg.path,ffmpeg.options,vlc.path,vlc.options"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.backup}}", "backup.path,backup.keep"));
settingsCategory.push(new SettingsCategoryItem("{{.settings.category.authentication}}", "authentication.web,authentication.pms,authentication.m3u,authentication.xml,authentication.api"));
var serverInformation = new Array();
serverInformation.push(new ServerInformationItem("{{.serverInfo.header.serverInfo}}", "version,errors,warnings"));
serverInformation.push(new ServerInformationItem("{{.serverInfo.header.streamInfo}}", "dvr,m3uUrl,xepgUrl,streams,xepg"));
serverInformation.push(new ServerInformationItem("{{.serverInfo.header.changeVersion}}", "changeVersion"));
function showElement(elmID, show) {
    if (elmID == "popupCustom" || elmID == "popup") {
        switch (show) {
            case true:
                popupModal.show();
                break;
            case false:
                popupModal.hide();
                break;
        }
    }
    if (elmID == "loading") {
        switch (show) {
            case true:
                loadingModal.show();
                break;
            case false:
                loadingModal.hide();
                break;
        }
    }
}
function changeButtonAction(element, buttonID, attribute) {
    var value = element.options[element.selectedIndex].value;
    document.getElementById(buttonID).setAttribute(attribute, value);
}
function getLocalData(dataType, id) {
    var data = new Object();
    switch (dataType) {
        case "m3u":
            data = SERVER["settings"]["files"][dataType][id];
            break;
        case "hdhr":
            data = SERVER["settings"]["files"][dataType][id];
            break;
        case "filter":
        case "custom-filter":
        case "group-title":
            if (id == -1) {
                data["active"] = true;
                data["caseSensitive"] = false;
                data["description"] = "";
                data["exclude"] = "";
                data["filter"] = "";
                data["include"] = "";
                data["name"] = "";
                data["type"] = "group-title";
                data["x-category"] = "";
                SERVER["settings"]["filter"][id] = data;
            }
            data = SERVER["settings"]["filter"][id];
            break;
        case "xmltv":
            data = SERVER["settings"]["files"][dataType][id];
            break;
        case "users":
            data = SERVER["users"][id]["data"];
            break;
        case "mapping":
            data = SERVER["xepg"]["epgMapping"][id];
            break;
        case "m3uGroups":
            data = SERVER["data"]["playlist"]["m3u"]["groups"];
            break;
    }
    return data;
}
function getObjKeys(obj) {
    var keys = new Array();
    for (var i in obj) {
        if (obj.hasOwnProperty(i)) {
            keys.push(i);
        }
    }
    return keys;
}
function getOwnObjProps(object) {
    return object ? Object.getOwnPropertyNames(object) : [];
}
function getAllSelectedChannels() {
    var channels = new Array();
    if (BULK_EDIT == false) {
        return channels;
    }
    var trs = document.getElementById("contentTable").getElementsByTagName("TR");
    for (var i = 1; i < trs.length; i++) {
        if (trs[i].style.display != "none") {
            if (trs[i].firstChild.firstChild.checked == true) {
                channels.push(trs[i].id);
            }
        }
    }
    var trs_inactive = document.getElementById("inactiveContentTable").getElementsByTagName("TR");
    for (var i = 1; i < trs_inactive.length; i++) {
        if (trs_inactive[i].style.display != "none") {
            if (trs_inactive[i].firstChild.firstChild.checked == true) {
                channels.push(trs_inactive[i].id);
            }
        }
    }
    return channels;
}
function selectAllChannels(table_name = "contentTable") {
    var bulk = false;
    var trs = document.getElementById(table_name).getElementsByTagName("TR");
    if (trs[0].firstChild.firstChild.checked == true) {
        bulk = true;
    }
    for (var i = 1; i < trs.length; i++) {
        if (trs[i].style.display != "none") {
            switch (bulk) {
                case true:
                    trs[i].firstChild.firstChild.checked = true;
                    break;
                case false:
                    trs[i].firstChild.firstChild.checked = false;
                    break;
            }
        }
    }
    return;
}
function bulkEdit() {
    BULK_EDIT = !BULK_EDIT;
    var className;
    var rows = document.getElementsByClassName("bulk");
    switch (BULK_EDIT) {
        case true:
            className = "bulk showBulk";
            break;
        case false:
            className = "bulk hideBulk";
            break;
    }
    for (var i = 0; i < rows.length; i++) {
        rows[i].className = className;
        rows[i].checked = false;
    }
    return;
}
function sortTable(column, table_name = "contentTable") {
    // console.log("COLUMN: " + column);
    if ((column == COLUMN_TO_SORT && table_name == "contentTable") || (column == INACTIVE_COLUMN_TO_SORT && table_name == "inactiveContentTable")) {
        return;
    }
    var table = document.getElementById(table_name);
    var tableHead = table.getElementsByTagName("TR")[0];
    var tableItems = tableHead.getElementsByTagName("TD");
    var sortObj = new Object();
    var x, xValue;
    var tableHeader;
    var sortByString = false;
    if (column > 0 && COLUMN_TO_SORT > 0 && table_name == "contentTable") {
        tableItems[COLUMN_TO_SORT].className = "pointer";
        tableItems[column].className = "sortThis";
    }
    else if (column > 0 && INACTIVE_COLUMN_TO_SORT > 0 && table_name == "inactiveContentTable") {
        tableItems[INACTIVE_COLUMN_TO_SORT].className = "pointer";
        tableItems[column].className = "sortThis";
    }
    if (table_name == "contentTable") {
        COLUMN_TO_SORT = column;
    }
    else if (table_name == "inactiveContentTable") {
        INACTIVE_COLUMN_TO_SORT = column;
    }
    var rows = table.rows;
    if (rows[1] != undefined) {
        tableHeader = rows[0];
        x = rows[1].getElementsByTagName("TD")[column];
        for (i = 1; i < rows.length; i++) {
            x = rows[i].getElementsByTagName("TD")[column];
            switch (x.childNodes[0].tagName.toLowerCase()) {
                case "input":
                    xValue = x.getElementsByTagName("INPUT")[0].value.toLowerCase();
                    break;
                case "p":
                    xValue = x.getElementsByTagName("P")[0].innerText.toLowerCase();
                    break;
                default: console.log(x.childNodes[0].tagName);
            }
            if (xValue == "") {
                xValue = i;
                sortObj[i] = rows[i];
            }
            else {
                switch (isNaN(xValue)) {
                    case false:
                        xValue = parseFloat(xValue);
                        sortObj[xValue] = rows[i];
                        break;
                    case true:
                        sortByString = true;
                        sortObj[xValue.toLowerCase() + i] = rows[i];
                        break;
                }
            }
        }
        while (table.firstChild) {
            table.removeChild(table.firstChild);
        }
        var sortValues = getObjKeys(sortObj);
        if (sortByString == true) {
            if (column == 3) {
                var collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
                sortValues.sort(collator.compare);
            }
            else {
                sortValues.sort();
            }
        }
        else {
            function sortFloat(a, b) {
                return a - b;
            }
            sortValues.sort(sortFloat);
        }
        table.appendChild(tableHeader);
        for (var i = 0; i < sortValues.length; i++) {
            table.appendChild(sortObj[sortValues[i]]);
        }
    }
    return;
}
function createSearchObj() {
    SEARCH_MAPPING = new Object();
    var data = SERVER["xepg"]["epgMapping"];
    var channels = getObjKeys(data);
    var channelKeys = ["x-active", "x-channelID", "x-name", "_file.m3u.name", "x-group-title", "x-xmltv-file"];
    channels.forEach(id => {
        channelKeys.forEach(key => {
            if (key == "x-active") {
                switch (data[id][key]) {
                    case true:
                        SEARCH_MAPPING[id] = "online ";
                        break;
                    case false:
                        SEARCH_MAPPING[id] = "offline ";
                        break;
                }
            }
            else {
                if (key == "x-xmltv-file") {
                    var xmltvFile = getValueFromProviderFile(data[id][key], "xmltv", "name");
                    if (xmltvFile != undefined) {
                        SEARCH_MAPPING[id] = SEARCH_MAPPING[id] + xmltvFile + " ";
                    }
                }
                else {
                    SEARCH_MAPPING[id] = SEARCH_MAPPING[id] + data[id][key] + " ";
                }
            }
        });
    });
    return;
}
function enableGroupSelection(selector) {
    var lastcheck = null; // no checkboxes clicked yet
    // get desired checkboxes
    var checkboxes = document.querySelectorAll(selector);
    // loop over checkboxes to add event listener
    Array.prototype.forEach.call(checkboxes, function (cbx, idx) {
        cbx.addEventListener('click', function (evt) {
            // test for shift key, not first checkbox, and not same checkbox
            if (evt.shiftKey && null !== lastcheck && idx !== lastcheck) {
                // get range of checks between last-checkbox and shift-checkbox
                // Math.min/max does our sorting for us
                Array.prototype.slice.call(checkboxes, Math.min(lastcheck, idx), Math.max(lastcheck, idx))
                    // and loop over each
                    .forEach(function (ccbx) {
                    ccbx.checked = true;
                });
            }
            lastcheck = idx; // set this checkbox as last-checked for later
        });
    });
}
function searchInMapping() {
    var searchValue = document.getElementById("searchMapping").value;
    var trs = document.getElementById("contentTable").getElementsByTagName("TR");
    for (var i = 1; i < trs.length; ++i) {
        var id = trs[i].getAttribute("id");
        var element = SEARCH_MAPPING[id];
        switch (element.toLowerCase().includes(searchValue.toLowerCase())) {
            case true:
                document.getElementById(id).style.display = "";
                break;
            case false:
                document.getElementById(id).style.display = "none";
                break;
        }
    }
    return;
}
function changeChannelNumbers(elements) {
    var starting_number_element = document.getElementsByName("x-channels-start")[0];
    var elems = elements.split(",");
    var starting_number = parseFloat(starting_number_element.value);
    var data = SERVER["xepg"]["epgMapping"];
    elems.forEach(element => {
        var elem = document.getElementById(element);
        var input = elem.childNodes[1].firstChild;
        input.value = starting_number.toString();
        data[element]["x-channelID"] = starting_number.toString();
        starting_number++;
    });
    if (COLUMN_TO_SORT == 1) {
        COLUMN_TO_SORT = -1;
        sortTable(1);
    }
    if (INACTIVE_COLUMN_TO_SORT == 1) {
        INACTIVE_COLUMN_TO_SORT = -1;
        sortTable(1, "inactive_content_page");
    }
}
function changeChannelNumber(element) {
    var dbID = element.parentNode.parentNode.id;
    var newNumber = parseFloat(element.value);
    var channelNumbers = [];
    var data = SERVER["xepg"]["epgMapping"];
    var channels = getObjKeys(data);
    if (isNaN(newNumber)) {
        alert("{{.alert.invalidChannelNumber}}");
        return;
    }
    channels.forEach(id => {
        var channelNumber = parseFloat(data[id]["x-channelID"]);
        channelNumbers.push(channelNumber);
    });
    for (var i = 0; i < channelNumbers.length; i++) {
        if (channelNumbers.indexOf(newNumber) == -1) {
            break;
        }
        if (Math.floor(newNumber) == newNumber) {
            newNumber = newNumber + 1;
        }
        else {
            newNumber = newNumber + 0.1;
            newNumber.toFixed(1);
            newNumber = Math.round(newNumber * 10) / 10;
        }
    }
    data[dbID]["x-channelID"] = newNumber.toString();
    element.value = newNumber;
    if (COLUMN_TO_SORT == 1) {
        COLUMN_TO_SORT = -1;
        sortTable(1);
    }
    if (INACTIVE_COLUMN_TO_SORT == 1) {
        INACTIVE_COLUMN_TO_SORT = -1;
        sortTable(1, "inactive_content_page");
    }
    return;
}
function backup() {
    var data = new Object();
    console.log("Backup data");
    var cmd = "ThreadfinBackup";
    console.log("SEND TO SERVER");
    console.log(data);
    var server = new Server(cmd);
    server.request(data);
    return;
}
function toggleChannelStatus(id) {
    var element;
    var status;
    if (document.getElementById("active")) {
        var checkbox = document.getElementById("active");
        status = (checkbox).checked;
    }
    var ids = getAllSelectedChannels();
    if (ids.length == 0) {
        ids.push(id);
    }
    ids.forEach(id => {
        var channel = SERVER["xepg"]["epgMapping"][id];
        channel["x-active"] = status;
        switch (channel["x-active"]) {
            case true:
                if (channel["x-xmltv-file"] == "-" || channel["x-mapping"] == "-") {
                    if (BULK_EDIT == false) {
                        // alert(channel["x-name"] + ": Missing XMLTV file / channel")
                        checkbox.checked = true;
                    }
                    channel["x-active"] = true;
                }
                break;
            case false:
                // code...
                break;
        }
        if (channel["x-active"] == false) {
            document.getElementById(id).className = "notActiveEPG";
        }
        else {
            document.getElementById(id).className = "activeEPG";
        }
    });
}
function restore() {
    if (document.getElementById('upload')) {
        document.getElementById('upload').remove();
    }
    var restore = document.createElement("INPUT");
    restore.setAttribute("type", "file");
    restore.setAttribute("class", "notVisible");
    restore.setAttribute("name", "");
    restore.id = "upload";
    document.body.appendChild(restore);
    restore.click();
    restore.onchange = function () {
        var filename = restore.files[0].name;
        var check = confirm("File: " + filename + "\n{{.confirm.restore}}");
        if (check == true) {
            var reader = new FileReader();
            var file = document.querySelector('input[type=file]').files[0];
            if (file) {
                reader.readAsDataURL(file);
                reader.onload = function () {
                    console.log(reader.result);
                    var data = new Object();
                    var cmd = "ThreadfinRestore";
                    data["base64"] = reader.result;
                    var server = new Server(cmd);
                    server.request(data);
                };
            }
            else {
                alert("File could not be loaded");
            }
            restore.remove();
            return;
        }
    };
    return;
}
function uploadLogo() {
    if (document.getElementById('upload')) {
        document.getElementById('upload').remove();
    }
    var upload = document.createElement("INPUT");
    upload.setAttribute("type", "file");
    upload.setAttribute("class", "notVisible");
    upload.setAttribute("name", "");
    upload.id = "upload";
    document.body.appendChild(upload);
    upload.click();
    upload.onblur = function () {
        alert();
    };
    upload.onchange = function () {
        var filename = upload.files[0].name;
        var reader = new FileReader();
        var file = document.querySelector('input[type=file]').files[0];
        if (file) {
            reader.readAsDataURL(file);
            reader.onload = function () {
                console.log(reader.result);
                var data = new Object();
                var cmd = "uploadLogo";
                data["base64"] = reader.result;
                data["filename"] = file.name;
                var server = new Server(cmd);
                server.request(data);
                var updateLogo = document.getElementById('update-icon');
                updateLogo.checked = false;
                updateLogo.className = "changed";
            };
        }
        else {
            alert("File could not be loaded");
        }
        upload.remove();
        return;
    };
}
function checkUndo(key) {
    switch (key) {
        case "epgMapping":
            if (UNDO.hasOwnProperty(key)) {
                SERVER["xepg"][key] = JSON.parse(JSON.stringify(UNDO[key]));
            }
            else {
                UNDO[key] = JSON.parse(JSON.stringify(SERVER["xepg"][key]));
            }
            break;
        default:
            break;
    }
    return;
}
function sortSelect(elem) {
    var tmpAry = [];
    var selectedValue = elem[elem.selectedIndex].value;
    for (var i = 0; i < elem.options.length; i++)
        tmpAry.push(elem.options[i]);
    tmpAry.sort(function (a, b) { return (a.text < b.text) ? -1 : 1; });
    while (elem.options.length > 0)
        elem.options[0] = null;
    var newSelectedIndex = 0;
    for (var i = 0; i < tmpAry.length; i++) {
        elem.options[i] = tmpAry[i];
        if (elem.options[i].value == selectedValue)
            newSelectedIndex = i;
    }
    elem.selectedIndex = newSelectedIndex; // Set new selected index after sorting
    return;
}
function updateLog() {
    console.log("TOKEN");
    var server = new Server("updateLog");
    server.request(new Object());
}
// Get the button:
let backToTop = document.getElementById("backToTop");
backToTop.setAttribute("title", "{{.button.backToTop}}");
// When the user scrolls down 20px from the top of the document, show the button
window.onscroll = function () { scrollFunction(); };
function scrollFunction() {
    if (document.body.scrollTop > 20 || document.documentElement.scrollTop > 20) {
        backToTop.style.display = "block";
    }
    else {
        backToTop.style.display = "none";
    }
}
// When the user clicks on the button, scroll to the top of the document
function topFunction() {
    document.body.scrollTop = 0; // For Safari
    document.documentElement.scrollTop = 0; // For Chrome, Firefox, IE and Opera
}
//# sourceMappingURL=base.js.map" + webUI["web/public/js/base.js.map"] = "{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/ts/base.ts"],"names":[],"mappings":"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"}" webUI["web/public/js/configuration.js"] = "Y2xhc3MgV2l6YXJkQ2F0ZWdvcnkgewogICAgY29uc3RydWN0b3IoKSB7CiAgICAgICAgdGhpcy5Eb2N1bWVudElEID0gImNvbnRlbnQiOwogICAgfQogICAgY3JlYXRlQ2F0ZWdvcnlIZWFkbGluZSh2YWx1ZSkgewogICAgICAgIHZhciBlbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiSDQiKTsKICAgICAgICBlbGVtZW50LmlubmVySFRNTCA9IHZhbHVlOwogICAgICAgIHJldHVybiBlbGVtZW50OwogICAgfQp9CmNsYXNzIFdpemFyZEl0ZW0gZXh0ZW5kcyBXaXphcmRDYXRlZ29yeSB7CiAgICBjb25zdHJ1Y3RvcihrZXksIGhlYWRsaW5lKSB7CiAgICAgICAgc3VwZXIoKTsKICAgICAgICB0aGlzLmhlYWRsaW5lID0gaGVhZGxpbmU7CiAgICAgICAgdGhpcy5rZXkgPSBrZXk7CiAgICB9CiAgICBjcmVhdGVXaXphcmQoKSB7CiAgICAgICAgdmFyIGhlYWRsaW5lID0gdGhpcy5jcmVhdGVDYXRlZ29yeUhlYWRsaW5lKHRoaXMuaGVhZGxpbmUpOwogICAgICAgIHZhciBrZXkgPSB0aGlzLmtleTsKICAgICAgICB2YXIgY29udGVudCA9IG5ldyBQb3B1cENvbnRlbnQoKTsKICAgICAgICB2YXIgZGVzY3JpcHRpb247CiAgICAgICAgdmFyIGRvYyA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKHRoaXMuRG9jdW1lbnRJRCk7CiAgICAgICAgZG9jLmlubmVySFRNTCA9ICIiOwogICAgICAgIGRvYy5hcHBlbmRDaGlsZChoZWFkbGluZSk7CiAgICAgICAgc3dpdGNoIChrZXkpIHsKICAgICAgICAgICAgY2FzZSAidHVuZXIiOgogICAgICAgICAgICAgICAgdmFyIHRleHQgPSBuZXcgQXJyYXkoKTsKICAgICAgICAgICAgICAgIHZhciB2YWx1ZXMgPSBuZXcgQXJyYXkoKTsKICAgICAgICAgICAgICAgIGZvciAodmFyIGkgPSAxOyBpIDw9IDEwMDsgaSsrKSB7CiAgICAgICAgICAgICAgICAgICAgdGV4dC5wdXNoKGkpOwogICAgICAgICAgICAgICAgICAgIHZhbHVlcy5wdXNoKGkpOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgdmFyIHNlbGVjdCA9IGNvbnRlbnQuY3JlYXRlU2VsZWN0KHRleHQsIHZhbHVlcywgIjEiLCBrZXkpOwogICAgICAgICAgICAgICAgc2VsZWN0LnNldEF0dHJpYnV0ZSgiY2xhc3MiLCAid2l6YXJkIik7CiAgICAgICAgICAgICAgICBzZWxlY3QuaWQgPSBrZXk7CiAgICAgICAgICAgICAgICBkb2MuYXBwZW5kQ2hpbGQoc2VsZWN0KTsKICAgICAgICAgICAgICAgIGRlc2NyaXB0aW9uID0gInt7LndpemFyZC50dW5lci5kZXNjcmlwdGlvbn19IjsKICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICBjYXNlICJlcGdTb3VyY2UiOgogICAgICAgICAgICAgICAgdmFyIHRleHQgPSBbIlBNUyIsICJYRVBHIl07CiAgICAgICAgICAgICAgICB2YXIgdmFsdWVzID0gWyJQTVMiLCAiWEVQRyJdOwogICAgICAgICAgICAgICAgdmFyIHNlbGVjdCA9IGNvbnRlbnQuY3JlYXRlU2VsZWN0KHRleHQsIHZhbHVlcywgIlhFUEciLCBrZXkpOwogICAgICAgICAgICAgICAgc2VsZWN0LnNldEF0dHJpYnV0ZSgiY2xhc3MiLCAid2l6YXJkIik7CiAgICAgICAgICAgICAgICBzZWxlY3QuaWQgPSBrZXk7CiAgICAgICAgICAgICAgICBkb2MuYXBwZW5kQ2hpbGQoc2VsZWN0KTsKICAgICAgICAgICAgICAgIGRlc2NyaXB0aW9uID0gInt7LndpemFyZC5lcGdTb3VyY2UuZGVzY3JpcHRpb259fSI7CiAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgY2FzZSAibTN1IjoKICAgICAgICAgICAgICAgIHZhciBpbnB1dCA9IGNvbnRlbnQuY3JlYXRlSW5wdXQoInRleHQiLCBrZXksICIiKTsKICAgICAgICAgICAgICAgIGlucHV0LnNldEF0dHJpYnV0ZSgicGxhY2Vob2xkZXIiLCAie3sud2l6YXJkLm0zdS5wbGFjZWhvbGRlcn19Iik7CiAgICAgICAgICAgICAgICBpbnB1dC5zZXRBdHRyaWJ1dGUoImNsYXNzIiwgIndpemFyZCIpOwogICAgICAgICAgICAgICAgaW5wdXQuaWQgPSBrZXk7CiAgICAgICAgICAgICAgICBkb2MuYXBwZW5kQ2hpbGQoaW5wdXQpOwogICAgICAgICAgICAgICAgZGVzY3JpcHRpb24gPSAie3sud2l6YXJkLm0zdS5kZXNjcmlwdGlvbn19IjsKICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICBjYXNlICJ4bWx0diI6CiAgICAgICAgICAgICAgICB2YXIgaW5wdXQgPSBjb250ZW50LmNyZWF0ZUlucHV0KCJ0ZXh0Iiwga2V5LCAiIik7CiAgICAgICAgICAgICAgICBpbnB1dC5zZXRBdHRyaWJ1dGUoInBsYWNlaG9sZGVyIiwgInt7LndpemFyZC54bWx0di5wbGFjZWhvbGRlcn19Iik7CiAgICAgICAgICAgICAgICBpbnB1dC5zZXRBdHRyaWJ1dGUoImNsYXNzIiwgIndpemFyZCIpOwogICAgICAgICAgICAgICAgaW5wdXQuaWQgPSBrZXk7CiAgICAgICAgICAgICAgICBkb2MuYXBwZW5kQ2hpbGQoaW5wdXQpOwogICAgICAgICAgICAgICAgZGVzY3JpcHRpb24gPSAie3sud2l6YXJkLnhtbHR2LmRlc2NyaXB0aW9ufX0iOwogICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICAgICBjb25zb2xlLmxvZyhrZXkpOwogICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgfQogICAgICAgIHZhciBwcmUgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJQUkUiKTsKICAgICAgICBwcmUuaW5uZXJIVE1MID0gZGVzY3JpcHRpb247CiAgICAgICAgZG9jLmFwcGVuZENoaWxkKHByZSk7CiAgICAgICAgY29uc29sZS5sb2coaGVhZGxpbmUsIGtleSk7CiAgICB9Cn0KZnVuY3Rpb24gcmVhZHlGb3JDb25maWd1cmF0aW9uKHdpemFyZCkgewogICAgdmFyIHNlcnZlciA9IG5ldyBTZXJ2ZXIoImdldFNlcnZlckNvbmZpZyIpOwogICAgc2VydmVyLnJlcXVlc3QobmV3IE9iamVjdCgpKTsKICAgIHNob3dFbGVtZW50KCJsb2FkaW5nIiwgZmFsc2UpOwogICAgY29uZmlndXJhdGlvbldpemFyZFt3aXphcmRdLmNyZWF0ZVdpemFyZCgpOwp9CmZ1bmN0aW9uIHNhdmVXaXphcmQoKSB7CiAgICB2YXIgY21kID0gInNhdmVXaXphcmQiOwogICAgdmFyIGRpdiA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJjb250ZW50Iik7CiAgICB2YXIgY29uZmlnID0gZGl2LmdldEVsZW1lbnRzQnlDbGFzc05hbWUoIndpemFyZCIpOwogICAgdmFyIHdpemFyZCA9IG5ldyBPYmplY3QoKTsKICAgIGZvciAodmFyIGkgPSAwOyBpIDwgY29uZmlnLmxlbmd0aDsgaSsrKSB7CiAgICAgICAgdmFyIG5hbWU7CiAgICAgICAgdmFyIHZhbHVlOwogICAgICAgIHN3aXRjaCAoY29uZmlnW2ldLnRhZ05hbWUpIHsKICAgICAgICAgICAgY2FzZSAiU0VMRUNUIjoKICAgICAgICAgICAgICAgIG5hbWUgPSBjb25maWdbaV0ubmFtZTsKICAgICAgICAgICAgICAgIHZhbHVlID0gY29uZmlnW2ldLnZhbHVlOwogICAgICAgICAgICAgICAgLy8gV2VubiBkZXIgV2VydCBlaW5lIFphaGwgaXN0LCB3aXJkIGRpZXNlciBhbHMgWmFobCBnZXNwZWljaGVydAogICAgICAgICAgICAgICAgaWYgKGlzTmFOKHZhbHVlKSkgewogICAgICAgICAgICAgICAgICAgIHdpemFyZFtuYW1lXSA9IHZhbHVlOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgZWxzZSB7CiAgICAgICAgICAgICAgICAgICAgd2l6YXJkW25hbWVdID0gcGFyc2VJbnQodmFsdWUpOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgIGNhc2UgIklOUFVUIjoKICAgICAgICAgICAgICAgIHN3aXRjaCAoY29uZmlnW2ldLnR5cGUpIHsKICAgICAgICAgICAgICAgICAgICBjYXNlICJ0ZXh0IjoKICAgICAgICAgICAgICAgICAgICAgICAgbmFtZSA9IGNvbmZpZ1tpXS5uYW1lOwogICAgICAgICAgICAgICAgICAgICAgICB2YWx1ZSA9IGNvbmZpZ1tpXS52YWx1ZTsKICAgICAgICAgICAgICAgICAgICAgICAgaWYgKHZhbHVlLmxlbmd0aCA9PSAwKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICB2YXIgbXNnID0gbmFtZS50b1VwcGVyQ2FzZSgpICsgIjogIiArICJ7ey5hbGVydC5taXNzaW5nSW5wdXR9fSI7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICBhbGVydChtc2cpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgICAgIHdpemFyZFtuYW1lXSA9IHZhbHVlOwogICAgICAgICAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICAgICAgLy8gY29kZS4uLgogICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgfQogICAgfQogICAgdmFyIGRhdGEgPSBuZXcgT2JqZWN0KCk7CiAgICBkYXRhWyJ3aXphcmQiXSA9IHdpemFyZDsKICAgIHZhciBzZXJ2ZXIgPSBuZXcgU2VydmVyKGNtZCk7CiAgICBzZXJ2ZXIucmVxdWVzdChkYXRhKTsKICAgIGNvbnNvbGUubG9nKGRhdGEpOwp9Ci8vIFdpemFyZAp2YXIgY29uZmlndXJhdGlvbldpemFyZCA9IG5ldyBBcnJheSgpOwpjb25maWd1cmF0aW9uV2l6YXJkLnB1c2gobmV3IFdpemFyZEl0ZW0oInR1bmVyIiwgInt7LndpemFyZC50dW5lci50aXRsZX19IikpOwpjb25maWd1cmF0aW9uV2l6YXJkLnB1c2gobmV3IFdpemFyZEl0ZW0oImVwZ1NvdXJjZSIsICJ7ey53aXphcmQuZXBnU291cmNlLnRpdGxlfX0iKSk7CmNvbmZpZ3VyYXRpb25XaXphcmQucHVzaChuZXcgV2l6YXJkSXRlbSgibTN1IiwgInt7LndpemFyZC5tM3UudGl0bGV9fSIpKTsKY29uZmlndXJhdGlvbldpemFyZC5wdXNoKG5ldyBXaXphcmRJdGVtKCJ4bWx0diIsICJ7ey53aXphcmQueG1sdHYudGl0bGV9fSIpKTsKLy8jIHNvdXJjZU1hcHBpbmdVUkw9Y29uZmlndXJhdGlvbi5qcy5tYXA=" webUI["web/public/js/configuration.js.map"] = "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" webUI["web/public/js/logs.js"] = "Y2xhc3MgTG9nIHsKICAgIGNyZWF0ZUxvZyhlbnRyeSkgewogICAgICAgIHZhciBlbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiUFJFIik7CiAgICAgICAgaWYgKGVudHJ5LmluZGV4T2YoIldBUk5JTkciKSAhPSAtMSkgewogICAgICAgICAgICBlbGVtZW50LmNsYXNzTmFtZSA9ICJ3YXJuaW5nTXNnIjsKICAgICAgICB9CiAgICAgICAgaWYgKGVudHJ5LmluZGV4T2YoIkVSUk9SIikgIT0gLTEpIHsKICAgICAgICAgICAgZWxlbWVudC5jbGFzc05hbWUgPSAiZXJyb3JNc2ciOwogICAgICAgIH0KICAgICAgICBpZiAoZW50cnkuaW5kZXhPZigiREVCVUciKSAhPSAtMSkgewogICAgICAgICAgICBlbGVtZW50LmNsYXNzTmFtZSA9ICJkZWJ1Z01zZyI7CiAgICAgICAgfQogICAgICAgIGVsZW1lbnQuaW5uZXJIVE1MID0gZW50cnk7CiAgICAgICAgcmV0dXJuIGVsZW1lbnQ7CiAgICB9Cn0KZnVuY3Rpb24gc2hvd0xvZ3MoYm90dG9tKSB7CiAgICB2YXIgbG9nID0gbmV3IExvZygpOwogICAgdmFyIGxvZ3MgPSBTRVJWRVJbImxvZyJdWyJsb2ciXTsKICAgIHZhciBkaXYgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29udGVudF9sb2ciKTsKICAgIGRpdi5pbm5lckhUTUwgPSAiIjsKICAgIHZhciBrZXlzID0gZ2V0T2JqS2V5cyhsb2dzKTsKICAgIGtleXMuZm9yRWFjaChsb2dJRCA9PiB7CiAgICAgICAgdmFyIGVudHJ5ID0gbG9nLmNyZWF0ZUxvZyhsb2dzW2xvZ0lEXSk7CiAgICAgICAgZGl2LmFwcGVuZChlbnRyeSk7CiAgICB9KTsKICAgIHNldFRpbWVvdXQoZnVuY3Rpb24gKCkgewogICAgICAgIGlmIChib3R0b20gPT0gdHJ1ZSkgewogICAgICAgICAgICB2YXIgd3JhcHBlciA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJib3gtd3JhcHBlciIpOwogICAgICAgICAgICB3cmFwcGVyLnNjcm9sbFRvcCA9IHdyYXBwZXIuc2Nyb2xsSGVpZ2h0OwogICAgICAgIH0KICAgIH0sIDEwKTsKfQpmdW5jdGlvbiByZXNldExvZ3MoKSB7CiAgICB2YXIgY21kID0gInJlc2V0TG9ncyI7CiAgICB2YXIgZGF0YSA9IG5ldyBPYmplY3QoKTsKICAgIHZhciBzZXJ2ZXIgPSBuZXcgU2VydmVyKGNtZCk7CiAgICBzZXJ2ZXIucmVxdWVzdChkYXRhKTsKfQovLyMgc291cmNlTWFwcGluZ1VSTD1sb2dzLmpzLm1hcA==" webUI["web/public/js/logs.js.map"] = "eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9ncy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90cy9sb2dzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sR0FBRztJQUVQLFNBQVMsQ0FBQyxLQUFZO1FBRXBCLElBQUksT0FBTyxHQUFHLFFBQVEsQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDLENBQUM7UUFFNUMsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDbkMsT0FBTyxDQUFDLFNBQVMsR0FBRyxZQUFZLENBQUE7UUFDbEMsQ0FBQztRQUVELElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsRUFBRSxDQUFDO1lBQ2pDLE9BQU8sQ0FBQyxTQUFTLEdBQUcsVUFBVSxDQUFBO1FBQ2hDLENBQUM7UUFFRCxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQUUsQ0FBQztZQUNqQyxPQUFPLENBQUMsU0FBUyxHQUFHLFVBQVUsQ0FBQTtRQUNoQyxDQUFDO1FBRUQsT0FBTyxDQUFDLFNBQVMsR0FBRyxLQUFLLENBQUE7UUFFekIsT0FBTyxPQUFPLENBQUE7SUFDaEIsQ0FBQztDQUVGO0FBRUQsU0FBUyxRQUFRLENBQUMsTUFBYztJQUU5QixJQUFJLEdBQUcsR0FBRyxJQUFJLEdBQUcsRUFBRSxDQUFBO0lBRW5CLElBQUksSUFBSSxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQTtJQUMvQixJQUFJLEdBQUcsR0FBRyxRQUFRLENBQUMsY0FBYyxDQUFDLGFBQWEsQ0FBQyxDQUFBO0lBRWhELEdBQUcsQ0FBQyxTQUFTLEdBQUcsRUFBRSxDQUFBO0lBRWxCLElBQUksSUFBSSxHQUFHLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQTtJQUUzQixJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFO1FBRW5CLElBQUksS0FBSyxHQUFHLEdBQUcsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUE7UUFFdEMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQTtJQUVuQixDQUFDLENBQUMsQ0FBQztJQUVILFVBQVUsQ0FBQztRQUVULElBQUksTUFBTSxJQUFJLElBQUksRUFBRSxDQUFDO1lBRW5CLElBQUksT0FBTyxHQUFHLFFBQVEsQ0FBQyxjQUFjLENBQUMsYUFBYSxDQUFDLENBQUM7WUFDckQsT0FBTyxDQUFDLFNBQVMsR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFDO1FBRTNDLENBQUM7SUFFSCxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7QUFFVCxDQUFDO0FBRUQsU0FBUyxTQUFTO0lBRWhCLElBQUksR0FBRyxHQUFHLFdBQVcsQ0FBQTtJQUNyQixJQUFJLElBQUksR0FBRyxJQUFJLE1BQU0sRUFBRSxDQUFBO0lBQ3ZCLElBQUksTUFBTSxHQUFVLElBQUksTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFBO0lBQ25DLE1BQU0sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUE7QUFFdEIsQ0FBQyJ9" - webUI["web/public/js/menu.js"] = "var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
class MainMenu {
    constructor() {
        this.DocumentID = "main-menu";
        this.HTMLTag = "LI";
        this.ImagePath = "img/";
    }
    createIMG(src, alt) {
        var element = document.createElement("IMG");
        element.setAttribute("src", this.ImagePath + src);
        element.setAttribute("alt", alt);
        return element;
    }
    createValue(value) {
        var element = document.createElement("P");
        element.innerHTML = value;
        return element;
    }
}
class MainMenuItem extends MainMenu {
    constructor(menuKey, value, image, headline) {
        super();
        this.menuKey = menuKey;
        this.value = value;
        this.imgSrc = image;
        this.headline = headline;
    }
    createItem() {
        var item = document.createElement("LI");
        item.setAttribute("onclick", "javascript: openThisMenu(this)");
        item.setAttribute("id", this.id);
        item.setAttribute("class", "nav-item");
        var img = this.createIMG(this.imgSrc, this.value);
        var value = this.createValue(this.value);
        item.appendChild(img);
        item.appendChild(value);
        var doc = document.getElementById(this.DocumentID);
        doc.appendChild(item);
        switch (this.menuKey) {
            case "playlist":
                this.tableHeader = ["{{.playlist.table.playlist}}", "{{.playlist.table.tuner}}", "{{.playlist.table.lastUpdate}}", "{{.playlist.table.availability}} %", "{{.playlist.table.type}}", "{{.playlist.table.streams}}", "{{.playlist.table.groupTitle}} %", "{{.playlist.table.tvgID}} %", "{{.playlist.table.uniqueID}} %"];
                break;
            case "xmltv":
                this.tableHeader = ["{{.xmltv.table.guide}}", "{{.xmltv.table.lastUpdate}}", "{{.xmltv.table.availability}} %", "{{.xmltv.table.channels}}", "{{.xmltv.table.programs}}"];
                break;
            case "filter":
                this.tableHeader = ["{{.filter.table.name}}", "{{.filter.table.type}}", "{{.filter.table.filter}}"];
                break;
            case "users":
                this.tableHeader = ["{{.users.table.username}}", "{{.users.table.password}}", "{{.users.table.web}}", "{{.users.table.pms}}", "{{.users.table.m3u}}", "{{.users.table.xml}}", "{{.users.table.api}}"];
                break;
            case "mapping":
                this.tableHeader = ["BULK", "{{.mapping.table.chNo}}", "{{.mapping.table.logo}}", "{{.mapping.table.channelName}}", "{{.mapping.table.playlist}}", "{{.mapping.table.groupTitle}}", "{{.mapping.table.xmltvFile}}", "{{.mapping.table.xmltvID}}"];
                break;
        }
    }
}
class Content {
    constructor() {
        this.DocumentID = "content";
        this.HeaderID = "popupHeader";
        this.TableID = "contentTable";
        this.InactiveTableID = "inactiveContentTable";
        this.headerClass = "contentTableHeader";
        this.headerClassInactive = "inactiveContentTableHeader";
        this.interactionID = "content-interaction";
    }
    createHeadline(value) {
        var element = document.createElement("H3");
        element.innerHTML = value;
        return element;
    }
    createHR() {
        var element = document.createElement("HR");
        return element;
    }
    createBR() {
        var element = document.createElement("BR");
        return element;
    }
    createInteraction() {
        var element = document.createElement("DIV");
        element.setAttribute("id", this.interactionID);
        return element;
    }
    createDIV() {
        var element = document.createElement("DIV");
        element.id = this.DivID;
        return element;
    }
    createTABLE() {
        var element = document.createElement("TABLE");
        element.setAttribute('class', 'table');
        element.id = this.TableID;
        return element;
    }
    createTableRow() {
        var element = document.createElement("TR");
        element.className = this.headerClass;
        return element;
    }
    createInactiveTABLE() {
        var element = document.createElement("TABLE");
        element.id = this.InactiveTableID;
        return element;
    }
    createInactiveTableRow() {
        var element = document.createElement("TR");
        element.className = this.headerClassInactive;
        return element;
    }
    createTableContent(menuKey) {
        var data = new Object();
        var rows = new Array();
        switch (menuKey) {
            case "playlist":
                var fileTypes = new Array("m3u", "hdhr");
                fileTypes.forEach(fileType => {
                    data = SERVER["settings"]["files"][fileType];
                    var keys = getObjKeys(data);
                    keys.forEach(key => {
                        var tr = document.createElement("TR");
                        tr.id = key;
                        tr.setAttribute('onclick', 'javascript: openPopUp("' + fileType + '", this)');
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["name"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (SERVER["settings"]["buffer"] != "-") {
                            cell.value = data[key]["tuner"];
                        }
                        else {
                            cell.value = "-";
                        }
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["last.update"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["provider.availability"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["type"].toUpperCase();
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["compatibility"]["streams"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["compatibility"]["group.title"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["compatibility"]["tvg.id"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["compatibility"]["stream.id"];
                        tr.appendChild(cell.createCell());
                        rows.push(tr);
                    });
                });
                break;
            case "filter":
                delete SERVER["settings"]["filter"][-1];
                data = SERVER["settings"]["filter"];
                var keys = getObjKeys(data);
                keys.forEach(key => {
                    var tr = document.createElement("TR");
                    tr.id = key;
                    tr.setAttribute('onclick', 'javascript: openPopUp("' + data[key]["type"] + '", this)');
                    var cell = new Cell();
                    cell.child = true;
                    cell.childType = "P";
                    cell.value = data[key]["name"];
                    tr.appendChild(cell.createCell());
                    var cell = new Cell();
                    cell.child = true;
                    cell.childType = "P";
                    switch (data[key]["type"]) {
                        case "custom-filter":
                            cell.value = "{{.filter.custom}}";
                            break;
                        case "group-title":
                            cell.value = "{{.filter.group}}";
                            break;
                        default:
                            break;
                    }
                    tr.appendChild(cell.createCell());
                    var cell = new Cell();
                    cell.child = true;
                    cell.childType = "P";
                    cell.value = data[key]["filter"];
                    tr.appendChild(cell.createCell());
                    rows.push(tr);
                });
                break;
            case "xmltv":
                var fileTypes = new Array("xmltv");
                fileTypes.forEach(fileType => {
                    data = SERVER["settings"]["files"][fileType];
                    var keys = getObjKeys(data);
                    keys.forEach(key => {
                        var tr = document.createElement("TR");
                        tr.id = key;
                        tr.setAttribute('onclick', 'javascript: openPopUp("' + fileType + '", this)');
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["name"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["last.update"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["provider.availability"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["compatibility"]["xmltv.channels"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["compatibility"]["xmltv.programs"];
                        tr.appendChild(cell.createCell());
                        rows.push(tr);
                    });
                });
                break;
            case "users":
                var fileTypes = new Array("users");
                fileTypes.forEach(fileType => {
                    data = SERVER[fileType];
                    var keys = getObjKeys(data);
                    keys.forEach(key => {
                        var tr = document.createElement("TR");
                        tr.id = key;
                        tr.setAttribute('onclick', 'javascript: openPopUp("' + fileType + '", this)');
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["data"]["username"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = "******";
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["data"]["authentication.web"] == true) {
                            cell.value = "✓";
                        }
                        else {
                            cell.value = "-";
                        }
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["data"]["authentication.pms"] == true) {
                            cell.value = "✓";
                        }
                        else {
                            cell.value = "-";
                        }
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["data"]["authentication.m3u"] == true) {
                            cell.value = "✓";
                        }
                        else {
                            cell.value = "-";
                        }
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["data"]["authentication.xml"] == true) {
                            cell.value = "✓";
                        }
                        else {
                            cell.value = "-";
                        }
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["data"]["authentication.api"] == true) {
                            cell.value = "✓";
                        }
                        else {
                            cell.value = "-";
                        }
                        tr.appendChild(cell.createCell());
                        rows.push(tr);
                    });
                });
                break;
            case "mapping":
                BULK_EDIT = false;
                createSearchObj();
                checkUndo("epgMapping");
                console.log("MAPPING");
                data = SERVER["xepg"]["epgMapping"];
                var keys = getObjKeys(data);
                keys.forEach(key => {
                    if (data[key]["x-active"]) {
                        var tr = document.createElement("TR");
                        tr.id = key;
                        tr.className = "activeEPG";
                        // Bulk
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "BULK";
                        cell.value = false;
                        tr.appendChild(cell.createCell());
                        // Kanalnummer
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "INPUTCHANNEL";
                        cell.value = data[key]["x-channelID"];
                        //td.setAttribute('onclick', 'javascript: changeChannelNumber("' + key + '", this)')
                        tr.appendChild(cell.createCell());
                        // Logo
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "IMG";
                        cell.imageURL = data[key]["tvg-logo"];
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // Kanalname
                        var cell = new Cell();
                        var cats = data[key]["x-category"].split(":");
                        cell.child = true;
                        cell.childType = "P";
                        cell.className = "category";
                        var catColorSettings = SERVER["settings"]["epgCategoriesColors"];
                        var colors_split = catColorSettings.split("|");
                        for (var i = 0; i < colors_split.length; i++) {
                            var catsColor_split = colors_split[i].split(":");
                            if (catsColor_split[0] == cats[0]) {
                                cell.classColor = catsColor_split[1];
                            }
                        }
                        cell.value = data[key]["x-name"];
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // Playlist
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        //cell.value = data[key]["_file.m3u.name"] 
                        cell.value = getValueFromProviderFile(data[key]["_file.m3u.id"], "m3u", "name");
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // Gruppe (group-title)
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["x-group-title"];
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // XMLTV Datei
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["x-xmltv-file"] != "-") {
                            cell.value = getValueFromProviderFile(data[key]["x-xmltv-file"], "xmltv", "name");
                        }
                        else {
                            cell.value = data[key]["x-xmltv-file"];
                        }
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // XMLTV Kanal
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        //var value = str.substring(1, 4);
                        var value = data[key]["x-mapping"];
                        if (value.length > 20) {
                            value = data[key]["x-mapping"].substring(0, 20) + "...";
                        }
                        cell.value = value;
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        rows.push(tr);
                    }
                });
                break;
            case "settings":
                alert();
                break;
            default:
                console.log("Table content (menuKey):", menuKey);
                break;
        }
        return rows;
    }
    createInactiveTableContent(menuKey) {
        var data = new Object();
        var rows = new Array();
        switch (menuKey) {
            case "mapping":
                BULK_EDIT = false;
                createSearchObj();
                checkUndo("epgMapping");
                console.log("MAPPING");
                data = SERVER["xepg"]["epgMapping"];
                var keys = getObjKeys(data);
                keys.forEach(key => {
                    if (data[key]["x-active"] === false) {
                        var tr = document.createElement("TR");
                        tr.id = key;
                        tr.className = "notActiveEPG";
                        // Bulk
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "BULK";
                        cell.value = false;
                        tr.appendChild(cell.createCell());
                        // Kanalnummer
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "INPUTCHANNEL";
                        if (data[key]["x-active"] == true) {
                            cell.value = data[key]["x-channelID"];
                        }
                        else {
                            cell.value = data[key]["x-channelID"] * 10;
                        }
                        //td.setAttribute('onclick', 'javascript: changeChannelNumber("' + key + '", this)')
                        tr.appendChild(cell.createCell());
                        // Logo
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "IMG";
                        cell.imageURL = data[key]["tvg-logo"];
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // Kanalname
                        var cell = new Cell();
                        var cats = data[key]["x-category"].split(":");
                        cell.child = true;
                        cell.childType = "P";
                        cell.className = "category";
                        var catColorSettings = SERVER["settings"]["epgCategoriesColors"];
                        var colors_split = catColorSettings.split("|");
                        for (var i = 0; i < colors_split.length; i++) {
                            var catsColor_split = colors_split[i].split(":");
                            if (catsColor_split[0] == cats[0]) {
                                cell.classColor = catsColor_split[1];
                            }
                        }
                        cell.value = data[key]["x-name"];
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // Playlist
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        //cell.value = data[key]["_file.m3u.name"] 
                        cell.value = getValueFromProviderFile(data[key]["_file.m3u.id"], "m3u", "name");
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // Gruppe (group-title)
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["x-group-title"];
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // XMLTV Datei
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["x-xmltv-file"] != "-") {
                            cell.value = getValueFromProviderFile(data[key]["x-xmltv-file"], "xmltv", "name");
                        }
                        else {
                            cell.value = data[key]["x-xmltv-file"];
                        }
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // XMLTV Kanal
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        //var value = str.substring(1, 4);
                        var value = data[key]["x-mapping"];
                        if (value.length > 20) {
                            value = data[key]["x-mapping"].substring(0, 20) + "...";
                        }
                        cell.value = value;
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        rows.push(tr);
                    }
                });
                break;
            case "settings":
                alert();
                break;
            default:
                console.log("Table content (menuKey):", menuKey);
                break;
        }
        return rows;
    }
}
class Cell {
    createCell() {
        var td = document.createElement("TD");
        if (this.child == true) {
            var element;
            switch (this.childType) {
                case "P":
                    element = document.createElement(this.childType);
                    element.innerHTML = this.value;
                    element.className = this.className;
                    if (this.classColor) {
                        element.style.borderColor = this.classColor;
                    }
                    break;
                case "INPUT":
                    element = document.createElement(this.childType);
                    element.value = this.value;
                    element.type = "text";
                    break;
                case "INPUTCHANNEL":
                    element = document.createElement("INPUT");
                    element.setAttribute("onchange", "javscript: changeChannelNumber(this)");
                    element.value = this.value;
                    element.type = "text";
                    break;
                case "BULK":
                    element = document.createElement("INPUT");
                    element.checked = this.value;
                    element.type = "checkbox";
                    element.className = "bulk hideBulk";
                    break;
                case "BULK_HEAD":
                    element = document.createElement("INPUT");
                    element.checked = this.value;
                    element.type = "checkbox";
                    element.className = "bulk hideBulk";
                    if (this.active) {
                        element.setAttribute("onclick", "javascript: selectAllChannels()");
                    }
                    else {
                        element.setAttribute("onclick", "javascript: selectAllChannels('inactiveContentTable')");
                    }
                    break;
                case "IMG":
                    element = document.createElement(this.childType);
                    element.setAttribute("src", this.imageURL);
                    if (this.imageURL != "") {
                        element.setAttribute("onerror", "javascript: this.onerror=null;this.src=''");
                        //onerror="this.onerror=null;this.src='missing.gif';"
                    }
            }
            td.appendChild(element);
        }
        else {
            td.innerHTML = this.value;
        }
        if (this.onclick == true) {
            td.setAttribute("onclick", this.onclickFunktion);
            td.className = "pointer";
        }
        if (this.tdClassName != undefined) {
            td.className = this.tdClassName;
        }
        return td;
    }
}
class ShowContent extends Content {
    constructor(menuID) {
        super();
        this.menuID = menuID;
    }
    createInput(type, name, value) {
        var input = document.createElement("INPUT");
        input.setAttribute("type", type);
        input.setAttribute("name", name);
        input.setAttribute("value", value);
        return input;
    }
    show() {
        COLUMN_TO_SORT = -1;
        // Alten Inhalt löschen
        var doc = document.getElementById(this.DocumentID);
        doc.innerHTML = "";
        showPreview(false);
        // Überschrift
        var popupHeader = document.getElementById(this.HeaderID);
        var headline = menuItems[this.menuID].headline;
        var menuKey = menuItems[this.menuID].menuKey;
        var h = this.createHeadline(headline);
        var existingHeader = popupHeader.querySelector('h3');
        if (existingHeader) {
            popupHeader.replaceChild(h, existingHeader);
        }
        else {
            popupHeader.appendChild(h);
        }
        var hr = this.createHR();
        doc.appendChild(hr);
        // Interaktion
        var div = this.createInteraction();
        doc.appendChild(div);
        var interaction = document.getElementById(this.interactionID);
        switch (menuKey) {
            case "playlist":
                var input = this.createInput("button", menuKey, "{{.button.new}}");
                input.setAttribute("id", "-");
                input.setAttribute("onclick", 'javascript: openPopUp("playlist")');
                interaction.appendChild(input);
                break;
            case "filter":
                var input = this.createInput("button", menuKey, "{{.button.new}}");
                input.setAttribute("id", -1);
                input.setAttribute("onclick", 'javascript: openPopUp("filter", this)');
                interaction.appendChild(input);
                break;
            case "xmltv":
                var input = this.createInput("button", menuKey, "{{.button.new}}");
                input.setAttribute("id", "xmltv");
                input.setAttribute("onclick", 'javascript: openPopUp("xmltv")');
                interaction.appendChild(input);
                break;
            case "users":
                var input = this.createInput("button", menuKey, "{{.button.new}}");
                input.setAttribute("id", "users");
                input.setAttribute("onclick", 'javascript: openPopUp("users")');
                interaction.appendChild(input);
                break;
            case "mapping":
                // showElement("loading", true)
                var input = this.createInput("button", menuKey, "{{.button.save}}");
                input.setAttribute("onclick", 'javascript: savePopupData("mapping", "", "")');
                interaction.appendChild(input);
                var input = this.createInput("button", menuKey, "{{.button.bulkEdit}}");
                input.setAttribute("onclick", 'javascript: bulkEdit()');
                interaction.appendChild(input);
                var input = this.createInput("search", "search", "");
                input.setAttribute("id", "searchMapping");
                input.setAttribute("placeholder", "{{.button.search}}");
                input.className = "search";
                input.setAttribute("onchange", 'javascript: searchInMapping()');
                interaction.appendChild(input);
                break;
            case "settings":
                var input = this.createInput("button", menuKey, "{{.button.save}}");
                input.setAttribute("onclick", 'javascript: saveSettings();');
                interaction.appendChild(input);
                var input = this.createInput("button", menuKey, "{{.button.backup}}");
                input.setAttribute("onclick", 'javascript: backup();');
                interaction.appendChild(input);
                var input = this.createInput("button", menuKey, "{{.button.restore}}");
                input.setAttribute("onclick", 'javascript: restore();');
                interaction.appendChild(input);
                var wrapper = document.createElement("DIV");
                wrapper.setAttribute("id", "box-wrapper");
                doc.appendChild(wrapper);
                this.DivID = "content_settings";
                var settings = this.createDIV();
                wrapper.appendChild(settings);
                showSettings();
                return;
                break;
            case "log":
                var input = this.createInput("button", menuKey, "{{.button.resetLogs}}");
                input.setAttribute("onclick", 'javascript: resetLogs();');
                interaction.appendChild(input);
                var wrapper = document.createElement("DIV");
                wrapper.setAttribute("id", "box-wrapper");
                doc.appendChild(wrapper);
                this.DivID = "content_log";
                var logs = this.createDIV();
                wrapper.appendChild(logs);
                showLogs(true);
                return;
                break;
            case "logout":
                location.reload();
                document.cookie = "Token= ; expires = Thu, 01 Jan 1970 00:00:00 GMT";
                break;
            default:
                console.log("Show content (menuKey):", menuKey);
                break;
        }
        // Tabelle erstellen (falls benötigt)
        var tableHeader = menuItems[this.menuID].tableHeader;
        if (tableHeader.length > 0) {
            var wrapper = document.createElement("DIV");
            doc.appendChild(wrapper);
            wrapper.setAttribute("id", "box-wrapper");
            var table = this.createTABLE();
            wrapper.appendChild(table);
            var header = this.createTableRow();
            table.appendChild(header);
            // Kopfzeile der Tablle
            tableHeader.forEach(element => {
                var cell = new Cell();
                cell.child = true;
                cell.childType = "P";
                cell.value = element;
                if (element == "BULK") {
                    cell.childType = "BULK_HEAD";
                    cell.active = true;
                    cell.value = false;
                }
                if (menuKey == "mapping") {
                    if (element == "{{.mapping.table.chNo}}") {
                        cell.onclick = true;
                        cell.onclickFunktion = "javascript: sortTable(1);";
                        cell.tdClassName = "sortThis";
                    }
                    if (element == "{{.mapping.table.channelName}}") {
                        cell.onclick = true;
                        cell.onclickFunktion = "javascript: sortTable(3);";
                    }
                    if (element == "{{.mapping.table.playlist}}") {
                        cell.onclick = true;
                        cell.onclickFunktion = "javascript: sortTable(4);";
                    }
                    if (element == "{{.mapping.table.groupTitle}}") {
                        cell.onclick = true;
                        cell.onclickFunktion = "javascript: sortTable(5);";
                    }
                }
                header.appendChild(cell.createCell());
            });
            table.appendChild(header);
            // Inhalt der Tabelle
            var rows = this.createTableContent(menuKey);
            rows.forEach(tr => {
                table.appendChild(tr);
            });
            var br = this.createBR();
            doc.appendChild(br);
            // Create inactive channels for mapping
            if (menuKey == "mapping") {
                var inactivetable = this.createInactiveTABLE();
                wrapper.appendChild(inactivetable);
                var header = this.createInactiveTableRow();
                inactivetable.appendChild(header);
                // Kopfzeile der Tablle
                tableHeader.forEach(element => {
                    var cell = new Cell();
                    cell.child = true;
                    cell.childType = "P";
                    cell.value = element;
                    if (element == "BULK") {
                        cell.childType = "BULK_HEAD";
                        cell.active = false;
                        cell.value = false;
                    }
                    if (menuKey == "mapping") {
                        if (element == "{{.mapping.table.chNo}}") {
                            cell.onclick = true;
                            cell.onclickFunktion = "javascript: sortTable(1, 'inactiveContentTable');";
                            cell.tdClassName = "sortThis";
                        }
                        if (element == "{{.mapping.table.channelName}}") {
                            cell.onclick = true;
                            cell.onclickFunktion = "javascript: sortTable(3, 'inactiveContentTable');";
                        }
                        if (element == "{{.mapping.table.playlist}}") {
                            cell.onclick = true;
                            cell.onclickFunktion = "javascript: sortTable(4, 'inactiveContentTable');";
                        }
                        if (element == "{{.mapping.table.groupTitle}}") {
                            cell.onclick = true;
                            cell.onclickFunktion = "javascript: sortTable(5, 'inactiveContentTable');";
                        }
                    }
                    header.appendChild(cell.createCell());
                });
                inactivetable.appendChild(header);
                // Inhalt der Tabelle
                var rows = this.createInactiveTableContent(menuKey);
                rows.forEach(tr => {
                    inactivetable.appendChild(tr);
                });
                savePopupData("mapping", "", false, 0);
            }
        }
        switch (menuKey) {
            case "mapping":
                sortTable(1);
                sortTable(1, "inactiveContentTable");
                break;
            case "filter":
                showPreview(true);
                sortTable(0);
                break;
            default:
                COLUMN_TO_SORT = -1;
                sortTable(0);
                break;
        }
        showElement("loading", false);
    }
}
function PageReady() {
    var server = new Server("getServerConfig");
    server.request(new Object());
    setInterval(function () {
        updateLog();
    }, 10000);
    getNewestReleaseFromGithub();
    return;
}
var checkboxesInitialState = [];
function setCheckboxes() {
    return __awaiter(this, void 0, void 0, function* () {
        const content = new PopupContent();
        const table = document.getElementById("checkboxTable");
        yield new Promise(f => setTimeout(f, 1000));
        if ("clientInfo" in SERVER) {
            const bindingIPs = SERVER['settings']['bindingIPs'];
            const bindingIPspArray = bindingIPs.split(";");
            const systemnIPs = SERVER["clientInfo"]["systemIPs"];
            systemnIPs.forEach((ipAddress, index) => {
                if (!ipAddress.includes('169.254')) {
                    const tr = document.createElement('tr');
                    const tdLeft = document.createElement('td');
                    const tdRight = document.createElement('td');
                    const checkbox = content.createCheckbox(ipAddress, 'ipCheckbox' + index);
                    checkbox.checked = bindingIPspArray.includes(ipAddress);
                    const label = document.createElement("label");
                    label.setAttribute("for", "ipCheckbox" + index);
                    label.innerHTML = ipAddress;
                    tdLeft.appendChild(checkbox);
                    tdRight.appendChild(label);
                    tr.appendChild(tdLeft);
                    tr.appendChild(tdRight);
                    table.appendChild(tr);
                }
            });
            const checkbox_container = document.getElementById("checkbox_container");
            const saveButton = createButton(content, "buttonUpdate", "{{.button.update}}", 'javsrcipt: updateBindingIPs()');
            const cancelButton = createButton(content, "buttonCancel", "{{.button.cancel}}");
            checkbox_container.appendChild(saveButton);
            checkbox_container.appendChild(cancelButton);
            const checkboxes = checkbox_container.querySelectorAll('input[type="checkbox"]');
            checkboxesInitialState = Array.from(checkboxes).map(checkbox => checkbox.checked);
            const ipSelection = document.getElementById('ip_selection');
            const closeButton = ipSelection.querySelector('button.btn-close');
            closeButton.addEventListener('click', () => resetCheckboxes(checkboxes, checkboxesInitialState));
            cancelButton.addEventListener('click', () => resetCheckboxes(checkboxes, checkboxesInitialState));
        }
    });
}
function resetCheckboxes(checkboxes, initialStates) {
    checkboxes.forEach((checkbox, index) => {
        checkbox.checked = initialStates[index];
    });
}
function createLayout() {
    if (!document.getElementById("main-menu")) {
        return;
    }
    // Menü erstellen
    document.getElementById("main-menu").innerHTML = "";
    for (let i = 0; i < menuItems.length; i++) {
        menuItems[i].id = i;
        switch (menuItems[i]["menuKey"]) {
            case "users":
            case "logout":
                if (SERVER["settings"]["authentication.web"] == true) {
                    menuItems[i].createItem();
                }
                break;
            default:
                menuItems[i].createItem();
                break;
        }
    }
    // Create server information
    document.getElementById("server_information").innerHTML = "";
    const serverInfo = new ServerInformation();
    serverInfo.addContent(serverInformation);
    document.getElementById("server_information").replaceWith(serverInfo.container);
    // initialize tool tips
    tooltipTriggerList = document.querySelectorAll('[data-bs-toggle="tooltip"]');
    tooltipList = Array.from(tooltipTriggerList).map(tooltipTriggerEl => new bootstrap.Tooltip(tooltipTriggerEl));
    // Client Info (Server Information)
    var obj = SERVER["clientInfo"];
    var keys = getObjKeys(obj);
    const changeVersion = document.getElementById("changeVersion");
    changeVersion.value = "{{.serverInfo.changeVersion.changeToBeta}}";
    changeVersion.onclick = () => {
        changeVersion.value = "{{.serverInfo.changeVersion.changing}}";
        const server = new Server("changeVersion");
        server.request(new Object());
        setTimeout(() => {
            location.reload();
        }, 20000);
    };
    for (var i = 0; i < keys.length; i++) {
        if (document.getElementById(keys[i])) {
            document.getElementById(keys[i]).value = obj[keys[i]];
            if (keys[i] === "version") {
                if (obj["beta"]) {
                    const version = document.getElementById(keys[i]);
                    version.value += " Beta";
                    changeVersion.value = "{{.serverInfo.changeVersion.changeToRelease}}";
                }
            }
        }
    }
    return;
}
function openThisMenu(element) {
    var id = element.id;
    var content = new ShowContent(id);
    content.show();
    enableGroupSelection(".bulk");
    return;
}
class PopupWindow {
    constructor() {
        this.DocumentID = "popupCustom";
        this.InteractionID = "interaction";
        this.doc = document.getElementById(this.DocumentID);
    }
    createTitle(title) {
        var td = document.createElement("TD");
        td.className = "left";
        td.innerHTML = title + ":";
        return td;
    }
    createContent(element) {
        var td = document.createElement("TD");
        td.appendChild(element);
        return td;
    }
    createInteraction() {
        var div = document.createElement("div");
        div.setAttribute("id", "popupInteraction");
        div.className = "interaction";
        this.doc.appendChild(div);
    }
}
class PopupContent extends PopupWindow {
    constructor() {
        super(...arguments);
        this.table = document.createElement("TABLE");
    }
    createHeadline(headline) {
        this.doc.innerHTML = "";
        var element = document.createElement("H3");
        element.innerHTML = headline.toUpperCase();
        this.doc.appendChild(element);
        // Tabelle erstellen
        this.table = document.createElement("TABLE");
        this.doc.appendChild(this.table);
    }
    appendRow(title, element) {
        var tr = document.createElement("TR");
        // Bezeichnung
        if (title.length != 0) {
            tr.appendChild(this.createTitle(title));
        }
        // Content
        tr.appendChild(this.createContent(element));
        this.table.appendChild(tr);
    }
    createInput(type, name, value) {
        var input = document.createElement("INPUT");
        if (value == undefined) {
            value = "";
        }
        input.setAttribute("type", type);
        input.setAttribute("name", name);
        input.setAttribute("value", value);
        return input;
    }
    createCheckbox(name, id = '') {
        var input = document.createElement("INPUT");
        input.setAttribute("type", "checkbox");
        if (id != '') {
            input.setAttribute("id", id);
        }
        input.setAttribute("name", name);
        return input;
    }
    createSelect(text, values, set, dbKey) {
        var select = document.createElement("SELECT");
        select.setAttribute("name", dbKey);
        for (let i = 0; i < text.length; i++) {
            var option = document.createElement("OPTION");
            option.setAttribute("value", values[i]);
            option.innerText = text[i];
            select.appendChild(option);
        }
        if (set != "") {
            select.value = set;
        }
        if (set == undefined) {
            select.value = values[0];
        }
        return select;
    }
    selectOption(select, value) {
        //select.selectedOptions = value
        var s = select;
        s.options[s.selectedIndex].value = value;
        return select;
    }
    description(value) {
        var tr = document.createElement("TR");
        var td = document.createElement("TD");
        var span = document.createElement("PRE");
        span.innerHTML = value;
        tr.appendChild(td);
        tr.appendChild(this.createContent(span));
        this.table.appendChild(tr);
    }
    // Interaktion
    addInteraction(element) {
        var interaction = document.getElementById("popupInteraction");
        interaction.appendChild(element);
    }
}
function openPopUp(dataType, element) {
    var data = new Object();
    var id;
    switch (element) {
        case undefined:
            switch (dataType) {
                case "group-title":
                    if (id == undefined) {
                        id = -1;
                    }
                    data = getLocalData("filter", id);
                    data["type"] = "group-title";
                    break;
                case "custom-filter":
                    if (id == undefined) {
                        id = -1;
                    }
                    data = getLocalData("filter", id);
                    data["type"] = "custom-filter";
                    break;
                default:
                    data["id.provider"] = "-";
                    data["type"] = dataType;
                    id = "-";
                    break;
            }
            break;
        default:
            id = element.id;
            data = getLocalData(dataType, id);
            break;
    }
    var content = new PopupContent();
    switch (dataType) {
        case "playlist":
            content.createHeadline("{{.playlist.playlistType.title}}");
            // Type
            var text = ["M3U", "HDHomeRun"];
            var values = ["javascript: openPopUp('m3u')", "javascript: openPopUp('hdhr')"];
            var select = content.createSelect(text, values, "", "type");
            select.setAttribute("id", "type");
            select.setAttribute("onchange", 'javascript: changeButtonAction(this, "next", "onclick")'); // changeButtonAction
            content.appendRow("{{.playlist.type.title}}", select);
            // Interaktion
            content.createInteraction();
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Weiter
            var input = content.createInput("button", "next", "{{.button.next}}");
            input.setAttribute("onclick", 'javascript: openPopUp("m3u")');
            input.setAttribute("id", 'next');
            content.addInteraction(input);
            break;
        case "m3u":
            content.createHeadline(dataType);
            // Name
            var dbKey = "name";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.name.placeholder}}");
            content.appendRow("{{.playlist.name.title}}", input);
            // Beschreibung
            var dbKey = "description";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.description.placeholder}}");
            content.appendRow("{{.playlist.description.title}}", input);
            // URL
            var dbKey = "file.source";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.fileM3U.placeholder}}");
            content.appendRow("{{.playlist.fileM3U.title}}", input);
            // Tuner
            if (SERVER["settings"]["buffer"] != "-") {
                var text = new Array();
                var values = new Array();
                for (var i = 1; i <= 100; i++) {
                    text.push(i.toString());
                    values.push(i.toString());
                }
                var dbKey = "tuner";
                var select = content.createSelect(text, values, data[dbKey], dbKey);
                select.setAttribute("onfocus", "javascript: return;");
                content.appendRow("{{.playlist.tuner.title}}", select);
            }
            else {
                var dbKey = "tuner";
                if (data[dbKey] == undefined) {
                    data[dbKey] = 1;
                }
                var input = content.createInput("text", dbKey, data[dbKey]);
                input.setAttribute("readonly", "true");
                input.className = "notAvailable";
                content.appendRow("{{.playlist.tuner.title}}", input);
            }
            content.description("{{.playlist.tuner.description}}");
            var dbKey = "http_proxy.ip";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.http_proxy_ip.placeholder}}");
            content.appendRow("{{.playlist.http_proxy_ip.title}}", input);
            content.description("{{.playlist.http_proxy_ip.description}}");
            var dbKey = "http_proxy.port";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.http_proxy_port.placeholder}}");
            content.appendRow("{{.playlist.http_proxy_port.title}}", input);
            content.description("{{.playlist.http_proxy_port.description}}");
            // Interaktion
            content.createInteraction();
            // Löschen
            if (data["id.provider"] != "-") {
                var input = content.createInput("button", "delete", "{{.button.delete}}");
                input.className = "delete";
                input.setAttribute('onclick', 'javascript: savePopupData("m3u", "' + id + '", true, 0)');
                content.addInteraction(input);
            }
            else {
                var input = content.createInput("button", "back", "{{.button.back}}");
                input.setAttribute("onclick", 'javascript: openPopUp("playlist")');
                content.addInteraction(input);
            }
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Aktualisieren
            if (data["id.provider"] != "-") {
                var input = content.createInput("button", "update", "{{.button.update}}");
                input.setAttribute('onclick', 'javascript: savePopupData("m3u", "' + id + '", false, 1)');
                content.addInteraction(input);
            }
            // Speichern
            var input = content.createInput("button", "save", "{{.button.save}}");
            input.setAttribute('onclick', 'javascript: savePopupData("m3u", "' + id + '", false, 0)');
            content.addInteraction(input);
            break;
        case "hdhr":
            content.createHeadline(dataType);
            // Name
            var dbKey = "name";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.name.placeholder}}");
            content.appendRow("{{.playlist.name.title}}", input);
            // Beschreibung
            var dbKey = "description";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.description.placeholder}}");
            content.appendRow("{{.playlist.description.placeholder}}", input);
            // URL
            var dbKey = "file.source";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.fileHDHR.placeholder}}");
            content.appendRow("{{.playlist.fileHDHR.title}}", input);
            // Tuner
            if (SERVER["settings"]["buffer"] != "-") {
                var text = new Array();
                var values = new Array();
                for (var i = 1; i <= 100; i++) {
                    text.push(i.toString());
                    values.push(i.toString());
                }
                var dbKey = "tuner";
                var select = content.createSelect(text, values, data[dbKey], dbKey);
                select.setAttribute("onfocus", "javascript: return;");
                content.appendRow("{{.playlist.tuner.title}}", select);
            }
            else {
                var dbKey = "tuner";
                if (data[dbKey] == undefined) {
                    data[dbKey] = 1;
                }
                var input = content.createInput("text", dbKey, data[dbKey]);
                input.setAttribute("readonly", "true");
                input.className = "notAvailable";
                content.appendRow("{{.playlist.tuner.title}}", input);
            }
            content.description("{{.playlist.tuner.description}}");
            var dbKey = "http_proxy.ip";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.http_proxy_ip.placeholder}}");
            content.appendRow("{{.playlist.http_proxy_ip.title}}", input);
            content.description("{{.playlist.http_proxy_ip.description}}");
            var dbKey = "http_proxy.port";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.http_proxy_port.placeholder}}");
            content.appendRow("{{.playlist.http_proxy_port.title}}", input);
            content.description("{{.playlist.http_proxy_port.description}}");
            // Interaktion
            content.createInteraction();
            // Löschen
            if (data["id.provider"] != "-") {
                var input = content.createInput("button", "delete", "{{.button.delete}}");
                input.setAttribute('onclick', 'javascript: savePopupData("hdhr", "' + id + '", true, 0)');
                input.className = "delete";
                content.addInteraction(input);
            }
            else {
                var input = content.createInput("button", "back", "{{.button.back}}");
                input.setAttribute("onclick", 'javascript: openPopUp("playlist")');
                content.addInteraction(input);
            }
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Aktualisieren
            if (data["id.provider"] != "-") {
                var input = content.createInput("button", "update", "{{.button.update}}");
                input.setAttribute('onclick', 'javascript: savePopupData("hdhr", "' + id + '", false, 1)');
                content.addInteraction(input);
            }
            // Speichern
            var input = content.createInput("button", "save", "{{.button.save}}");
            input.setAttribute('onclick', 'javascript: savePopupData("hdhr", "' + id + '", false, 0)');
            content.addInteraction(input);
            break;
        case "filter":
            content.createHeadline(dataType);
            // Type
            var dbKey = "type";
            var text = ["M3U: " + "{{.filter.type.groupTitle}}", "Threadfin: " + "{{.filter.type.customFilter}}"];
            var values = ["javascript: openPopUp('group-title')", "javascript: openPopUp('custom-filter')"];
            var select = content.createSelect(text, values, "javascript: openPopUp('group-title')", dbKey);
            select.setAttribute("id", id);
            select.setAttribute("onchange", 'javascript: changeButtonAction(this, "next", "onclick");'); // changeButtonAction
            content.appendRow("{{.filter.type.title}}", select);
            // Interaktion
            content.createInteraction();
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Weiter
            var input = content.createInput("button", "next", "{{.button.next}}");
            input.setAttribute("onclick", 'javascript: openPopUp("group-title")');
            input.setAttribute("id", 'next');
            content.addInteraction(input);
            break;
        case "custom-filter":
        case "group-title":
            switch (dataType) {
                case "custom-filter":
                    content.createHeadline("{{.filter.custom}}");
                    break;
                case "group-title":
                    content.createHeadline("{{.filter.group}}");
                    break;
            }
            // Name      
            var dbKey = "name";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.filter.name.placeholder}}");
            content.appendRow("{{.filter.name.title}}", input);
            // Beschreibung
            var dbKey = "description";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.filter.description.placeholder}}");
            content.appendRow("{{.filter.description.title}}", input);
            // Typ
            var dbKey = "type";
            var input = content.createInput("hidden", dbKey, data[dbKey]);
            content.appendRow("", input);
            var filterType = data[dbKey];
            switch (filterType) {
                case "custom-filter":
                    // Groß- Kleinschreibung beachten
                    var dbKey = "caseSensitive";
                    var input = content.createCheckbox(dbKey);
                    input.checked = data[dbKey];
                    content.appendRow("{{.filter.caseSensitive.title}}", input);
                    // Filterregel (Benutzerdefiniert)
                    var dbKey = "filter";
                    var input = content.createInput("text", dbKey, data[dbKey]);
                    input.setAttribute("placeholder", "{{.filter.filterRule.placeholder}}");
                    content.appendRow("{{.filter.filterRule.title}}", input);
                    break;
                case "group-title":
                    //alert(dbKey + " " + filterType)
                    // Filter basierend auf den Gruppen in der M3U
                    var dbKey = "filter";
                    var groupsM3U = getLocalData("m3uGroups", "");
                    var text = groupsM3U["text"];
                    var values = groupsM3U["value"];
                    var select = content.createSelect(text, values, data[dbKey], dbKey);
                    select.setAttribute("onchange", "javascript: this.className = 'changed'");
                    content.appendRow("{{.filter.filterGroup.title}}", select);
                    content.description("{{.filter.filterGroup.description}}");
                    // Groß- Kleinschreibung beachten
                    var dbKey = "caseSensitive";
                    var input = content.createCheckbox(dbKey);
                    input.checked = data[dbKey];
                    content.appendRow("{{.filter.caseSensitive.title}}", input);
                    var dbKey = "include";
                    var input = content.createInput("text", dbKey, data[dbKey]);
                    input.setAttribute("placeholder", "{{.filter.include.placeholder}}");
                    content.appendRow("{{.filter.include.title}}", input);
                    content.description("{{.filter.include.description}}");
                    var dbKey = "exclude";
                    var input = content.createInput("text", dbKey, data[dbKey]);
                    input.setAttribute("placeholder", "{{.filter.exclude.placeholder}}");
                    content.appendRow("{{.filter.exclude.title}}", input);
                    content.description("{{.filter.exclude.description}}");
                    break;
                default:
                    break;
            }
            // Name      
            var dbKey = "startingNumber";
            if (data[dbKey] !== undefined) {
                var input = content.createInput("text", dbKey, data[dbKey]);
            }
            else {
                var input = content.createInput("text", dbKey, "1000");
            }
            input.setAttribute("placeholder", "{{.filter.startingnumber.placeholder}}");
            content.appendRow("{{.filter.startingnumber.title}}", input);
            content.description("{{.filter.startingnumber.description}}");
            var dbKey = "x-category";
            var text = ["-"];
            var values = [""];
            var epgCategories = SERVER["settings"]["epgCategories"];
            var categories = epgCategories.split("|");
            for (i = 0; i <= categories.length; i++) {
                var cat = categories[i];
                if (cat) {
                    var cat_split = cat.split(":");
                    text.push(cat_split[0]);
                    values.push(cat_split[1]);
                }
            }
            var select = content.createSelect(text, values, data[dbKey], dbKey);
            select.setAttribute("onchange", "javascript: this.className = 'changed'");
            content.appendRow("{{.filter.category.title}}", select);
            // Interaktion
            content.createInteraction();
            // Löschen
            var input = content.createInput("button", "delete", "{{.button.delete}}");
            input.setAttribute('onclick', 'javascript: savePopupData("filter", "' + id + '", true, 0)');
            input.className = "delete";
            content.addInteraction(input);
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Speichern
            var input = content.createInput("button", "save", "{{.button.save}}");
            input.setAttribute('onclick', 'javascript: savePopupData("filter", "' + id + '", false, 0)');
            content.addInteraction(input);
            break;
        case "xmltv":
            content.createHeadline(dataType);
            // Name
            var dbKey = "name";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.xmltv.name.placeholder}}");
            content.appendRow("{{.xmltv.name.title}}", input);
            // Beschreibung
            var dbKey = "description";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.xmltv.description.placeholder}}");
            content.appendRow("{{.xmltv.description.title}}", input);
            // URL
            var dbKey = "file.source";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.xmltv.fileXMLTV.placeholder}}");
            content.appendRow("{{.xmltv.fileXMLTV.title}}", input);
            var dbKey = "http_proxy.ip";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.xmltv.http_proxy_ip.placeholder}}");
            content.appendRow("{{.xmltv.http_proxy_ip.title}}", input);
            content.description("{{.xmltv.http_proxy_ip.description}}");
            var dbKey = "http_proxy.port";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.xmltv.http_proxy_port.placeholder}}");
            content.appendRow("{{.xmltv.http_proxy_port.title}}", input);
            content.description("{{.xmltv.http_proxy_port.description}}");
            // Interaktion
            content.createInteraction();
            // Löschen
            if (data["id.provider"] != "-") {
                var input = content.createInput("button", "delete", "{{.button.delete}}");
                input.setAttribute('onclick', 'javascript: savePopupData("xmltv", "' + id + '", true, 0)');
                input.className = "delete";
                content.addInteraction(input);
            }
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Aktualisieren
            if (data["id.provider"] != "-") {
                var input = content.createInput("button", "update", "{{.button.update}}");
                input.setAttribute('onclick', 'javascript: savePopupData("xmltv", "' + id + '", false, 1)');
                content.addInteraction(input);
            }
            // Speichern
            var input = content.createInput("button", "save", "{{.button.save}}");
            input.setAttribute('onclick', 'javascript: savePopupData("xmltv", "' + id + '", false, 0)');
            content.addInteraction(input);
            break;
        case "users":
            content.createHeadline("{{.mainMenu.item.users}}");
            // Benutzername 
            var dbKey = "username";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.users.username.placeholder}}");
            content.appendRow("{{.users.username.title}}", input);
            // Neues Passwort 
            var dbKey = "password";
            var input = content.createInput("password", dbKey, "");
            input.setAttribute("placeholder", "{{.users.password.placeholder}}");
            content.appendRow("{{.users.password.title}}", input);
            // Bestätigung 
            var dbKey = "confirm";
            var input = content.createInput("password", dbKey, "");
            input.setAttribute("placeholder", "{{.users.confirm.placeholder}}");
            content.appendRow("{{.users.confirm.title}}", input);
            // Berechtigung WEB
            var dbKey = "authentication.web";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            if (data["defaultUser"] == true) {
                input.setAttribute("onclick", "javascript: return false");
            }
            content.appendRow("{{.users.web.title}}", input);
            // Berechtigung PMS
            var dbKey = "authentication.pms";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            content.appendRow("{{.users.pms.title}}", input);
            // Berechtigung M3U
            var dbKey = "authentication.m3u";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            content.appendRow("{{.users.m3u.title}}", input);
            // Berechtigung XML
            var dbKey = "authentication.xml";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            content.appendRow("{{.users.xml.title}}", input);
            // Berechtigung API
            var dbKey = "authentication.api";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            content.appendRow("{{.users.api.title}}", input);
            // Interaktion
            content.createInteraction();
            // Löschen
            if (data["defaultUser"] != true && id != "-") {
                var input = content.createInput("button", "delete", "{{.button.delete}}");
                input.className = "delete";
                input.setAttribute('onclick', 'javascript: savePopupData("' + dataType + '", "' + id + '", true, 0)');
                content.addInteraction(input);
            }
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Speichern
            var input = content.createInput("button", "save", "{{.button.save}}");
            input.setAttribute("onclick", 'javascript: savePopupData("' + dataType + '", "' + id + '", "false");');
            content.addInteraction(input);
            break;
        case "mapping":
            content.createHeadline("{{.mainMenu.item.mapping}}");
            if (BULK_EDIT == true) {
                var dbKey = "x-channels-start";
                var input = content.createInput("text", dbKey, data[dbKey]);
                // Set the value to the first selected channel
                var channels = getAllSelectedChannels();
                var channel = SERVER["xepg"]["epgMapping"][channels[0]];
                if (typeof channel !== "undefined") {
                    input.setAttribute("value", channel["x-channelID"]);
                }
                input.setAttribute("onchange", 'javascript: changeChannelNumbers("' + channels + '");');
                content.appendRow("{{.mapping.channelGroupStart.title}}", input);
            }
            // Aktiv 
            var dbKey = "x-active";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            input.id = "active";
            //input.setAttribute("onchange", "javascript: this.className = 'changed'")
            input.setAttribute("onchange", "javascript: toggleChannelStatus('" + id + "', this)");
            content.appendRow("{{.mapping.active.title}}", input);
            // Kanalname 
            var dbKey = "x-name";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("onchange", "javascript: this.className = 'changed'");
            if (BULK_EDIT == true) {
                input.style.border = "solid 1px red";
                input.setAttribute("readonly", "true");
            }
            content.appendRow("{{.mapping.channelName.title}}", input);
            "<span class='text-danger'>" + data["tvg-id"] + "</span> <span class='text-primary'>(" + data["x-epg"] + ")</span>";
            // Beschreibung 
            var dbKey = "x-description";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.mapping.description.placeholder}}");
            input.setAttribute("onchange", "javascript: this.className = 'changed'");
            content.appendRow("{{.mapping.description.title}}", input);
            // Aktualisierung des Kanalnamens
            if (data.hasOwnProperty("_uuid.key")) {
                if (data["_uuid.key"] != "") {
                    var dbKey = "x-update-channel-name";
                    var input = content.createCheckbox(dbKey);
                    input.setAttribute("onchange", "javascript: this.className = 'changed'");
                    input.checked = data[dbKey];
                    content.appendRow("{{.mapping.updateChannelName.title}}", input);
                }
            }
            // Logo URL (Kanal) 
            var dbKey = "tvg-logo";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("onchange", "javascript: this.className = 'changed'");
            input.setAttribute("id", "channel-icon");
            content.appendRow("{{.mapping.channelLogo.title}}", input);
            // Aktualisierung des Kanallogos
            var dbKey = "x-update-channel-icon";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            input.setAttribute("id", "update-icon");
            input.setAttribute("onchange", "javascript: this.className = 'changed'; changeChannelLogo('" + id + "');");
            content.appendRow("{{.mapping.updateChannelLogo.title}}", input);
            // Erweitern der EPG Kategorie
            var dbKey = "x-category";
            var text = ["-"];
            var values = [""];
            var epgCategories = SERVER["settings"]["epgCategories"];
            var categories = epgCategories.split("|");
            for (i = 0; i <= categories.length; i++) {
                var cat = categories[i];
                if (cat) {
                    var cat_split = cat.split(":");
                    text.push(cat_split[0]);
                    values.push(cat_split[1]);
                }
            }
            var select = content.createSelect(text, values, data[dbKey], dbKey);
            select.setAttribute("onchange", "javascript: this.className = 'changed'");
            content.appendRow("{{.mapping.epgCategory.title}}", select);
            // M3U Gruppentitel
            var dbKey = "x-group-title";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("onchange", "javascript: this.className = 'changed'");
            content.appendRow("{{.mapping.m3uGroupTitle.title}}", input);
            if (data["group-title"] != undefined) {
                content.description(data["group-title"]);
            }
            // XMLTV Datei
            var dbKey = "x-xmltv-file";
            var xmlFile = data[dbKey];
            var xmltv = new XMLTVFile();
            var select = xmltv.getFiles(data[dbKey]);
            select.setAttribute("name", dbKey);
            select.setAttribute("id", "popup-xmltv");
            select.setAttribute("onchange", "javascript: this.className = 'changed'; setXmltvChannel('" + id + "',this, '" + data["x-mapping"] + "');");
            content.appendRow("{{.mapping.xmltvFile.title}}", select);
            var file = data[dbKey];
            // XMLTV Mapping
            var dbKey = "x-mapping";
            var xmltv = new XMLTVFile();
            const currentXmlTvId = data[dbKey];
            const [xmlTvIdContainer, xmlTvIdInput, xmlTvIdDatalist] = xmltv.newXmlTvIdPicker(xmlFile, currentXmlTvId);
            xmlTvIdContainer.setAttribute('id', 'xmltv-id-picker-container');
            xmlTvIdInput.setAttribute('list', 'xmltv-id-picker-datalist');
            xmlTvIdInput.setAttribute('name', 'x-mapping'); // Should stay x-mapping as it will be used in donePopupData to make a server request
            xmlTvIdInput.setAttribute('id', 'xmltv-id-picker-input');
            xmlTvIdInput.setAttribute('onchange', `javascript: this.className = 'changed'; checkXmltvChannel('${id}', this, '${xmlFile}');`);
            xmlTvIdDatalist.setAttribute('id', 'xmltv-id-picker-datalist');
            // sortSelect(xmlTvIdDatalist); // TODO: Better sort before adding
            content.appendRow('{{.mapping.xmltvChannel.title}}', xmlTvIdContainer);
            // Extra PPV Data
            if (currentXmlTvId == "PPV") {
                var dbKey = "x-ppv-extra";
                var input = content.createInput("text", dbKey, data[dbKey]);
                input.setAttribute("onchange", "javascript: this.className = 'changed'");
                input.setAttribute("id", "ppv-extra");
                content.appendRow("{{.mapping.ppvextra.title}}", input);
            }
            var dbKey = "x-backup-channel-1";
            var xmltv = new XMLTVFile();
            const backup1XmlTvId = data[dbKey];
            const [xmlTvBackup1IdContainer, xmlTvBackup1IdInput, xmlTvBackup1IdDatalist] = xmltv.newXmlTvIdPicker(xmlFile, backup1XmlTvId);
            xmlTvBackup1IdContainer.setAttribute('id', 'xmltv-id-picker-container-1');
            xmlTvBackup1IdInput.setAttribute('list', 'xmltv-id-picker-datalist');
            xmlTvBackup1IdInput.setAttribute('name', dbKey); // Should stay x-mapping as it will be used in donePopupData to make a server request
            xmlTvBackup1IdInput.setAttribute("id", "backup-channel-1");
            xmlTvBackup1IdInput.setAttribute('onchange', `javascript: this.className = 'changed'; checkXmltvChannel('${id}', this, '${xmlFile}');`);
            xmlTvBackup1IdDatalist.setAttribute('id', 'xmltv-id-picker-datalist-backup1');
            // sortSelect(xmlTvIdDatalist); // TODO: Better sort before adding
            content.appendRow('{{.mapping.backupChannel1.title}}', xmlTvBackup1IdContainer);
            var dbKey = "x-backup-channel-2";
            var xmltv = new XMLTVFile();
            const backup2XmlTvId = data[dbKey];
            const [xmlTvBackup2IdContainer, xmlTvBackup2IdInput, xmlTvBackup2IdDatalist] = xmltv.newXmlTvIdPicker(xmlFile, backup2XmlTvId);
            xmlTvBackup2IdContainer.setAttribute('id', 'xmltv-id-picker-container-2');
            xmlTvBackup2IdInput.setAttribute('list', 'xmltv-id-picker-datalist');
            xmlTvBackup2IdInput.setAttribute('name', dbKey); // Should stay x-mapping as it will be used in donePopupData to make a server request
            xmlTvBackup2IdInput.setAttribute("id", "backup-channel-2");
            xmlTvBackup2IdInput.setAttribute('onchange', `javascript: this.className = 'changed'; checkXmltvChannel('${id}', this, '${xmlFile}');`);
            xmlTvBackup2IdDatalist.setAttribute('id', 'xmltv-id-picker-datalist-backup2');
            content.appendRow("{{.mapping.backupChannel2.title}}", xmlTvBackup2IdContainer);
            var dbKey = "x-backup-channel-3";
            var xmltv = new XMLTVFile();
            const backup3XmlTvId = data[dbKey];
            const [xmlTvBackup3IdContainer, xmlTvBackup3IdInput, xmlTvBackup3IdDatalist] = xmltv.newXmlTvIdPicker(xmlFile, backup3XmlTvId);
            xmlTvBackup3IdContainer.setAttribute('id', 'xmltv-id-picker-container-3');
            xmlTvBackup3IdInput.setAttribute('list', 'xmltv-id-picker-datalist');
            xmlTvBackup3IdInput.setAttribute('name', dbKey); // Should stay x-mapping as it will be used in donePopupData to make a server request
            xmlTvBackup3IdInput.setAttribute("id", "backup-channel-3");
            xmlTvBackup3IdInput.setAttribute('onchange', `javascript: this.className = 'changed'; checkXmltvChannel('${id}', this, '${xmlFile}');`);
            xmlTvBackup3IdDatalist.setAttribute('id', 'xmltv-id-picker-datalist-backup3');
            content.appendRow("{{.mapping.backupChannel3.title}}", xmlTvBackup3IdContainer);
            // Interaktion
            content.createInteraction();
            // Logo hochladen
            var input = content.createInput("button", "upload", "{{.button.uploadLogo}}");
            input.setAttribute("onclick", 'javascript: uploadLogo();');
            content.addInteraction(input);
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Fertig
            var ids = new Array();
            ids = getAllSelectedChannels();
            if (ids.length == 0) {
                ids.push(id);
            }
            var input = content.createInput("button", "save", "{{.button.done}}");
            input.setAttribute("onclick", 'javascript: donePopupData("' + dataType + '", "' + ids + '", "false");');
            content.addInteraction(input);
            break;
        default:
            break;
    }
    showElement('popupCustom', true);
}
class XMLTVFile {
    getFiles(set) {
        var fileIDs = getObjKeys(SERVER["xepg"]["xmltvMap"]);
        var values = new Array("-");
        var text = new Array("-");
        for (let i = 0; i < fileIDs.length; i++) {
            if (fileIDs[i] != "Threadfin Dummy") {
                values.push(getValueFromProviderFile(fileIDs[i], "xmltv", "file.threadfin"));
                text.push(getValueFromProviderFile(fileIDs[i], "xmltv", "name"));
            }
            else {
                values.push(fileIDs[i]);
                text.push(fileIDs[i]);
            }
        }
        var select = document.createElement("SELECT");
        for (let i = 0; i < text.length; i++) {
            var option = document.createElement("OPTION");
            option.setAttribute("value", values[i]);
            option.innerText = text[i];
            select.appendChild(option);
        }
        if (set != "") {
            select.value = set;
        }
        return select;
    }
    /**
   * @param xmlTvFile XML file path to get EPG from.
   * @param currentXmlTvId Current XMLTV ID to set initial input value to.
   * @returns Array of, sequentially:
   * 1) Container of the picker.
   * 2) Input field to type at and get choice from.
   * 3) Datalist containing every option.
   */
    newXmlTvIdPicker(xmlTvFile, currentXmlTvId) {
        const container = document.createElement('div');
        const input = document.createElement('input');
        input.setAttribute('type', 'text');
        // Initially, set value to '-' if input is empty
        input.value = (currentXmlTvId) ? currentXmlTvId : '-';
        // When input is focused, remove '-' from it
        input.addEventListener('focus', (evt) => {
            const target = evt.target;
            target.value = (target.value === '-') ? '' : target.value;
        });
        // When input lose focus or take a value, if it's empty, set value to '-'
        input.addEventListener('blur', setFallbackValue);
        input.addEventListener('change', setFallbackValue);
        function setFallbackValue(evt) {
            const target = evt.target;
            target.value = (target.value) ? target.value : '-';
        }
        container.appendChild(input);
        const datalist = document.createElement('datalist');
        const option = document.createElement('option');
        option.setAttribute('value', '-');
        option.innerText = '-';
        datalist.appendChild(option);
        const epg = SERVER['xepg']['xmltvMap'][xmlTvFile];
        if (epg) {
            const programIds = getOwnObjProps(epg);
            programIds.forEach((programId) => {
                const program = epg[programId];
                if (program.hasOwnProperty('display-name')) {
                    const option = document.createElement('option');
                    option.setAttribute('value', programId);
                    option.innerText = program["display-name"];
                    datalist.appendChild(option);
                }
                else {
                    const option = document.createElement('option');
                    option.setAttribute('value', programId);
                    option.innerText = '-';
                    datalist.appendChild(option);
                }
            });
        }
        container.appendChild(datalist);
        return [container, input, datalist];
    }
    getPrograms(file, set, active) {
        //var fileIDs:string[] = getObjKeys(SERVER["xepg"]["xmltvMap"])
        var values = getObjKeys(SERVER["xepg"]["xmltvMap"][file]);
        var text = new Array();
        var displayName;
        var actives = getObjKeys(SERVER["data"]["StreamPreviewUI"]["activeStreams"]);
        var active_list = new Array();
        if (active == true) {
            for (let i = 0; i < actives.length; i++) {
                var names_split = SERVER["data"]["StreamPreviewUI"]["activeStreams"][actives[i]].split("[");
                displayName = names_split[0].trim();
                if (displayName != "") {
                    var object = { "value": displayName, "display": displayName };
                    active_list.push(object);
                }
            }
        }
        else {
            for (let i = 0; i < values.length; i++) {
                if (SERVER["xepg"]["xmltvMap"][file][values[i]].hasOwnProperty('display-name') == true) {
                    displayName = SERVER["xepg"]["xmltvMap"][file][values[i]]["display-name"];
                }
                else {
                    displayName = "-";
                }
                text[i] = displayName + " (" + values[i] + ")";
            }
        }
        text.unshift("-");
        values.unshift("-");
        var select = document.createElement("SELECT");
        for (let i = 0; i < text.length; i++) {
            var option = document.createElement("OPTION");
            option.setAttribute("value", values[i]);
            option.innerText = text[i];
            select.appendChild(option);
        }
        for (let i = 0; i < active_list.length; i++) {
            var option = document.createElement("OPTION");
            option.setAttribute("value", active_list[i]["value"]);
            option.innerText = active_list[i]["display"];
            select.appendChild(option);
        }
        if (set != "") {
            select.value = set;
        }
        if (select.value != set) {
            select.value = "-";
        }
        return select;
    }
}
function getValueFromProviderFile(file, fileType, key) {
    if (file == "Threadfin Dummy") {
        return file;
    }
    var fileID;
    var indicator = file.charAt(0);
    switch (indicator) {
        case "M":
            fileType = "m3u";
            fileID = file;
            break;
        case "H":
            fileType = "hdhr";
            fileID = file;
            break;
        case "X":
            fileType = "xmltv";
            fileID = file.substring(0, file.lastIndexOf('.'));
            break;
    }
    if (SERVER["settings"]["files"][fileType].hasOwnProperty(fileID) == true) {
        var data = SERVER["settings"]["files"][fileType][fileID];
        return data[key];
    }
    return;
}
function setXmltvChannel(epgMapId, xmlTvFileSelect) {
    const xmlTv = new XMLTVFile();
    const newXmlTvFile = xmlTvFileSelect.value;
    // Remove old XMLTV ID selection box
    const xmlTvIdPickerParent = document.getElementById('xmltv-id-picker-container').parentElement;
    xmlTvIdPickerParent.innerHTML = '';
    // Create new XMLTV ID selection box
    const tvgId = SERVER['xepg']['epgMapping'][epgMapId]['tvg-id'];
    const [xmlTvIdContainer, xmlTvIdInput, xmlTvIdDatalist] = xmlTv.newXmlTvIdPicker(newXmlTvFile, tvgId);
    xmlTvIdContainer.setAttribute('id', 'xmltv-id-picker-container');
    xmlTvIdInput.setAttribute('list', 'xmltv-id-picker-datalist');
    xmlTvIdInput.setAttribute('name', 'x-mapping'); // Should stay x-mapping as it will be used in donePopupData to make a server request
    xmlTvIdInput.setAttribute('id', 'xmltv-id-picker-input');
    xmlTvIdInput.setAttribute('onchange', `javascript: this.className = 'changed'; checkXmltvChannel('${epgMapId}', this.value, '${newXmlTvFile}');`);
    xmlTvIdInput.classList.add('changed');
    xmlTvIdDatalist.setAttribute('id', 'xmltv-id-picker-datalist');
    // Add new XMLTV ID selection box to it's parent
    xmlTvIdPickerParent.appendChild(xmlTvIdContainer);
    checkXmltvChannel(epgMapId, xmlTvIdInput.value, newXmlTvFile);
}
function checkPPV(title, element) {
    var value = element.value;
    console.log("DUMMY TYPE: " + value);
    if (value == "PPV") {
        var td = document.getElementById("x-ppv-extra").parentElement;
        td.innerHTML = "";
        var dbKey = "x-ppv-extra";
        var input = document.createElement("INPUT");
        input.setAttribute("type", "text");
        input.setAttribute("name", dbKey);
        // input.setAttribute("value", value)
        input.setAttribute("onchange", "javascript: this.className = 'changed'");
        input.setAttribute("id", "ppv-extra");
        var tr = document.createElement("TR");
        // Bezeichnung
        if (title.length != 0) {
            var td = document.createElement("TD");
            td.className = "left";
            td.innerHTML = title + ":";
        }
        // Content
        td.appendChild(element);
        this.table.appendChild(tr);
    }
}
function checkXmltvChannel(id, element, xmlFile) {
    var value = element.value;
    var bool;
    var checkbox = document.getElementById('active');
    var channel = SERVER["xepg"]["epgMapping"][id];
    var updateLogo;
    if (value == "-") {
        bool = false;
    }
    else {
        bool = true;
    }
    checkbox.checked = bool;
    checkbox.className = "changed";
    console.log(xmlFile);
    // Kanallogo aktualisieren
    /*
    updateLogo = (document.getElementById("update-icon") as HTMLInputElement).checked
    console.log(updateLogo);
    */
    if (xmlFile != "Threadfin Dummy" && bool == true) {
        //(document.getElementById("update-icon") as HTMLInputElement).checked = true;
        //(document.getElementById("update-icon") as HTMLInputElement).className = "changed";
        console.log("ID", id);
        changeChannelLogo(id);
        return;
    }
    if (xmlFile == "Threadfin Dummy") {
        document.getElementById("update-icon").checked = false;
        document.getElementById("update-icon").className = "changed";
    }
    return;
}
function changeChannelLogo(epgMapId) {
    const channel = SERVER['xepg']['epgMapping'][epgMapId];
    const xmlTvFileSelect = document.getElementById('popup-xmltv');
    const xmlTvFile = xmlTvFileSelect.options[xmlTvFileSelect.selectedIndex].value;
    const xmlTvIdInput = document.getElementById('xmltv-id-picker-input');
    const newXmlTvId = xmlTvIdInput.value;
    const updateLogo = !BULK_EDIT || document.getElementById('update-icon').checked;
    let logo;
    if (updateLogo == true && xmlTvFile != 'Threadfin Dummy') {
        if (SERVER['xepg']['xmltvMap'][xmlTvFile].hasOwnProperty(newXmlTvId)) {
            logo = SERVER['xepg']['xmltvMap'][xmlTvFile][newXmlTvId]['icon'];
        }
        else {
            logo = channel['tvg-logo'];
        }
    }
}
function savePopupData(dataType, id, remove, option) {
    showElement('popup', false);
    showElement("loading", true);
    if (dataType == "mapping") {
        var data = new Object();
        console.log("Save mapping data");
        cmd = "saveEpgMapping";
        data["epgMapping"] = SERVER["xepg"]["epgMapping"];
        console.log("SEND TO SERVER");
        var server = new Server(cmd);
        server.request(data);
        delete UNDO["epgMapping"];
        showElement("loading", false);
        return;
    }
    console.log("Save popup data");
    var div = document.getElementById("popupCustom");
    var inputs = div.getElementsByTagName("TABLE")[0].getElementsByTagName("INPUT");
    var selects = div.getElementsByTagName("TABLE")[0].getElementsByTagName("SELECT");
    var input = new Object();
    var confirmMsg;
    for (let i = 0; i < selects.length; i++) {
        var name;
        name = selects[i].name;
        var value = selects[i].value;
        switch (name) {
            case "tuner":
                input[name] = parseInt(value);
                break;
            default:
                input[name] = value;
                break;
        }
    }
    for (let i = 0; i < inputs.length; i++) {
        switch (inputs[i].type) {
            case "checkbox":
                name = inputs[i].name;
                input[name] = inputs[i].checked;
                break;
            case "text":
            case "hidden":
            case "password":
                name = inputs[i].name;
                switch (name) {
                    case "tuner":
                        input[name] = parseInt(inputs[i].value);
                        break;
                    default:
                        input[name] = inputs[i].value;
                        break;
                }
                break;
        }
    }
    var data = new Object();
    var cmd;
    if (remove == true) {
        input["delete"] = true;
    }
    switch (dataType) {
        case "users":
            confirmMsg = "Delete this user?";
            if (id == "-") {
                cmd = "saveNewUser";
                data["userData"] = input;
            }
            else {
                cmd = "saveUserData";
                var d = new Object();
                d[id] = input;
                data["userData"] = d;
            }
            break;
        case "m3u":
            confirmMsg = "Delete this playlist?";
            switch (option) {
                // Popup: Save
                case 0:
                    cmd = "saveFilesM3U";
                    break;
                // Popup: Update
                case 1:
                    cmd = "updateFileM3U";
                    break;
            }
            data["files"] = new Object;
            data["files"][dataType] = new Object;
            data["files"][dataType][id] = input;
            break;
        case "hdhr":
            confirmMsg = "Delete this HDHomeRun tuner?";
            switch (option) {
                // Popup: Save
                case 0:
                    cmd = "saveFilesHDHR";
                    break;
                // Popup: Update
                case 1:
                    cmd = "updateFileHDHR";
                    break;
            }
            data["files"] = new Object;
            data["files"][dataType] = new Object;
            data["files"][dataType][id] = input;
            break;
        case "xmltv":
            confirmMsg = "Delete this XMLTV file?";
            switch (option) {
                // Popup: Save
                case 0:
                    cmd = "saveFilesXMLTV";
                    break;
                // Popup: Update
                case 1:
                    cmd = "updateFileXMLTV";
                    break;
            }
            data["files"] = new Object;
            data["files"][dataType] = new Object;
            data["files"][dataType][id] = input;
            break;
        case "filter":
            confirmMsg = "Delete this filter?";
            cmd = "saveFilter";
            data["filter"] = new Object;
            data["filter"][id] = input;
            break;
        default:
            console.log(dataType, id);
            return;
            break;
    }
    if (remove == true) {
        if (!confirm(confirmMsg)) {
            showElement("popup", false);
            return;
        }
    }
    console.log("SEND TO SERVER");
    console.log(data);
    var server = new Server(cmd);
    server.request(data);
    showElement("loading", false);
}
function donePopupData(dataType, idsStr) {
    var ids = idsStr.split(',');
    var div = document.getElementById("popupCustom");
    var inputs = div.getElementsByClassName("changed");
    ids.forEach(id => {
        var input = new Object();
        input = SERVER["xepg"]["epgMapping"][id];
        console.log("INPUT: " + input);
        for (let i = 0; i < inputs.length; i++) {
            var name;
            var value;
            switch (inputs[i].tagName) {
                case "INPUT":
                    switch (inputs[i].type) {
                        case "checkbox":
                            name = inputs[i].name;
                            value = inputs[i].checked;
                            input[name] = value;
                            break;
                        case "text":
                            name = inputs[i].name;
                            value = inputs[i].value;
                            input[name] = value;
                            break;
                    }
                    break;
                case "SELECT":
                    name = inputs[i].name;
                    value = inputs[i].value;
                    input[name] = value;
                    break;
            }
            switch (name) {
                case "tvg-logo":
                    //(document.getElementById(id).childNodes[2].firstChild as HTMLElement).setAttribute("src", value)
                    break;
                case "x-channel-start":
                    document.getElementById(id).childNodes[3].firstChild.innerHTML = value;
                    break;
                case "x-name":
                    document.getElementById(id).childNodes[3].firstChild.innerHTML = value;
                    break;
                case "x-category":
                    var color = "white";
                    var catColorSettings = SERVER["settings"]["epgCategoriesColors"];
                    var colors_split = catColorSettings.split("|");
                    for (var ii = 0; ii < colors_split.length; ii++) {
                        var catsColor_split = colors_split[ii].split(":");
                        if (catsColor_split[0] == value) {
                            color = catsColor_split[1];
                        }
                    }
                    document.getElementById(id).childNodes[3].firstChild.style.borderColor = color;
                    break;
                case "x-group-title":
                    document.getElementById(id).childNodes[5].firstChild.innerHTML = value;
                    break;
                case "x-xmltv-file":
                    if (value != "Threadfin Dummy" && value != "-") {
                        value = getValueFromProviderFile(value, "xmltv", "name");
                    }
                    if (value == "-") {
                        input["x-active"] = false;
                    }
                    document.getElementById(id).childNodes[6].firstChild.innerHTML = value;
                    break;
                case "x-mapping":
                    if (value == "-") {
                        input["x-active"] = false;
                    }
                    document.getElementById(id).childNodes[7].firstChild.innerHTML = value;
                    break;
                case "x-backup-channel":
                    document.getElementById(id).childNodes[7].firstChild.innerHTML = value;
                    break;
                case "x-hide-channel":
                    document.getElementById(id).childNodes[7].firstChild.innerHTML = value;
                    break;
                default:
            }
            createSearchObj();
            searchInMapping();
        }
        if (input["x-active"] == false) {
            document.getElementById(id).className = "notActiveEPG";
        }
        else {
            document.getElementById(id).className = "activeEPG";
        }
        console.log(input["tvg-logo"]);
        document.getElementById(id).childNodes[2].firstChild.setAttribute("src", input["tvg-logo"]);
    });
    showElement("popup", false);
    return;
}
function showPreview(element) {
    var div = document.getElementById("myStreamsBox");
    switch (element) {
        case false:
            div.className = "notVisible";
            return;
            break;
    }
    var streams = ["activeStreams", "inactiveStreams"];
    streams.forEach(preview => {
        var table = document.getElementById(preview);
        table.innerHTML = "";
        var obj = SERVER["data"]["StreamPreviewUI"][preview];
        var caption = document.createElement("CAPTION");
        var result = preview.replace(/([A-Z])/g, " $1");
        var finalResult = result.charAt(0).toUpperCase() + result.slice(1);
        caption.innerHTML = finalResult;
        table.appendChild(caption);
        var tbody = document.createElement("TBODY");
        table.appendChild(tbody);
        obj.slice(0, 1000).forEach(channel => {
            var tr = document.createElement("TR");
            var tdKey = document.createElement("TD");
            var tdVal = document.createElement("TD");
            tdKey.className = "tdKey";
            tdVal.className = "tdVal";
            switch (preview) {
                case "activeStreams":
                    tdKey.innerText = "Channel: (+)";
                    break;
                case "inactiveStreams":
                    tdKey.innerText = "Channel: (-)";
                    break;
            }
            tdVal.innerText = channel;
            tr.appendChild(tdKey);
            tr.appendChild(tdVal);
            tbody.appendChild(tr);
            table.appendChild(tr);
        });
    });
    // showElement("loading", false)
    div.className = "visible";
    return;
}
//# sourceMappingURL=menu.js.map" - webUI["web/public/js/menu.js.map"] = "{"version":3,"file":"menu.js","sourceRoot":"","sources":["../../src/ts/menu.ts"],"names":[],"mappings":"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"}" + webUI["web/public/js/menu.js"] = "var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
class MainMenu {
    constructor() {
        this.DocumentID = "main-menu";
        this.HTMLTag = "LI";
        this.ImagePath = "img/";
    }
    createIMG(src, alt) {
        var element = document.createElement("IMG");
        element.setAttribute("src", this.ImagePath + src);
        element.setAttribute("alt", alt);
        return element;
    }
    createValue(value) {
        var element = document.createElement("P");
        element.innerHTML = value;
        return element;
    }
}
class MainMenuItem extends MainMenu {
    constructor(menuKey, value, image, headline) {
        super();
        this.menuKey = menuKey;
        this.value = value;
        this.imgSrc = image;
        this.headline = headline;
    }
    createItem() {
        var item = document.createElement("LI");
        item.setAttribute("onclick", "javascript: openThisMenu(this)");
        item.setAttribute("id", this.id);
        item.setAttribute("class", "nav-item");
        var img = this.createIMG(this.imgSrc, this.value);
        var value = this.createValue(this.value);
        item.appendChild(img);
        item.appendChild(value);
        var doc = document.getElementById(this.DocumentID);
        doc.appendChild(item);
        switch (this.menuKey) {
            case "playlist":
                this.tableHeader = ["{{.playlist.table.playlist}}", "{{.playlist.table.tuner}}", "{{.playlist.table.lastUpdate}}", "{{.playlist.table.availability}} %", "{{.playlist.table.type}}", "{{.playlist.table.streams}}", "{{.playlist.table.groupTitle}} %", "{{.playlist.table.tvgID}} %", "{{.playlist.table.uniqueID}} %"];
                break;
            case "xmltv":
                this.tableHeader = ["{{.xmltv.table.guide}}", "{{.xmltv.table.lastUpdate}}", "{{.xmltv.table.availability}} %", "{{.xmltv.table.channels}}", "{{.xmltv.table.programs}}"];
                break;
            case "filter":
                this.tableHeader = ["{{.filter.table.name}}", "{{.filter.table.type}}", "{{.filter.table.filter}}"];
                break;
            case "users":
                this.tableHeader = ["{{.users.table.username}}", "{{.users.table.password}}", "{{.users.table.web}}", "{{.users.table.pms}}", "{{.users.table.m3u}}", "{{.users.table.xml}}", "{{.users.table.api}}"];
                break;
            case "mapping":
                this.tableHeader = ["BULK", "{{.mapping.table.chNo}}", "{{.mapping.table.logo}}", "{{.mapping.table.channelName}}", "{{.mapping.table.playlist}}", "{{.mapping.table.groupTitle}}", "{{.mapping.table.xmltvFile}}", "{{.mapping.table.xmltvID}}"];
                break;
        }
    }
}
class Content {
    constructor() {
        this.DocumentID = "content";
        this.HeaderID = "popupHeader";
        this.TableID = "contentTable";
        this.InactiveTableID = "inactiveContentTable";
        this.headerClass = "contentTableHeader";
        this.headerClassInactive = "inactiveContentTableHeader";
        this.interactionID = "content-interaction";
    }
    createHeadline(value) {
        var element = document.createElement("H3");
        element.innerHTML = value;
        return element;
    }
    createHR() {
        var element = document.createElement("HR");
        return element;
    }
    createBR() {
        var element = document.createElement("BR");
        return element;
    }
    createInteraction() {
        var element = document.createElement("DIV");
        element.setAttribute("id", this.interactionID);
        return element;
    }
    createDIV() {
        var element = document.createElement("DIV");
        element.id = this.DivID;
        return element;
    }
    createTABLE() {
        var element = document.createElement("TABLE");
        element.setAttribute('class', 'contentTable');
        element.id = this.TableID;
        return element;
    }
    createTableRow() {
        var element = document.createElement("TR");
        element.className = this.headerClass;
        return element;
    }
    createInactiveTABLE() {
        var element = document.createElement("TABLE");
        element.id = this.InactiveTableID;
        return element;
    }
    createInactiveTableRow() {
        var element = document.createElement("TR");
        element.className = this.headerClassInactive;
        return element;
    }
    createTableContent(menuKey) {
        var data = new Object();
        var rows = new Array();
        switch (menuKey) {
            case "playlist":
                var fileTypes = new Array("m3u", "hdhr");
                fileTypes.forEach(fileType => {
                    data = SERVER["settings"]["files"][fileType];
                    var keys = getObjKeys(data);
                    keys.forEach(key => {
                        var tr = document.createElement("TR");
                        tr.id = key;
                        tr.setAttribute('onclick', 'javascript: openPopUp("' + fileType + '", this)');
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["name"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (SERVER["settings"]["buffer"] != "-") {
                            cell.value = data[key]["tuner"];
                        }
                        else {
                            cell.value = "-";
                        }
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["last.update"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["provider.availability"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["type"].toUpperCase();
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["compatibility"]["streams"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["compatibility"]["group.title"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["compatibility"]["tvg.id"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["compatibility"]["stream.id"];
                        tr.appendChild(cell.createCell());
                        rows.push(tr);
                    });
                });
                break;
            case "filter":
                delete SERVER["settings"]["filter"][-1];
                data = SERVER["settings"]["filter"];
                var keys = getObjKeys(data);
                keys.forEach(key => {
                    var tr = document.createElement("TR");
                    tr.id = key;
                    tr.setAttribute('onclick', 'javascript: openPopUp("' + data[key]["type"] + '", this)');
                    var cell = new Cell();
                    cell.child = true;
                    cell.childType = "P";
                    cell.value = data[key]["name"];
                    tr.appendChild(cell.createCell());
                    var cell = new Cell();
                    cell.child = true;
                    cell.childType = "P";
                    switch (data[key]["type"]) {
                        case "custom-filter":
                            cell.value = "{{.filter.custom}}";
                            break;
                        case "group-title":
                            cell.value = "{{.filter.group}}";
                            break;
                        default:
                            break;
                    }
                    tr.appendChild(cell.createCell());
                    var cell = new Cell();
                    cell.child = true;
                    cell.childType = "P";
                    cell.value = data[key]["filter"];
                    tr.appendChild(cell.createCell());
                    rows.push(tr);
                });
                break;
            case "xmltv":
                var fileTypes = new Array("xmltv");
                fileTypes.forEach(fileType => {
                    data = SERVER["settings"]["files"][fileType];
                    var keys = getObjKeys(data);
                    keys.forEach(key => {
                        var tr = document.createElement("TR");
                        tr.id = key;
                        tr.setAttribute('onclick', 'javascript: openPopUp("' + fileType + '", this)');
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["name"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["last.update"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["provider.availability"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["compatibility"]["xmltv.channels"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["compatibility"]["xmltv.programs"];
                        tr.appendChild(cell.createCell());
                        rows.push(tr);
                    });
                });
                break;
            case "users":
                var fileTypes = new Array("users");
                fileTypes.forEach(fileType => {
                    data = SERVER[fileType];
                    var keys = getObjKeys(data);
                    keys.forEach(key => {
                        var tr = document.createElement("TR");
                        tr.id = key;
                        tr.setAttribute('onclick', 'javascript: openPopUp("' + fileType + '", this)');
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["data"]["username"];
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = "******";
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["data"]["authentication.web"] == true) {
                            cell.value = "✓";
                        }
                        else {
                            cell.value = "-";
                        }
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["data"]["authentication.pms"] == true) {
                            cell.value = "✓";
                        }
                        else {
                            cell.value = "-";
                        }
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["data"]["authentication.m3u"] == true) {
                            cell.value = "✓";
                        }
                        else {
                            cell.value = "-";
                        }
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["data"]["authentication.xml"] == true) {
                            cell.value = "✓";
                        }
                        else {
                            cell.value = "-";
                        }
                        tr.appendChild(cell.createCell());
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["data"]["authentication.api"] == true) {
                            cell.value = "✓";
                        }
                        else {
                            cell.value = "-";
                        }
                        tr.appendChild(cell.createCell());
                        rows.push(tr);
                    });
                });
                break;
            case "mapping":
                BULK_EDIT = false;
                createSearchObj();
                checkUndo("epgMapping");
                console.log("MAPPING");
                data = SERVER["xepg"]["epgMapping"];
                var keys = getObjKeys(data);
                keys.forEach(key => {
                    if (data[key]["x-active"]) {
                        var tr = document.createElement("TR");
                        tr.id = key;
                        tr.className = "activeEPG";
                        // Bulk
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "BULK";
                        cell.value = false;
                        tr.appendChild(cell.createCell());
                        // Kanalnummer
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "INPUTCHANNEL";
                        cell.value = data[key]["x-channelID"];
                        //td.setAttribute('onclick', 'javascript: changeChannelNumber("' + key + '", this)')
                        tr.appendChild(cell.createCell());
                        // Logo
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "IMG";
                        cell.imageURL = data[key]["tvg-logo"];
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // Kanalname
                        var cell = new Cell();
                        var cats = data[key]["x-category"].split(":");
                        cell.child = true;
                        cell.childType = "P";
                        cell.className = "category";
                        var catColorSettings = SERVER["settings"]["epgCategoriesColors"];
                        var colors_split = catColorSettings.split("|");
                        for (var i = 0; i < colors_split.length; i++) {
                            var catsColor_split = colors_split[i].split(":");
                            if (catsColor_split[0] == cats[0]) {
                                cell.classColor = catsColor_split[1];
                            }
                        }
                        cell.value = data[key]["x-name"];
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // Playlist
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        //cell.value = data[key]["_file.m3u.name"] 
                        cell.value = getValueFromProviderFile(data[key]["_file.m3u.id"], "m3u", "name");
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // Gruppe (group-title)
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["x-group-title"];
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // XMLTV Datei
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["x-xmltv-file"] != "-") {
                            cell.value = getValueFromProviderFile(data[key]["x-xmltv-file"], "xmltv", "name");
                        }
                        else {
                            cell.value = data[key]["x-xmltv-file"];
                        }
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // XMLTV Kanal
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        //var value = str.substring(1, 4);
                        var value = data[key]["x-mapping"];
                        if (value.length > 20) {
                            value = data[key]["x-mapping"].substring(0, 20) + "...";
                        }
                        cell.value = value;
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        rows.push(tr);
                    }
                });
                break;
            case "settings":
                alert();
                break;
            default:
                console.log("Table content (menuKey):", menuKey);
                break;
        }
        return rows;
    }
    createInactiveTableContent(menuKey) {
        var data = new Object();
        var rows = new Array();
        switch (menuKey) {
            case "mapping":
                BULK_EDIT = false;
                createSearchObj();
                checkUndo("epgMapping");
                console.log("MAPPING");
                data = SERVER["xepg"]["epgMapping"];
                var keys = getObjKeys(data);
                keys.forEach(key => {
                    if (data[key]["x-active"] === false) {
                        var tr = document.createElement("TR");
                        tr.id = key;
                        tr.className = "notActiveEPG";
                        // Bulk
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "BULK";
                        cell.value = false;
                        tr.appendChild(cell.createCell());
                        // Kanalnummer
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "INPUTCHANNEL";
                        if (data[key]["x-active"] == true) {
                            cell.value = data[key]["x-channelID"];
                        }
                        else {
                            cell.value = data[key]["x-channelID"] * 10;
                        }
                        //td.setAttribute('onclick', 'javascript: changeChannelNumber("' + key + '", this)')
                        tr.appendChild(cell.createCell());
                        // Logo
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "IMG";
                        cell.imageURL = data[key]["tvg-logo"];
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // Kanalname
                        var cell = new Cell();
                        var cats = data[key]["x-category"].split(":");
                        cell.child = true;
                        cell.childType = "P";
                        cell.className = "category";
                        var catColorSettings = SERVER["settings"]["epgCategoriesColors"];
                        var colors_split = catColorSettings.split("|");
                        for (var i = 0; i < colors_split.length; i++) {
                            var catsColor_split = colors_split[i].split(":");
                            if (catsColor_split[0] == cats[0]) {
                                cell.classColor = catsColor_split[1];
                            }
                        }
                        cell.value = data[key]["x-name"];
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // Playlist
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        //cell.value = data[key]["_file.m3u.name"] 
                        cell.value = getValueFromProviderFile(data[key]["_file.m3u.id"], "m3u", "name");
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // Gruppe (group-title)
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        cell.value = data[key]["x-group-title"];
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // XMLTV Datei
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        if (data[key]["x-xmltv-file"] != "-") {
                            cell.value = getValueFromProviderFile(data[key]["x-xmltv-file"], "xmltv", "name");
                        }
                        else {
                            cell.value = data[key]["x-xmltv-file"];
                        }
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        // XMLTV Kanal
                        var cell = new Cell();
                        cell.child = true;
                        cell.childType = "P";
                        //var value = str.substring(1, 4);
                        var value = data[key]["x-mapping"];
                        if (value.length > 20) {
                            value = data[key]["x-mapping"].substring(0, 20) + "...";
                        }
                        cell.value = value;
                        var td = cell.createCell();
                        td.setAttribute('onclick', 'javascript: openPopUp("mapping", this)');
                        td.id = key;
                        tr.appendChild(td);
                        rows.push(tr);
                    }
                });
                break;
            case "settings":
                alert();
                break;
            default:
                console.log("Table content (menuKey):", menuKey);
                break;
        }
        return rows;
    }
}
class Cell {
    createCell() {
        var td = document.createElement("TD");
        if (this.child == true) {
            var element;
            switch (this.childType) {
                case "P":
                    element = document.createElement(this.childType);
                    element.innerHTML = this.value;
                    if (this.className !== undefined) {
                        element.className = this.className;
                    }
                    if (this.classColor) {
                        element.style.borderColor = this.classColor;
                    }
                    break;
                case "INPUT":
                    element = document.createElement(this.childType);
                    element.value = this.value;
                    element.type = "text";
                    break;
                case "INPUTCHANNEL":
                    element = document.createElement("INPUT");
                    element.setAttribute("onchange", "javscript: changeChannelNumber(this)");
                    element.value = this.value;
                    element.type = "text";
                    break;
                case "BULK":
                    element = document.createElement("INPUT");
                    element.checked = this.value;
                    element.type = "checkbox";
                    element.className = "bulk hideBulk";
                    break;
                case "BULK_HEAD":
                    element = document.createElement("INPUT");
                    element.checked = this.value;
                    element.type = "checkbox";
                    element.className = "bulk hideBulk";
                    if (this.active) {
                        element.setAttribute("onclick", "javascript: selectAllChannels()");
                    }
                    else {
                        element.setAttribute("onclick", "javascript: selectAllChannels('inactiveContentTable')");
                    }
                    break;
                case "IMG":
                    element = document.createElement(this.childType);
                    element.setAttribute("src", this.imageURL);
                    if (this.imageURL != "") {
                        element.setAttribute("onerror", "javascript: this.onerror=null;this.src=''");
                        //onerror="this.onerror=null;this.src='missing.gif';"
                    }
            }
            td.appendChild(element);
        }
        else {
            td.innerHTML = this.value;
        }
        if (this.onclick == true) {
            td.setAttribute("onclick", this.onclickFunktion);
            td.className = "pointer";
        }
        if (this.tdClassName != undefined) {
            td.className = this.tdClassName;
        }
        return td;
    }
}
class ShowContent extends Content {
    constructor(menuID) {
        super();
        this.menuID = menuID;
    }
    createInput(type, name, value) {
        var input = document.createElement("INPUT");
        input.setAttribute("type", type);
        input.setAttribute("name", name);
        input.setAttribute("value", value);
        return input;
    }
    show() {
        COLUMN_TO_SORT = -1;
        // Alten Inhalt löschen
        var doc = document.getElementById(this.DocumentID);
        doc.innerHTML = "";
        showPreview(false);
        // Überschrift
        var popupHeader = document.getElementById(this.HeaderID);
        var headline = menuItems[this.menuID].headline;
        var menuKey = menuItems[this.menuID].menuKey;
        var h = this.createHeadline(headline);
        var existingHeader = popupHeader.querySelector('h3');
        if (existingHeader) {
            popupHeader.replaceChild(h, existingHeader);
        }
        else {
            popupHeader.appendChild(h);
        }
        var hr = this.createHR();
        doc.appendChild(hr);
        // Interaktion
        var div = this.createInteraction();
        doc.appendChild(div);
        var interaction = document.getElementById(this.interactionID);
        switch (menuKey) {
            case "playlist":
                var input = this.createInput("button", menuKey, "{{.button.new}}");
                input.setAttribute("id", "-");
                input.setAttribute("onclick", 'javascript: openPopUp("playlist")');
                interaction.appendChild(input);
                break;
            case "filter":
                var input = this.createInput("button", menuKey, "{{.button.new}}");
                input.setAttribute("id", -1);
                input.setAttribute("onclick", 'javascript: openPopUp("filter", this)');
                interaction.appendChild(input);
                break;
            case "xmltv":
                var input = this.createInput("button", menuKey, "{{.button.new}}");
                input.setAttribute("id", "xmltv");
                input.setAttribute("onclick", 'javascript: openPopUp("xmltv")');
                interaction.appendChild(input);
                break;
            case "users":
                var input = this.createInput("button", menuKey, "{{.button.new}}");
                input.setAttribute("id", "users");
                input.setAttribute("onclick", 'javascript: openPopUp("users")');
                interaction.appendChild(input);
                break;
            case "mapping":
                // showElement("loading", true)
                var input = this.createInput("button", menuKey, "{{.button.save}}");
                input.setAttribute("onclick", 'javascript: savePopupData("mapping", "", "")');
                interaction.appendChild(input);
                var input = this.createInput("button", menuKey, "{{.button.bulkEdit}}");
                input.setAttribute("onclick", 'javascript: bulkEdit()');
                interaction.appendChild(input);
                var input = this.createInput("search", "search", "");
                input.setAttribute("id", "searchMapping");
                input.setAttribute("placeholder", "{{.button.search}}");
                input.className = "search";
                input.setAttribute("onchange", 'javascript: searchInMapping()');
                interaction.appendChild(input);
                break;
            case "settings":
                var input = this.createInput("button", menuKey, "{{.button.save}}");
                input.setAttribute("onclick", 'javascript: saveSettings();');
                interaction.appendChild(input);
                var input = this.createInput("button", menuKey, "{{.button.backup}}");
                input.setAttribute("onclick", 'javascript: backup();');
                interaction.appendChild(input);
                var input = this.createInput("button", menuKey, "{{.button.restore}}");
                input.setAttribute("onclick", 'javascript: restore();');
                interaction.appendChild(input);
                var wrapper = document.createElement("DIV");
                wrapper.setAttribute("id", "box-wrapper");
                doc.appendChild(wrapper);
                this.DivID = "content_settings";
                var settings = this.createDIV();
                wrapper.appendChild(settings);
                showSettings();
                return;
                break;
            case "log":
                var input = this.createInput("button", menuKey, "{{.button.resetLogs}}");
                input.setAttribute("onclick", 'javascript: resetLogs();');
                interaction.appendChild(input);
                var wrapper = document.createElement("DIV");
                wrapper.setAttribute("id", "box-wrapper");
                doc.appendChild(wrapper);
                this.DivID = "content_log";
                var logs = this.createDIV();
                wrapper.appendChild(logs);
                showLogs(true);
                return;
                break;
            case "logout":
                location.reload();
                document.cookie = "Token= ; expires = Thu, 01 Jan 1970 00:00:00 GMT";
                break;
            default:
                console.log("Show content (menuKey):", menuKey);
                break;
        }
        // Tabelle erstellen (falls benötigt)
        var tableHeader = menuItems[this.menuID].tableHeader;
        if (tableHeader.length > 0) {
            var wrapper = document.createElement("DIV");
            doc.appendChild(wrapper);
            wrapper.setAttribute("id", "box-wrapper");
            var table = this.createTABLE();
            wrapper.appendChild(table);
            var header = this.createTableRow();
            table.appendChild(header);
            // Kopfzeile der Tablle
            tableHeader.forEach(element => {
                var cell = new Cell();
                cell.child = true;
                cell.childType = "P";
                cell.value = element;
                if (element == "BULK") {
                    cell.childType = "BULK_HEAD";
                    cell.active = true;
                    cell.value = false;
                }
                if (menuKey == "mapping") {
                    if (element == "{{.mapping.table.chNo}}") {
                        cell.onclick = true;
                        cell.onclickFunktion = "javascript: sortTable(1);";
                        cell.tdClassName = "sortThis";
                    }
                    if (element == "{{.mapping.table.channelName}}") {
                        cell.onclick = true;
                        cell.onclickFunktion = "javascript: sortTable(3);";
                    }
                    if (element == "{{.mapping.table.playlist}}") {
                        cell.onclick = true;
                        cell.onclickFunktion = "javascript: sortTable(4);";
                    }
                    if (element == "{{.mapping.table.groupTitle}}") {
                        cell.onclick = true;
                        cell.onclickFunktion = "javascript: sortTable(5);";
                    }
                }
                header.appendChild(cell.createCell());
            });
            table.appendChild(header);
            // Inhalt der Tabelle
            var rows = this.createTableContent(menuKey);
            rows.forEach(tr => {
                table.appendChild(tr);
            });
            var br = this.createBR();
            doc.appendChild(br);
            // Create inactive channels for mapping
            if (menuKey == "mapping") {
                var inactivetable = this.createInactiveTABLE();
                wrapper.appendChild(inactivetable);
                var header = this.createInactiveTableRow();
                inactivetable.appendChild(header);
                // Kopfzeile der Tablle
                tableHeader.forEach(element => {
                    var cell = new Cell();
                    cell.child = true;
                    cell.childType = "P";
                    cell.value = element;
                    if (element == "BULK") {
                        cell.childType = "BULK_HEAD";
                        cell.active = false;
                        cell.value = false;
                    }
                    if (menuKey == "mapping") {
                        if (element == "{{.mapping.table.chNo}}") {
                            cell.onclick = true;
                            cell.onclickFunktion = "javascript: sortTable(1, 'inactiveContentTable');";
                            cell.tdClassName = "sortThis";
                        }
                        if (element == "{{.mapping.table.channelName}}") {
                            cell.onclick = true;
                            cell.onclickFunktion = "javascript: sortTable(3, 'inactiveContentTable');";
                        }
                        if (element == "{{.mapping.table.playlist}}") {
                            cell.onclick = true;
                            cell.onclickFunktion = "javascript: sortTable(4, 'inactiveContentTable');";
                        }
                        if (element == "{{.mapping.table.groupTitle}}") {
                            cell.onclick = true;
                            cell.onclickFunktion = "javascript: sortTable(5, 'inactiveContentTable');";
                        }
                    }
                    header.appendChild(cell.createCell());
                });
                inactivetable.appendChild(header);
                // Inhalt der Tabelle
                var rows = this.createInactiveTableContent(menuKey);
                rows.forEach(tr => {
                    inactivetable.appendChild(tr);
                });
                savePopupData("mapping", "", false, 0);
            }
        }
        switch (menuKey) {
            case "mapping":
                sortTable(1);
                sortTable(1, "inactiveContentTable");
                break;
            case "filter":
                showPreview(true);
                sortTable(0);
                break;
            default:
                COLUMN_TO_SORT = -1;
                sortTable(0);
                break;
        }
        showElement("loading", false);
    }
}
function PageReady() {
    var server = new Server("getServerConfig");
    server.request(new Object());
    setInterval(function () {
        updateLog();
    }, 10000);
    getNewestReleaseFromGithub();
    return;
}
var checkboxesInitialState = [];
function setCheckboxes() {
    return __awaiter(this, void 0, void 0, function* () {
        const content = new PopupContent();
        const table = document.getElementById("checkboxTable");
        yield new Promise(f => setTimeout(f, 1000));
        if ("clientInfo" in SERVER) {
            const bindingIPs = SERVER['settings']['bindingIPs'];
            const bindingIPspArray = bindingIPs.split(";");
            const systemnIPs = SERVER["clientInfo"]["systemIPs"];
            systemnIPs.forEach((ipAddress, index) => {
                if (!ipAddress.includes('169.254')) {
                    const tr = document.createElement('tr');
                    const tdLeft = document.createElement('td');
                    const tdRight = document.createElement('td');
                    const checkbox = content.createCheckbox(ipAddress, 'ipCheckbox' + index);
                    checkbox.checked = bindingIPspArray.includes(ipAddress);
                    const label = document.createElement("label");
                    label.setAttribute("for", "ipCheckbox" + index);
                    label.innerHTML = ipAddress;
                    tdLeft.appendChild(checkbox);
                    tdRight.appendChild(label);
                    tr.appendChild(tdLeft);
                    tr.appendChild(tdRight);
                    table.appendChild(tr);
                }
            });
            const checkbox_container = document.getElementById("checkbox_container");
            const saveButton = createButton(content, "buttonUpdate", "{{.button.update}}", 'javsrcipt: updateBindingIPs()');
            const cancelButton = createButton(content, "buttonCancel", "{{.button.cancel}}");
            checkbox_container.appendChild(saveButton);
            checkbox_container.appendChild(cancelButton);
            const checkboxes = checkbox_container.querySelectorAll('input[type="checkbox"]');
            checkboxesInitialState = Array.from(checkboxes).map(checkbox => checkbox.checked);
            const ipSelection = document.getElementById('ip_selection');
            const closeButton = ipSelection.querySelector('button.btn-close');
            closeButton.addEventListener('click', () => resetCheckboxes(checkboxes, checkboxesInitialState));
            cancelButton.addEventListener('click', () => resetCheckboxes(checkboxes, checkboxesInitialState));
        }
    });
}
function resetCheckboxes(checkboxes, initialStates) {
    checkboxes.forEach((checkbox, index) => {
        checkbox.checked = initialStates[index];
    });
}
function createLayout() {
    if (!document.getElementById("main-menu")) {
        return;
    }
    // Menü erstellen
    document.getElementById("main-menu").innerHTML = "";
    for (let i = 0; i < menuItems.length; i++) {
        menuItems[i].id = i;
        switch (menuItems[i]["menuKey"]) {
            case "users":
            case "logout":
                if (SERVER["settings"]["authentication.web"] == true) {
                    menuItems[i].createItem();
                }
                break;
            default:
                menuItems[i].createItem();
                break;
        }
    }
    // Create server information
    document.getElementById("server_information").innerHTML = "";
    const serverInfo = new ServerInformation();
    serverInfo.addContent(serverInformation);
    document.getElementById("server_information").replaceWith(serverInfo.container);
    // initialize tool tips
    tooltipTriggerList = document.querySelectorAll('[data-bs-toggle="tooltip"]');
    tooltipList = Array.from(tooltipTriggerList).map(tooltipTriggerEl => new bootstrap.Tooltip(tooltipTriggerEl));
    // Client Info (Server Information)
    var obj = SERVER["clientInfo"];
    var keys = getObjKeys(obj);
    const changeVersion = document.getElementById("changeVersion");
    changeVersion.value = "{{.serverInfo.changeVersion.changeToBeta}}";
    changeVersion.onclick = () => {
        changeVersion.value = "{{.serverInfo.changeVersion.changing}}";
        const server = new Server("changeVersion");
        server.request(new Object());
        setTimeout(() => {
            location.reload();
        }, 20000);
    };
    for (var i = 0; i < keys.length; i++) {
        if (document.getElementById(keys[i])) {
            document.getElementById(keys[i]).value = obj[keys[i]];
            if (keys[i] === "version") {
                if (obj["beta"]) {
                    const version = document.getElementById(keys[i]);
                    version.value += " Beta";
                    changeVersion.value = "{{.serverInfo.changeVersion.changeToRelease}}";
                }
            }
        }
    }
    return;
}
function openThisMenu(element) {
    var id = element.id;
    var content = new ShowContent(id);
    content.show();
    enableGroupSelection(".bulk");
    return;
}
class PopupWindow {
    constructor() {
        this.DocumentID = "popupCustom";
        this.InteractionID = "interaction";
        this.doc = document.getElementById(this.DocumentID);
    }
    createTitle(title) {
        var td = document.createElement("TD");
        td.className = "left";
        td.innerHTML = title + ":";
        return td;
    }
    createContent(element) {
        var td = document.createElement("TD");
        td.appendChild(element);
        return td;
    }
    createInteraction() {
        var div = document.createElement("div");
        div.setAttribute("id", "popupInteraction");
        div.className = "interaction";
        this.doc.appendChild(div);
    }
}
class PopupContent extends PopupWindow {
    constructor() {
        super(...arguments);
        this.table = document.createElement("TABLE");
    }
    createHeadline(headline) {
        this.doc.innerHTML = "";
        var element = document.createElement("H3");
        element.innerHTML = headline.toUpperCase();
        this.doc.appendChild(element);
        // Tabelle erstellen
        this.table = document.createElement("TABLE");
        this.doc.appendChild(this.table);
    }
    appendRow(title, element) {
        var tr = document.createElement("TR");
        // Bezeichnung
        if (title.length != 0) {
            tr.appendChild(this.createTitle(title));
        }
        // Content
        tr.appendChild(this.createContent(element));
        this.table.appendChild(tr);
    }
    createInput(type, name, value) {
        var input = document.createElement("INPUT");
        if (value == undefined) {
            value = "";
        }
        input.setAttribute("type", type);
        input.setAttribute("name", name);
        input.setAttribute("value", value);
        return input;
    }
    createCheckbox(name, id = '') {
        var input = document.createElement("INPUT");
        input.setAttribute("type", "checkbox");
        if (id != '') {
            input.setAttribute("id", id);
        }
        input.setAttribute("name", name);
        return input;
    }
    createSelect(text, values, set, dbKey) {
        var select = document.createElement("SELECT");
        select.setAttribute("name", dbKey);
        for (let i = 0; i < text.length; i++) {
            var option = document.createElement("OPTION");
            option.setAttribute("value", values[i]);
            option.innerText = text[i];
            select.appendChild(option);
        }
        if (set != "") {
            select.value = set;
        }
        if (set == undefined) {
            select.value = values[0];
        }
        return select;
    }
    selectOption(select, value) {
        //select.selectedOptions = value
        var s = select;
        s.options[s.selectedIndex].value = value;
        return select;
    }
    description(value) {
        var tr = document.createElement("TR");
        var td = document.createElement("TD");
        var span = document.createElement("PRE");
        span.innerHTML = value;
        tr.appendChild(td);
        tr.appendChild(this.createContent(span));
        this.table.appendChild(tr);
    }
    // Interaktion
    addInteraction(element) {
        var interaction = document.getElementById("popupInteraction");
        interaction.appendChild(element);
    }
}
function openPopUp(dataType, element) {
    var data = new Object();
    var id;
    switch (element) {
        case undefined:
            switch (dataType) {
                case "group-title":
                    if (id == undefined) {
                        id = -1;
                    }
                    data = getLocalData("filter", id);
                    data["type"] = "group-title";
                    break;
                case "custom-filter":
                    if (id == undefined) {
                        id = -1;
                    }
                    data = getLocalData("filter", id);
                    data["type"] = "custom-filter";
                    break;
                default:
                    data["id.provider"] = "-";
                    data["type"] = dataType;
                    id = "-";
                    break;
            }
            break;
        default:
            id = element.id;
            data = getLocalData(dataType, id);
            break;
    }
    var content = new PopupContent();
    switch (dataType) {
        case "playlist":
            content.createHeadline("{{.playlist.playlistType.title}}");
            // Type
            var text = ["M3U", "HDHomeRun"];
            var values = ["javascript: openPopUp('m3u')", "javascript: openPopUp('hdhr')"];
            var select = content.createSelect(text, values, "", "type");
            select.setAttribute("id", "type");
            select.setAttribute("onchange", 'javascript: changeButtonAction(this, "next", "onclick")'); // changeButtonAction
            content.appendRow("{{.playlist.type.title}}", select);
            // Interaktion
            content.createInteraction();
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Weiter
            var input = content.createInput("button", "next", "{{.button.next}}");
            input.setAttribute("onclick", 'javascript: openPopUp("m3u")');
            input.setAttribute("id", 'next');
            content.addInteraction(input);
            break;
        case "m3u":
            content.createHeadline(dataType);
            // Name
            var dbKey = "name";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.name.placeholder}}");
            content.appendRow("{{.playlist.name.title}}", input);
            // Beschreibung
            var dbKey = "description";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.description.placeholder}}");
            content.appendRow("{{.playlist.description.title}}", input);
            // URL
            var dbKey = "file.source";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.fileM3U.placeholder}}");
            content.appendRow("{{.playlist.fileM3U.title}}", input);
            // Tuner
            if (SERVER["settings"]["buffer"] != "-") {
                var text = new Array();
                var values = new Array();
                for (var i = 1; i <= 100; i++) {
                    text.push(i.toString());
                    values.push(i.toString());
                }
                var dbKey = "tuner";
                var select = content.createSelect(text, values, data[dbKey], dbKey);
                select.setAttribute("onfocus", "javascript: return;");
                content.appendRow("{{.playlist.tuner.title}}", select);
            }
            else {
                var dbKey = "tuner";
                if (data[dbKey] == undefined) {
                    data[dbKey] = 1;
                }
                var input = content.createInput("text", dbKey, data[dbKey]);
                input.setAttribute("readonly", "true");
                input.className = "notAvailable";
                content.appendRow("{{.playlist.tuner.title}}", input);
            }
            content.description("{{.playlist.tuner.description}}");
            var dbKey = "http_proxy.ip";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.http_proxy_ip.placeholder}}");
            content.appendRow("{{.playlist.http_proxy_ip.title}}", input);
            content.description("{{.playlist.http_proxy_ip.description}}");
            var dbKey = "http_proxy.port";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.http_proxy_port.placeholder}}");
            content.appendRow("{{.playlist.http_proxy_port.title}}", input);
            content.description("{{.playlist.http_proxy_port.description}}");
            // Interaktion
            content.createInteraction();
            // Löschen
            if (data["id.provider"] != "-") {
                var input = content.createInput("button", "delete", "{{.button.delete}}");
                input.className = "delete";
                input.setAttribute('onclick', 'javascript: savePopupData("m3u", "' + id + '", true, 0)');
                content.addInteraction(input);
            }
            else {
                var input = content.createInput("button", "back", "{{.button.back}}");
                input.setAttribute("onclick", 'javascript: openPopUp("playlist")');
                content.addInteraction(input);
            }
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Aktualisieren
            if (data["id.provider"] != "-") {
                var input = content.createInput("button", "update", "{{.button.update}}");
                input.setAttribute('onclick', 'javascript: savePopupData("m3u", "' + id + '", false, 1)');
                content.addInteraction(input);
            }
            // Speichern
            var input = content.createInput("button", "save", "{{.button.save}}");
            input.setAttribute('onclick', 'javascript: savePopupData("m3u", "' + id + '", false, 0)');
            content.addInteraction(input);
            break;
        case "hdhr":
            content.createHeadline(dataType);
            // Name
            var dbKey = "name";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.name.placeholder}}");
            content.appendRow("{{.playlist.name.title}}", input);
            // Beschreibung
            var dbKey = "description";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.description.placeholder}}");
            content.appendRow("{{.playlist.description.placeholder}}", input);
            // URL
            var dbKey = "file.source";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.fileHDHR.placeholder}}");
            content.appendRow("{{.playlist.fileHDHR.title}}", input);
            // Tuner
            if (SERVER["settings"]["buffer"] != "-") {
                var text = new Array();
                var values = new Array();
                for (var i = 1; i <= 100; i++) {
                    text.push(i.toString());
                    values.push(i.toString());
                }
                var dbKey = "tuner";
                var select = content.createSelect(text, values, data[dbKey], dbKey);
                select.setAttribute("onfocus", "javascript: return;");
                content.appendRow("{{.playlist.tuner.title}}", select);
            }
            else {
                var dbKey = "tuner";
                if (data[dbKey] == undefined) {
                    data[dbKey] = 1;
                }
                var input = content.createInput("text", dbKey, data[dbKey]);
                input.setAttribute("readonly", "true");
                input.className = "notAvailable";
                content.appendRow("{{.playlist.tuner.title}}", input);
            }
            content.description("{{.playlist.tuner.description}}");
            var dbKey = "http_proxy.ip";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.http_proxy_ip.placeholder}}");
            content.appendRow("{{.playlist.http_proxy_ip.title}}", input);
            content.description("{{.playlist.http_proxy_ip.description}}");
            var dbKey = "http_proxy.port";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.playlist.http_proxy_port.placeholder}}");
            content.appendRow("{{.playlist.http_proxy_port.title}}", input);
            content.description("{{.playlist.http_proxy_port.description}}");
            // Interaktion
            content.createInteraction();
            // Löschen
            if (data["id.provider"] != "-") {
                var input = content.createInput("button", "delete", "{{.button.delete}}");
                input.setAttribute('onclick', 'javascript: savePopupData("hdhr", "' + id + '", true, 0)');
                input.className = "delete";
                content.addInteraction(input);
            }
            else {
                var input = content.createInput("button", "back", "{{.button.back}}");
                input.setAttribute("onclick", 'javascript: openPopUp("playlist")');
                content.addInteraction(input);
            }
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Aktualisieren
            if (data["id.provider"] != "-") {
                var input = content.createInput("button", "update", "{{.button.update}}");
                input.setAttribute('onclick', 'javascript: savePopupData("hdhr", "' + id + '", false, 1)');
                content.addInteraction(input);
            }
            // Speichern
            var input = content.createInput("button", "save", "{{.button.save}}");
            input.setAttribute('onclick', 'javascript: savePopupData("hdhr", "' + id + '", false, 0)');
            content.addInteraction(input);
            break;
        case "filter":
            content.createHeadline(dataType);
            // Type
            var dbKey = "type";
            var text = ["M3U: " + "{{.filter.type.groupTitle}}", "Threadfin: " + "{{.filter.type.customFilter}}"];
            var values = ["javascript: openPopUp('group-title')", "javascript: openPopUp('custom-filter')"];
            var select = content.createSelect(text, values, "javascript: openPopUp('group-title')", dbKey);
            select.setAttribute("id", id);
            select.setAttribute("onchange", 'javascript: changeButtonAction(this, "next", "onclick");'); // changeButtonAction
            content.appendRow("{{.filter.type.title}}", select);
            // Interaktion
            content.createInteraction();
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Weiter
            var input = content.createInput("button", "next", "{{.button.next}}");
            input.setAttribute("onclick", 'javascript: openPopUp("group-title")');
            input.setAttribute("id", 'next');
            content.addInteraction(input);
            break;
        case "custom-filter":
        case "group-title":
            switch (dataType) {
                case "custom-filter":
                    content.createHeadline("{{.filter.custom}}");
                    break;
                case "group-title":
                    content.createHeadline("{{.filter.group}}");
                    break;
            }
            // Name      
            var dbKey = "name";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.filter.name.placeholder}}");
            content.appendRow("{{.filter.name.title}}", input);
            // Beschreibung
            var dbKey = "description";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.filter.description.placeholder}}");
            content.appendRow("{{.filter.description.title}}", input);
            // Typ
            var dbKey = "type";
            var input = content.createInput("hidden", dbKey, data[dbKey]);
            content.appendRow("", input);
            var filterType = data[dbKey];
            switch (filterType) {
                case "custom-filter":
                    // Groß- Kleinschreibung beachten
                    var dbKey = "caseSensitive";
                    var input = content.createCheckbox(dbKey);
                    input.checked = data[dbKey];
                    content.appendRow("{{.filter.caseSensitive.title}}", input);
                    // Filterregel (Benutzerdefiniert)
                    var dbKey = "filter";
                    var input = content.createInput("text", dbKey, data[dbKey]);
                    input.setAttribute("placeholder", "{{.filter.filterRule.placeholder}}");
                    content.appendRow("{{.filter.filterRule.title}}", input);
                    break;
                case "group-title":
                    //alert(dbKey + " " + filterType)
                    // Filter basierend auf den Gruppen in der M3U
                    var dbKey = "filter";
                    var groupsM3U = getLocalData("m3uGroups", "");
                    var text = groupsM3U["text"];
                    var values = groupsM3U["value"];
                    var select = content.createSelect(text, values, data[dbKey], dbKey);
                    select.setAttribute("onchange", "javascript: this.className = 'changed'");
                    content.appendRow("{{.filter.filterGroup.title}}", select);
                    content.description("{{.filter.filterGroup.description}}");
                    // Groß- Kleinschreibung beachten
                    var dbKey = "caseSensitive";
                    var input = content.createCheckbox(dbKey);
                    input.checked = data[dbKey];
                    content.appendRow("{{.filter.caseSensitive.title}}", input);
                    var dbKey = "include";
                    var input = content.createInput("text", dbKey, data[dbKey]);
                    input.setAttribute("placeholder", "{{.filter.include.placeholder}}");
                    content.appendRow("{{.filter.include.title}}", input);
                    content.description("{{.filter.include.description}}");
                    var dbKey = "exclude";
                    var input = content.createInput("text", dbKey, data[dbKey]);
                    input.setAttribute("placeholder", "{{.filter.exclude.placeholder}}");
                    content.appendRow("{{.filter.exclude.title}}", input);
                    content.description("{{.filter.exclude.description}}");
                    break;
                default:
                    break;
            }
            // Name      
            var dbKey = "startingNumber";
            if (data[dbKey] !== undefined) {
                var input = content.createInput("text", dbKey, data[dbKey]);
            }
            else {
                var input = content.createInput("text", dbKey, "1000");
            }
            input.setAttribute("placeholder", "{{.filter.startingnumber.placeholder}}");
            content.appendRow("{{.filter.startingnumber.title}}", input);
            content.description("{{.filter.startingnumber.description}}");
            var dbKey = "x-category";
            var text = ["-"];
            var values = [""];
            var epgCategories = SERVER["settings"]["epgCategories"];
            var categories = epgCategories.split("|");
            for (i = 0; i <= categories.length; i++) {
                var cat = categories[i];
                if (cat) {
                    var cat_split = cat.split(":");
                    text.push(cat_split[0]);
                    values.push(cat_split[1]);
                }
            }
            var select = content.createSelect(text, values, data[dbKey], dbKey);
            select.setAttribute("onchange", "javascript: this.className = 'changed'");
            content.appendRow("{{.filter.category.title}}", select);
            // Interaktion
            content.createInteraction();
            // Löschen
            var input = content.createInput("button", "delete", "{{.button.delete}}");
            input.setAttribute('onclick', 'javascript: savePopupData("filter", "' + id + '", true, 0)');
            input.className = "delete";
            content.addInteraction(input);
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Speichern
            var input = content.createInput("button", "save", "{{.button.save}}");
            input.setAttribute('onclick', 'javascript: savePopupData("filter", "' + id + '", false, 0)');
            content.addInteraction(input);
            break;
        case "xmltv":
            content.createHeadline(dataType);
            // Name
            var dbKey = "name";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.xmltv.name.placeholder}}");
            content.appendRow("{{.xmltv.name.title}}", input);
            // Beschreibung
            var dbKey = "description";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.xmltv.description.placeholder}}");
            content.appendRow("{{.xmltv.description.title}}", input);
            // URL
            var dbKey = "file.source";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.xmltv.fileXMLTV.placeholder}}");
            content.appendRow("{{.xmltv.fileXMLTV.title}}", input);
            var dbKey = "http_proxy.ip";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.xmltv.http_proxy_ip.placeholder}}");
            content.appendRow("{{.xmltv.http_proxy_ip.title}}", input);
            content.description("{{.xmltv.http_proxy_ip.description}}");
            var dbKey = "http_proxy.port";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.xmltv.http_proxy_port.placeholder}}");
            content.appendRow("{{.xmltv.http_proxy_port.title}}", input);
            content.description("{{.xmltv.http_proxy_port.description}}");
            // Interaktion
            content.createInteraction();
            // Löschen
            if (data["id.provider"] != "-") {
                var input = content.createInput("button", "delete", "{{.button.delete}}");
                input.setAttribute('onclick', 'javascript: savePopupData("xmltv", "' + id + '", true, 0)');
                input.className = "delete";
                content.addInteraction(input);
            }
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Aktualisieren
            if (data["id.provider"] != "-") {
                var input = content.createInput("button", "update", "{{.button.update}}");
                input.setAttribute('onclick', 'javascript: savePopupData("xmltv", "' + id + '", false, 1)');
                content.addInteraction(input);
            }
            // Speichern
            var input = content.createInput("button", "save", "{{.button.save}}");
            input.setAttribute('onclick', 'javascript: savePopupData("xmltv", "' + id + '", false, 0)');
            content.addInteraction(input);
            break;
        case "users":
            content.createHeadline("{{.mainMenu.item.users}}");
            // Benutzername 
            var dbKey = "username";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.users.username.placeholder}}");
            content.appendRow("{{.users.username.title}}", input);
            // Neues Passwort 
            var dbKey = "password";
            var input = content.createInput("password", dbKey, "");
            input.setAttribute("placeholder", "{{.users.password.placeholder}}");
            content.appendRow("{{.users.password.title}}", input);
            // Bestätigung 
            var dbKey = "confirm";
            var input = content.createInput("password", dbKey, "");
            input.setAttribute("placeholder", "{{.users.confirm.placeholder}}");
            content.appendRow("{{.users.confirm.title}}", input);
            // Berechtigung WEB
            var dbKey = "authentication.web";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            if (data["defaultUser"] == true) {
                input.setAttribute("onclick", "javascript: return false");
            }
            content.appendRow("{{.users.web.title}}", input);
            // Berechtigung PMS
            var dbKey = "authentication.pms";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            content.appendRow("{{.users.pms.title}}", input);
            // Berechtigung M3U
            var dbKey = "authentication.m3u";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            content.appendRow("{{.users.m3u.title}}", input);
            // Berechtigung XML
            var dbKey = "authentication.xml";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            content.appendRow("{{.users.xml.title}}", input);
            // Berechtigung API
            var dbKey = "authentication.api";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            content.appendRow("{{.users.api.title}}", input);
            // Interaktion
            content.createInteraction();
            // Löschen
            if (data["defaultUser"] != true && id != "-") {
                var input = content.createInput("button", "delete", "{{.button.delete}}");
                input.className = "delete";
                input.setAttribute('onclick', 'javascript: savePopupData("' + dataType + '", "' + id + '", true, 0)');
                content.addInteraction(input);
            }
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Speichern
            var input = content.createInput("button", "save", "{{.button.save}}");
            input.setAttribute("onclick", 'javascript: savePopupData("' + dataType + '", "' + id + '", "false");');
            content.addInteraction(input);
            break;
        case "mapping":
            content.createHeadline("{{.mainMenu.item.mapping}}");
            if (BULK_EDIT == true) {
                var dbKey = "x-channels-start";
                var input = content.createInput("text", dbKey, data[dbKey]);
                // Set the value to the first selected channel
                var channels = getAllSelectedChannels();
                var channel = SERVER["xepg"]["epgMapping"][channels[0]];
                if (typeof channel !== "undefined") {
                    input.setAttribute("value", channel["x-channelID"]);
                }
                input.setAttribute("onchange", 'javascript: changeChannelNumbers("' + channels + '");');
                content.appendRow("{{.mapping.channelGroupStart.title}}", input);
            }
            // Aktiv 
            var dbKey = "x-active";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            input.id = "active";
            //input.setAttribute("onchange", "javascript: this.className = 'changed'")
            input.setAttribute("onchange", "javascript: toggleChannelStatus('" + id + "', this)");
            content.appendRow("{{.mapping.active.title}}", input);
            // Kanalname 
            var dbKey = "x-name";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("onchange", "javascript: this.className = 'changed'");
            if (BULK_EDIT == true) {
                input.style.border = "solid 1px red";
                input.setAttribute("readonly", "true");
            }
            content.appendRow("{{.mapping.channelName.title}}", input);
            "<span class='text-danger'>" + data["tvg-id"] + "</span> <span class='text-primary'>(" + data["x-epg"] + ")</span>";
            // Beschreibung 
            var dbKey = "x-description";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("placeholder", "{{.mapping.description.placeholder}}");
            input.setAttribute("onchange", "javascript: this.className = 'changed'");
            content.appendRow("{{.mapping.description.title}}", input);
            // Aktualisierung des Kanalnamens
            if (data.hasOwnProperty("_uuid.key")) {
                if (data["_uuid.key"] != "") {
                    var dbKey = "x-update-channel-name";
                    var input = content.createCheckbox(dbKey);
                    input.setAttribute("onchange", "javascript: this.className = 'changed'");
                    input.checked = data[dbKey];
                    content.appendRow("{{.mapping.updateChannelName.title}}", input);
                }
            }
            // Logo URL (Kanal) 
            var dbKey = "tvg-logo";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("onchange", "javascript: this.className = 'changed'");
            input.setAttribute("id", "channel-icon");
            content.appendRow("{{.mapping.channelLogo.title}}", input);
            // Aktualisierung des Kanallogos
            var dbKey = "x-update-channel-icon";
            var input = content.createCheckbox(dbKey);
            input.checked = data[dbKey];
            input.setAttribute("id", "update-icon");
            input.setAttribute("onchange", "javascript: this.className = 'changed'; changeChannelLogo('" + id + "');");
            content.appendRow("{{.mapping.updateChannelLogo.title}}", input);
            // Erweitern der EPG Kategorie
            var dbKey = "x-category";
            var text = ["-"];
            var values = [""];
            var epgCategories = SERVER["settings"]["epgCategories"];
            var categories = epgCategories.split("|");
            for (i = 0; i <= categories.length; i++) {
                var cat = categories[i];
                if (cat) {
                    var cat_split = cat.split(":");
                    text.push(cat_split[0]);
                    values.push(cat_split[1]);
                }
            }
            var select = content.createSelect(text, values, data[dbKey], dbKey);
            select.setAttribute("onchange", "javascript: this.className = 'changed'");
            content.appendRow("{{.mapping.epgCategory.title}}", select);
            // M3U Gruppentitel
            var dbKey = "x-group-title";
            var input = content.createInput("text", dbKey, data[dbKey]);
            input.setAttribute("onchange", "javascript: this.className = 'changed'");
            content.appendRow("{{.mapping.m3uGroupTitle.title}}", input);
            if (data["group-title"] != undefined) {
                content.description(data["group-title"]);
            }
            // XMLTV Datei
            var dbKey = "x-xmltv-file";
            var xmlFile = data[dbKey];
            var xmltv = new XMLTVFile();
            var select = xmltv.getFiles(data[dbKey]);
            select.setAttribute("name", dbKey);
            select.setAttribute("id", "popup-xmltv");
            select.setAttribute("onchange", "javascript: this.className = 'changed'; setXmltvChannel('" + id + "',this, '" + data["x-mapping"] + "');");
            content.appendRow("{{.mapping.xmltvFile.title}}", select);
            var file = data[dbKey];
            // XMLTV Mapping
            var dbKey = "x-mapping";
            var xmltv = new XMLTVFile();
            const currentXmlTvId = data[dbKey];
            const [xmlTvIdContainer, xmlTvIdInput, xmlTvIdDatalist] = xmltv.newXmlTvIdPicker(xmlFile, currentXmlTvId);
            xmlTvIdContainer.setAttribute('id', 'xmltv-id-picker-container');
            xmlTvIdInput.setAttribute('list', 'xmltv-id-picker-datalist');
            xmlTvIdInput.setAttribute('name', 'x-mapping'); // Should stay x-mapping as it will be used in donePopupData to make a server request
            xmlTvIdInput.setAttribute('id', 'xmltv-id-picker-input');
            xmlTvIdInput.setAttribute('onchange', `javascript: this.className = 'changed'; checkXmltvChannel('${id}', this, '${xmlFile}');`);
            xmlTvIdDatalist.setAttribute('id', 'xmltv-id-picker-datalist');
            // sortSelect(xmlTvIdDatalist); // TODO: Better sort before adding
            content.appendRow('{{.mapping.xmltvChannel.title}}', xmlTvIdContainer);
            // Extra PPV Data
            if (currentXmlTvId == "PPV") {
                var dbKey = "x-ppv-extra";
                var input = content.createInput("text", dbKey, data[dbKey]);
                input.setAttribute("onchange", "javascript: this.className = 'changed'");
                input.setAttribute("id", "ppv-extra");
                content.appendRow("{{.mapping.ppvextra.title}}", input);
            }
            var dbKey = "x-backup-channel-1";
            var xmltv = new XMLTVFile();
            const backup1XmlTvId = data[dbKey];
            const [xmlTvBackup1IdContainer, xmlTvBackup1IdInput, xmlTvBackup1IdDatalist] = xmltv.newXmlTvIdPicker(xmlFile, backup1XmlTvId);
            xmlTvBackup1IdContainer.setAttribute('id', 'xmltv-id-picker-container-1');
            xmlTvBackup1IdInput.setAttribute('list', 'xmltv-id-picker-datalist');
            xmlTvBackup1IdInput.setAttribute('name', dbKey); // Should stay x-mapping as it will be used in donePopupData to make a server request
            xmlTvBackup1IdInput.setAttribute("id", "backup-channel-1");
            xmlTvBackup1IdInput.setAttribute('onchange', `javascript: this.className = 'changed'; checkXmltvChannel('${id}', this, '${xmlFile}');`);
            xmlTvBackup1IdDatalist.setAttribute('id', 'xmltv-id-picker-datalist-backup1');
            // sortSelect(xmlTvIdDatalist); // TODO: Better sort before adding
            content.appendRow('{{.mapping.backupChannel1.title}}', xmlTvBackup1IdContainer);
            var dbKey = "x-backup-channel-2";
            var xmltv = new XMLTVFile();
            const backup2XmlTvId = data[dbKey];
            const [xmlTvBackup2IdContainer, xmlTvBackup2IdInput, xmlTvBackup2IdDatalist] = xmltv.newXmlTvIdPicker(xmlFile, backup2XmlTvId);
            xmlTvBackup2IdContainer.setAttribute('id', 'xmltv-id-picker-container-2');
            xmlTvBackup2IdInput.setAttribute('list', 'xmltv-id-picker-datalist');
            xmlTvBackup2IdInput.setAttribute('name', dbKey); // Should stay x-mapping as it will be used in donePopupData to make a server request
            xmlTvBackup2IdInput.setAttribute("id", "backup-channel-2");
            xmlTvBackup2IdInput.setAttribute('onchange', `javascript: this.className = 'changed'; checkXmltvChannel('${id}', this, '${xmlFile}');`);
            xmlTvBackup2IdDatalist.setAttribute('id', 'xmltv-id-picker-datalist-backup2');
            content.appendRow("{{.mapping.backupChannel2.title}}", xmlTvBackup2IdContainer);
            var dbKey = "x-backup-channel-3";
            var xmltv = new XMLTVFile();
            const backup3XmlTvId = data[dbKey];
            const [xmlTvBackup3IdContainer, xmlTvBackup3IdInput, xmlTvBackup3IdDatalist] = xmltv.newXmlTvIdPicker(xmlFile, backup3XmlTvId);
            xmlTvBackup3IdContainer.setAttribute('id', 'xmltv-id-picker-container-3');
            xmlTvBackup3IdInput.setAttribute('list', 'xmltv-id-picker-datalist');
            xmlTvBackup3IdInput.setAttribute('name', dbKey); // Should stay x-mapping as it will be used in donePopupData to make a server request
            xmlTvBackup3IdInput.setAttribute("id", "backup-channel-3");
            xmlTvBackup3IdInput.setAttribute('onchange', `javascript: this.className = 'changed'; checkXmltvChannel('${id}', this, '${xmlFile}');`);
            xmlTvBackup3IdDatalist.setAttribute('id', 'xmltv-id-picker-datalist-backup3');
            content.appendRow("{{.mapping.backupChannel3.title}}", xmlTvBackup3IdContainer);
            // Interaktion
            content.createInteraction();
            // Logo hochladen
            var input = content.createInput("button", "upload", "{{.button.uploadLogo}}");
            input.setAttribute("onclick", 'javascript: uploadLogo();');
            content.addInteraction(input);
            // Abbrechen
            var input = content.createInput("button", "cancel", "{{.button.cancel}}");
            input.setAttribute("onclick", 'javascript: showElement("popup", false);');
            content.addInteraction(input);
            // Fertig
            var ids = new Array();
            ids = getAllSelectedChannels();
            if (ids.length == 0) {
                ids.push(id);
            }
            var input = content.createInput("button", "save", "{{.button.done}}");
            input.setAttribute("onclick", 'javascript: donePopupData("' + dataType + '", "' + ids + '", "false");');
            content.addInteraction(input);
            break;
        default:
            break;
    }
    showElement('popupCustom', true);
}
class XMLTVFile {
    getFiles(set) {
        var fileIDs = getObjKeys(SERVER["xepg"]["xmltvMap"]);
        var values = new Array("-");
        var text = new Array("-");
        for (let i = 0; i < fileIDs.length; i++) {
            if (fileIDs[i] != "Threadfin Dummy") {
                values.push(getValueFromProviderFile(fileIDs[i], "xmltv", "file.threadfin"));
                text.push(getValueFromProviderFile(fileIDs[i], "xmltv", "name"));
            }
            else {
                values.push(fileIDs[i]);
                text.push(fileIDs[i]);
            }
        }
        var select = document.createElement("SELECT");
        for (let i = 0; i < text.length; i++) {
            var option = document.createElement("OPTION");
            option.setAttribute("value", values[i]);
            option.innerText = text[i];
            select.appendChild(option);
        }
        if (set != "") {
            select.value = set;
        }
        return select;
    }
    /**
   * @param xmlTvFile XML file path to get EPG from.
   * @param currentXmlTvId Current XMLTV ID to set initial input value to.
   * @returns Array of, sequentially:
   * 1) Container of the picker.
   * 2) Input field to type at and get choice from.
   * 3) Datalist containing every option.
   */
    newXmlTvIdPicker(xmlTvFile, currentXmlTvId) {
        const container = document.createElement('div');
        const input = document.createElement('input');
        input.setAttribute('type', 'text');
        // Initially, set value to '-' if input is empty
        input.value = (currentXmlTvId) ? currentXmlTvId : '-';
        // When input is focused, remove '-' from it
        input.addEventListener('focus', (evt) => {
            const target = evt.target;
            target.value = (target.value === '-') ? '' : target.value;
        });
        // When input lose focus or take a value, if it's empty, set value to '-'
        input.addEventListener('blur', setFallbackValue);
        input.addEventListener('change', setFallbackValue);
        function setFallbackValue(evt) {
            const target = evt.target;
            target.value = (target.value) ? target.value : '-';
        }
        container.appendChild(input);
        const datalist = document.createElement('datalist');
        const option = document.createElement('option');
        option.setAttribute('value', '-');
        option.innerText = '-';
        datalist.appendChild(option);
        const epg = SERVER['xepg']['xmltvMap'][xmlTvFile];
        if (epg) {
            const programIds = getOwnObjProps(epg);
            programIds.forEach((programId) => {
                const program = epg[programId];
                if (program.hasOwnProperty('display-name')) {
                    const option = document.createElement('option');
                    option.setAttribute('value', programId);
                    option.innerText = program["display-name"];
                    datalist.appendChild(option);
                }
                else {
                    const option = document.createElement('option');
                    option.setAttribute('value', programId);
                    option.innerText = '-';
                    datalist.appendChild(option);
                }
            });
        }
        container.appendChild(datalist);
        return [container, input, datalist];
    }
    getPrograms(file, set, active) {
        //var fileIDs:string[] = getObjKeys(SERVER["xepg"]["xmltvMap"])
        var values = getObjKeys(SERVER["xepg"]["xmltvMap"][file]);
        var text = new Array();
        var displayName;
        var actives = getObjKeys(SERVER["data"]["StreamPreviewUI"]["activeStreams"]);
        var active_list = new Array();
        if (active == true) {
            for (let i = 0; i < actives.length; i++) {
                var names_split = SERVER["data"]["StreamPreviewUI"]["activeStreams"][actives[i]].split("[");
                displayName = names_split[0].trim();
                if (displayName != "") {
                    var object = { "value": displayName, "display": displayName };
                    active_list.push(object);
                }
            }
        }
        else {
            for (let i = 0; i < values.length; i++) {
                if (SERVER["xepg"]["xmltvMap"][file][values[i]].hasOwnProperty('display-name') == true) {
                    displayName = SERVER["xepg"]["xmltvMap"][file][values[i]]["display-name"];
                }
                else {
                    displayName = "-";
                }
                text[i] = displayName + " (" + values[i] + ")";
            }
        }
        text.unshift("-");
        values.unshift("-");
        var select = document.createElement("SELECT");
        for (let i = 0; i < text.length; i++) {
            var option = document.createElement("OPTION");
            option.setAttribute("value", values[i]);
            option.innerText = text[i];
            select.appendChild(option);
        }
        for (let i = 0; i < active_list.length; i++) {
            var option = document.createElement("OPTION");
            option.setAttribute("value", active_list[i]["value"]);
            option.innerText = active_list[i]["display"];
            select.appendChild(option);
        }
        if (set != "") {
            select.value = set;
        }
        if (select.value != set) {
            select.value = "-";
        }
        return select;
    }
}
function getValueFromProviderFile(file, fileType, key) {
    if (file == "Threadfin Dummy") {
        return file;
    }
    var fileID;
    var indicator = file.charAt(0);
    switch (indicator) {
        case "M":
            fileType = "m3u";
            fileID = file;
            break;
        case "H":
            fileType = "hdhr";
            fileID = file;
            break;
        case "X":
            fileType = "xmltv";
            fileID = file.substring(0, file.lastIndexOf('.'));
            break;
    }
    if (SERVER["settings"]["files"][fileType].hasOwnProperty(fileID) == true) {
        var data = SERVER["settings"]["files"][fileType][fileID];
        return data[key];
    }
    return;
}
function setXmltvChannel(epgMapId, xmlTvFileSelect) {
    const xmlTv = new XMLTVFile();
    const newXmlTvFile = xmlTvFileSelect.value;
    // Remove old XMLTV ID selection box
    const xmlTvIdPickerParent = document.getElementById('xmltv-id-picker-container').parentElement;
    xmlTvIdPickerParent.innerHTML = '';
    // Create new XMLTV ID selection box
    const tvgId = SERVER['xepg']['epgMapping'][epgMapId]['tvg-id'];
    const [xmlTvIdContainer, xmlTvIdInput, xmlTvIdDatalist] = xmlTv.newXmlTvIdPicker(newXmlTvFile, tvgId);
    xmlTvIdContainer.setAttribute('id', 'xmltv-id-picker-container');
    xmlTvIdInput.setAttribute('list', 'xmltv-id-picker-datalist');
    xmlTvIdInput.setAttribute('name', 'x-mapping'); // Should stay x-mapping as it will be used in donePopupData to make a server request
    xmlTvIdInput.setAttribute('id', 'xmltv-id-picker-input');
    xmlTvIdInput.setAttribute('onchange', `javascript: this.className = 'changed'; checkXmltvChannel('${epgMapId}', this.value, '${newXmlTvFile}');`);
    xmlTvIdInput.classList.add('changed');
    xmlTvIdDatalist.setAttribute('id', 'xmltv-id-picker-datalist');
    // Add new XMLTV ID selection box to it's parent
    xmlTvIdPickerParent.appendChild(xmlTvIdContainer);
    checkXmltvChannel(epgMapId, xmlTvIdInput.value, newXmlTvFile);
}
function checkPPV(title, element) {
    var value = element.value;
    console.log("DUMMY TYPE: " + value);
    if (value == "PPV") {
        var td = document.getElementById("x-ppv-extra").parentElement;
        td.innerHTML = "";
        var dbKey = "x-ppv-extra";
        var input = document.createElement("INPUT");
        input.setAttribute("type", "text");
        input.setAttribute("name", dbKey);
        // input.setAttribute("value", value)
        input.setAttribute("onchange", "javascript: this.className = 'changed'");
        input.setAttribute("id", "ppv-extra");
        var tr = document.createElement("TR");
        // Bezeichnung
        if (title.length != 0) {
            var td = document.createElement("TD");
            td.className = "left";
            td.innerHTML = title + ":";
        }
        // Content
        td.appendChild(element);
        this.table.appendChild(tr);
    }
}
function checkXmltvChannel(id, element, xmlFile) {
    var value = element.value;
    var bool;
    var checkbox = document.getElementById('active');
    var channel = SERVER["xepg"]["epgMapping"][id];
    var updateLogo;
    if (value == "-") {
        bool = false;
    }
    else {
        bool = true;
    }
    checkbox.checked = bool;
    checkbox.className = "changed";
    console.log(xmlFile);
    // Kanallogo aktualisieren
    /*
    updateLogo = (document.getElementById("update-icon") as HTMLInputElement).checked
    console.log(updateLogo);
    */
    if (xmlFile != "Threadfin Dummy" && bool == true) {
        //(document.getElementById("update-icon") as HTMLInputElement).checked = true;
        //(document.getElementById("update-icon") as HTMLInputElement).className = "changed";
        console.log("ID", id);
        changeChannelLogo(id);
        return;
    }
    if (xmlFile == "Threadfin Dummy") {
        document.getElementById("update-icon").checked = false;
        document.getElementById("update-icon").className = "changed";
    }
    return;
}
function changeChannelLogo(epgMapId) {
    const channel = SERVER['xepg']['epgMapping'][epgMapId];
    const xmlTvFileSelect = document.getElementById('popup-xmltv');
    const xmlTvFile = xmlTvFileSelect.options[xmlTvFileSelect.selectedIndex].value;
    const xmlTvIdInput = document.getElementById('xmltv-id-picker-input');
    const newXmlTvId = xmlTvIdInput.value;
    const updateLogo = !BULK_EDIT || document.getElementById('update-icon').checked;
    let logo;
    if (updateLogo == true && xmlTvFile != 'Threadfin Dummy') {
        if (SERVER['xepg']['xmltvMap'][xmlTvFile].hasOwnProperty(newXmlTvId)) {
            logo = SERVER['xepg']['xmltvMap'][xmlTvFile][newXmlTvId]['icon'];
        }
        else {
            logo = channel['tvg-logo'];
        }
    }
}
function savePopupData(dataType, id, remove, option) {
    showElement('popup', false);
    showElement("loading", true);
    if (dataType == "mapping") {
        var data = new Object();
        console.log("Save mapping data");
        cmd = "saveEpgMapping";
        data["epgMapping"] = SERVER["xepg"]["epgMapping"];
        console.log("SEND TO SERVER");
        var server = new Server(cmd);
        server.request(data);
        delete UNDO["epgMapping"];
        showElement("loading", false);
        return;
    }
    console.log("Save popup data");
    var div = document.getElementById("popupCustom");
    var inputs = div.getElementsByTagName("TABLE")[0].getElementsByTagName("INPUT");
    var selects = div.getElementsByTagName("TABLE")[0].getElementsByTagName("SELECT");
    var input = new Object();
    var confirmMsg;
    for (let i = 0; i < selects.length; i++) {
        var name;
        name = selects[i].name;
        var value = selects[i].value;
        switch (name) {
            case "tuner":
                input[name] = parseInt(value);
                break;
            default:
                input[name] = value;
                break;
        }
    }
    for (let i = 0; i < inputs.length; i++) {
        switch (inputs[i].type) {
            case "checkbox":
                name = inputs[i].name;
                input[name] = inputs[i].checked;
                break;
            case "text":
            case "hidden":
            case "password":
                name = inputs[i].name;
                switch (name) {
                    case "tuner":
                        input[name] = parseInt(inputs[i].value);
                        break;
                    default:
                        input[name] = inputs[i].value;
                        break;
                }
                break;
        }
    }
    var data = new Object();
    var cmd;
    if (remove == true) {
        input["delete"] = true;
    }
    switch (dataType) {
        case "users":
            confirmMsg = "Delete this user?";
            if (id == "-") {
                cmd = "saveNewUser";
                data["userData"] = input;
            }
            else {
                cmd = "saveUserData";
                var d = new Object();
                d[id] = input;
                data["userData"] = d;
            }
            break;
        case "m3u":
            confirmMsg = "Delete this playlist?";
            switch (option) {
                // Popup: Save
                case 0:
                    cmd = "saveFilesM3U";
                    break;
                // Popup: Update
                case 1:
                    cmd = "updateFileM3U";
                    break;
            }
            data["files"] = new Object;
            data["files"][dataType] = new Object;
            data["files"][dataType][id] = input;
            break;
        case "hdhr":
            confirmMsg = "Delete this HDHomeRun tuner?";
            switch (option) {
                // Popup: Save
                case 0:
                    cmd = "saveFilesHDHR";
                    break;
                // Popup: Update
                case 1:
                    cmd = "updateFileHDHR";
                    break;
            }
            data["files"] = new Object;
            data["files"][dataType] = new Object;
            data["files"][dataType][id] = input;
            break;
        case "xmltv":
            confirmMsg = "Delete this XMLTV file?";
            switch (option) {
                // Popup: Save
                case 0:
                    cmd = "saveFilesXMLTV";
                    break;
                // Popup: Update
                case 1:
                    cmd = "updateFileXMLTV";
                    break;
            }
            data["files"] = new Object;
            data["files"][dataType] = new Object;
            data["files"][dataType][id] = input;
            break;
        case "filter":
            confirmMsg = "Delete this filter?";
            cmd = "saveFilter";
            data["filter"] = new Object;
            data["filter"][id] = input;
            break;
        default:
            console.log(dataType, id);
            return;
            break;
    }
    if (remove == true) {
        if (!confirm(confirmMsg)) {
            showElement("popup", false);
            return;
        }
    }
    console.log("SEND TO SERVER");
    console.log(data);
    var server = new Server(cmd);
    server.request(data);
    showElement("loading", false);
}
function donePopupData(dataType, idsStr) {
    var ids = idsStr.split(',');
    var div = document.getElementById("popupCustom");
    var inputs = div.getElementsByClassName("changed");
    ids.forEach(id => {
        var input = new Object();
        input = SERVER["xepg"]["epgMapping"][id];
        console.log("INPUT: " + input);
        for (let i = 0; i < inputs.length; i++) {
            var name;
            var value;
            switch (inputs[i].tagName) {
                case "INPUT":
                    switch (inputs[i].type) {
                        case "checkbox":
                            name = inputs[i].name;
                            value = inputs[i].checked;
                            input[name] = value;
                            break;
                        case "text":
                            name = inputs[i].name;
                            value = inputs[i].value;
                            input[name] = value;
                            break;
                    }
                    break;
                case "SELECT":
                    name = inputs[i].name;
                    value = inputs[i].value;
                    input[name] = value;
                    break;
            }
            switch (name) {
                case "tvg-logo":
                    //(document.getElementById(id).childNodes[2].firstChild as HTMLElement).setAttribute("src", value)
                    break;
                case "x-channel-start":
                    document.getElementById(id).childNodes[3].firstChild.innerHTML = value;
                    break;
                case "x-name":
                    document.getElementById(id).childNodes[3].firstChild.innerHTML = value;
                    break;
                case "x-category":
                    var color = "white";
                    var catColorSettings = SERVER["settings"]["epgCategoriesColors"];
                    var colors_split = catColorSettings.split("|");
                    for (var ii = 0; ii < colors_split.length; ii++) {
                        var catsColor_split = colors_split[ii].split(":");
                        if (catsColor_split[0] == value) {
                            color = catsColor_split[1];
                        }
                    }
                    document.getElementById(id).childNodes[3].firstChild.style.borderColor = color;
                    break;
                case "x-group-title":
                    document.getElementById(id).childNodes[5].firstChild.innerHTML = value;
                    break;
                case "x-xmltv-file":
                    if (value != "Threadfin Dummy" && value != "-") {
                        value = getValueFromProviderFile(value, "xmltv", "name");
                    }
                    if (value == "-") {
                        input["x-active"] = false;
                    }
                    document.getElementById(id).childNodes[6].firstChild.innerHTML = value;
                    break;
                case "x-mapping":
                    if (value == "-") {
                        input["x-active"] = false;
                    }
                    document.getElementById(id).childNodes[7].firstChild.innerHTML = value;
                    break;
                case "x-backup-channel":
                    document.getElementById(id).childNodes[7].firstChild.innerHTML = value;
                    break;
                case "x-hide-channel":
                    document.getElementById(id).childNodes[7].firstChild.innerHTML = value;
                    break;
                default:
            }
            createSearchObj();
            searchInMapping();
        }
        if (input["x-active"] == false) {
            document.getElementById(id).className = "notActiveEPG";
        }
        else {
            document.getElementById(id).className = "activeEPG";
        }
        console.log(input["tvg-logo"]);
        document.getElementById(id).childNodes[2].firstChild.setAttribute("src", input["tvg-logo"]);
    });
    showElement("popup", false);
    return;
}
function showPreview(element) {
    var div = document.getElementById("myStreamsBox");
    switch (element) {
        case false:
            div.className = "notVisible";
            return;
            break;
    }
    var streams = ["activeStreams", "inactiveStreams"];
    streams.forEach(preview => {
        var table = document.getElementById(preview);
        table.innerHTML = "";
        var obj = SERVER["data"]["StreamPreviewUI"][preview];
        var caption = document.createElement("CAPTION");
        var result = preview.replace(/([A-Z])/g, " $1");
        var finalResult = result.charAt(0).toUpperCase() + result.slice(1);
        caption.innerHTML = finalResult;
        table.appendChild(caption);
        var tbody = document.createElement("TBODY");
        table.appendChild(tbody);
        obj.slice(0, 1000).forEach(channel => {
            var tr = document.createElement("TR");
            var tdKey = document.createElement("TD");
            var tdVal = document.createElement("TD");
            tdKey.className = "tdKey";
            tdVal.className = "tdVal";
            switch (preview) {
                case "activeStreams":
                    tdKey.innerText = "Channel: (+)";
                    break;
                case "inactiveStreams":
                    tdKey.innerText = "Channel: (-)";
                    break;
            }
            tdVal.innerText = channel;
            tr.appendChild(tdKey);
            tr.appendChild(tdVal);
            tbody.appendChild(tr);
            table.appendChild(tr);
        });
    });
    // showElement("loading", false)
    div.className = "visible";
    return;
}
//# sourceMappingURL=menu.js.map" + webUI["web/public/js/menu.js.map"] = "{"version":3,"file":"menu.js","sourceRoot":"","sources":["../../src/ts/menu.ts"],"names":[],"mappings":"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"}" webUI["web/public/js/network.js"] = "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" webUI["web/public/js/network.js.map"] = "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" webUI["web/public/js/option_dialogue.js"] = "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" webUI["web/public/js/option_dialogue.js.map"] = "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" webUI["web/public/js/server_information.js"] = "class ServerInformation {
    constructor() {
        this.container = document.getElementById('server_information');
        const modalDialogue = document.createElement('div');
        modalDialogue.className = 'modal-dialog modal-xl';
        this.container.appendChild(modalDialogue);
        const modalContent = document.createElement('div');
        modalContent.className = 'modal-content';
        modalDialogue.appendChild(modalContent);
        const modalHeader = document.createElement('div');
        modalHeader.className = 'modal-header';
        modalContent.appendChild(modalHeader);
        const modalTitle = document.createElement('h3');
        modalTitle.className = 'modal-title';
        modalTitle.innerHTML = '{{.serverInfo.title}}';
        modalHeader.appendChild(modalTitle);
        const closeButton = document.createElement('button');
        closeButton.className = 'btn-close btn-close-white';
        closeButton.type = 'button';
        closeButton.addEventListener('click', () => {
            this.container.style.display = 'none';
            this.container.setAttribute('aria-hidden', 'false');
        });
        closeButton.setAttribute('data-bs-dismiss', 'modal');
        //closeButton.setAttribute('aria-label', 'Close');
        modalHeader.appendChild(closeButton);
        const modalBody = document.createElement('div');
        modalBody.className = 'modal-body';
        const containerFluid = document.createElement('div');
        containerFluid.className = 'container-fluid';
        const row = document.createElement('div');
        row.className = 'row';
        containerFluid.appendChild(row);
        modalBody.appendChild(containerFluid);
        modalContent.appendChild(modalBody);
    }
    addContent(content) {
        const row = this.container.getElementsByClassName('row')[0];
        for (const group of content) {
            row.appendChild(group.GroupHTMLElement);
        }
    }
}
class ServerInformationGroup {
    constructor(title) {
        const group = document.createElement('div');
        group.className = 'card text-bg-dark mb-3';
        const header = document.createElement('div');
        header.className = 'card-header';
        header.innerHTML = title;
        this.Header = header;
        const body = document.createElement('div');
        body.className = 'card-body';
        this.Body = body;
        group.appendChild(header);
        group.appendChild(this.Body);
        this.GroupHTMLElement = group;
    }
    addBodyContent(item) {
        switch (item) {
            case 'version':
                this.Body.appendChild(this.addLabel(item, '{{.serverInfo.label.version}}'));
                this.Body.appendChild(this.addTextInput(item, true));
                break;
            case 'errors':
                this.Body.appendChild(this.addLabel(item, '{{.serverInfo.label.errors}}'));
                this.Body.appendChild(this.addTextInput(item, true));
                break;
            case 'warnings':
                this.Body.appendChild(this.addLabel(item, '{{.serverInfo.label.warnings}}'));
                this.Body.appendChild(this.addTextInput(item, true));
                break;
            case 'dvr':
                this.Body.appendChild(this.addLabel(item, '{{.serverInfo.label.dvr}}'));
                this.Body.appendChild(this.addTextInput(item, true));
                break;
            case 'streams':
                this.Body.appendChild(this.addLabel(item, '{{.serverInfo.label.streams}}'));
                this.Body.appendChild(this.addTextInput(item, true));
                break;
            case 'xepg':
                this.Body.appendChild(this.addLabel(item, '{{.serverInfo.label.xepg}}'));
                this.Body.appendChild(this.addTextInput(item, true));
                break;
            case 'm3uUrl':
                this.Body.appendChild(this.addLabel(item, '{{.serverInfo.label.m3uUrl}}'));
                this.Body.appendChild(this.addContainer(item));
                break;
            case 'xepgUrl':
                this.Body.appendChild(this.addLabel(item, '{{.serverInfo.label.xepgUrl}}'));
                this.Body.appendChild(this.addContainer(item));
                break;
            case 'changeVersion':
                this.Body.appendChild(this.addButtonInput(item));
            default:
                console.log('Unknown item: ', item);
        }
    }
    addLabel(forValue, text) {
        const label = document.createElement('label');
        label.className = 'form-label';
        label.setAttribute('for', forValue);
        label.innerHTML = text;
        return label;
    }
    addTextInput(id, disabled = false) {
        const input = document.createElement('input');
        input.type = 'text';
        input.className = 'form-control';
        input.setAttribute('id', id);
        input.setAttribute('aria-describedby', 'basic-addon3');
        input.readOnly = true;
        if (disabled) {
            input.disabled = true;
        }
        return input;
    }
    addButtonInput(id) {
        const input = document.createElement('input');
        input.type = 'button';
        input.setAttribute('id', id);
        return input;
    }
    addContainer(id) {
        const container = document.createElement('div');
        container.className = 'input-group';
        container.appendChild(this.addTextInput(id));
        container.appendChild(this.addButton(id));
        return container;
    }
    addButton(id) {
        const button = document.createElement('button');
        button.type = 'button';
        button.className = 'input-group-text copy-btn';
        button.setAttribute('data-clipboard-target', '#' + id);
        button.setAttribute('data-bs-toggle', 'tooltip');
        button.setAttribute('data-bs-placement', 'bottom');
        button.setAttribute('data-bs-title', 'Copy to clipboard');
        button.setAttribute('alt', '');
        button.style.backgroundColor = '#333';
        button.style.borderColor = '#444';
        button.innerHTML = '<i class="far fa-clipboard fa-style"></i>';
        return button;
    }
}
class ServerInformationItem extends ServerInformationGroup {
    constructor(groupTitle, items) {
        super(groupTitle);
        for (const item of items.split(',')) {
            this.addBodyContent(item);
        }
    }
}
//# sourceMappingURL=server_information.js.map" webUI["web/public/js/server_information.js.map"] = "{"version":3,"file":"server_information.js","sourceRoot":"","sources":["../../src/ts/server_information.ts"],"names":[],"mappings":"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"}" - webUI["web/public/js/settings.js"] = "class SettingsCategory {
    constructor(headline, settingsKeys) {
        this.DocumentID = 'content_settings';
        this.Content = new PopupContent();
        this.headline = headline;
        this.settingsKeys = settingsKeys;
    }
    createSettingsCheckbox(settingsKey, title) {
        var setting = document.createElement('TR');
        var data = SERVER['settings'][settingsKey];
        var tdLeft = document.createElement('TD');
        tdLeft.innerHTML = title + ':';
        var tdRight = document.createElement('TD');
        var input = this.Content.createCheckbox(settingsKey);
        input.checked = data;
        input.setAttribute('onchange', 'javascript: this.className = "changed"');
        tdRight.appendChild(input);
        setting.appendChild(tdLeft);
        setting.appendChild(tdRight);
        return setting;
    }
    createTextInput(settingsKey, title, placeholder, setID = false) {
        var data = SERVER['settings'][settingsKey];
        var setting = document.createElement('TR');
        var tdLeft = document.createElement('TD');
        tdLeft.innerHTML = title + ':';
        var tdRight = document.createElement('TD');
        var input = this.Content.createInput('text', settingsKey, data.toString());
        input.setAttribute('placeholder', placeholder);
        input.setAttribute('onchange', 'javascript: this.className = "changed"');
        if (setID) {
            input.setAttribute('id', settingsKey);
        }
        tdRight.appendChild(input);
        setting.appendChild(tdLeft);
        setting.appendChild(tdRight);
        return setting;
    }
    createSelectInput(settingsKey, title, text, values) {
        var data = SERVER['settings'][settingsKey];
        var setting = document.createElement('TR');
        var tdLeft = document.createElement('TD');
        tdLeft.innerHTML = title + ':';
        var tdRight = document.createElement('TD');
        var select = this.Content.createSelect(text, values, data, settingsKey);
        select.setAttribute('onchange', 'javascript: this.className = "changed"');
        tdRight.appendChild(select);
        setting.appendChild(tdLeft);
        setting.appendChild(tdRight);
        return setting;
    }
    createCategoryHeadline(value) {
        var element = document.createElement('H4');
        element.innerHTML = value;
        return element;
    }
    createHR() {
        var element = document.createElement('HR');
        return element;
    }
    createSettings(settingsKey) {
        var setting = document.createElement('TR');
        switch (settingsKey) {
            // Text inputs
            case 'update':
                setting = this.createTextInput(settingsKey, '{{.settings.update.title}}', '{{.settings.update.placeholder}}');
                break;
            case 'backup.path':
                setting = this.createTextInput(settingsKey, '{{.settings.backupPath.title}}', '{{.settings.backupPath.placeholder}}');
                break;
            case 'temp.path':
                setting = this.createTextInput(settingsKey, '{{.settings.tempPath.title}}', '{{.settings.tmpPath.placeholder}}');
                break;
            case 'user.agent':
                setting = this.createTextInput(settingsKey, '{{.settings.userAgent.title}}', '{{.settings.userAgent.placeholder}}');
                break;
            case 'buffer.timeout':
                setting = this.createTextInput(settingsKey, '{{.settings.bufferTimeout.title}}', '{{.settings.bufferTimeout.placeholder}}');
                break;
            case 'ffmpeg.path':
                setting = this.createTextInput(settingsKey, '{{.settings.ffmpegPath.title}}', '{{.settings.ffmpegPath.placeholder}}');
                break;
            case 'ffmpeg.options':
                setting = this.createTextInput(settingsKey, '{{.settings.ffmpegOptions.title}}', '{{.settings.ffmpegOptions.placeholder}}');
                break;
            case 'vlc.path':
                setting = this.createTextInput(settingsKey, '{{.settings.vlcPath.title}}', '{{.settings.vlcPath.placeholder}}');
                break;
            case 'vlc.options':
                setting = this.createTextInput(settingsKey, '{{.settings.vlcOptions.title}}', '{{.settings.vlcOptions.placeholder}}');
                break;
            case 'bindingIPs':
                setting = this.createTextInput(settingsKey, '{{.settings.bindingIPs.title}}', '{{.settings.bindingIPs.placeholder}}', true);
                const input = setting.querySelector('input[id=' + settingsKey + ']');
                if (null != input) {
                    input.addEventListener('click', () => {
                        showIPBindingDialogue();
                    });
                }
                break;
            case 'epgCategories':
                setting = this.createTextInput(settingsKey, '{{.settings.epgCategories.title}}', '{{.settings.epgCategories.placeholder}}');
                break;
            case 'epgCategoriesColors':
                setting = this.createTextInput(settingsKey, '{{.settings.epgCategoriesColors.title}}', '{{.settings.epgCategoriesColors.placeholder}}');
                break;
            case 'threadfinDomain':
                setting = this.createTextInput(settingsKey, '{{.settings.threadfinDomain.title}}', '{{.settings.threadfinDomain.placeholder}}');
                break;
            case 'udpxy':
                setting = this.createTextInput(settingsKey, '{{.settings.udpxy.title}}', '{{.settings.udpxy.placeholder}}');
                break;
            // Checkboxen
            case 'authentication.web':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.authenticationWEB.title}}');
                break;
            case 'authentication.pms':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.authenticationPMS.title}}');
                break;
            case 'authentication.m3u':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.authenticationM3U.title}}');
                break;
            case 'authentication.xml':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.authenticationXML.title}}');
                break;
            case 'authentication.api':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.authenticationAPI.title}}');
                break;
            case 'files.update':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.filesUpdate.title}}');
                break;
            case 'cache.images':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.cacheImages.title}}');
                break;
            case 'xepg.replace.missing.images':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.replaceEmptyImages.title}}');
                break;
            case 'xepg.replace.channel.title':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.replaceChannelTitle.title}}');
                break;
            case 'storeBufferInRAM':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.storeBufferInRAM.title}}');
                break;
            case 'buffer.autoReconnect':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.autoReconnect.title}}');
                break;
            case 'omitPorts':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.omitPorts.title}}');
                break;
            case 'forceHttps':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.forceHttps.title}}');
                break;
            case 'useHttps':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.useHttps.title}}');
                break;
            case 'forceClientHttps':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.forceClientHttps.title}}');
                break;
            case 'domainUseHttps':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.domainUseHttps.title}}');
                break;
            case 'enableNonAscii':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.enableNonAscii.title}}');
                break;
            case 'ThreadfinAutoUpdate':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.ThreadfinAutoUpdate.title}}');
                break;
            case 'ssdp':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.ssdp.title}}');
                break;
            case 'dummy':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.dummy.title}}');
                break;
            case 'ignoreFilters':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.ignoreFilters.title}}');
                break;
            case 'api':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.api.title}}');
                break;
            // Select
            case 'dummyChannel':
                var title = '{{.settings.dummyChannel.title}}';
                var text = ['PPV', '30 Minutes', '60 Minutes', '90 Minutes', '120 Minutes', '180 Minutes', '240 Minutes', '360 Minutes'];
                var values = ['PPV', '30_Minutes', '60_Minutes', '90_Minutes', '120_Minutes', '180_Minutes', '240_Minutes', '360_Minutes'];
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            case 'tuner':
                var title = '{{.settings.tuner.title}}';
                var text = new Array();
                var values = new Array();
                for (var i = 1; i <= 100; i++) {
                    text.push(i);
                    values.push(i);
                }
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            case 'epgSource':
                var title = '{{.settings.epgSource.title}}';
                var text = ['PMS', 'XEPG'];
                var values = ['PMS', 'XEPG'];
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            case 'backup.keep':
                var title = '{{.settings.backupKeep.title}}';
                var text = ['5', '10', '20', '30', '40', '50'];
                var values = ['5', '10', '20', '30', '40', '50'];
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            case 'buffer.size.kb':
                var title = '{{.settings.bufferSize.title}}';
                var text = ['0.5 MB', '1 MB', '2 MB', '3 MB', '4 MB', '5 MB', '6 MB', '7 MB', '8 MB'];
                var values = ['512', '1024', '2048', '3072', '4096', '5120', '6144', '7168', '8192'];
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            case 'buffer':
                var title = '{{.settings.streamBuffering.title}}';
                var text = ['{{.settings.streamBuffering.info_false}}', 'FFmpeg: ({{.settings.streamBuffering.info_ffmpeg}})', 'VLC: ({{.settings.streamBuffering.info_vlc}})', 'Threadfin: ({{.settings.streamBuffering.info_threadfin}})'];
                var values = ['-', 'ffmpeg', 'vlc', 'threadfin'];
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            case 'webclient.language':
                var title = '{{.settings.webclient.language.title}}';
                var text = ['English', 'Deutsch'];
                var values = ['en', 'de'];
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            // Button
            case 'uploadCustomImage':
                setting = document.createElement('TR');
                var tdLeft = document.createElement('TD');
                tdLeft.innerHTML = '{{.settings.uploadCustomImage.title}}' + ':';
                var tdRight = document.createElement('TD');
                var button = this.Content.createInput('button', 'upload', '{{.button.uploadCustomImage}}');
                button.setAttribute('onclick', 'javascript: uploadCustomImage();');
                tdRight.appendChild(button);
                setting.appendChild(tdLeft);
                setting.appendChild(tdRight);
                break;
        }
        return setting;
    }
    createDescription(settingsKey) {
        var description = document.createElement('TR');
        var text;
        switch (settingsKey) {
            case 'authentication.web':
                text = '{{.settings.authenticationWEB.description}}';
                break;
            case 'authentication.m3u':
                text = '{{.settings.authenticationM3U.description}}';
                break;
            case 'authentication.pms':
                text = '{{.settings.authenticationPMS.description}}';
                break;
            case 'authentication.xml':
                text = '{{.settings.authenticationXML.description}}';
                break;
            case 'authentication.api':
                if (SERVER['settings']['authentication.web'] == true) {
                    text = '{{.settings.authenticationAPI.description}}';
                }
                break;
            case 'uploadCustomImage':
                text = '{{.settings.uploadCustomImage.description}}';
                break;
            case 'ThreadfinAutoUpdate':
                text = '{{.settings.ThreadfinAutoUpdate.description}}';
                break;
            case 'bindingIPs':
                text = '{{.settings.bindingIPs.description}}';
                break;
            case 'backup.keep':
                text = '{{.settings.backupKeep.description}}';
                break;
            case 'backup.path':
                text = '{{.settings.backupPath.description}}';
                break;
            case 'temp.path':
                text = '{{.settings.tempPath.description}}';
                break;
            case 'buffer':
                text = '{{.settings.streamBuffering.description}}';
                break;
            case 'buffer.size.kb':
                text = '{{.settings.bufferSize.description}}';
                break;
            case 'buffer.autoReconnect':
                text = '{{.settings.autoReconnect.description}}';
                break;
            case 'storeBufferInRAM':
                text = '{{.settings.storeBufferInRAM.description}}';
                break;
            case 'omitPorts':
                text = '{{.settings.omitPorts.description}}';
                break;
            case 'forceHttps':
                text = '{{.settings.forceHttps.description}}';
                break;
            case 'useHttps':
                text = '{{.settings.useHttps.description}}';
                break;
            case 'forceClientHttps':
                text = '{{.settings.forceClientHttps.description}}';
                break;
            case 'threadfinDomain':
                text = '{{.settings.threadfinDomain.description}}';
                break;
            case 'enableNonAscii':
                text = '{{.settings.enableNonAscii.description}}';
                break;
            case 'epgCategories':
                text = '{{.settings.epgCategories.description}}';
                break;
            case 'epgCategoriesColors':
                text = '{{.settings.epgCategoriesColors.description}}';
                break;
            case 'buffer.timeout':
                text = '{{.settings.bufferTimeout.description}}';
                break;
            case 'user.agent':
                text = '{{.settings.userAgent.description}}';
                break;
            case 'ffmpeg.path':
                text = '{{.settings.ffmpegPath.description}}';
                break;
            case 'ffmpeg.options':
                text = '{{.settings.ffmpegOptions.description}}';
                break;
            case 'vlc.path':
                text = '{{.settings.vlcPath.description}}';
                break;
            case 'vlc.options':
                text = '{{.settings.vlcOptions.description}}';
                break;
            case 'epgSource':
                text = '{{.settings.epgSource.description}}';
                break;
            case 'tuner':
                text = '{{.settings.tuner.description}}';
                break;
            case 'update':
                text = '{{.settings.update.description}}';
                break;
            case 'api':
                text = '{{.settings.api.description}}';
                break;
            case 'ssdp':
                text = '{{.settings.ssdp.description}}';
                break;
            case 'files.update':
                text = '{{.settings.filesUpdate.description}}';
                break;
            case 'cache.images':
                text = '{{.settings.cacheImages.description}}';
                break;
            case 'xepg.replace.missing.images':
                text = '{{.settings.replaceEmptyImages.description}}';
                break;
            case 'xepg.replace.channel.title':
                text = '{{.settings.replaceChannelTitle.description}}';
                break;
            case 'udpxy':
                text = '{{.settings.udpxy.description}}';
                break;
            case 'webclient.language':
                text = '{{.settings.webclient.language.description}}';
                break;
            default:
                text = '';
                break;
        }
        var tdLeft = document.createElement('TD');
        tdLeft.innerHTML = '';
        var tdRight = document.createElement('TD');
        var pre = document.createElement('PRE');
        pre.innerHTML = text;
        tdRight.appendChild(pre);
        description.appendChild(tdLeft);
        description.appendChild(tdRight);
        return description;
    }
}
class SettingsCategoryItem extends SettingsCategory {
    constructor(headline, settingsKeys) {
        super(headline, settingsKeys);
    }
    createCategory() {
        var doc = document.getElementById(this.DocumentID);
        doc.appendChild(this.createCategoryHeadline(this.headline));
        // Tabelle für die Kategorie erstellen
        var table = document.createElement('TABLE');
        var keys = this.settingsKeys.split(',');
        keys.forEach(settingsKey => {
            switch (settingsKey) {
                case 'authentication.pms':
                case 'authentication.m3u':
                case 'authentication.xml':
                case 'authentication.api':
                    if (SERVER['settings']['authentication.web'] == false) {
                        break;
                    }
                default:
                    var item = this.createSettings(settingsKey);
                    var description = this.createDescription(settingsKey);
                    table.appendChild(item);
                    table.appendChild(description);
                    break;
            }
        });
        doc.appendChild(table);
        doc.appendChild(this.createHR());
    }
}
function showSettings() {
    console.log('SETTINGS');
    for (let i = 0; i < settingsCategory.length; i++) {
        settingsCategory[i].createCategory();
    }
}
function saveSettings() {
    console.log('Save Settings');
    var cmd = 'saveSettings';
    var div = document.getElementById('content_settings');
    var settings = div.getElementsByClassName('changed');
    var newSettings = new Object();
    for (let i = 0; i < settings.length; i++) {
        var name;
        var value;
        switch (settings[i].tagName) {
            case 'INPUT':
                switch (settings[i].type) {
                    case 'checkbox':
                        name = settings[i].name;
                        value = settings[i].checked;
                        newSettings[name] = value;
                        switch (name) {
                            case 'useHttps':
                                setTimeout(() => {
                                    if (value) {
                                        location.protocol = 'https';
                                    }
                                    else {
                                        location.protocol = 'http';
                                    }
                                    location.reload();
                                }, 3000);
                        }
                        break;
                    case 'text':
                        name = settings[i].name;
                        value = settings[i].value;
                        switch (name) {
                            case 'update':
                                value = value.split(',');
                                value = value.filter(function (e) { return e; });
                                break;
                            case 'buffer.timeout':
                                value = parseFloat(value);
                            case 'bindingIPs':
                                setTimeout(() => {
                                    let isLocalhost = false;
                                    let hostname = String(location.hostname);
                                    const newValue = value;
                                    if (hostname === 'localhost') {
                                        hostname = '127.0.0.1';
                                    }
                                    if (!newValue.includes(hostname)) {
                                        const newHostname = newValue.split(';')[0];
                                        if (newHostname === '127.0.0.1') {
                                            location.href = location.href.replace(hostname, 'localhost');
                                        }
                                        else {
                                            location.href = location.href.replace(hostname, newHostname);
                                        }
                                    }
                                    location.reload();
                                }, 3000);
                        }
                        newSettings[name] = value;
                        break;
                }
                break;
            case 'SELECT':
                name = settings[i].name;
                value = settings[i].value;
                // Wenn der Wert eine Zahl ist, wird dieser als Zahl gespeichert
                if (isNaN(value)) {
                    newSettings[name] = value;
                }
                else {
                    newSettings[name] = parseInt(value);
                }
                if (name === 'webclient.language') {
                    setTimeout(() => {
                        location.reload();
                    }, 3000);
                }
                break;
        }
    }
    var data = new Object();
    data['settings'] = newSettings;
    var server = new Server(cmd);
    server.request(data);
}
function uploadCustomImage() {
    if (document.getElementById('upload')) {
        document.getElementById('upload').remove();
    }
    var upload = document.createElement('INPUT');
    upload.setAttribute('type', 'file');
    upload.setAttribute('accept', '.jpg,.png');
    upload.setAttribute('class', 'notVisible');
    upload.setAttribute('name', '');
    upload.id = 'upload';
    document.body.appendChild(upload);
    upload.click();
    upload.onblur = function () {
        alert();
    };
    upload.onchange = function () {
        var filename = upload.files[0].name;
        var reader = new FileReader();
        var file = document.querySelector('input[type=file]').files[0];
        if (file) {
            reader.readAsDataURL(file);
            reader.onload = function () {
                console.log(reader.result);
                var data = new Object();
                var cmd = 'uploadCustomImage';
                data['base64'] = reader.result;
                data['filename'] = file.name;
                var server = new Server(cmd);
                server.request(data);
                var updateLogo = document.getElementById('update-icon');
                updateLogo.checked = false;
                updateLogo.className = 'changed';
            };
        }
        else {
            alert('File could not be loaded');
        }
        upload.remove();
        return;
    };
}
//# sourceMappingURL=settings.js.map" - webUI["web/public/js/settings.js.map"] = "{"version":3,"file":"settings.js","sourceRoot":"","sources":["../../src/ts/settings.ts"],"names":[],"mappings":"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"}" - webUI["web/public/js/version_check.js"] = "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" - webUI["web/public/js/version_check.js.map"] = "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" - webUI["web/public/lang/de.json"] = "{
  "mainMenu": {
    "item": {
      "playlist": "Wiedergabeliste",
      "pmsID": "PMS ID",
      "filter": "Filter",
      "xmltv": "XMLTV",
      "mapping": "Zuordnung",
      "users": "Benutzer",
      "settings": "Einstellungen",
      "log": "Protokoll",
      "logout": "Abmelden"
    },
    "headline": {
      "playlist": "Lokale oder entfernte Wiedergabelisten",
      "filter": "Wiedergabeliste filtern",
      "xmltv": "Lokale oder entfernte XMLTV-Dateien",
      "mapping": "Zuordnung der Wiedergabelistenkanäle zu EPG-Kanälen",
      "users": "Benutzerverwaltung",
      "settings": "Einstellungen",
      "log": "Protokoll",
      "logout": "Abmelden"
    }
  },
  "confirm": {
    "restore": "Alle Daten werden durch die aus dem Backup ersetzt. Sollen die Dateien wiederhergestellt werden?"
  },
  "alert": {
    "fileLoadingError": "Datei konnte nicht geladen werden",
    "invalidChannelNumber": "Ungültige Kanalnummer",
    "missingInput": "Fehlende Eingabe"
  },
  "button": {
    "back": "Zurück",
    "backup": "Backup",
    "bulkEdit": "Massenbearbeitung",
    "cancel": "Abbrechen",
    "delete": "Löschen",
    "done": "Fertig",
    "login": "Anmelden",
    "new": "Neu",
    "next": "Weiter",
    "restore": "Wiederherstellen",
    "save": "Speichern",
    "search": "Suchen",
    "update": "Aktualisieren",
    "updating": "Aktualisiere...",
    "craeteAccount": "Konto erstellen",
    "resetLogs": "Protokolle zurücksetzen",
    "uploadLogo": "Logo hochladen",
    "uploadCustomImage": "Benutzerdefiniertes Bild hochladen",
    "sortChannelsAlpha": "Kanäle alphabetisch sortieren",
    "sortChannelNumbers": "Kanäle sortieren",
    "backToTop": "Gehe nach oben",
    "serverInformation": "Server Informationen"
  },
  "filter": {
    "table": {
      "name": "Filtername",
      "type": "Filtertyp",
      "filter": "Filter"
    },
    "custom": "Benutzerdefiniert",
    "group": "Gruppe",
    "name": {
      "title": "Filtername",
      "placeholder": "Filtername",
      "description": ""
    },
    "startingnumber": {
      "title": "Filter-Startnummer",
      "placeholder": "Filter-Startnummer",
      "description": "Startkanalnummer für diesen Gruppenfilter (Standard ist 1000)"
    },
    "category": {
      "title": "Filterkategorie",
      "placeholder": "Filterkategorie",
      "description": "Filterkategorie setzt alle Kanäle im Filter auf eine bestimmte Kategorie (Nachrichten, Sport usw.)"
    },
    "description": {
      "title": "Beschreibung",
      "placeholder": "Beschreibung",
      "description": ""
    },
    "type": {
      "title": "Typ",
      "groupTitle": "Gruppentitel",
      "customFilter": "Benutzerdefinierter Filter"
    },
    "caseSensitive": {
      "title": "Groß-/Kleinschreibung beachten",
      "placeholder": "",
      "description": ""
    },
    "filterRule": {
      "title": "Filterregel",
      "placeholder": "Sport {HD} !{ES,IT}",
      "description": ""
    },
    "filterGroup": {
      "title": "Gruppentitel",
      "placeholder": "",
      "description": "Wählen Sie eine M3U-Gruppe. (Zähler)<br>Das Ändern des Gruppentitels in der M3U macht den Filter ungültig."
    },
    "include": {
      "title": "Einschließen",
      "placeholder": "FHD,UHD",
      "description": "Kanalname muss enthalten.<br>(Kommagetrennt) Komma bedeutet oder"
    },
    "exclude": {
      "title": "Ausschließen",
      "placeholder": "ES,IT",
      "description": "Kanalname darf nicht enthalten.<br>(Kommagetrennt) Komma bedeutet oder"
    }
  },
  "playlist": {
    "table": {
      "playlist": "Wiedergabeliste",
      "tuner": "Tuner",
      "lastUpdate": "Letzte Aktualisierung",
      "availability": "Verfügbarkeit",
      "type": "Typ",
      "streams": "Streams",
      "groupTitle": "Gruppentitel",
      "tvgID": "tvg-id",
      "uniqueID": "Eindeutige ID"
    },
    "playlistType": {
      "title": "Wiedergabelistentyp",
      "placeholder": "",
      "description": ""
    },
    "type": {
      "title": "Typ",
      "placeholder": "",
      "description": ""
    },
    "name": {
      "title": "Name",
      "placeholder": "Wiedergabelistenname",
      "description": ""
    },
    "description": {
      "title": "Beschreibung",
      "placeholder": "Beschreibung",
      "description": ""
    },
    "fileM3U": {
      "title": "M3U-Datei",
      "placeholder": "Dateipfad oder URL der M3U",
      "description": ""
    },
    "fileHDHR": {
      "title": "HDHomeRun IP",
      "placeholder": "IP-Adresse und Port (192.168.1.10:5004)",
      "description": ""
    },
    "tuner": {
      "title": "Tuner / Streams",
      "placeholder": "",
      "description": "Anzahl der parallelen Verbindungen, die zum Anbieter hergestellt werden können. <br>Nur verfügbar mit aktiviertem Puffer.<br>Neue Einstellungen werden erst nach Beenden aller Streams angewendet."
    },
    "http_proxy_ip": {
      "title": "HTTP-Proxy-IP",
      "placeholder": "192.168.0.2",
      "description": "IP-Adresse, die vom HTTP-Proxy verwendet werden soll"
    },
    "http_proxy_port": {
      "title": "HTTP-Proxy-Port",
      "placeholder": "8888",
      "description": "Port, der vom HTTP-Proxy verwendet werden soll"
    }
  },
  "xmltv": {
    "table": {
      "guide": "Guide",
      "lastUpdate": "Letzte Aktualisierung",
      "availability": "Verfügbarkeit",
      "channels": "Kanäle",
      "programs": "Programme"
    },
    "name": {
      "title": "Name",
      "placeholder": "Guidename",
      "description": ""
    },
    "description": {
      "title": "Beschreibung",
      "placeholder": "Beschreibung",
      "description": ""
    },
    "fileXMLTV": {
      "title": "XMLTV-Datei",
      "placeholder": "Dateipfad oder URL der XMLTV",
      "description": ""
    },
    "http_proxy_ip": {
      "title": "HTTP-Proxy-IP",
      "placeholder": "192.168.0.2",
      "description": "IP-Adresse, die vom HTTP-Proxy verwendet werden soll"
    },
    "http_proxy_port": {
      "title": "HTTP-Proxy-Port",
      "placeholder": "8888",
      "description": "Port, der vom HTTP-Proxy verwendet werden soll"
    }
  },
  "mapping": {
    "table": {
      "chNo": "Kanalnr.",
      "logo": "Logo",
      "channelName": "Kanalname",
      "playlist": "Wiedergabeliste",
      "groupTitle": "Gruppentitel",
      "xmltvFile": "XMLTV-Datei",
      "xmltvID": "XMLTV-ID"
    },
    "active": {
      "title": "Aktiv",
      "placeholder": "",
      "description": ""
    },
    "channelName": {
      "title": "Kanalname",
      "placeholder": "",
      "description": ""
    },
    "channelGroupStart": {
      "title": "Kanalgruppenstart",
      "placeholder": "",
      "description": ""
    },
    "sortChannelsAlpha": {
      "title": "Alphabetisch sortieren",
      "placeholder": "",
      "description": ""
    },
    "sortChannels": {
      "title": "Kanäle sortieren",
      "placeholder": "",
      "description": ""
    },
    "description": {
      "title": "Kanalbeschreibung",
      "placeholder": "Wird vom Dummy als XML-Beschreibung verwendet",
      "description": ""
    },
    "updateChannelName": {
      "title": "Kanalname aktualisieren",
      "placeholder": "",
      "description": ""
    },
    "channelLogo": {
      "title": "Logo-URL",
      "placeholder": "",
      "description": ""
    },
    "updateChannelLogo": {
      "title": "Kanal-Logo aktualisieren",
      "placeholder": "",
      "description": ""
    },
    "epgCategory": {
      "title": "EPG-Kategorie",
      "placeholder": "",
      "description": ""
    },
    "m3uGroupTitle": {
      "title": "Gruppentitel (threadfin.m3u)",
      "placeholder": "",
      "description": ""
    },
    "xmltvFile": {
      "title": "XMLTV-Datei",
      "placeholder": "",
      "description": ""
    },
    "xmltvChannel": {
      "title": "XMLTV-Kanal",
      "placeholder": "",
      "description": ""
    },
    "ppvextra": {
      "title": "PPV-Zusatztitel",
      "placeholder": "",
      "description": "Dies fügt dem Programmdaten benutzerdefinierten Text hinzu"
    },
    "backupChannel1": {
      "title": "Backup-Kanal 1",
      "placeholder": "",
      "description": ""
    },
    "backupChannel2": {
      "title": "Backup-Kanal 2",
      "placeholder": "",
      "description": ""
    },
    "backupChannel3": {
      "title": "Backup-Kanal 3",
      "placeholder": "",
      "description": ""
    },
    "hideChannel": {
      "title": "Backup-Kanal ausblenden",
      "placeholder": "",
      "description": ""
    }
  },
  "users": {
    "table": {
      "username": "Benutzername",
      "password": "Passwort",
      "web": "WEB",
      "pms": "PMS",
      "m3u": "M3U",
      "xml": "XML",
      "api": "API"
    },
    "username": {
      "title": "Benutzername",
      "placeholder": "Benutzername",
      "description": ""
    },
    "password": {
      "title": "Passwort",
      "placeholder": "Passwort",
      "description": ""
    },
    "confirm": {
      "title": "Bestätigen",
      "placeholder": "Passwort bestätigen",
      "description": ""
    },
    "web": {
      "title": "Web-Zugang",
      "placeholder": "",
      "description": ""
    },
    "pms": {
      "title": "PMS-Zugang",
      "placeholder": "",
      "description": ""
    },
    "m3u": {
      "title": "M3U-Zugang",
      "placeholder": "",
      "description": ""
    },
    "xml": {
      "title": "XML-Zugang",
      "placeholder": "",
      "description": ""
    },
    "api": {
      "title": "API-Zugang",
      "placeholder": "",
      "description": ""
    }
  },
  "settings": {
    "category": {
      "general": "Allgemein",
      "customization": "Anpassung",
      "files": "Dateien",
      "network": "Netzwerk",
      "streaming": "Streaming",
      "backup": "Sicherung",
      "authentication": "Authentifizierung",
      "webclient": "Web client"
    },
    "uploadCustomImage": {
      "title": "Benutzerdefiniertes Bild",
      "description": "Hier können Sie ein Bild hochladen, das den Benutzern angezeigt wird, wenn keine weiteren Tuner in der Wiedergabeliste verfügbar sind!"
    },
    "update": {
      "title": "Zeitplan für Updates (Wiedergabeliste, XMLTV, Sicherung)",
      "placeholder": "0000,1000,2000",
      "description": "Zeit im 24-Stunden-Format (0800 = 8:00 Uhr). Mehrere Zeiten können durch Kommas getrennt eingegeben werden. Lassen Sie dieses Feld leer, wenn keine Updates durchgeführt werden sollen."
    },
    "api": {
      "title": "API-Schnittstelle",
      "description": "Über die API-Schnittstelle können Befehle an Threadfin gesendet werden. API-Dokumentation ist <a href=\"https://github.com/marcelGoerentz/Threadfin/wiki/API\">hier</a>"
    },
    "ssdp": {
      "title": "SSDP",
      "description": "SSDP ist ein Netzwerkprotokoll zur Diensterkennung. Es wird zur automatischen Erkennung von Threadfin im Netzwerk verwendet."
    },
    "dummy": {
      "title": "Standard-Dummy-Daten aktivieren",
      "description": "Wenn aktiviert, werden inaktive Kanäle automatisch dem unten angegebenen Dummy-Kanal zugeordnet. Verwenden Sie dies, um Live-Event-Kanäle aktiv zu halten."
    },
    "dummyChannel": {
      "title": "Dummy-Kanal",
      "description": "Wählen Sie den Standardkanal aus, der verwendet werden soll, wenn inaktive Kanäle den Dummy-Daten zugeordnet werden."
    },
    "ignoreFilters": {
      "title": "Filter ignorieren",
      "description": "Wenn aktiviert, werden Filter vollständig ignoriert."
    },
    "epgSource": {
      "title": "EPG-Quelle",
      "description": "PMS:<br>- Verwenden Sie EPG-Daten von Plex, Emby oder Jellyfin <br><br>XEPG:<br>- Verwendung einer oder mehrerer XMLTV-Dateien<br>- Kanalverwaltung<br>- M3U / XMLTV-Export (HTTP-Link für IPTV-Apps)"
    },
    "tuner": {
      "title": "Anzahl der Tuner",
      "description": "Anzahl der parallelen Verbindungen, die zum Anbieter hergestellt werden können.<br>Verfügbar für: Plex, Emby, Jellyfin, M3U (mit aktivem Puffer).<br>Nach einer Änderung muss Threadfin in den DVR-Einstellungen von Plex / Emby / Jellyfin gelöscht und erneut eingerichtet werden."
    },
    "filesUpdate": {
      "title": "Aktualisiert alle Dateien beim Start",
      "description": "Aktualisiert alle Wiedergabelisten, Tuner und XMLTV-Dateien beim Start."
    },
    "cacheImages": {
      "title": "Bild-Caching",
      "description": "Diese Option schreibt die m3u-Datei in den lokalen Bild-Cache für TV-Logos um.<br>Alle Bilder aus der XMLTV-Datei werden zwischengespeichert, was eine schnellere Darstellung des Rasters im Client ermöglicht.<br>Das Herunterladen der Bilder kann eine Weile dauern und wird im Hintergrund durchgeführt.<br>"
    },
    "replaceEmptyImages": {
      "title": "Fehlende Programmbilder ersetzen",
      "description": "Wenn das Poster im XMLTV-Programm fehlt, wird das Kanallogo verwendet."
    },
    "replaceChannelTitle": {
      "title": "PPV-Kanaltitel/Beschreibung ersetzen",
      "description": "Verwenden Sie dies, wenn Ihr Anbieter den PPV-Ereignisnamen dem Kanalnamen zuordnet"
    },
    "ThreadfinAutoUpdate": {
      "title": "Automatisches Update von Threadfin",
      "description": "Wenn eine neue Version von Threadfin verfügbar ist, wird sie automatisch installiert. Die Updates werden von GitHub heruntergeladen."
    },
    "streamBuffering": {
      "title": "Stream-Puffer",
      "description": "Funktionen des Puffers:<br>- Der Stream wird von FFmpeg, VLC oder Threadfin an Plex, Emby, Jellyfin oder M3U Player weitergeleitet<br>- Kleine Ruckler der Streams können ausgeglichen werden<br>- HLS / M3U8-Unterstützung<br>- RTP / RTPS-Unterstützung<br>- Re-Streaming<br>- Separates Tuner-Limit für jede Wiedergabeliste",
      "info_false": "Kein Puffer (Client verbindet sich direkt mit dem Streaming-Server)",
      "info_ffmpeg": "FFmpeg verbindet sich mit dem Streaming-Server",
      "info_vlc": "VLC verbindet sich mit dem Streaming-Server",
      "info_threadfin": "Threadfin verbindet sich mit dem Streaming-Server"
    },
    "udpxy": {
      "title": "UDPxy-Adresse",
      "description": "Die Adresse Ihres UDPxy-Servers. Wenn gesetzt und die Kanal-URLs in der m3u Multicast sind, wird Threadfin sie so umschreiben, dass sie über den UDPxy-Dienst aufgerufen werden.",
      "placeholder": "host:port"
    },
    "ffmpegPath": {
      "title": "Pfad zur FFmpeg-Binärdatei",
      "description": "Pfad zur FFmpeg-Binärdatei.",
      "placeholder": "/path/to/ffmpeg"
    },
    "ffmpegOptions": {
      "title": "FFmpeg-Optionen",
      "description": "FFmpeg-Optionen.<br>Ändern Sie diese nur, wenn Sie wissen, was Sie tun.<br>Lassen Sie das Feld leer, um die Standardeinstellungen zu verwenden.",
      "placeholder": "Lassen Sie das Feld leer, um die Standardeinstellungen zu verwenden"
    },
    "vlcPath": {
      "title": "Pfad zur VLC / CVLC-Binärdatei",
      "description": "Pfad zur VLC / CVLC-Binärdatei.",
      "placeholder": "/path/to/cvlc"
    },
    "vlcOptions": {
      "title": "VLC / CVLC-Optionen",
      "description": "VLC / CVLC-Optionen.<br>Ändern Sie diese nur, wenn Sie wissen, was Sie tun.<br>Lassen Sie das Feld leer, um die Standardeinstellungen zu verwenden.",
      "placeholder": "Lassen Sie das Feld leer, um die Standardeinstellungen zu verwenden"
    },
    "bufferSize": {
      "title": "Puffergröße",
      "description": "Puffergröße in MB.<br>M3U8: Wenn das TS-Segment kleiner als die Puffergröße ist, wird die Dateigröße des Segments verwendet."
    },
    "storeBufferInRAM":
    {
      "title": "Puffer im RAM speichern",
      "description": "Wenn aktiviert, wird der Puffer im RAM anstelle auf der Festplatte gespeichert"
    },
    "autoReconnect":{
      "title": "Automatisch mit Stream neuverbinden",
      "description": "Wenn aktiviert, verbindet sich der Puffer automatisch wieder mit dem Stream"
    },
    "omitPorts":
    {
      "title": "Port weglassen",
      "description": "Durch Aktivieren dieses Kontrollkästchens wird die m3u-Datei keine Ports in der URL enthalten"
    },
    "bindingIPs" :
    {
      "title": "IP(s) binden",
      "description": "Durch Klicken auf das Eingabefeld öffnet sich ein Dialog, in dem Sie die IP(s) auswählen können<br>Bitte beachten Sie, dass dies auch die DVR-IPs sind<br>Das Ändern dieser Option und das Speichern der Einstellungen beendet das Programm!<br>Sie müssen es neu starten, wenn Sie keinen automatischen Neustart konfiguriert haben!"
    },
    "forceHttps":
    {
      "title": "HTTPS zum Upstream-Server erzwingen",
      "description": "Wenn dieses Kontrollkästchen aktiviert ist, wird Threadfin gezwungen, eine HTTPS-Verbindung zum Upstream-Server zu verwenden <br>Dies wird nicht empfohlen, da die angegebenen URLs in HTTPS-URLs umgeschrieben werden, was zu 404-HTTP-Fehlercodes führen kann</br>"
    },
    "useHttps":
    {
      "title": "HTTPS verwenden",
      "description": "HTTPS-Protokoll für Threadfin aktivieren, HTTPS-Port muss gesetzt werden, ansonsten wird 443 verwendet!<br>Stellen Sie außerdem sicher, dass server.crt und server.key im Konfigurationsordner abgelegt sind!<br>Die Schlüsseldatei muss unverschlüsselt sein!"
    },
    "forceClientHttps":
    {
      "title": "Client zur Verwendung von HTTPS zwingen",
      "description": "Alle URLs zu dieser Threadfin-Instanz beginnen mit HTTPS"
    },
    "threadfinDomain":
    {
      "title": "Threadfin-Domain",
      "description": "Wenn nicht leer, werden die URLs in der neuen m3u in einen FQDN umgeschrieben.<br>Es wird auch die angezeigte DVR-IP im Serverinfo-Dialog umschreiben.<br>Schließen Sie http nicht ein (z.B.: somedomain.com)</br>"
    },
    "enableNonAscii":
    {
      "title": "Nicht-ASCII aktivieren",
      "description": "Wenn aktiviert, werden spezielle Nicht-ASCII-Zeichen in der M3U und EPG erlaubt. Standardmäßig deaktiviert"
    },
    "epgCategories":
    {
      "title": "EPG-Kategorien",
      "description": "Passen Sie die EPG-Kategorien an. Das Format ist Schlüssel:Wert|Schlüssel:Wert, also Nachrichten:news|Sport:sports|Filme:movies"
    },
    "epgCategoriesColors":
    {
      "title": "EPG-Kategorien-Farben",
      "description": "Passen Sie die Farben der EPG-Kategorien an. Das Format ist Wert:farbe|Wert:farbe, also news:tomato|sports:yellowgreen|movies:royalblue"
    },
    "bufferTimeout": {
      "title": "Timeout für neue Client-Verbindungen",
      "description": "Der Threadfin-Puffer wartet, bis neue Client-Verbindungen hergestellt sind. Hilfreich für schnelles Umschalten der Kanäle. Wert in Millisekunden.",
      "placeholder": "100"
    },
    "userAgent": {
      "title": "User-Agent",
      "description": "User-Agent für HTTP-Anfragen. Für jede HTTP-Verbindung wird dieser Wert als User-Agent verwendet. Sollte nur geändert werden, wenn Threadfin blockiert wird.",
      "placeholder": "Threadfin"
    },
    "backupPath": {
      "title": "Speicherort für automatische Sicherungen",
      "placeholder": "/mnt/data/backup/threadfin/",
      "description": "Vor jedem Update der Anbieterdaten durch den Zeitplan erstellt Threadfin eine Sicherung. Der Pfad für die automatischen Sicherungen kann geändert werden. Threadfin benötigt Schreibberechtigung für diesen Ordner."
    },
    "tempPath": {
      "title": "Speicherort für temporäre Dateien",
      "placeholder": "/tmp/threadfin/",
      "description": "Speicherort für die Pufferdateien."
    },
    "backupKeep": {
      "title": "Anzahl der zu behaltenden Sicherungen",
      "description": "Anzahl der zu behaltenden Sicherungen. Ältere Sicherungen werden automatisch gelöscht."
    },
    "authenticationWEB": {
      "title": "WEB-Authentifizierung",
      "description": "Zugriff auf die Weboberfläche nur mit Anmeldeinformationen möglich."
    },
    "authenticationPMS": {
      "title": "PMS-Authentifizierung",
      "description": "Plex-Anfragen sind nur mit Authentifizierung möglich. <br><b>Warnung!!!</b> Nach Aktivierung dieser Funktion muss Threadfin in den DVR-Einstellungen von PMS gelöscht und erneut eingerichtet werden."
    },
    "authenticationM3U": {
      "title": "M3U-Authentifizierung",
      "description": "Das Herunterladen der threadfin.m3u-Datei über eine HTTP-Anfrage ist nur mit Authentifizierung möglich."
    },
    "authenticationXML": {
      "title": "XML-Authentifizierung",
      "description": "Das Herunterladen der threadfin.xml-Datei über eine HTTP-Anfrage ist nur mit Authentifizierung möglich"
    },
    "authenticationAPI": {
      "title": "API-Authentifizierung",
      "description": "Zugriff auf die API-Schnittstelle nur mit Authentifizierung möglich."
    },
    "webclient": {
      "language": {
        "title": "Web client Sprache",
        "description": "Ändern der Sprache des Web Clients"

      }
    }
  },
  "wizard": {
    "epgSource": {
      "title": "EPG-Quelle",
      "description": "PMS:<br>- Verwenden Sie EPG-Daten von Plex, Emby oder Jellyfin <br><br>XEPG:<br>- Verwendung einer oder mehrerer XMLTV-Dateien<br>- Kanalverwaltung<br>- M3U / XMLTV-Export (HTTP-Link für IPTV-Apps)"
    },
    "tuner": {
      "title": "Anzahl der Tuner",
      "description": "Anzahl der parallelen Verbindungen, die zum Anbieter hergestellt werden können.<br>Verfügbar für: Plex, Emby, Jellyfin, M3U (mit aktivem Puffer).<br>Nach einer Änderung muss Threadfin in den DVR-Einstellungen von Plex / Emby / Jellyfin gelöscht und erneut eingerichtet werden."
    },
    "m3u": {
      "title": "M3U-Wiedergabeliste",
      "placeholder": "Dateipfad oder URL der M3U",
      "description": "Lokale oder entfernte Wiedergabelisten"
    },
    "xmltv": {
      "title": "XMLTV-Datei",
      "placeholder": "Dateipfad oder URL der XMLTV",
      "description": "Lokale oder entfernte XMLTV-Datei"
    }
  },
  "login": {
    "failed": "Benutzerauthentifizierung fehlgeschlagen",
    "headline": "Anmelden",
    "username": {
      "title": "Benutzername",
      "placeholder": "Benutzername"
    },
    "password": {
      "title": "Passwort",
      "placeholder": "Passwort"
    }
  },
  "account": {
    "failed": "Passwort stimmt nicht überein",
    "headline": "Benutzerkonto erstellen",
    "username": {
      "title": "Benutzername",
      "placeholder": "Benutzername"
    },
    "password": {
      "title": "Passwort",
      "placeholder": "Passwort"
    },
    "confirm": {
      "title": "Bestätigen",
      "placeholder": "Bestätigen"
    }
  },
  "notification" : {
    "update": {
      "title": "Update verfügbar",
      "content": "Eine neuere Version von Threadfin ist verfügbare. Bitte auf die neuste Version aktualisieren."
    }
  },
  "serverInfo": {
    "title": "Server Informationen",
    "header": {
      "serverInfo": "Server Informationen",
      "streamInfo": "Stream Informationen",
      "changeVersion": "Wechsel Threadfin Version"
    },
    "label": {
      "version": "Threadfin Version",
      "errors": "Fehler",
      "warnings": "Warnungen",
      "dvr": "DVR IP",
      "m3uUrl": "M3U URL (Specifc groups: [http://...?group-title=foo,bar])",
      "xepgUrl": "XMLTV URL",
      "streams": "Gefilterte Kanäle",
      "xepg": "Zugeordnete Kanäle"
    },
    "changeVersion": {
      "changeToBeta": "Wechsel zur Beta Version",
      "changeToRelease": "Wechsel zur offiziellen Version",
      "changing": "Wechsel..."
    }
  }
}" - webUI["web/public/lang/en.json"] = "{
  "mainMenu": {
    "item": {
      "playlist": "Playlist",
      "pmsID": "PMS ID",
      "filter": "Filter",
      "xmltv": "XMLTV",
      "mapping": "Mapping",
      "users": "Users",
      "settings": "Settings",
      "log": "Log",
      "logout": "Logout"
    },
    "headline": {
      "playlist": "Local or remote playlists",
      "filter": "Filter playlist",
      "xmltv": "Local or remote XMLTV files",
      "mapping": "Map playlist channels to EPG channels",
      "users": "User management",
      "settings": "Settings",
      "log": "Log",
      "logout": "Logout"
    }
  },
  "confirm": {
    "restore": "All data will be replaced with those from the backup. Should the files be restored?"
  },
  "alert": {
    "fileLoadingError": "File could not be loaded",
    "invalidChannelNumber": "Invalid channel number",
    "missingInput": "Missing input"
  },
  "button": {
    "back": "Back",
    "backup": "Backup",
    "bulkEdit": "Bulk Edit",
    "cancel": "Cancel",
    "delete": "Delete",
    "done": "Done",
    "login": "Login",
    "new": "New",
    "next": "Next",
    "restore": "Restore",
    "save": "Save",
    "search": "Search",
    "update": "Update",
    "updating": "Updating...",
    "craeteAccount": "Create Account",
    "resetLogs": "Reset Logs",
    "uploadLogo": "Upload Logo",
    "uploadCustomImage": "Upload custom image",
    "sortChannelsAlpha": "Sort Channels Alphabetically",
    "sortChannelNumbers": "Sort Channels",
    "backToTop": "Go to top",
    "serverInformation": "Server Information"
  },
  "filter": {
    "table": {
      "name": "Filter Name",
      "type": "Filter Type",
      "filter": "Filter"
    },
    "custom": "Custom",
    "group": "Group",
    "name": {
      "title": "Filter Name",
      "placeholder": "Filter name",
      "description": ""
    },
    "startingnumber": {
      "title": "Filter Starting Number",
      "placeholder": "Filter Starting Number",
      "description": "Starting Channel Number to use for this Group Filter (Default is 1000)"
    },
    "category": {
      "title": "Filter Category",
      "placeholder": "Filter Category",
      "description": "Filter Category sets all channels in the filter to a specific category (news, sports, etc)"
    },
    "description": {
      "title": "Description",
      "placeholder": "Description",
      "description": ""
    },
    "type": {
      "title": "Type",
      "groupTitle": "Group Title",
      "customFilter": "Custom Filter"
    },
    "caseSensitive": {
      "title": "Case Sensitive",
      "placeholder": "",
      "description": ""
    },
    "filterRule": {
      "title": "Filter Rule",
      "placeholder": "Sport {HD} !{ES,IT}",
      "description": ""
    },
    "filterGroup": {
      "title": "Group Title",
      "placeholder": "",
      "description": "Select a M3U group. (Counter)<br>Changing the group title in the M3U invalidates the filter."
    },
    "include": {
      "title": "Include",
      "placeholder": "FHD,UHD",
      "description": "Channel name must include.<br>(Comma separated) Comma means or"
    },
    "exclude": {
      "title": "Exclude",
      "placeholder": "ES,IT",
      "description": "Channel name must not contain.<br>(Comma separated) Comma means or"
    }
  },
  "playlist": {
    "table": {
      "playlist": "Playlist",
      "tuner": "Tuner",
      "lastUpdate": "Last Update",
      "availability": "Availability",
      "type": "Type",
      "streams": "Streams",
      "groupTitle": "group-title",
      "tvgID": "tvg-id",
      "uniqueID": "Unique ID"
    },
    "playlistType": {
      "title": "Playlist type",
      "placeholder": "",
      "description": ""
    },
    "type": {
      "title": "Type",
      "placeholder": "",
      "description": ""
    },
    "name": {
      "title": "Name",
      "placeholder": "Playlist name",
      "description": ""
    },
    "description": {
      "title": "Description",
      "placeholder": "Description",
      "description": ""
    },
    "fileM3U": {
      "title": "M3U File",
      "placeholder": "File path or URL of the M3U",
      "description": ""
    },
    "fileHDHR": {
      "title": "HDHomeRun IP",
      "placeholder": "IP address and port (192.168.1.10:5004)",
      "description": ""
    },
    "tuner": {
      "title": "Tuner / Streams",
      "placeholder": "",
      "description": "Number of parallel connections that can be established to the provider. <br>Only available with activated buffer.<br>New settings will only be applied after quitting all streams."
    },
    "http_proxy_ip": {
      "title": "HTTP Proxy IP",
      "placeholder": "192.168.0.2",
      "description": "IP address to be used by HTTP Proxy"
    },
    "http_proxy_port": {
      "title": "HTTP Proxy Port",
      "placeholder": "8888",
      "description": "Port to be used by HTTP Proxy"
    }
  },
  "xmltv": {
    "table": {
      "guide": "Guide",
      "lastUpdate": "Last Update",
      "availability": "Availability",
      "channels": "Channels",
      "programs": "Programs"
    },
    "name": {
      "title": "Name",
      "placeholder": "Guide name",
      "description": ""
    },
    "description": {
      "title": "Description",
      "placeholder": "Description",
      "description": ""
    },
    "fileXMLTV": {
      "title": "XMLTV File",
      "placeholder": "File path or URL of the XMLTV",
      "description": ""
    },
    "http_proxy_ip": {
      "title": "HTTP Proxy IP",
      "placeholder": "192.168.0.2",
      "description": "IP address to be used by HTTP Proxy"
    },
    "http_proxy_port": {
      "title": "HTTP Proxy Port",
      "placeholder": "8888",
      "description": "Port to be used by HTTP Proxy"
    }
  },
  "mapping": {
    "table": {
      "chNo": "Ch. No.",
      "logo": "Logo",
      "channelName": "Channel Name",
      "playlist": "Playlist",
      "groupTitle": "Group Title",
      "xmltvFile": "XMLTV File",
      "xmltvID": "XMLTV ID"
    },
    "active": {
      "title": "Active",
      "placeholder": "",
      "description": ""
    },
    "channelName": {
      "title": "Channel Name",
      "placeholder": "",
      "description": ""
    },
    "channelGroupStart": {
      "title": "Channel Group Start",
      "placeholder": "",
      "description": ""
    },
    "sortChannelsAlpha": {
      "title": "Sort Alphabetically",
      "placeholder": "",
      "description": ""
    },
    "sortChannels": {
      "title": "Sort Channels",
      "placeholder": "",
      "description": ""
    },
    "description": {
      "title": "Channel Description",
      "placeholder": "Used by the Dummy as an XML description",
      "description": ""
    },
    "updateChannelName": {
      "title": "Update Channel Name",
      "placeholder": "",
      "description": ""
    },
    "channelLogo": {
      "title": "Logo URL",
      "placeholder": "",
      "description": ""
    },
    "updateChannelLogo": {
      "title": "Update Channel Logo",
      "placeholder": "",
      "description": ""
    },
    "epgCategory": {
      "title": "EPG Category",
      "placeholder": "",
      "description": ""
    },
    "m3uGroupTitle": {
      "title": "Group Title (threadfin.m3u)",
      "placeholder": "",
      "description": ""
    },
    "xmltvFile": {
      "title": "XMLTV File",
      "placeholder": "",
      "description": ""
    },
    "xmltvChannel": {
      "title": "XMLTV Channel",
      "placeholder": "",
      "description": ""
    },
    "ppvextra": {
      "title": "PPV Extra Title",
      "placeholder": "",
      "description": "This will add custom text to the Programme data"
    },
    "backupChannel1": {
      "title": "Backup Channel 1",
      "placeholder": "",
      "description": ""
    },
    "backupChannel2": {
      "title": "Backup Channel 2",
      "placeholder": "",
      "description": ""
    },
    "backupChannel3": {
      "title": "Backup Channel 3",
      "placeholder": "",
      "description": ""
    },
    "hideChannel": {
      "title": "Hide Backup Channel",
      "placeholder": "",
      "description": ""
    }
  },
  "users": {
    "table": {
      "username": "Username",
      "password": "Password",
      "web": "WEB",
      "pms": "PMS",
      "m3u": "M3U",
      "xml": "XML",
      "api": "API"
    },
    "username": {
      "title": "Username",
      "placeholder": "Username",
      "description": ""
    },
    "password": {
      "title": "Password",
      "placeholder": "Password",
      "description": ""
    },
    "confirm": {
      "title": "Confirm",
      "placeholder": "Password confirm",
      "description": ""
    },
    "web": {
      "title": "Web Access",
      "placeholder": "",
      "description": ""
    },
    "pms": {
      "title": "PMS Access",
      "placeholder": "",
      "description": ""
    },
    "m3u": {
      "title": "M3U Access",
      "placeholder": "",
      "description": ""
    },
    "xml": {
      "title": "XML Access",
      "placeholder": "",
      "description": ""
    },
    "api": {
      "title": "API Access",
      "placeholder": "",
      "description": ""
    }
  },
  "settings": {
    "category": {
      "general": "General",
      "customization": "Customization",
      "files": "Files",
      "network": "Network",
      "streaming": "Streaming",
      "backup": "Backup",
      "authentication": "Authentication",
      "webclient": "Web client"
    },
    "uploadCustomImage": {
      "title": "Custom Image",
      "description": "Here you can upload an image that will be shown to users when no more tuners are available in the playlist!"
    },
    "update": {
      "title": "Schedule for updating (Playlist, XMLTV, Backup)",
      "placeholder": "0000,1000,2000",
      "description": "Time in 24 hour format (0800 = 8:00 am). More times can be entered comma separated. Leave this field empty if no updates are to be carried out."
    },
    "api": {
      "title": "API Interface",
      "description": "Via API interface it is possible to send commands to Threadfin. API documentation is <a href=\"https://github.com/marcelGoerentz/Threadfin/wiki/API\">here</a>"
    },
    "ssdp": {
      "title": "SSDP",
      "description": "SSDP is a network protocol for service discovery. It is used for the automatic detection of Threadfin in the network."
    },
    "dummy": {
      "title": "Enable Default Dummy Data",
      "description": "When enabled, this will automatically map inactive channels to the dummy data channel below. Use this to keep Live Event channels active."
    },
    "dummyChannel": {
      "title": "Dummy Data Channel",
      "description": "Select the default channel to use when mapping inactive channels to the dummy data."
    },
    "ignoreFilters": {
      "title": "Ignore Filters",
      "description": "If checked, filtering is completely ignored."
    },
    "epgSource": {
      "title": "EPG Source",
      "description": "PMS:<br>- Use EPG data from Plex, Emby or Jellyfin <br><br>XEPG:<br>- Use of one or more XMLTV files<br>- Channel management<br>- M3U / XMLTV export (HTTP link for IPTV apps)"
    },
    "tuner": {
      "title": "Number of Tuners",
      "description": "Number of parallel connections that can be established to the provider.<br>Available for: Plex, Emby, Jellyfin, M3U (with active buffer).<br>After a change, Threadfin must be delete in the Plex / Emby / Jellyfin DVR settings and set up again."
    },
    "filesUpdate": {
      "title": "Updates all files at startup",
      "description": "Updates all playlists, tuner and XMLTV files at startup."
    },
    "cacheImages": {
      "title": "Image Caching",
      "description": "This option will rewrite the m3u file to local image cache for tv logos.<br>All images from the XMLTV file are cached, allowing faster rendering of the grid in the client.<br>Downloading the images may take a while and will be done in the background.<br>"
    },
    "replaceEmptyImages": {
      "title": "Replace missing program images",
      "description": "If the poster in the XMLTV program is missing, the channel logo will be used."
    },
    "replaceChannelTitle": {
      "title": "Replace PPV channels title/desc",
      "description": "Use this if your provider maps the PPV event name to the channel name"
    },
    "ThreadfinAutoUpdate": {
      "title": "Automatic update of Threadfin",
      "description": "If a new version of Threadfin is available, it will be automatically installed. The updates are downloaded from GitHub."
    },
    "streamBuffering": {
      "title": "Stream Buffer",
      "description": "Functions of the buffer:<br>- The stream is passed from FFmpeg, VLC or Threadfin to Plex, Emby, Jellyfin or M3U Player<br>- Small jerking of the streams can be compensated<br>- HLS / M3U8 support<br>- RTP / RTPS support<br>- Re-streaming<br>- Separate tuner limit for each playlist",
      "info_false": "No Buffer (Client connects directly to the streaming server)",
      "info_ffmpeg": "FFmpeg connects to the streaming server",
      "info_vlc": "VLC connects to the streaming server",
      "info_threadfin": "Threadfin connects to the streaming server"
    },
    "udpxy": {
      "title": "UDPxy address",
      "description": "The address of your UDPxy server. If set, and the channel URLs in the m3u is multicast, Threadfin will rewrite it so that it is accessed via the UDPxy service.",
      "placeholder": "host:port"
    },
    "ffmpegPath": {
      "title": "FFmpeg Binary Path",
      "description": "Path to FFmpeg binary.",
      "placeholder": "/path/to/ffmpeg"
    },
    "ffmpegOptions": {
      "title": "FFmpeg Options",
      "description": "FFmpeg options.<br>Only change if you know what you are doing.<br>Leave blank to set default settings.",
      "placeholder": "Leave blank to set default settings"
    },
    "vlcPath": {
      "title": "VLC / CVLC Binary Path",
      "description": "Path to VLC / CVLC binary.",
      "placeholder": "/path/to/cvlc"
    },
    "vlcOptions": {
      "title": "VLC / CVLC Options",
      "description": "VLC / CVLC options.<br>Only change if you know what you are doing.<br>Leave blank to set default settings.",
      "placeholder": "Leave blank to set default settings"
    },
    "bufferSize": {
      "title": "Buffer Size",
      "description": "Buffer size in MB.<br>M3U8: If the TS segment smaller then the buffer size, the file size of the segment is used."
    },
    "storeBufferInRAM":
    {
      "title": "Store buffer in RAM",
      "description": "If checked, write buffer to RAM instead of writing to disk"
    },
    "autoReconnect":{
      "title": "Automatic reconnect to stream",
      "description": "If checked, the buffer will automatically reconnect to stream"
    },
    "omitPorts":
    {
      "title": "Omit port",
      "description": "By activating this checkbox the m3u file will not contain the port in the url"
    },
    "bindingIPs" :
    {
      "title": "Binding IP(s)",
      "description": "By clicking on the input a dialogue will open where you can select the IP(s)<br>Please note that these are also the DVR IPs<br>Changing this option and saving the settings will exit the program!<br>You need to restart it if you did not configured an automatical restart!"
    },
    "forceHttps":
    {
      "title": "Force HTTPS to Upstream server",
      "description": "When this checkbox is activated Threadfin will be forced to use HTTPS connection to upstream server <br>This is not recommended as the given urls will be rewritten to https urls, this can lead to 404 HTTP Error Codes</br>"
    },
    "useHttps":
    {
      "title": "Use HTTPS",
      "description": "Enable HTTPS protocol for Threadfin, HTTPS Port needs to be set, otherwise the 443 will be used!<br>Also make sure that server.crt and server.key are placed in the config folder!<br>The key file needs to be unencrypted!"
    },
    "forceClientHttps":
    {
      "title": "Force client to use https",
      "description": "All URLs to this threadfin instance will be starting with https"
    },
    "threadfinDomain":
    {
      "title": "Threadfin Domain",
      "description": "When not empty, this will rewrite the URLs in the new m3u to a FQDN.<br>It will also rewrite the shown DVR IP in the server info dialogue.<br>Do NOT include http (ex: somedomain.com)</br>"
    },
    "enableNonAscii":
    {
      "title": "Enable Non-ASCII",
      "description": "If checked, will allow special non ascii characters in the M3U and EPG. Default is disabled"
    },
    "epgCategories":
    {
      "title": "EPG Categories",
      "description": "Customize the EPG Categories. The format is key:value|key:value, so News:news|Sports:sports|Movies:movies"
    },
    "epgCategoriesColors":
    {
      "title": "EPG Categories Colors",
      "description": "Customize the EPG Category colors. The format is value:color|value:color, so news:tomato|sports:yellowgreen|movies:royalblue"
    },
    "bufferTimeout": {
      "title": "Timeout for new client connections",
      "description": "The Threadfin buffer waits until new client connections are established. Helpful for fast channel switching. Value in milliseconds.",
      "placeholder": "100"
    },
    "userAgent": {
      "title": "User Agent",
      "description": "User Agent for HTTP requests. For every HTTP connection, this value is used for the user agent. Should only be changed if Threadfin is blocked.",
      "placeholder": "Threadfin"
    },
    "backupPath": {
      "title": "Location for automatic backups",
      "placeholder": "/mnt/data/backup/threadfin/",
      "description": "Before any update of the provider data by the schedule, Threadfin creates a backup. The path for the automatic backups can be changed. Threadfin requires write permission for this folder."
    },
    "tempPath": {
      "title": "Location for the temporary files",
      "placeholder": "/tmp/threadfin/",
      "description": "Location for the buffer files."
    },
    "backupKeep": {
      "title": "Number of backups to keep",
      "description": "Number of backups to keep. Older backups are automatically deleted."
    },
    "authenticationWEB": {
      "title": "WEB Authentication",
      "description": "Access to the web interface only possible with credentials."
    },
    "authenticationPMS": {
      "title": "PMS Authentication",
      "description": "Plex requests are only possible with authentication. <br><b>Warning!!!</b> After activating this function Threadfin must be delete in the PMS DVR settings and set up again."
    },
    "authenticationM3U": {
      "title": "M3U Authentication",
      "description": "Downloading the threadfin.m3u file via an HTTP request is only possible with authentication."
    },
    "authenticationXML": {
      "title": "XML Authentication",
      "description": "Downloading the threadfin.xml file via an HTTP request is only possible with authentication"
    },
    "authenticationAPI": {
      "title": "API Authentication",
      "description": "Access to the API interface is only possible with authentication."
    },
    "webclient": {
      "language": {
        "title": "Web client language",
        "description": "Change the language for the web client"

      }
    }
  },
  "wizard": {
    "epgSource": {
      "title": "EPG Source",
      "description": "PMS:<br>- Use EPG data from Plex, Emby or Jellyfin <br><br>XEPG:<br>- Use of one or more XMLTV files<br>- Channel management<br>- M3U / XMLTV export (HTTP link for IPTV apps)"
    },
    "tuner": {
      "title": "Number of tuners",
      "description": "Number of parallel connections that can be established to the provider.<br>Available for: Plex, Emby, Jellyfin, M3U (with active buffer).<br>After a change, Threadfin must be delete in the Plex / Emby / Jellyfin DVR settings and set up again."
    },
    "m3u": {
      "title": "M3U Playlist",
      "placeholder": "File path or URL of the M3U",
      "description": "Local or remote playlists"
    },
    "xmltv": {
      "title": "XMLTV File",
      "placeholder": "File path or URL of the XMLTV",
      "description": "Local or remote XMLTV file"
    }
  },
  "login": {
    "failed": "User authentication failed",
    "headline": "Login",
    "username": {
      "title": "Username",
      "placeholder": "Username"
    },
    "password": {
      "title": "Password",
      "placeholder": "Password"
    }
  },
  "account": {
    "failed": "Password does not match",
    "headline": "Create user account",
    "username": {
      "title": "Username",
      "placeholder": "Username"
    },
    "password": {
      "title": "Password",
      "placeholder": "Password"
    },
    "confirm": {
      "title": "Confirm",
      "placeholder": "Confirm"
    }
  },
  "notification": {
    "update": {
      "title": "Update available",
      "content": "A newer version of Threadfin is available. Please update to the latest version."
    }
  },
  "serverInfo": {
    "title": "Server Information",
    "header": {
      "serverInfo": "Server Information",
      "streamInfo": "Stream Information",
      "changeVersion": "Change Threadfin Version"
    },
    "label": {
      "version": "Threadfin Version",
      "errors": "Errors",
      "warnings": "Warnings",
      "dvr": "DVR IP",
      "m3uUrl": "M3U URL (Specifc groups: [http://...?group-title=foo,bar])",
      "xepgUrl": "XMLTV URL",
      "streams": "Filtered Channels",
      "xepg": "Mapped Channels"
    },
    "changeVersion": {
      "changeToBeta": "Change to beta version",
      "changeToRelease": "Change to release version",
      "changing": "Changing..."
    }
  }
}" + webUI["web/public/js/settings.js"] = "class SettingsCategory {
    constructor(headline, settingsKeys) {
        this.DocumentID = 'content_settings';
        this.Content = new PopupContent();
        this.headline = headline;
        this.settingsKeys = settingsKeys;
    }
    createSettingsCheckbox(settingsKey, title) {
        var setting = document.createElement('TR');
        var data = SERVER['settings'][settingsKey];
        var tdLeft = document.createElement('TD');
        tdLeft.innerHTML = title + ':';
        var tdRight = document.createElement('TD');
        var input = this.Content.createCheckbox(settingsKey);
        input.checked = data;
        input.setAttribute('onchange', 'javascript: this.className = "changed"');
        tdRight.appendChild(input);
        setting.appendChild(tdLeft);
        setting.appendChild(tdRight);
        return setting;
    }
    createTextInput(settingsKey, title, placeholder, setID = false) {
        var data = SERVER['settings'][settingsKey];
        var setting = document.createElement('TR');
        var tdLeft = document.createElement('TD');
        tdLeft.innerHTML = title + ':';
        var tdRight = document.createElement('TD');
        var input = this.Content.createInput('text', settingsKey, data.toString());
        input.setAttribute('placeholder', placeholder);
        input.setAttribute('onchange', 'javascript: this.className = "changed"');
        if (setID) {
            input.setAttribute('id', settingsKey);
        }
        tdRight.appendChild(input);
        setting.appendChild(tdLeft);
        setting.appendChild(tdRight);
        return setting;
    }
    createSelectInput(settingsKey, title, text, values) {
        var data = SERVER['settings'][settingsKey];
        var setting = document.createElement('TR');
        var tdLeft = document.createElement('TD');
        tdLeft.innerHTML = title + ':';
        var tdRight = document.createElement('TD');
        var select = this.Content.createSelect(text, values, data, settingsKey);
        select.setAttribute('onchange', 'javascript: this.className = "changed"');
        tdRight.appendChild(select);
        setting.appendChild(tdLeft);
        setting.appendChild(tdRight);
        return setting;
    }
    createCategoryHeadline(value) {
        var element = document.createElement('H4');
        element.innerHTML = value;
        return element;
    }
    createHR() {
        var element = document.createElement('HR');
        return element;
    }
    createSettings(settingsKey) {
        var setting = document.createElement('TR');
        switch (settingsKey) {
            // Text inputs
            case 'update':
                setting = this.createTextInput(settingsKey, '{{.settings.update.title}}', '{{.settings.update.placeholder}}');
                break;
            case 'backup.path':
                setting = this.createTextInput(settingsKey, '{{.settings.backupPath.title}}', '{{.settings.backupPath.placeholder}}');
                break;
            case 'temp.path':
                setting = this.createTextInput(settingsKey, '{{.settings.tempPath.title}}', '{{.settings.tmpPath.placeholder}}');
                break;
            case 'user.agent':
                setting = this.createTextInput(settingsKey, '{{.settings.userAgent.title}}', '{{.settings.userAgent.placeholder}}');
                break;
            case 'buffer.timeout':
                setting = this.createTextInput(settingsKey, '{{.settings.bufferTimeout.title}}', '{{.settings.bufferTimeout.placeholder}}');
                break;
            case 'buffer.terminationTimeout':
                setting = this.createTextInput(settingsKey, '{{.settings.bufferTerminationTimeout.title}}', '{{.settings.bufferTerminationTimeout.placeholder}}');
                break;
            case 'ffmpeg.path':
                setting = this.createTextInput(settingsKey, '{{.settings.ffmpegPath.title}}', '{{.settings.ffmpegPath.placeholder}}');
                break;
            case 'ffmpeg.options':
                setting = this.createTextInput(settingsKey, '{{.settings.ffmpegOptions.title}}', '{{.settings.ffmpegOptions.placeholder}}');
                break;
            case 'vlc.path':
                setting = this.createTextInput(settingsKey, '{{.settings.vlcPath.title}}', '{{.settings.vlcPath.placeholder}}');
                break;
            case 'vlc.options':
                setting = this.createTextInput(settingsKey, '{{.settings.vlcOptions.title}}', '{{.settings.vlcOptions.placeholder}}');
                break;
            case 'bindingIPs':
                setting = this.createTextInput(settingsKey, '{{.settings.bindingIPs.title}}', '{{.settings.bindingIPs.placeholder}}', true);
                const input = setting.querySelector('input[id=' + settingsKey + ']');
                if (null != input) {
                    input.addEventListener('click', () => {
                        showIPBindingDialogue();
                    });
                }
                break;
            case 'epgCategories':
                setting = this.createTextInput(settingsKey, '{{.settings.epgCategories.title}}', '{{.settings.epgCategories.placeholder}}');
                break;
            case 'epgCategoriesColors':
                setting = this.createTextInput(settingsKey, '{{.settings.epgCategoriesColors.title}}', '{{.settings.epgCategoriesColors.placeholder}}');
                break;
            case 'threadfinDomain':
                setting = this.createTextInput(settingsKey, '{{.settings.threadfinDomain.title}}', '{{.settings.threadfinDomain.placeholder}}');
                break;
            case 'udpxy':
                setting = this.createTextInput(settingsKey, '{{.settings.udpxy.title}}', '{{.settings.udpxy.placeholder}}');
                break;
            // Checkboxen
            case 'authentication.web':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.authenticationWEB.title}}');
                break;
            case 'authentication.pms':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.authenticationPMS.title}}');
                break;
            case 'authentication.m3u':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.authenticationM3U.title}}');
                break;
            case 'authentication.xml':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.authenticationXML.title}}');
                break;
            case 'authentication.api':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.authenticationAPI.title}}');
                break;
            case 'files.update':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.filesUpdate.title}}');
                break;
            case 'cache.images':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.cacheImages.title}}');
                break;
            case 'xepg.replace.missing.images':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.replaceEmptyImages.title}}');
                break;
            case 'xepg.replace.channel.title':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.replaceChannelTitle.title}}');
                break;
            case 'storeBufferInRAM':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.storeBufferInRAM.title}}');
                break;
            case 'buffer.autoReconnect':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.autoReconnect.title}}');
                break;
            case 'omitPorts':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.omitPorts.title}}');
                break;
            case 'forceHttps':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.forceHttps.title}}');
                break;
            case 'useHttps':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.useHttps.title}}');
                break;
            case 'forceClientHttps':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.forceClientHttps.title}}');
                break;
            case 'domainUseHttps':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.domainUseHttps.title}}');
                break;
            case 'enableNonAscii':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.enableNonAscii.title}}');
                break;
            case 'ThreadfinAutoUpdate':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.ThreadfinAutoUpdate.title}}');
                break;
            case 'ssdp':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.ssdp.title}}');
                break;
            case 'dummy':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.dummy.title}}');
                break;
            case 'ignoreFilters':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.ignoreFilters.title}}');
                break;
            case 'api':
                setting = this.createSettingsCheckbox(settingsKey, '{{.settings.api.title}}');
                break;
            // Select
            case 'dummyChannel':
                var title = '{{.settings.dummyChannel.title}}';
                var text = ['PPV', '30 Minutes', '60 Minutes', '90 Minutes', '120 Minutes', '180 Minutes', '240 Minutes', '360 Minutes'];
                var values = ['PPV', '30_Minutes', '60_Minutes', '90_Minutes', '120_Minutes', '180_Minutes', '240_Minutes', '360_Minutes'];
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            case 'tuner':
                var title = '{{.settings.tuner.title}}';
                var text = new Array();
                var values = new Array();
                for (var i = 1; i <= 100; i++) {
                    text.push(i);
                    values.push(i);
                }
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            case 'epgSource':
                var title = '{{.settings.epgSource.title}}';
                var text = ['PMS', 'XEPG'];
                var values = ['PMS', 'XEPG'];
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            case 'backup.keep':
                var title = '{{.settings.backupKeep.title}}';
                var text = ['5', '10', '20', '30', '40', '50'];
                var values = ['5', '10', '20', '30', '40', '50'];
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            case 'buffer.size.kb':
                var title = '{{.settings.bufferSize.title}}';
                var text = ['0.5 MB', '1 MB', '2 MB', '3 MB', '4 MB', '5 MB', '6 MB', '7 MB', '8 MB'];
                var values = ['512', '1024', '2048', '3072', '4096', '5120', '6144', '7168', '8192'];
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            case 'buffer':
                var title = '{{.settings.streamBuffering.title}}';
                var text = ['{{.settings.streamBuffering.info_false}}', 'FFmpeg: ({{.settings.streamBuffering.info_ffmpeg}})', 'VLC: ({{.settings.streamBuffering.info_vlc}})', 'Threadfin: ({{.settings.streamBuffering.info_threadfin}})'];
                var values = ['-', 'ffmpeg', 'vlc', 'threadfin'];
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            case 'webclient.language':
                var title = '{{.settings.webclient.language.title}}';
                var text = ['English', 'Deutsch'];
                var values = ['en', 'de'];
                setting = this.createSelectInput(settingsKey, title, text, values);
                break;
            // Button
            case 'uploadCustomImage':
                setting = document.createElement('TR');
                var tdLeft = document.createElement('TD');
                tdLeft.innerHTML = '{{.settings.uploadCustomImage.title}}' + ':';
                var tdRight = document.createElement('TD');
                var button = this.Content.createInput('button', 'upload', '{{.button.uploadCustomImage}}');
                button.setAttribute('onclick', 'javascript: uploadCustomImage();');
                tdRight.appendChild(button);
                setting.appendChild(tdLeft);
                setting.appendChild(tdRight);
                break;
        }
        return setting;
    }
    createDescription(settingsKey) {
        var description = document.createElement('TR');
        var text;
        switch (settingsKey) {
            case 'authentication.web':
                text = '{{.settings.authenticationWEB.description}}';
                break;
            case 'authentication.m3u':
                text = '{{.settings.authenticationM3U.description}}';
                break;
            case 'authentication.pms':
                text = '{{.settings.authenticationPMS.description}}';
                break;
            case 'authentication.xml':
                text = '{{.settings.authenticationXML.description}}';
                break;
            case 'authentication.api':
                if (SERVER['settings']['authentication.web'] == true) {
                    text = '{{.settings.authenticationAPI.description}}';
                }
                break;
            case 'uploadCustomImage':
                text = '{{.settings.uploadCustomImage.description}}';
                break;
            case 'ThreadfinAutoUpdate':
                text = '{{.settings.ThreadfinAutoUpdate.description}}';
                break;
            case 'bindingIPs':
                text = '{{.settings.bindingIPs.description}}';
                break;
            case 'backup.keep':
                text = '{{.settings.backupKeep.description}}';
                break;
            case 'backup.path':
                text = '{{.settings.backupPath.description}}';
                break;
            case 'temp.path':
                text = '{{.settings.tempPath.description}}';
                break;
            case 'buffer':
                text = '{{.settings.streamBuffering.description}}';
                break;
            case 'buffer.size.kb':
                text = '{{.settings.bufferSize.description}}';
                break;
            case 'buffer.terminationTimeout':
                text = '{{.settings.bufferTerminationTimeout.description}}';
                break;
            case 'buffer.autoReconnect':
                text = '{{.settings.autoReconnect.description}}';
                break;
            case 'storeBufferInRAM':
                text = '{{.settings.storeBufferInRAM.description}}';
                break;
            case 'omitPorts':
                text = '{{.settings.omitPorts.description}}';
                break;
            case 'forceHttps':
                text = '{{.settings.forceHttps.description}}';
                break;
            case 'useHttps':
                text = '{{.settings.useHttps.description}}';
                break;
            case 'forceClientHttps':
                text = '{{.settings.forceClientHttps.description}}';
                break;
            case 'threadfinDomain':
                text = '{{.settings.threadfinDomain.description}}';
                break;
            case 'enableNonAscii':
                text = '{{.settings.enableNonAscii.description}}';
                break;
            case 'epgCategories':
                text = '{{.settings.epgCategories.description}}';
                break;
            case 'epgCategoriesColors':
                text = '{{.settings.epgCategoriesColors.description}}';
                break;
            case 'buffer.timeout':
                text = '{{.settings.bufferTimeout.description}}';
                break;
            case 'user.agent':
                text = '{{.settings.userAgent.description}}';
                break;
            case 'ffmpeg.path':
                text = '{{.settings.ffmpegPath.description}}';
                break;
            case 'ffmpeg.options':
                text = '{{.settings.ffmpegOptions.description}}';
                break;
            case 'vlc.path':
                text = '{{.settings.vlcPath.description}}';
                break;
            case 'vlc.options':
                text = '{{.settings.vlcOptions.description}}';
                break;
            case 'epgSource':
                text = '{{.settings.epgSource.description}}';
                break;
            case 'tuner':
                text = '{{.settings.tuner.description}}';
                break;
            case 'update':
                text = '{{.settings.update.description}}';
                break;
            case 'api':
                text = '{{.settings.api.description}}';
                break;
            case 'ssdp':
                text = '{{.settings.ssdp.description}}';
                break;
            case 'files.update':
                text = '{{.settings.filesUpdate.description}}';
                break;
            case 'cache.images':
                text = '{{.settings.cacheImages.description}}';
                break;
            case 'xepg.replace.missing.images':
                text = '{{.settings.replaceEmptyImages.description}}';
                break;
            case 'xepg.replace.channel.title':
                text = '{{.settings.replaceChannelTitle.description}}';
                break;
            case 'udpxy':
                text = '{{.settings.udpxy.description}}';
                break;
            case 'webclient.language':
                text = '{{.settings.webclient.language.description}}';
                break;
            default:
                text = '';
                break;
        }
        var tdLeft = document.createElement('TD');
        tdLeft.innerHTML = '';
        var tdRight = document.createElement('TD');
        var pre = document.createElement('PRE');
        pre.innerHTML = text;
        tdRight.appendChild(pre);
        description.appendChild(tdLeft);
        description.appendChild(tdRight);
        return description;
    }
}
class SettingsCategoryItem extends SettingsCategory {
    constructor(headline, settingsKeys) {
        super(headline, settingsKeys);
    }
    createCategory() {
        var doc = document.getElementById(this.DocumentID);
        doc.appendChild(this.createCategoryHeadline(this.headline));
        // Tabelle für die Kategorie erstellen
        var table = document.createElement('TABLE');
        var keys = this.settingsKeys.split(',');
        keys.forEach(settingsKey => {
            switch (settingsKey) {
                case 'authentication.pms':
                case 'authentication.m3u':
                case 'authentication.xml':
                case 'authentication.api':
                    if (SERVER['settings']['authentication.web'] == false) {
                        break;
                    }
                default:
                    var item = this.createSettings(settingsKey);
                    var description = this.createDescription(settingsKey);
                    table.appendChild(item);
                    table.appendChild(description);
                    break;
            }
        });
        doc.appendChild(table);
        doc.appendChild(this.createHR());
    }
}
function showSettings() {
    console.log('SETTINGS');
    for (let i = 0; i < settingsCategory.length; i++) {
        settingsCategory[i].createCategory();
    }
}
function saveSettings() {
    console.log('Save Settings');
    var cmd = 'saveSettings';
    var div = document.getElementById('content_settings');
    var settings = div.getElementsByClassName('changed');
    var newSettings = new Object();
    for (let i = 0; i < settings.length; i++) {
        var name;
        var value;
        switch (settings[i].tagName) {
            case 'INPUT':
                switch (settings[i].type) {
                    case 'checkbox':
                        name = settings[i].name;
                        value = settings[i].checked;
                        newSettings[name] = value;
                        switch (name) {
                            case 'useHttps':
                                setTimeout(() => {
                                    if (value) {
                                        location.protocol = 'https';
                                    }
                                    else {
                                        location.protocol = 'http';
                                    }
                                    location.reload();
                                }, 3000);
                        }
                        break;
                    case 'text':
                        name = settings[i].name;
                        value = settings[i].value;
                        switch (name) {
                            case 'update':
                                value = value.split(',');
                                value = value.filter(function (e) { return e; });
                                break;
                            case 'buffer.timeout':
                            case 'buffer.terminationTimeout':
                                value = parseFloat(value);
                            case 'bindingIPs':
                                setTimeout(() => {
                                    let isLocalhost = false;
                                    let hostname = String(location.hostname);
                                    const newValue = value;
                                    if (hostname === 'localhost') {
                                        hostname = '127.0.0.1';
                                    }
                                    if (!newValue.includes(hostname)) {
                                        const newHostname = newValue.split(';')[0];
                                        if (newHostname === '127.0.0.1') {
                                            location.href = location.href.replace(hostname, 'localhost');
                                        }
                                        else {
                                            location.href = location.href.replace(hostname, newHostname);
                                        }
                                    }
                                    location.reload();
                                }, 3000);
                        }
                        newSettings[name] = value;
                        break;
                }
                break;
            case 'SELECT':
                name = settings[i].name;
                value = settings[i].value;
                // Wenn der Wert eine Zahl ist, wird dieser als Zahl gespeichert
                if (isNaN(value)) {
                    newSettings[name] = value;
                }
                else {
                    newSettings[name] = parseInt(value);
                }
                if (name === 'webclient.language') {
                    setTimeout(() => {
                        location.reload();
                    }, 3000);
                }
                break;
        }
    }
    var data = new Object();
    data['settings'] = newSettings;
    var server = new Server(cmd);
    server.request(data);
}
function uploadCustomImage() {
    if (document.getElementById('upload')) {
        document.getElementById('upload').remove();
    }
    var upload = document.createElement('INPUT');
    upload.setAttribute('type', 'file');
    upload.setAttribute('accept', '.jpg,.png');
    upload.setAttribute('class', 'notVisible');
    upload.setAttribute('name', '');
    upload.id = 'upload';
    document.body.appendChild(upload);
    upload.click();
    upload.onblur = function () {
        alert();
    };
    upload.onchange = function () {
        var filename = upload.files[0].name;
        var reader = new FileReader();
        var file = document.querySelector('input[type=file]').files[0];
        if (file) {
            reader.readAsDataURL(file);
            reader.onload = function () {
                console.log(reader.result);
                var data = new Object();
                var cmd = 'uploadCustomImage';
                data['base64'] = reader.result;
                data['filename'] = file.name;
                var server = new Server(cmd);
                server.request(data);
                var updateLogo = document.getElementById('update-icon');
                updateLogo.checked = false;
                updateLogo.className = 'changed';
            };
        }
        else {
            alert('File could not be loaded');
        }
        upload.remove();
        return;
    };
}
//# sourceMappingURL=settings.js.map" + webUI["web/public/js/settings.js.map"] = "{"version":3,"file":"settings.js","sourceRoot":"","sources":["../../src/ts/settings.ts"],"names":[],"mappings":"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"}" + webUI["web/public/js/version_check.js"] = "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" + webUI["web/public/js/version_check.js.map"] = "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" + webUI["web/public/lang/de.json"] = "{
  "mainMenu": {
    "item": {
      "playlist": "Wiedergabeliste",
      "pmsID": "PMS ID",
      "filter": "Filter",
      "xmltv": "XMLTV",
      "mapping": "Zuordnung",
      "users": "Benutzer",
      "settings": "Einstellungen",
      "log": "Protokoll",
      "logout": "Abmelden"
    },
    "headline": {
      "playlist": "Lokale oder entfernte Wiedergabelisten",
      "filter": "Wiedergabeliste filtern",
      "xmltv": "Lokale oder entfernte XMLTV-Dateien",
      "mapping": "Zuordnung der Wiedergabelistenkanäle zu EPG-Kanälen",
      "users": "Benutzerverwaltung",
      "settings": "Einstellungen",
      "log": "Protokoll",
      "logout": "Abmelden"
    }
  },
  "confirm": {
    "restore": "Alle Daten werden durch die aus dem Backup ersetzt. Sollen die Dateien wiederhergestellt werden?"
  },
  "alert": {
    "fileLoadingError": "Datei konnte nicht geladen werden",
    "invalidChannelNumber": "Ungültige Kanalnummer",
    "missingInput": "Fehlende Eingabe"
  },
  "button": {
    "back": "Zurück",
    "backup": "Backup",
    "bulkEdit": "Massenbearbeitung",
    "cancel": "Abbrechen",
    "delete": "Löschen",
    "done": "Fertig",
    "login": "Anmelden",
    "new": "Neu",
    "next": "Weiter",
    "restore": "Wiederherstellen",
    "save": "Speichern",
    "search": "Suchen",
    "update": "Aktualisieren",
    "updating": "Aktualisiere...",
    "craeteAccount": "Konto erstellen",
    "resetLogs": "Protokolle zurücksetzen",
    "uploadLogo": "Logo hochladen",
    "uploadCustomImage": "Benutzerdefiniertes Bild hochladen",
    "sortChannelsAlpha": "Kanäle alphabetisch sortieren",
    "sortChannelNumbers": "Kanäle sortieren",
    "backToTop": "Gehe nach oben",
    "serverInformation": "Server Informationen"
  },
  "filter": {
    "table": {
      "name": "Filtername",
      "type": "Filtertyp",
      "filter": "Filter"
    },
    "custom": "Benutzerdefiniert",
    "group": "Gruppe",
    "name": {
      "title": "Filtername",
      "placeholder": "Filtername",
      "description": ""
    },
    "startingnumber": {
      "title": "Filter-Startnummer",
      "placeholder": "Filter-Startnummer",
      "description": "Startkanalnummer für diesen Gruppenfilter (Standard ist 1000)"
    },
    "category": {
      "title": "Filterkategorie",
      "placeholder": "Filterkategorie",
      "description": "Filterkategorie setzt alle Kanäle im Filter auf eine bestimmte Kategorie (Nachrichten, Sport usw.)"
    },
    "description": {
      "title": "Beschreibung",
      "placeholder": "Beschreibung",
      "description": ""
    },
    "type": {
      "title": "Typ",
      "groupTitle": "Gruppentitel",
      "customFilter": "Benutzerdefinierter Filter"
    },
    "caseSensitive": {
      "title": "Groß-/Kleinschreibung beachten",
      "placeholder": "",
      "description": ""
    },
    "filterRule": {
      "title": "Filterregel",
      "placeholder": "Sport {HD} !{ES,IT}",
      "description": ""
    },
    "filterGroup": {
      "title": "Gruppentitel",
      "placeholder": "",
      "description": "Wählen Sie eine M3U-Gruppe. (Zähler)<br>Das Ändern des Gruppentitels in der M3U macht den Filter ungültig."
    },
    "include": {
      "title": "Einschließen",
      "placeholder": "FHD,UHD",
      "description": "Kanalname muss enthalten.<br>(Kommagetrennt) Komma bedeutet oder"
    },
    "exclude": {
      "title": "Ausschließen",
      "placeholder": "ES,IT",
      "description": "Kanalname darf nicht enthalten.<br>(Kommagetrennt) Komma bedeutet oder"
    }
  },
  "playlist": {
    "table": {
      "playlist": "Wiedergabeliste",
      "tuner": "Tuner",
      "lastUpdate": "Letzte Aktualisierung",
      "availability": "Verfügbarkeit",
      "type": "Typ",
      "streams": "Streams",
      "groupTitle": "Gruppentitel",
      "tvgID": "tvg-id",
      "uniqueID": "Eindeutige ID"
    },
    "playlistType": {
      "title": "Wiedergabelistentyp",
      "placeholder": "",
      "description": ""
    },
    "type": {
      "title": "Typ",
      "placeholder": "",
      "description": ""
    },
    "name": {
      "title": "Name",
      "placeholder": "Wiedergabelistenname",
      "description": ""
    },
    "description": {
      "title": "Beschreibung",
      "placeholder": "Beschreibung",
      "description": ""
    },
    "fileM3U": {
      "title": "M3U-Datei",
      "placeholder": "Dateipfad oder URL der M3U",
      "description": ""
    },
    "fileHDHR": {
      "title": "HDHomeRun IP",
      "placeholder": "IP-Adresse und Port (192.168.1.10:5004)",
      "description": ""
    },
    "tuner": {
      "title": "Tuner / Streams",
      "placeholder": "",
      "description": "Anzahl der parallelen Verbindungen, die zum Anbieter hergestellt werden können. <br>Nur verfügbar mit aktiviertem Puffer.<br>Neue Einstellungen werden erst nach Beenden aller Streams angewendet."
    },
    "http_proxy_ip": {
      "title": "HTTP-Proxy-IP",
      "placeholder": "192.168.0.2",
      "description": "IP-Adresse, die vom HTTP-Proxy verwendet werden soll"
    },
    "http_proxy_port": {
      "title": "HTTP-Proxy-Port",
      "placeholder": "8888",
      "description": "Port, der vom HTTP-Proxy verwendet werden soll"
    }
  },
  "xmltv": {
    "table": {
      "guide": "Guide",
      "lastUpdate": "Letzte Aktualisierung",
      "availability": "Verfügbarkeit",
      "channels": "Kanäle",
      "programs": "Programme"
    },
    "name": {
      "title": "Name",
      "placeholder": "Guidename",
      "description": ""
    },
    "description": {
      "title": "Beschreibung",
      "placeholder": "Beschreibung",
      "description": ""
    },
    "fileXMLTV": {
      "title": "XMLTV-Datei",
      "placeholder": "Dateipfad oder URL der XMLTV",
      "description": ""
    },
    "http_proxy_ip": {
      "title": "HTTP-Proxy-IP",
      "placeholder": "192.168.0.2",
      "description": "IP-Adresse, die vom HTTP-Proxy verwendet werden soll"
    },
    "http_proxy_port": {
      "title": "HTTP-Proxy-Port",
      "placeholder": "8888",
      "description": "Port, der vom HTTP-Proxy verwendet werden soll"
    }
  },
  "mapping": {
    "table": {
      "chNo": "Kanalnr.",
      "logo": "Logo",
      "channelName": "Kanalname",
      "playlist": "Wiedergabeliste",
      "groupTitle": "Gruppentitel",
      "xmltvFile": "XMLTV-Datei",
      "xmltvID": "XMLTV-ID"
    },
    "active": {
      "title": "Aktiv",
      "placeholder": "",
      "description": ""
    },
    "channelName": {
      "title": "Kanalname",
      "placeholder": "",
      "description": ""
    },
    "channelGroupStart": {
      "title": "Kanalgruppenstart",
      "placeholder": "",
      "description": ""
    },
    "sortChannelsAlpha": {
      "title": "Alphabetisch sortieren",
      "placeholder": "",
      "description": ""
    },
    "sortChannels": {
      "title": "Kanäle sortieren",
      "placeholder": "",
      "description": ""
    },
    "description": {
      "title": "Kanalbeschreibung",
      "placeholder": "Wird vom Dummy als XML-Beschreibung verwendet",
      "description": ""
    },
    "updateChannelName": {
      "title": "Kanalname aktualisieren",
      "placeholder": "",
      "description": ""
    },
    "channelLogo": {
      "title": "Logo-URL",
      "placeholder": "",
      "description": ""
    },
    "updateChannelLogo": {
      "title": "Kanal-Logo aktualisieren",
      "placeholder": "",
      "description": ""
    },
    "epgCategory": {
      "title": "EPG-Kategorie",
      "placeholder": "",
      "description": ""
    },
    "m3uGroupTitle": {
      "title": "Gruppentitel (threadfin.m3u)",
      "placeholder": "",
      "description": ""
    },
    "xmltvFile": {
      "title": "XMLTV-Datei",
      "placeholder": "",
      "description": ""
    },
    "xmltvChannel": {
      "title": "XMLTV-Kanal",
      "placeholder": "",
      "description": ""
    },
    "ppvextra": {
      "title": "PPV-Zusatztitel",
      "placeholder": "",
      "description": "Dies fügt dem Programmdaten benutzerdefinierten Text hinzu"
    },
    "backupChannel1": {
      "title": "Backup-Kanal 1",
      "placeholder": "",
      "description": ""
    },
    "backupChannel2": {
      "title": "Backup-Kanal 2",
      "placeholder": "",
      "description": ""
    },
    "backupChannel3": {
      "title": "Backup-Kanal 3",
      "placeholder": "",
      "description": ""
    },
    "hideChannel": {
      "title": "Backup-Kanal ausblenden",
      "placeholder": "",
      "description": ""
    }
  },
  "users": {
    "table": {
      "username": "Benutzername",
      "password": "Passwort",
      "web": "WEB",
      "pms": "PMS",
      "m3u": "M3U",
      "xml": "XML",
      "api": "API"
    },
    "username": {
      "title": "Benutzername",
      "placeholder": "Benutzername",
      "description": ""
    },
    "password": {
      "title": "Passwort",
      "placeholder": "Passwort",
      "description": ""
    },
    "confirm": {
      "title": "Bestätigen",
      "placeholder": "Passwort bestätigen",
      "description": ""
    },
    "web": {
      "title": "Web-Zugang",
      "placeholder": "",
      "description": ""
    },
    "pms": {
      "title": "PMS-Zugang",
      "placeholder": "",
      "description": ""
    },
    "m3u": {
      "title": "M3U-Zugang",
      "placeholder": "",
      "description": ""
    },
    "xml": {
      "title": "XML-Zugang",
      "placeholder": "",
      "description": ""
    },
    "api": {
      "title": "API-Zugang",
      "placeholder": "",
      "description": ""
    }
  },
  "settings": {
    "category": {
      "general": "Allgemein",
      "customization": "Anpassung",
      "files": "Dateien",
      "network": "Netzwerk",
      "streaming": "Streaming",
      "backup": "Sicherung",
      "authentication": "Authentifizierung",
      "webclient": "Web client"
    },
    "uploadCustomImage": {
      "title": "Benutzerdefiniertes Bild",
      "description": "Hier können Sie ein Bild hochladen, das den Benutzern angezeigt wird, wenn keine weiteren Tuner in der Wiedergabeliste verfügbar sind!"
    },
    "update": {
      "title": "Zeitplan für Updates (Wiedergabeliste, XMLTV, Sicherung)",
      "placeholder": "0000,1000,2000",
      "description": "Zeit im 24-Stunden-Format (0800 = 8:00 Uhr). Mehrere Zeiten können durch Kommas getrennt eingegeben werden. Lassen Sie dieses Feld leer, wenn keine Updates durchgeführt werden sollen."
    },
    "api": {
      "title": "API-Schnittstelle",
      "description": "Über die API-Schnittstelle können Befehle an Threadfin gesendet werden. API-Dokumentation ist <a href=\"https://github.com/marcelGoerentz/Threadfin/wiki/API\">hier</a>"
    },
    "ssdp": {
      "title": "SSDP",
      "description": "SSDP ist ein Netzwerkprotokoll zur Diensterkennung. Es wird zur automatischen Erkennung von Threadfin im Netzwerk verwendet."
    },
    "dummy": {
      "title": "Standard-Dummy-Daten aktivieren",
      "description": "Wenn aktiviert, werden inaktive Kanäle automatisch dem unten angegebenen Dummy-Kanal zugeordnet. Verwenden Sie dies, um Live-Event-Kanäle aktiv zu halten."
    },
    "dummyChannel": {
      "title": "Dummy-Kanal",
      "description": "Wählen Sie den Standardkanal aus, der verwendet werden soll, wenn inaktive Kanäle den Dummy-Daten zugeordnet werden."
    },
    "ignoreFilters": {
      "title": "Filter ignorieren",
      "description": "Wenn aktiviert, werden Filter vollständig ignoriert."
    },
    "epgSource": {
      "title": "EPG-Quelle",
      "description": "PMS:<br>- Verwenden Sie EPG-Daten von Plex, Emby oder Jellyfin <br><br>XEPG:<br>- Verwendung einer oder mehrerer XMLTV-Dateien<br>- Kanalverwaltung<br>- M3U / XMLTV-Export (HTTP-Link für IPTV-Apps)"
    },
    "tuner": {
      "title": "Anzahl der Tuner",
      "description": "Anzahl der parallelen Verbindungen, die zum Anbieter hergestellt werden können.<br>Verfügbar für: Plex, Emby, Jellyfin, M3U (mit aktivem Puffer).<br>Nach einer Änderung muss Threadfin in den DVR-Einstellungen von Plex / Emby / Jellyfin gelöscht und erneut eingerichtet werden."
    },
    "filesUpdate": {
      "title": "Aktualisiert alle Dateien beim Start",
      "description": "Aktualisiert alle Wiedergabelisten, Tuner und XMLTV-Dateien beim Start."
    },
    "cacheImages": {
      "title": "Bild-Caching",
      "description": "Diese Option schreibt die m3u-Datei in den lokalen Bild-Cache für TV-Logos um.<br>Alle Bilder aus der XMLTV-Datei werden zwischengespeichert, was eine schnellere Darstellung des Rasters im Client ermöglicht.<br>Das Herunterladen der Bilder kann eine Weile dauern und wird im Hintergrund durchgeführt.<br>"
    },
    "replaceEmptyImages": {
      "title": "Fehlende Programmbilder ersetzen",
      "description": "Wenn das Poster im XMLTV-Programm fehlt, wird das Kanallogo verwendet."
    },
    "replaceChannelTitle": {
      "title": "PPV-Kanaltitel/Beschreibung ersetzen",
      "description": "Verwenden Sie dies, wenn Ihr Anbieter den PPV-Ereignisnamen dem Kanalnamen zuordnet"
    },
    "ThreadfinAutoUpdate": {
      "title": "Automatisches Update von Threadfin",
      "description": "Wenn eine neue Version von Threadfin verfügbar ist, wird sie automatisch installiert. Die Updates werden von GitHub heruntergeladen."
    },
    "streamBuffering": {
      "title": "Stream-Puffer",
      "description": "Funktionen des Puffers:<br>- Der Stream wird von FFmpeg, VLC oder Threadfin an Plex, Emby, Jellyfin oder M3U Player weitergeleitet<br>- Kleine Ruckler der Streams können ausgeglichen werden<br>- HLS / M3U8-Unterstützung<br>- RTP / RTPS-Unterstützung<br>- Re-Streaming<br>- Separates Tuner-Limit für jede Wiedergabeliste",
      "info_false": "Kein Puffer (Client verbindet sich direkt mit dem Streaming-Server)",
      "info_ffmpeg": "FFmpeg verbindet sich mit dem Streaming-Server",
      "info_vlc": "VLC verbindet sich mit dem Streaming-Server",
      "info_threadfin": "Threadfin verbindet sich mit dem Streaming-Server"
    },
    "udpxy": {
      "title": "UDPxy-Adresse",
      "description": "Die Adresse Ihres UDPxy-Servers. Wenn gesetzt und die Kanal-URLs in der m3u Multicast sind, wird Threadfin sie so umschreiben, dass sie über den UDPxy-Dienst aufgerufen werden.",
      "placeholder": "host:port"
    },
    "ffmpegPath": {
      "title": "Pfad zur FFmpeg-Binärdatei",
      "description": "Pfad zur FFmpeg-Binärdatei.",
      "placeholder": "/path/to/ffmpeg"
    },
    "ffmpegOptions": {
      "title": "FFmpeg-Optionen",
      "description": "FFmpeg-Optionen.<br>Ändern Sie diese nur, wenn Sie wissen, was Sie tun.<br>Lassen Sie das Feld leer, um die Standardeinstellungen zu verwenden.",
      "placeholder": "Lassen Sie das Feld leer, um die Standardeinstellungen zu verwenden"
    },
    "vlcPath": {
      "title": "Pfad zur VLC / CVLC-Binärdatei",
      "description": "Pfad zur VLC / CVLC-Binärdatei.",
      "placeholder": "/path/to/cvlc"
    },
    "vlcOptions": {
      "title": "VLC / CVLC-Optionen",
      "description": "VLC / CVLC-Optionen.<br>Ändern Sie diese nur, wenn Sie wissen, was Sie tun.<br>Lassen Sie das Feld leer, um die Standardeinstellungen zu verwenden.",
      "placeholder": "Lassen Sie das Feld leer, um die Standardeinstellungen zu verwenden"
    },
    "bufferSize": {
      "title": "Puffergröße",
      "description": "Puffergröße in MB.<br>M3U8: Wenn das TS-Segment kleiner als die Puffergröße ist, wird die Dateigröße des Segments verwendet."
    },
    "bufferTerminationTimeout": {
      "title": "Puffer-Schließ-Timeout",
      "description": "Zeit in Sekunden, die der Puffer nach dem Verlassen des letzten Clients aktiv bleibt",
      "placeholder": "Zeit in Sekunden"
    },
    "storeBufferInRAM":
    {
      "title": "Puffer im RAM speichern",
      "description": "Wenn aktiviert, wird der Puffer im RAM anstelle auf der Festplatte gespeichert"
    },
    "autoReconnect":{
      "title": "Automatisch mit Stream neuverbinden",
      "description": "Wenn aktiviert, verbindet sich der Puffer automatisch wieder mit dem Stream"
    },
    "omitPorts":
    {
      "title": "Port weglassen",
      "description": "Durch Aktivieren dieses Kontrollkästchens wird die m3u-Datei keine Ports in der URL enthalten"
    },
    "bindingIPs" :
    {
      "title": "IP(s) binden",
      "description": "Durch Klicken auf das Eingabefeld öffnet sich ein Dialog, in dem Sie die IP(s) auswählen können<br>Bitte beachten Sie, dass dies auch die DVR-IPs sind<br>Das Ändern dieser Option und das Speichern der Einstellungen beendet das Programm!<br>Sie müssen es neu starten, wenn Sie keinen automatischen Neustart konfiguriert haben!"
    },
    "forceHttps":
    {
      "title": "HTTPS zum Upstream-Server erzwingen",
      "description": "Wenn dieses Kontrollkästchen aktiviert ist, wird Threadfin gezwungen, eine HTTPS-Verbindung zum Upstream-Server zu verwenden <br>Dies wird nicht empfohlen, da die angegebenen URLs in HTTPS-URLs umgeschrieben werden, was zu 404-HTTP-Fehlercodes führen kann</br>"
    },
    "useHttps":
    {
      "title": "HTTPS verwenden",
      "description": "HTTPS-Protokoll für Threadfin aktivieren, HTTPS-Port muss gesetzt werden, ansonsten wird 443 verwendet!<br>Stellen Sie außerdem sicher, dass server.crt und server.key im Konfigurationsordner abgelegt sind!<br>Die Schlüsseldatei muss unverschlüsselt sein!"
    },
    "forceClientHttps":
    {
      "title": "Client zur Verwendung von HTTPS zwingen",
      "description": "Alle URLs zu dieser Threadfin-Instanz beginnen mit HTTPS"
    },
    "threadfinDomain":
    {
      "title": "Threadfin-Domain",
      "description": "Wenn nicht leer, werden die URLs in der neuen m3u in einen FQDN umgeschrieben.<br>Es wird auch die angezeigte DVR-IP im Serverinfo-Dialog umschreiben.<br>Schließen Sie http nicht ein (z.B.: somedomain.com)</br>"
    },
    "enableNonAscii":
    {
      "title": "Nicht-ASCII aktivieren",
      "description": "Wenn aktiviert, werden spezielle Nicht-ASCII-Zeichen in der M3U und EPG erlaubt. Standardmäßig deaktiviert"
    },
    "epgCategories":
    {
      "title": "EPG-Kategorien",
      "description": "Passen Sie die EPG-Kategorien an. Das Format ist Schlüssel:Wert|Schlüssel:Wert, also Nachrichten:news|Sport:sports|Filme:movies"
    },
    "epgCategoriesColors":
    {
      "title": "EPG-Kategorien-Farben",
      "description": "Passen Sie die Farben der EPG-Kategorien an. Das Format ist Wert:farbe|Wert:farbe, also news:tomato|sports:yellowgreen|movies:royalblue"
    },
    "bufferTimeout": {
      "title": "Timeout für neue Client-Verbindungen",
      "description": "Der Threadfin-Puffer wartet, bis neue Client-Verbindungen hergestellt sind. Hilfreich für schnelles Umschalten der Kanäle. Wert in Millisekunden.",
      "placeholder": "100"
    },
    "userAgent": {
      "title": "User-Agent",
      "description": "User-Agent für HTTP-Anfragen. Für jede HTTP-Verbindung wird dieser Wert als User-Agent verwendet. Sollte nur geändert werden, wenn Threadfin blockiert wird.",
      "placeholder": "Threadfin"
    },
    "backupPath": {
      "title": "Speicherort für automatische Sicherungen",
      "placeholder": "/mnt/data/backup/threadfin/",
      "description": "Vor jedem Update der Anbieterdaten durch den Zeitplan erstellt Threadfin eine Sicherung. Der Pfad für die automatischen Sicherungen kann geändert werden. Threadfin benötigt Schreibberechtigung für diesen Ordner."
    },
    "tempPath": {
      "title": "Speicherort für temporäre Dateien",
      "placeholder": "/tmp/threadfin/",
      "description": "Speicherort für die Pufferdateien."
    },
    "backupKeep": {
      "title": "Anzahl der zu behaltenden Sicherungen",
      "description": "Anzahl der zu behaltenden Sicherungen. Ältere Sicherungen werden automatisch gelöscht."
    },
    "authenticationWEB": {
      "title": "WEB-Authentifizierung",
      "description": "Zugriff auf die Weboberfläche nur mit Anmeldeinformationen möglich."
    },
    "authenticationPMS": {
      "title": "PMS-Authentifizierung",
      "description": "Plex-Anfragen sind nur mit Authentifizierung möglich. <br><b>Warnung!!!</b> Nach Aktivierung dieser Funktion muss Threadfin in den DVR-Einstellungen von PMS gelöscht und erneut eingerichtet werden."
    },
    "authenticationM3U": {
      "title": "M3U-Authentifizierung",
      "description": "Das Herunterladen der threadfin.m3u-Datei über eine HTTP-Anfrage ist nur mit Authentifizierung möglich."
    },
    "authenticationXML": {
      "title": "XML-Authentifizierung",
      "description": "Das Herunterladen der threadfin.xml-Datei über eine HTTP-Anfrage ist nur mit Authentifizierung möglich"
    },
    "authenticationAPI": {
      "title": "API-Authentifizierung",
      "description": "Zugriff auf die API-Schnittstelle nur mit Authentifizierung möglich."
    },
    "webclient": {
      "language": {
        "title": "Web client Sprache",
        "description": "Ändern der Sprache des Web Clients"

      }
    }
  },
  "wizard": {
    "epgSource": {
      "title": "EPG-Quelle",
      "description": "PMS:<br>- Verwenden Sie EPG-Daten von Plex, Emby oder Jellyfin <br><br>XEPG:<br>- Verwendung einer oder mehrerer XMLTV-Dateien<br>- Kanalverwaltung<br>- M3U / XMLTV-Export (HTTP-Link für IPTV-Apps)"
    },
    "tuner": {
      "title": "Anzahl der Tuner",
      "description": "Anzahl der parallelen Verbindungen, die zum Anbieter hergestellt werden können.<br>Verfügbar für: Plex, Emby, Jellyfin, M3U (mit aktivem Puffer).<br>Nach einer Änderung muss Threadfin in den DVR-Einstellungen von Plex / Emby / Jellyfin gelöscht und erneut eingerichtet werden."
    },
    "m3u": {
      "title": "M3U-Wiedergabeliste",
      "placeholder": "Dateipfad oder URL der M3U",
      "description": "Lokale oder entfernte Wiedergabelisten"
    },
    "xmltv": {
      "title": "XMLTV-Datei",
      "placeholder": "Dateipfad oder URL der XMLTV",
      "description": "Lokale oder entfernte XMLTV-Datei"
    }
  },
  "login": {
    "failed": "Benutzerauthentifizierung fehlgeschlagen",
    "headline": "Anmelden",
    "username": {
      "title": "Benutzername",
      "placeholder": "Benutzername"
    },
    "password": {
      "title": "Passwort",
      "placeholder": "Passwort"
    }
  },
  "account": {
    "failed": "Passwort stimmt nicht überein",
    "headline": "Benutzerkonto erstellen",
    "username": {
      "title": "Benutzername",
      "placeholder": "Benutzername"
    },
    "password": {
      "title": "Passwort",
      "placeholder": "Passwort"
    },
    "confirm": {
      "title": "Bestätigen",
      "placeholder": "Bestätigen"
    }
  },
  "notification" : {
    "update": {
      "title": "Update verfügbar",
      "content": "Eine neuere Version von Threadfin ist verfügbare. Bitte auf die neuste Version aktualisieren."
    }
  },
  "serverInfo": {
    "title": "Server Informationen",
    "header": {
      "serverInfo": "Server Informationen",
      "streamInfo": "Stream Informationen",
      "changeVersion": "Wechsel Threadfin Version"
    },
    "label": {
      "version": "Threadfin Version",
      "errors": "Fehler",
      "warnings": "Warnungen",
      "dvr": "DVR IP",
      "m3uUrl": "M3U URL (Specifc groups: [http://...?group-title=foo,bar])",
      "xepgUrl": "XMLTV URL",
      "streams": "Gefilterte Kanäle",
      "xepg": "Zugeordnete Kanäle"
    },
    "changeVersion": {
      "changeToBeta": "Wechsel zur Beta Version",
      "changeToRelease": "Wechsel zur offiziellen Version",
      "changing": "Wechsel..."
    }
  }
}" + webUI["web/public/lang/en.json"] = "{
  "mainMenu": {
    "item": {
      "playlist": "Playlist",
      "pmsID": "PMS ID",
      "filter": "Filter",
      "xmltv": "XMLTV",
      "mapping": "Mapping",
      "users": "Users",
      "settings": "Settings",
      "log": "Log",
      "logout": "Logout"
    },
    "headline": {
      "playlist": "Local or remote playlists",
      "filter": "Filter playlist",
      "xmltv": "Local or remote XMLTV files",
      "mapping": "Map playlist channels to EPG channels",
      "users": "User management",
      "settings": "Settings",
      "log": "Log",
      "logout": "Logout"
    }
  },
  "confirm": {
    "restore": "All data will be replaced with those from the backup. Should the files be restored?"
  },
  "alert": {
    "fileLoadingError": "File could not be loaded",
    "invalidChannelNumber": "Invalid channel number",
    "missingInput": "Missing input"
  },
  "button": {
    "back": "Back",
    "backup": "Backup",
    "bulkEdit": "Bulk Edit",
    "cancel": "Cancel",
    "delete": "Delete",
    "done": "Done",
    "login": "Login",
    "new": "New",
    "next": "Next",
    "restore": "Restore",
    "save": "Save",
    "search": "Search",
    "update": "Update",
    "updating": "Updating...",
    "craeteAccount": "Create Account",
    "resetLogs": "Reset Logs",
    "uploadLogo": "Upload Logo",
    "uploadCustomImage": "Upload custom image",
    "sortChannelsAlpha": "Sort Channels Alphabetically",
    "sortChannelNumbers": "Sort Channels",
    "backToTop": "Go to top",
    "serverInformation": "Server Information"
  },
  "filter": {
    "table": {
      "name": "Filter Name",
      "type": "Filter Type",
      "filter": "Filter"
    },
    "custom": "Custom",
    "group": "Group",
    "name": {
      "title": "Filter Name",
      "placeholder": "Filter name",
      "description": ""
    },
    "startingnumber": {
      "title": "Filter Starting Number",
      "placeholder": "Filter Starting Number",
      "description": "Starting Channel Number to use for this Group Filter (Default is 1000)"
    },
    "category": {
      "title": "Filter Category",
      "placeholder": "Filter Category",
      "description": "Filter Category sets all channels in the filter to a specific category (news, sports, etc)"
    },
    "description": {
      "title": "Description",
      "placeholder": "Description",
      "description": ""
    },
    "type": {
      "title": "Type",
      "groupTitle": "Group Title",
      "customFilter": "Custom Filter"
    },
    "caseSensitive": {
      "title": "Case Sensitive",
      "placeholder": "",
      "description": ""
    },
    "filterRule": {
      "title": "Filter Rule",
      "placeholder": "Sport {HD} !{ES,IT}",
      "description": ""
    },
    "filterGroup": {
      "title": "Group Title",
      "placeholder": "",
      "description": "Select a M3U group. (Counter)<br>Changing the group title in the M3U invalidates the filter."
    },
    "include": {
      "title": "Include",
      "placeholder": "FHD,UHD",
      "description": "Channel name must include.<br>(Comma separated) Comma means or"
    },
    "exclude": {
      "title": "Exclude",
      "placeholder": "ES,IT",
      "description": "Channel name must not contain.<br>(Comma separated) Comma means or"
    }
  },
  "playlist": {
    "table": {
      "playlist": "Playlist",
      "tuner": "Tuner",
      "lastUpdate": "Last Update",
      "availability": "Availability",
      "type": "Type",
      "streams": "Streams",
      "groupTitle": "group-title",
      "tvgID": "tvg-id",
      "uniqueID": "Unique ID"
    },
    "playlistType": {
      "title": "Playlist type",
      "placeholder": "",
      "description": ""
    },
    "type": {
      "title": "Type",
      "placeholder": "",
      "description": ""
    },
    "name": {
      "title": "Name",
      "placeholder": "Playlist name",
      "description": ""
    },
    "description": {
      "title": "Description",
      "placeholder": "Description",
      "description": ""
    },
    "fileM3U": {
      "title": "M3U File",
      "placeholder": "File path or URL of the M3U",
      "description": ""
    },
    "fileHDHR": {
      "title": "HDHomeRun IP",
      "placeholder": "IP address and port (192.168.1.10:5004)",
      "description": ""
    },
    "tuner": {
      "title": "Tuner / Streams",
      "placeholder": "",
      "description": "Number of parallel connections that can be established to the provider. <br>Only available with activated buffer.<br>New settings will only be applied after quitting all streams."
    },
    "http_proxy_ip": {
      "title": "HTTP Proxy IP",
      "placeholder": "192.168.0.2",
      "description": "IP address to be used by HTTP Proxy"
    },
    "http_proxy_port": {
      "title": "HTTP Proxy Port",
      "placeholder": "8888",
      "description": "Port to be used by HTTP Proxy"
    }
  },
  "xmltv": {
    "table": {
      "guide": "Guide",
      "lastUpdate": "Last Update",
      "availability": "Availability",
      "channels": "Channels",
      "programs": "Programs"
    },
    "name": {
      "title": "Name",
      "placeholder": "Guide name",
      "description": ""
    },
    "description": {
      "title": "Description",
      "placeholder": "Description",
      "description": ""
    },
    "fileXMLTV": {
      "title": "XMLTV File",
      "placeholder": "File path or URL of the XMLTV",
      "description": ""
    },
    "http_proxy_ip": {
      "title": "HTTP Proxy IP",
      "placeholder": "192.168.0.2",
      "description": "IP address to be used by HTTP Proxy"
    },
    "http_proxy_port": {
      "title": "HTTP Proxy Port",
      "placeholder": "8888",
      "description": "Port to be used by HTTP Proxy"
    }
  },
  "mapping": {
    "table": {
      "chNo": "Ch. No.",
      "logo": "Logo",
      "channelName": "Channel Name",
      "playlist": "Playlist",
      "groupTitle": "Group Title",
      "xmltvFile": "XMLTV File",
      "xmltvID": "XMLTV ID"
    },
    "active": {
      "title": "Active",
      "placeholder": "",
      "description": ""
    },
    "channelName": {
      "title": "Channel Name",
      "placeholder": "",
      "description": ""
    },
    "channelGroupStart": {
      "title": "Channel Group Start",
      "placeholder": "",
      "description": ""
    },
    "sortChannelsAlpha": {
      "title": "Sort Alphabetically",
      "placeholder": "",
      "description": ""
    },
    "sortChannels": {
      "title": "Sort Channels",
      "placeholder": "",
      "description": ""
    },
    "description": {
      "title": "Channel Description",
      "placeholder": "Used by the Dummy as an XML description",
      "description": ""
    },
    "updateChannelName": {
      "title": "Update Channel Name",
      "placeholder": "",
      "description": ""
    },
    "channelLogo": {
      "title": "Logo URL",
      "placeholder": "",
      "description": ""
    },
    "updateChannelLogo": {
      "title": "Update Channel Logo",
      "placeholder": "",
      "description": ""
    },
    "epgCategory": {
      "title": "EPG Category",
      "placeholder": "",
      "description": ""
    },
    "m3uGroupTitle": {
      "title": "Group Title (threadfin.m3u)",
      "placeholder": "",
      "description": ""
    },
    "xmltvFile": {
      "title": "XMLTV File",
      "placeholder": "",
      "description": ""
    },
    "xmltvChannel": {
      "title": "XMLTV Channel",
      "placeholder": "",
      "description": ""
    },
    "ppvextra": {
      "title": "PPV Extra Title",
      "placeholder": "",
      "description": "This will add custom text to the Programme data"
    },
    "backupChannel1": {
      "title": "Backup Channel 1",
      "placeholder": "",
      "description": ""
    },
    "backupChannel2": {
      "title": "Backup Channel 2",
      "placeholder": "",
      "description": ""
    },
    "backupChannel3": {
      "title": "Backup Channel 3",
      "placeholder": "",
      "description": ""
    },
    "hideChannel": {
      "title": "Hide Backup Channel",
      "placeholder": "",
      "description": ""
    }
  },
  "users": {
    "table": {
      "username": "Username",
      "password": "Password",
      "web": "WEB",
      "pms": "PMS",
      "m3u": "M3U",
      "xml": "XML",
      "api": "API"
    },
    "username": {
      "title": "Username",
      "placeholder": "Username",
      "description": ""
    },
    "password": {
      "title": "Password",
      "placeholder": "Password",
      "description": ""
    },
    "confirm": {
      "title": "Confirm",
      "placeholder": "Password confirm",
      "description": ""
    },
    "web": {
      "title": "Web Access",
      "placeholder": "",
      "description": ""
    },
    "pms": {
      "title": "PMS Access",
      "placeholder": "",
      "description": ""
    },
    "m3u": {
      "title": "M3U Access",
      "placeholder": "",
      "description": ""
    },
    "xml": {
      "title": "XML Access",
      "placeholder": "",
      "description": ""
    },
    "api": {
      "title": "API Access",
      "placeholder": "",
      "description": ""
    }
  },
  "settings": {
    "category": {
      "general": "General",
      "customization": "Customization",
      "files": "Files",
      "network": "Network",
      "streaming": "Streaming",
      "backup": "Backup",
      "authentication": "Authentication",
      "webclient": "Web client"
    },
    "uploadCustomImage": {
      "title": "Custom Image",
      "description": "Here you can upload an image that will be shown to users when no more tuners are available in the playlist!"
    },
    "update": {
      "title": "Schedule for updating (Playlist, XMLTV, Backup)",
      "placeholder": "0000,1000,2000",
      "description": "Time in 24 hour format (0800 = 8:00 am). More times can be entered comma separated. Leave this field empty if no updates are to be carried out."
    },
    "api": {
      "title": "API Interface",
      "description": "Via API interface it is possible to send commands to Threadfin. API documentation is <a href=\"https://github.com/marcelGoerentz/Threadfin/wiki/API\">here</a>"
    },
    "ssdp": {
      "title": "SSDP",
      "description": "SSDP is a network protocol for service discovery. It is used for the automatic detection of Threadfin in the network."
    },
    "dummy": {
      "title": "Enable Default Dummy Data",
      "description": "When enabled, this will automatically map inactive channels to the dummy data channel below. Use this to keep Live Event channels active."
    },
    "dummyChannel": {
      "title": "Dummy Data Channel",
      "description": "Select the default channel to use when mapping inactive channels to the dummy data."
    },
    "ignoreFilters": {
      "title": "Ignore Filters",
      "description": "If checked, filtering is completely ignored."
    },
    "epgSource": {
      "title": "EPG Source",
      "description": "PMS:<br>- Use EPG data from Plex, Emby or Jellyfin <br><br>XEPG:<br>- Use of one or more XMLTV files<br>- Channel management<br>- M3U / XMLTV export (HTTP link for IPTV apps)"
    },
    "tuner": {
      "title": "Number of Tuners",
      "description": "Number of parallel connections that can be established to the provider.<br>Available for: Plex, Emby, Jellyfin, M3U (with active buffer).<br>After a change, Threadfin must be delete in the Plex / Emby / Jellyfin DVR settings and set up again."
    },
    "filesUpdate": {
      "title": "Updates all files at startup",
      "description": "Updates all playlists, tuner and XMLTV files at startup."
    },
    "cacheImages": {
      "title": "Image Caching",
      "description": "This option will rewrite the m3u file to local image cache for tv logos.<br>All images from the XMLTV file are cached, allowing faster rendering of the grid in the client.<br>Downloading the images may take a while and will be done in the background.<br>"
    },
    "replaceEmptyImages": {
      "title": "Replace missing program images",
      "description": "If the poster in the XMLTV program is missing, the channel logo will be used."
    },
    "replaceChannelTitle": {
      "title": "Replace PPV channels title/desc",
      "description": "Use this if your provider maps the PPV event name to the channel name"
    },
    "ThreadfinAutoUpdate": {
      "title": "Automatic update of Threadfin",
      "description": "If a new version of Threadfin is available, it will be automatically installed. The updates are downloaded from GitHub."
    },
    "streamBuffering": {
      "title": "Stream Buffer",
      "description": "Functions of the buffer:<br>- The stream is passed from FFmpeg, VLC or Threadfin to Plex, Emby, Jellyfin or M3U Player<br>- Small jerking of the streams can be compensated<br>- HLS / M3U8 support<br>- RTP / RTPS support<br>- Re-streaming<br>- Separate tuner limit for each playlist",
      "info_false": "No Buffer (Client connects directly to the streaming server)",
      "info_ffmpeg": "FFmpeg connects to the streaming server",
      "info_vlc": "VLC connects to the streaming server",
      "info_threadfin": "Threadfin connects to the streaming server"
    },
    "udpxy": {
      "title": "UDPxy address",
      "description": "The address of your UDPxy server. If set, and the channel URLs in the m3u is multicast, Threadfin will rewrite it so that it is accessed via the UDPxy service.",
      "placeholder": "host:port"
    },
    "ffmpegPath": {
      "title": "FFmpeg Binary Path",
      "description": "Path to FFmpeg binary.",
      "placeholder": "/path/to/ffmpeg"
    },
    "ffmpegOptions": {
      "title": "FFmpeg Options",
      "description": "FFmpeg options.<br>Only change if you know what you are doing.<br>Leave blank to set default settings.",
      "placeholder": "Leave blank to set default settings"
    },
    "vlcPath": {
      "title": "VLC / CVLC Binary Path",
      "description": "Path to VLC / CVLC binary.",
      "placeholder": "/path/to/cvlc"
    },
    "vlcOptions": {
      "title": "VLC / CVLC Options",
      "description": "VLC / CVLC options.<br>Only change if you know what you are doing.<br>Leave blank to set default settings.",
      "placeholder": "Leave blank to set default settings"
    },
    "bufferSize": {
      "title": "Buffer Size",
      "description": "Buffer size in MB.<br>M3U8: If the TS segment smaller then the buffer size, the file size of the segment is used."
    },
    "bufferTerminationTimeout": {
      "title": "Buffer Termination Timeout",
      "description": "Time in seconds that the buffer stays alive after the last client left",
      "placeholder": "Time in seconds"
    },
    "storeBufferInRAM":
    {
      "title": "Store buffer in RAM",
      "description": "If checked, write buffer to RAM instead of writing to disk"
    },
    "autoReconnect":{
      "title": "Automatic reconnect to stream",
      "description": "If checked, the buffer will automatically reconnect to stream"
    },
    "omitPorts":
    {
      "title": "Omit port",
      "description": "By activating this checkbox the m3u file will not contain the port in the url"
    },
    "bindingIPs" :
    {
      "title": "Binding IP(s)",
      "description": "By clicking on the input a dialogue will open where you can select the IP(s)<br>Please note that these are also the DVR IPs<br>Changing this option and saving the settings will exit the program!<br>You need to restart it if you did not configured an automatical restart!"
    },
    "forceHttps":
    {
      "title": "Force HTTPS to Upstream server",
      "description": "When this checkbox is activated Threadfin will be forced to use HTTPS connection to upstream server <br>This is not recommended as the given urls will be rewritten to https urls, this can lead to 404 HTTP Error Codes</br>"
    },
    "useHttps":
    {
      "title": "Use HTTPS",
      "description": "Enable HTTPS protocol for Threadfin, HTTPS Port needs to be set, otherwise the 443 will be used!<br>Also make sure that server.crt and server.key are placed in the config folder!<br>The key file needs to be unencrypted!"
    },
    "forceClientHttps":
    {
      "title": "Force client to use https",
      "description": "All URLs to this threadfin instance will be starting with https"
    },
    "threadfinDomain":
    {
      "title": "Threadfin Domain",
      "description": "When not empty, this will rewrite the URLs in the new m3u to a FQDN.<br>It will also rewrite the shown DVR IP in the server info dialogue.<br>Do NOT include http (ex: somedomain.com)</br>"
    },
    "enableNonAscii":
    {
      "title": "Enable Non-ASCII",
      "description": "If checked, will allow special non ascii characters in the M3U and EPG. Default is disabled"
    },
    "epgCategories":
    {
      "title": "EPG Categories",
      "description": "Customize the EPG Categories. The format is key:value|key:value, so News:news|Sports:sports|Movies:movies"
    },
    "epgCategoriesColors":
    {
      "title": "EPG Categories Colors",
      "description": "Customize the EPG Category colors. The format is value:color|value:color, so news:tomato|sports:yellowgreen|movies:royalblue"
    },
    "bufferTimeout": {
      "title": "Timeout for new client connections",
      "description": "The Threadfin buffer waits until new client connections are established. Helpful for fast channel switching. Value in milliseconds.",
      "placeholder": "100"
    },
    "userAgent": {
      "title": "User Agent",
      "description": "User Agent for HTTP requests. For every HTTP connection, this value is used for the user agent. Should only be changed if Threadfin is blocked.",
      "placeholder": "Threadfin"
    },
    "backupPath": {
      "title": "Location for automatic backups",
      "placeholder": "/mnt/data/backup/threadfin/",
      "description": "Before any update of the provider data by the schedule, Threadfin creates a backup. The path for the automatic backups can be changed. Threadfin requires write permission for this folder."
    },
    "tempPath": {
      "title": "Location for the temporary files",
      "placeholder": "/tmp/threadfin/",
      "description": "Location for the buffer files."
    },
    "backupKeep": {
      "title": "Number of backups to keep",
      "description": "Number of backups to keep. Older backups are automatically deleted."
    },
    "authenticationWEB": {
      "title": "WEB Authentication",
      "description": "Access to the web interface only possible with credentials."
    },
    "authenticationPMS": {
      "title": "PMS Authentication",
      "description": "Plex requests are only possible with authentication. <br><b>Warning!!!</b> After activating this function Threadfin must be delete in the PMS DVR settings and set up again."
    },
    "authenticationM3U": {
      "title": "M3U Authentication",
      "description": "Downloading the threadfin.m3u file via an HTTP request is only possible with authentication."
    },
    "authenticationXML": {
      "title": "XML Authentication",
      "description": "Downloading the threadfin.xml file via an HTTP request is only possible with authentication"
    },
    "authenticationAPI": {
      "title": "API Authentication",
      "description": "Access to the API interface is only possible with authentication."
    },
    "webclient": {
      "language": {
        "title": "Web client language",
        "description": "Change the language for the web client"

      }
    }
  },
  "wizard": {
    "epgSource": {
      "title": "EPG Source",
      "description": "PMS:<br>- Use EPG data from Plex, Emby or Jellyfin <br><br>XEPG:<br>- Use of one or more XMLTV files<br>- Channel management<br>- M3U / XMLTV export (HTTP link for IPTV apps)"
    },
    "tuner": {
      "title": "Number of tuners",
      "description": "Number of parallel connections that can be established to the provider.<br>Available for: Plex, Emby, Jellyfin, M3U (with active buffer).<br>After a change, Threadfin must be delete in the Plex / Emby / Jellyfin DVR settings and set up again."
    },
    "m3u": {
      "title": "M3U Playlist",
      "placeholder": "File path or URL of the M3U",
      "description": "Local or remote playlists"
    },
    "xmltv": {
      "title": "XMLTV File",
      "placeholder": "File path or URL of the XMLTV",
      "description": "Local or remote XMLTV file"
    }
  },
  "login": {
    "failed": "User authentication failed",
    "headline": "Login",
    "username": {
      "title": "Username",
      "placeholder": "Username"
    },
    "password": {
      "title": "Password",
      "placeholder": "Password"
    }
  },
  "account": {
    "failed": "Password does not match",
    "headline": "Create user account",
    "username": {
      "title": "Username",
      "placeholder": "Username"
    },
    "password": {
      "title": "Password",
      "placeholder": "Password"
    },
    "confirm": {
      "title": "Confirm",
      "placeholder": "Confirm"
    }
  },
  "notification": {
    "update": {
      "title": "Update available",
      "content": "A newer version of Threadfin is available. Please update to the latest version."
    }
  },
  "serverInfo": {
    "title": "Server Information",
    "header": {
      "serverInfo": "Server Information",
      "streamInfo": "Stream Information",
      "changeVersion": "Change Threadfin Version"
    },
    "label": {
      "version": "Threadfin Version",
      "errors": "Errors",
      "warnings": "Warnings",
      "dvr": "DVR IP",
      "m3uUrl": "M3U URL (Specifc groups: [http://...?group-title=foo,bar])",
      "xepgUrl": "XMLTV URL",
      "streams": "Filtered Channels",
      "xepg": "Mapped Channels"
    },
    "changeVersion": {
      "changeToBeta": "Change to beta version",
      "changeToRelease": "Change to release version",
      "changing": "Changing..."
    }
  }
}" webUI["web/public/video/stream-limit.ts"] = "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" } diff --git a/src/webserver.go b/src/webserver.go index d3e58a9..f1bedf1 100644 --- a/src/webserver.go +++ b/src/webserver.go @@ -373,6 +373,10 @@ func stream(w http.ResponseWriter, r *http.Request) { } default: + w.Header().Set("Content-Type", "video/mp2t") + w.Header().Set("Cache-Control", "max-age=3600") + w.Header().Set("Connection", "keep-alive") + w.Header().Set("Keep-Alive", "timeout=10, max=100") streamManager.ServeStream(streamInfo, w, r) } } @@ -627,7 +631,7 @@ func WS(w http.ResponseWriter, r *http.Request) { var previousBindingIPs = Settings.BindingIPs var previousUseHttps = Settings.UseHttps response.Settings, err = updateServerSettings(request) - if err == nil { + if err == nil && response.Settings != nil { response.OpenMenu = strconv.Itoa(indexOfString("settings", System.WEB.Menu)) @@ -817,7 +821,7 @@ func WS(w http.ResponseWriter, r *http.Request) { if err != nil { response.Status = false response.Error = err.Error() - response.Settings = Settings + response.Settings = &Settings } response = setDefaultResponseData(response, true) @@ -1342,7 +1346,7 @@ func setDefaultResponseData(response ResponseStruct, data bool) (defaults Respon } - defaults.Settings = Settings + defaults.Settings = &Settings defaults.Data.Playlist.M3U.Groups.Text = Data.Playlist.M3U.Groups.Text defaults.Data.Playlist.M3U.Groups.Value = Data.Playlist.M3U.Groups.Value diff --git a/threadfin.go b/threadfin.go index 5bfb3ab..3ee05a4 100644 --- a/threadfin.go +++ b/threadfin.go @@ -11,10 +11,10 @@ import ( "flag" "fmt" "os" - "os/exec" "os/signal" "path/filepath" "runtime" + "strconv" "strings" "syscall" "time" @@ -46,7 +46,7 @@ var GitHub = GitHubStruct{Branch: "master", User: "marcelGoerentz", Repo: "Threa const Name = "Threadfin" // Version : Major, Minor, Patch, Build -const Version = "1.8.0.0" +const Version = "1.8.1.0" // DBVersion : Database version const DBVersion = "0.5.0" @@ -72,6 +72,8 @@ var dev = flag.Bool("dev", false, ": Activates the developer mode, the source co func main() { + cleanUpOldInstances() + webserver := &src.WebServer{} // Handle signals @@ -170,9 +172,6 @@ func main() { // Https webserver system.Flag.UseHttps = *useHttps - // Kill all remaining processes and remove PIDs file - killAllProcesses() - // Debug Level system.Flag.Debug = *debug if system.Flag.Debug > 3 { @@ -211,9 +210,8 @@ func main() { } // Update binary - err = src.BinaryUpdate(false) - if err != nil { - src.ShowError(err, 0) + if src.BinaryUpdate(false) { + os.Exit(0) } // Build the database @@ -254,19 +252,7 @@ func handleSignals(sigs chan os.Signal, done chan bool, webserver *src.WebServer continue case syscall.SIGINT, syscall.SIGABRT, syscall.SIGTERM: - // Lock against reconnection for clients - webserver.SM.LockAgainstNewStreams = true - - src.ShowInfo("Threadfin:Stop all streams") - // Stop all streams - stopAllStreams(webserver) - - src.ShowInfo("Threadfin:Killing all processes") - // Kill all processes - killAllProcesses() - - // Shutdown the webserver gracefully - shutdownWebserver(webserver) + CloseWebserverGracefully(webserver) // Send signal that everything has ended done <- true @@ -279,6 +265,27 @@ func handleSignals(sigs chan os.Signal, done chan bool, webserver *src.WebServer time.Sleep(100 * time.Millisecond) } +func cleanUpOldInstances() { + killAllProcesses() +} + +// +func CloseWebserverGracefully(webserver *src.WebServer){ + // Lock against reconnection for clients + webserver.SM.LockAgainstNewStreams = true + + src.ShowInfo("Threadfin:Stop all streams") + // Stop all streams + stopAllStreams(webserver) + + src.ShowInfo("Threadfin:Killing all processes") + // Kill all processes + killAllProcesses() + + // Shutdown the webserver gracefully + shutdownWebserver(webserver) +} + // stopAllStreams will stop all existing streams and buffers func stopAllStreams(webserver *src.WebServer) { if webserver != nil { @@ -334,8 +341,15 @@ func getPIDsFromFile(tempFolder string) ([]string, error) { // killProcess kills a process by its PID func killProcess(pid string) error { - cmd := exec.Command("kill", "-9", pid) - return cmd.Run() + pidInt, err := strconv.Atoi(pid) + if err != nil { + return err + } + proc, err := os.FindProcess(pidInt) + if err != nil { + return err + } + return proc.Kill() } // killAllProcesses kills processes that had been saved in PID diff --git a/threadfin_pubkey.pem b/threadfin_pubkey.pem new file mode 100644 index 0000000..86f9e53 --- /dev/null +++ b/threadfin_pubkey.pem @@ -0,0 +1,9 @@ +-----BEGIN PUBLIC KEY----- +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2ZkUyr5n1c1iSO8fMtFl +ZV1zncySavnEOOADT+1jHAJVASipxYbm+gZ9welcAl5iYZSXd0FV7uGBbU1HogIL +pl3zfRJ4xY+TmVDRGdKfnc2KMn/7aY3JdSUfSCZ+smZVvHNRWlnzVsRoYNHMe6gm +dHg50I1IgFuhdtYY4p3e4FS4SdZVNV3BJuJTaAG8viUpsoy30DnaWIBsDpX+CPjp +7ntWZPGxDxCRl011ri+DWd3dgcClDmt6YXJAzkiSnfuNqXwENu2nhFV7wCqwMmFU +nfkRuBOYqTJ3GAsAJK+HNthxWV09p9O1n1pgLpaBNcp8UosBWXH+JEJU7UKSp2u3 +bwIDAQAB +-----END PUBLIC KEY----- diff --git a/web/public/lang/de.json b/web/public/lang/de.json index 1f6986c..8c614f6 100644 --- a/web/public/lang/de.json +++ b/web/public/lang/de.json @@ -462,6 +462,11 @@ "title": "Puffergröße", "description": "Puffergröße in MB.
M3U8: Wenn das TS-Segment kleiner als die Puffergröße ist, wird die Dateigröße des Segments verwendet." }, + "bufferTerminationTimeout": { + "title": "Puffer-Schließ-Timeout", + "description": "Zeit in Sekunden, die der Puffer nach dem Verlassen des letzten Clients aktiv bleibt", + "placeholder": "Zeit in Sekunden" + }, "storeBufferInRAM": { "title": "Puffer im RAM speichern", diff --git a/web/public/lang/en.json b/web/public/lang/en.json index d8c2403..63dc1e3 100644 --- a/web/public/lang/en.json +++ b/web/public/lang/en.json @@ -462,6 +462,11 @@ "title": "Buffer Size", "description": "Buffer size in MB.
M3U8: If the TS segment smaller then the buffer size, the file size of the segment is used." }, + "bufferTerminationTimeout": { + "title": "Buffer Termination Timeout", + "description": "Time in seconds that the buffer stays alive after the last client left", + "placeholder": "Time in seconds" + }, "storeBufferInRAM": { "title": "Store buffer in RAM", diff --git a/web/src/ts/base.ts b/web/src/ts/base.ts index a0d7513..94ca1ff 100644 --- a/web/src/ts/base.ts +++ b/web/src/ts/base.ts @@ -59,7 +59,7 @@ settingsCategory.push(new SettingsCategoryItem("{{.settings.category.customizati settingsCategory.push(new SettingsCategoryItem("{{.settings.category.webclient}}", "webclient.language")) settingsCategory.push(new SettingsCategoryItem("{{.settings.category.files}}", "update,files.update,temp.path,cache.images,omitPorts,xepg.replace.missing.images,xepg.replace.channel.title,enableNonAscii")) settingsCategory.push(new SettingsCategoryItem("{{.settings.category.network}}", "bindingIPs,threadfinDomain,useHttps,forceClientHttps,forceHttps")) -settingsCategory.push(new SettingsCategoryItem("{{.settings.category.streaming}}", "buffer,udpxy,buffer.size.kb,storeBufferInRAM,buffer.timeout,buffer.autoReconnect,user.agent,ffmpeg.path,ffmpeg.options,vlc.path,vlc.options")) +settingsCategory.push(new SettingsCategoryItem("{{.settings.category.streaming}}", "buffer,udpxy,buffer.size.kb,storeBufferInRAM,buffer.terminationTimeout,buffer.timeout,buffer.autoReconnect,user.agent,ffmpeg.path,ffmpeg.options,vlc.path,vlc.options")) settingsCategory.push(new SettingsCategoryItem("{{.settings.category.backup}}", "backup.path,backup.keep")) settingsCategory.push(new SettingsCategoryItem("{{.settings.category.authentication}}", "authentication.web,authentication.pms,authentication.m3u,authentication.xml,authentication.api")) diff --git a/web/src/ts/settings.ts b/web/src/ts/settings.ts index 76bfefb..71c66a4 100644 --- a/web/src/ts/settings.ts +++ b/web/src/ts/settings.ts @@ -100,6 +100,10 @@ class SettingsCategory { setting = this.createTextInput(settingsKey, '{{.settings.bufferTimeout.title}}', '{{.settings.bufferTimeout.placeholder}}'); break; + case 'buffer.terminationTimeout': + setting = this.createTextInput(settingsKey, '{{.settings.bufferTerminationTimeout.title}}', '{{.settings.bufferTerminationTimeout.placeholder}}'); + break; + case 'ffmpeg.path': setting = this.createTextInput(settingsKey, '{{.settings.ffmpegPath.title}}', '{{.settings.ffmpegPath.placeholder}}'); break; @@ -295,15 +299,14 @@ class SettingsCategory { var tdRight = document.createElement('TD'); var button = this.Content.createInput('button', 'upload', '{{.button.uploadCustomImage}}'); + button.setAttribute('onclick', 'javascript: uploadCustomImage();'); tdRight.appendChild(button) setting.appendChild(tdLeft); setting.appendChild(tdRight); break; } - return setting; - } createDescription(settingsKey: string): any { @@ -366,6 +369,10 @@ class SettingsCategory { text = '{{.settings.bufferSize.description}}'; break; + case 'buffer.terminationTimeout': + text ='{{.settings.bufferTerminationTimeout.description}}'; + break; + case 'buffer.autoReconnect': text = '{{.settings.autoReconnect.description}}'; break; @@ -598,6 +605,7 @@ function saveSettings() { break; case 'buffer.timeout': + case 'buffer.terminationTimeout': value = parseFloat(value); case 'bindingIPs':