go fix for 1.26

src/authentication.go

@@ -16,7 +16,7 @@ func activatedSystemAuthentication() (err error) {
 		return
 	}
 
-	var defaults = make(map[string]interface{})
+	var defaults = make(map[string]any)
 	defaults["authentication.web"] = false
 	defaults["authentication.pms"] = false
 	defaults["authentication.xml"] = false
@@ -43,7 +43,7 @@ func createFirstUserForAuthentication(username, password string) (token string,
 	token, err = authentication.CheckTheValidityOfTheToken(token)
 	authenticationErr(err)
 
-	var userData = make(map[string]interface{})
+	var userData = make(map[string]any)
 	userData["username"] = username
 	userData["authentication.web"] = true
 	userData["authentication.pms"] = true

src/data.go

@@ -59,7 +59,7 @@ func updateServerSettings(request RequestStruct) (settings SettingsStruct, err e
 				// Leerzeichen aus den Werten entfernen und Formatierung der Uhrzeit überprüfen (0000 - 2359)
 				var newUpdateTimes = make([]string, 0)
 
-				for _, v := range value.([]interface{}) {
+				for _, v := range value.([]any) {
 
 					v = strings.Replace(v.(string), " ", "", -1)
 
@@ -282,8 +282,8 @@ func updateServerSettings(request RequestStruct) (settings SettingsStruct, err e
 // Providerdaten speichern (WebUI)
 func saveFiles(request RequestStruct, fileType string) (err error) {
 
-	var filesMap = make(map[string]interface{})
+	var filesMap = make(map[string]any)
-	var newData = make(map[string]interface{})
+	var newData = make(map[string]any)
 	var indicator string
 	var reloadData = false
 
@@ -305,7 +305,7 @@ func saveFiles(request RequestStruct, fileType string) (err error) {
 	}
 
 	if len(filesMap) == 0 {
-		filesMap = make(map[string]interface{})
+		filesMap = make(map[string]any)
 	}
 
 	for dataID, data := range newData {
@@ -314,15 +314,15 @@ func saveFiles(request RequestStruct, fileType string) (err error) {
 
 			// Neue Providerdatei
 			dataID = indicator + randomString(19)
-			data.(map[string]interface{})["new"] = true
+			data.(map[string]any)["new"] = true
 			filesMap[dataID] = data
 
 		} else {
 
 			// Bereits vorhandene Providerdatei
-			for key, value := range data.(map[string]interface{}) {
+			for key, value := range data.(map[string]any) {
 
-				var oldData = filesMap[dataID].(map[string]interface{})
+				var oldData = filesMap[dataID].(map[string]any)
 				oldData[key] = value
 
 			}
@@ -343,11 +343,11 @@ func saveFiles(request RequestStruct, fileType string) (err error) {
 		}
 
 		// Neue Providerdatei
-		if _, ok := data.(map[string]interface{})["new"]; ok {
+		if _, ok := data.(map[string]any)["new"]; ok {
 
 			reloadData = true
 			err = getProviderData(fileType, dataID)
-			delete(data.(map[string]interface{}), "new")
+			delete(data.(map[string]any), "new")
 
 			if err != nil {
 				delete(filesMap, dataID)
@@ -356,7 +356,7 @@ func saveFiles(request RequestStruct, fileType string) (err error) {
 
 		}
 
-		if _, ok := data.(map[string]interface{})["delete"]; ok {
+		if _, ok := data.(map[string]any)["delete"]; ok {
 
 			deleteLocalProviderFiles(dataID, fileType)
 			reloadData = true
@@ -389,7 +389,7 @@ func saveFiles(request RequestStruct, fileType string) (err error) {
 // Providerdaten manuell aktualisieren (WebUI)
 func updateFile(request RequestStruct, fileType string) (err error) {
 
-	var updateData = make(map[string]interface{})
+	var updateData = make(map[string]any)
 
 	switch fileType {
 
@@ -419,7 +419,7 @@ func updateFile(request RequestStruct, fileType string) (err error) {
 // Providerdaten löschen (WebUI)
 func deleteLocalProviderFiles(dataID, fileType string) {
 
-	var removeData = make(map[string]interface{})
+	var removeData = make(map[string]any)
 	var fileExtension string
 
 	switch fileType {
@@ -448,8 +448,8 @@ func deleteLocalProviderFiles(dataID, fileType string) {
 // Filtereinstellungen speichern (WebUI)
 func saveFilter(request RequestStruct) (settings SettingsStruct, err error) {
 
-	var filterMap = make(map[int64]interface{})
+	var filterMap = make(map[int64]any)
-	var newData = make(map[int64]interface{})
+	var newData = make(map[int64]any)
 	var defaultFilter FilterStruct
 	var newFilter = false
 
@@ -482,15 +482,15 @@ func saveFilter(request RequestStruct) (settings SettingsStruct, err error) {
 		}
 
 		// Filter aktualisieren / löschen
-		for key, value := range data.(map[string]interface{}) {
+		for key, value := range data.(map[string]any) {
 
 			// Filter löschen
-			if _, ok := data.(map[string]interface{})["delete"]; ok {
+			if _, ok := data.(map[string]any)["delete"]; ok {
 				delete(filterMap, dataID)
 				break
 			}
 
-			if filter, ok := data.(map[string]interface{})["filter"].(string); ok {
+			if filter, ok := data.(map[string]any)["filter"].(string); ok {
 
 				if len(filter) == 0 {
 
@@ -504,7 +504,7 @@ func saveFilter(request RequestStruct) (settings SettingsStruct, err error) {
 
 			}
 
-			if oldData, ok := filterMap[dataID].(map[string]interface{}); ok {
+			if oldData, ok := filterMap[dataID].(map[string]any); ok {
 				oldData[key] = value
 			}
 
@@ -597,7 +597,7 @@ func saveUserData(request RequestStruct) (err error) {
 
 	var userData = request.UserData
 
-	var newCredentials = func(userID string, newUserData map[string]interface{}) (err error) {
+	var newCredentials = func(userID string, newUserData map[string]any) (err error) {
 
 		var newUsername, newPassword string
 		if username, ok := newUserData["username"].(string); ok {
@@ -617,7 +617,7 @@ func saveUserData(request RequestStruct) (err error) {
 
 	for userID, newUserData := range userData {
 
-		err = newCredentials(userID, newUserData.(map[string]interface{}))
+		err = newCredentials(userID, newUserData.(map[string]any))
 		if err != nil {
 			return
 		}
@@ -627,16 +627,16 @@ func saveUserData(request RequestStruct) (err error) {
 			return
 		}
 
-		delete(newUserData.(map[string]interface{}), "password")
+		delete(newUserData.(map[string]any), "password")
-		delete(newUserData.(map[string]interface{}), "confirm")
+		delete(newUserData.(map[string]any), "confirm")
 
-		if _, ok := newUserData.(map[string]interface{})["delete"]; ok {
+		if _, ok := newUserData.(map[string]any)["delete"]; ok {
 
 			authentication.RemoveUser(userID)
 
 		} else {
 
-			err = authentication.WriteUserData(userID, newUserData.(map[string]interface{}))
+			err = authentication.WriteUserData(userID, newUserData.(map[string]any))
 			if err != nil {
 				return
 			}
@@ -686,11 +686,11 @@ func saveWizard(request RequestStruct) (nextStep int, err error) {
 
 		case "m3u", "xmltv":
 
-			var filesMap = make(map[string]interface{})
+			var filesMap = make(map[string]any)
-			var data = make(map[string]interface{})
+			var data = make(map[string]any)
 			var indicator, dataID string
 
-			filesMap = make(map[string]interface{})
+			filesMap = make(map[string]any)
 
 			data["type"] = key
 			data["new"] = true
@@ -821,9 +821,9 @@ func buildDatabaseDVR() (err error) {
 
 	System.ScanInProgress = 1
 
-	Data.Streams.All = make([]interface{}, 0, System.UnfilteredChannelLimit)
+	Data.Streams.All = make([]any, 0, System.UnfilteredChannelLimit)
-	Data.Streams.Active = make([]interface{}, 0, System.UnfilteredChannelLimit)
+	Data.Streams.Active = make([]any, 0, System.UnfilteredChannelLimit)
-	Data.Streams.Inactive = make([]interface{}, 0, System.UnfilteredChannelLimit)
+	Data.Streams.Inactive = make([]any, 0, System.UnfilteredChannelLimit)
 	Data.Playlist.M3U.Groups.Text = []string{}
 	Data.Playlist.M3U.Groups.Value = []string{}
 	Data.StreamPreviewUI.Active = []string{}
@@ -844,7 +844,7 @@ func buildDatabaseDVR() (err error) {
 
 		for n, i := range playlistFile {
 
-			var channels []interface{}
+			var channels []any
 			var groupTitle, tvgID, uuid int = 0, 0, 0
 			var keys = []string{"group-title", "tvg-id", "uuid"}
 			var compatibility = make(map[string]int)
@@ -981,7 +981,7 @@ func buildDatabaseDVR() (err error) {
 
 	if len(Data.Streams.Active) == 0 && len(Data.Streams.All) <= System.UnfilteredChannelLimit && len(Settings.Filter) == 0 {
 		Data.Streams.Active = Data.Streams.All
-		Data.Streams.Inactive = make([]interface{}, 0)
+		Data.Streams.Inactive = make([]any, 0)
 
 		Data.StreamPreviewUI.Active = Data.StreamPreviewUI.Inactive
 		Data.StreamPreviewUI.Inactive = []string{}
@@ -1015,7 +1015,7 @@ func buildDatabaseDVR() (err error) {
 func getLocalProviderFiles(fileType string) (localFiles []string) {
 
 	var fileExtension string
-	var dataMap = make(map[string]interface{})
+	var dataMap = make(map[string]any)
 
 	switch fileType {
 
@@ -1043,7 +1043,7 @@ func getLocalProviderFiles(fileType string) (localFiles []string) {
 // Providerparameter anhand von dem Key ausgeben
 func getProviderParameter(id, fileType, key string) (s string) {
 
-	var dataMap = make(map[string]interface{})
+	var dataMap = make(map[string]any)
 
 	switch fileType {
 	case "m3u":
@@ -1056,7 +1056,7 @@ func getProviderParameter(id, fileType, key string) (s string) {
 		dataMap = Settings.Files.XMLTV
 	}
 
-	if data, ok := dataMap[id].(map[string]interface{}); ok {
+	if data, ok := dataMap[id].(map[string]any); ok {
 
 		if v, ok := data[key].(string); ok {
 			s = v
@@ -1074,7 +1074,7 @@ func getProviderParameter(id, fileType, key string) (s string) {
 // Provider Statistiken Kompatibilität aktualisieren
 func setProviderCompatibility(id, fileType string, compatibility map[string]int) {
 
-	var dataMap = make(map[string]interface{})
+	var dataMap = make(map[string]any)
 
 	switch fileType {
 	case "m3u":
@@ -1087,7 +1087,7 @@ func setProviderCompatibility(id, fileType string, compatibility map[string]int)
 		dataMap = Settings.Files.XMLTV
 	}
 
-	if data, ok := dataMap[id].(map[string]interface{}); ok {
+	if data, ok := dataMap[id].(map[string]any); ok {
 
 		data["compatibility"] = compatibility
 

src/hdhr.go

@@ -7,9 +7,9 @@ import (
 	"fmt"
 )
 
-func makeInteraceFromHDHR(content []byte, playlistName, id string) (channels []interface{}, err error) {
+func makeInteraceFromHDHR(content []byte, playlistName, id string) (channels []any, err error) {
 
-	var hdhrData []interface{}
+	var hdhrData []any
 
 	err = json.Unmarshal(content, &hdhrData)
 	if err == nil {
@@ -17,7 +17,7 @@ func makeInteraceFromHDHR(content []byte, playlistName, id string) (channels []i
 		for _, d := range hdhrData {
 
 			var channel = make(map[string]string)
-			var data = d.(map[string]interface{})
+			var data = d.(map[string]any)
 
 			channel["group-title"] = playlistName
 			channel["name"] = data["GuideName"].(string)

src/html-build.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"strings"
 )
 
 var htmlFolder string
@@ -16,7 +17,7 @@ var goFile string
 var mapName string
 var packageName string
 
-var blankMap = make(map[string]interface{})
+var blankMap = make(map[string]any)
 
 // HTMLInit : Dateipfade festlegen
 // mapName = Name der zu erstellenden map
@@ -68,14 +69,14 @@ func createMapFromFiles(folder string) string {
 		checkErr(err)
 	}
 
-	var content string
+	var content strings.Builder
 
 	for key := range blankMap {
 		var newKey = key
-		content += `  ` + mapName + `["` + newKey + `"` + `] = "` + blankMap[key].(string) + `"` + "\n"
+		content.WriteString(`  ` + mapName + `["` + newKey + `"` + `] = "` + blankMap[key].(string) + `"` + "\n")
 	}
 
-	return content
+	return content.String()
 }
 
 func readFilesToMap(path string, info os.FileInfo, err error) error {

src/internal/authentication/authentication.go

@@ -1,21 +1,21 @@
 package authentication
 
 import (
-  "encoding/json"
+	"encoding/json"
-  "errors"
+	"errors"
-  "io/ioutil"
+	"io/ioutil"
-  "net/http"
+	"net/http"
-  "os"
+	"os"
-  "path/filepath"
+	"path/filepath"
 
-  "crypto/hmac"
+	"crypto/hmac"
-  "crypto/rand"
+	"crypto/rand"
-  "crypto/sha256"
+	"crypto/sha256"
-  "encoding/base64"
+	"encoding/base64"
 
-  "time"
+	"time"
-  //"fmt"
+	//"fmt"
-  //"log"
+	//"log"
 )
 
 const tokenLength = 40
@@ -27,19 +27,19 @@ var database string
 
 var databaseFile = "authentication.json"
 
-var data = make(map[string]interface{})
+var data = make(map[string]any)
-var tokens = make(map[string]interface{})
+var tokens = make(map[string]any)
 
 var initAuthentication = false
 
 // Cookie : cookie
 type Cookie struct {
-  Name       string
+	Name       string
-  Value      string
+	Value      string
-  Path       string
+	Path       string
-  Domain     string
+	Domain     string
-  Expires    time.Time
+	Expires    time.Time
-  RawExpires string
+	RawExpires string
 }
 
 // Framework examples
@@ -128,465 +128,465 @@ func main() {
 
 // Init : databasePath = Path to authentication.json
 func Init(databasePath string, validity int) (err error) {
-  database = filepath.Dir(databasePath) + string(os.PathSeparator) + databaseFile
+	database = filepath.Dir(databasePath) + string(os.PathSeparator) + databaseFile
 
-  // Check if the database already exists
+	// Check if the database already exists
-  if _, err = os.Stat(database); os.IsNotExist(err) {
+	if _, err = os.Stat(database); os.IsNotExist(err) {
-    // Create an empty database
+		// Create an empty database
-    var defaults = make(map[string]interface{})
+		var defaults = make(map[string]any)
-    defaults["dbVersion"] = "1.0"
+		defaults["dbVersion"] = "1.0"
-    defaults["hash"] = "sha256"
+		defaults["hash"] = "sha256"
-    defaults["users"] = make(map[string]interface{})
+		defaults["users"] = make(map[string]any)
 
-    if saveDatabase(defaults) != nil {
+		if saveDatabase(defaults) != nil {
-      return
+			return
-    }
+		}
-  }
+	}
 
-  // Loading the database
+	// Loading the database
-  err = loadDatabase()
+	err = loadDatabase()
 
-  // Set Token Validity
+	// Set Token Validity
-  tokenValidity = validity
+	tokenValidity = validity
-  initAuthentication = true
+	initAuthentication = true
-  return
+	return
 }
 
 // CreateDefaultUser = created efault user
 func CreateDefaultUser(username, password string) (err error) {
 
-  err = checkInit()
+	err = checkInit()
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  var users = data["users"].(map[string]interface{})
+	var users = data["users"].(map[string]any)
-  // Check if the default user exists
+	// Check if the default user exists
-  if len(users) > 0 {
+	if len(users) > 0 {
-    err = createError(001)
+		err = createError(001)
-    return
+		return
-  }
+	}
 
-  var defaults = defaultsForNewUser(username, password)
+	var defaults = defaultsForNewUser(username, password)
-  users[defaults["_id"].(string)] = defaults
+	users[defaults["_id"].(string)] = defaults
-  saveDatabase(data)
+	saveDatabase(data)
 
-  return
+	return
 }
 
 // CreateNewUser : create new user
 func CreateNewUser(username, password string) (userID string, err error) {
 
-  err = checkInit()
+	err = checkInit()
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  var checkIfTheUserAlreadyExists = func(username string, userData map[string]interface{}) (err error) {
+	var checkIfTheUserAlreadyExists = func(username string, userData map[string]any) (err error) {
-    var salt = userData["_salt"].(string)
+		var salt = userData["_salt"].(string)
-    var loginUsername = userData["_username"].(string)
+		var loginUsername = userData["_username"].(string)
 
-    if SHA256(username, salt) == loginUsername {
+		if SHA256(username, salt) == loginUsername {
-      err = createError(020)
+			err = createError(020)
-    }
+		}
 
-    return
+		return
-  }
+	}
 
-  var users = data["users"].(map[string]interface{})
+	var users = data["users"].(map[string]any)
-  for _, userData := range users {
+	for _, userData := range users {
-    err = checkIfTheUserAlreadyExists(username, userData.(map[string]interface{}))
+		err = checkIfTheUserAlreadyExists(username, userData.(map[string]any))
-    if err != nil {
+		if err != nil {
-      return
+			return
-    }
+		}
-  }
+	}
 
-  var defaults = defaultsForNewUser(username, password)
+	var defaults = defaultsForNewUser(username, password)
-  userID = defaults["_id"].(string)
+	userID = defaults["_id"].(string)
-  users[userID] = defaults
+	users[userID] = defaults
 
-  saveDatabase(data)
+	saveDatabase(data)
 
-  return
+	return
 }
 
 // UserAuthentication : user authentication
 func UserAuthentication(username, password string) (token string, err error) {
 
-  err = checkInit()
+	err = checkInit()
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  var login = func(username, password string, loginData map[string]interface{}) (err error) {
+	var login = func(username, password string, loginData map[string]any) (err error) {
-    err = createError(010)
+		err = createError(010)
 
-    var salt = loginData["_salt"].(string)
+		var salt = loginData["_salt"].(string)
-    var loginUsername = loginData["_username"].(string)
+		var loginUsername = loginData["_username"].(string)
-    var loginPassword = loginData["_password"].(string)
+		var loginPassword = loginData["_password"].(string)
 
-    if SHA256(username, salt) == loginUsername {
+		if SHA256(username, salt) == loginUsername {
-      if SHA256(password, salt) == loginPassword {
+			if SHA256(password, salt) == loginPassword {
-        err = nil
+				err = nil
-      }
+			}
-    }
+		}
 
-    return
+		return
-  }
+	}
 
-  var users = data["users"].(map[string]interface{})
+	var users = data["users"].(map[string]any)
-  for id, loginData := range users {
+	for id, loginData := range users {
-    err = login(username, password, loginData.(map[string]interface{}))
+		err = login(username, password, loginData.(map[string]any))
-    if err == nil {
+		if err == nil {
-      token = setToken(id, "-")
+			token = setToken(id, "-")
-      return
+			return
-    }
+		}
-  }
+	}
 
-  return
+	return
 }
 
 // CheckTheValidityOfTheToken : check token
 func CheckTheValidityOfTheToken(token string) (newToken string, err error) {
 
-  err = checkInit()
+	err = checkInit()
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  err = createError(011)
+	err = createError(011)
 
-  if v, ok := tokens[token]; ok {
+	if v, ok := tokens[token]; ok {
-    var expires = v.(map[string]interface{})["expires"].(time.Time)
+		var expires = v.(map[string]any)["expires"].(time.Time)
-    var userID = v.(map[string]interface{})["id"].(string)
+		var userID = v.(map[string]any)["id"].(string)
 
-    if expires.Sub(time.Now().Local()) < 0 {
+		if expires.Sub(time.Now().Local()) < 0 {
-      return
+			return
-    }
+		}
 
-    newToken = setToken(userID, token)
+		newToken = setToken(userID, token)
 
-    err = nil
+		err = nil
 
-  } else {
+	} else {
-    return
+		return
-  }
+	}
 
-  return
+	return
 }
 
 // GetUserID : get user ID
 func GetUserID(token string) (userID string, err error) {
 
-  err = checkInit()
+	err = checkInit()
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  err = createError(002)
+	err = createError(002)
 
-  if v, ok := tokens[token]; ok {
+	if v, ok := tokens[token]; ok {
-    var expires = v.(map[string]interface{})["expires"].(time.Time)
+		var expires = v.(map[string]any)["expires"].(time.Time)
-    userID = v.(map[string]interface{})["id"].(string)
+		userID = v.(map[string]any)["id"].(string)
 
-    if expires.Sub(time.Now().Local()) < 0 {
+		if expires.Sub(time.Now().Local()) < 0 {
-      return
+			return
-    }
+		}
 
-    err = nil
+		err = nil
-  }
+	}
 
-  return
+	return
 }
 
 // WriteUserData : save user date
-func WriteUserData(userID string, userData map[string]interface{}) (err error) {
+func WriteUserData(userID string, userData map[string]any) (err error) {
 
-  err = checkInit()
+	err = checkInit()
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  err = createError(030)
+	err = createError(030)
 
-  if v, ok := data["users"].(map[string]interface{})[userID].(map[string]interface{}); ok {
+	if v, ok := data["users"].(map[string]any)[userID].(map[string]any); ok {
 
-    v["data"] = userData
+		v["data"] = userData
-    err = saveDatabase(data)
+		err = saveDatabase(data)
 
-  } else {
+	} else {
-    return
+		return
-  }
+	}
 
-  return
+	return
 }
 
 // ReadUserData : load user date
-func ReadUserData(userID string) (userData map[string]interface{}, err error) {
+func ReadUserData(userID string) (userData map[string]any, err error) {
 
-  err = checkInit()
+	err = checkInit()
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  err = createError(031)
+	err = createError(031)
 
-  if v, ok := data["users"].(map[string]interface{})[userID].(map[string]interface{}); ok {
+	if v, ok := data["users"].(map[string]any)[userID].(map[string]any); ok {
-    userData = v["data"].(map[string]interface{})
+		userData = v["data"].(map[string]any)
-    err = nil
+		err = nil
 
-    return
+		return
-  }
+	}
 
-  return
+	return
 }
 
 // RemoveUser : remove user
 func RemoveUser(userID string) (err error) {
 
-  err = checkInit()
+	err = checkInit()
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  err = createError(032)
+	err = createError(032)
 
-  if _, ok := data["users"].(map[string]interface{})[userID]; ok {
+	if _, ok := data["users"].(map[string]any)[userID]; ok {
 
-    delete(data["users"].(map[string]interface{}), userID)
+		delete(data["users"].(map[string]any), userID)
-    err = saveDatabase(data)
+		err = saveDatabase(data)
 
-    return
+		return
-  }
+	}
 
-  return
+	return
 }
 
 // SetDefaultUserData : set default user data
-func SetDefaultUserData(defaults map[string]interface{}) (err error) {
+func SetDefaultUserData(defaults map[string]any) (err error) {
 
-  allUserData, err := GetAllUserData()
+	allUserData, err := GetAllUserData()
 
-  for _, d := range allUserData {
+	for _, d := range allUserData {
-    var data = d.(map[string]interface{})["data"].(map[string]interface{})
+		var data = d.(map[string]any)["data"].(map[string]any)
-    var userID = d.(map[string]interface{})["_id"].(string)
+		var userID = d.(map[string]any)["_id"].(string)
 
-    for k, v := range defaults {
+		for k, v := range defaults {
-      if _, ok := data[k]; ok {
+			if _, ok := data[k]; ok {
-        // Key exist
+				// Key exist
-      } else {
+			} else {
-        data[k] = v
+				data[k] = v
-      }
+			}
-    }
+		}
-    err = WriteUserData(userID, data)
+		err = WriteUserData(userID, data)
-  }
+	}
-  return
+	return
 }
 
 // ChangeCredentials : change credentials
 func ChangeCredentials(userID, username, password string) (err error) {
-  err = checkInit()
+	err = checkInit()
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  err = createError(032)
+	err = createError(032)
 
-  if userData, ok := data["users"].(map[string]interface{})[userID]; ok {
+	if userData, ok := data["users"].(map[string]any)[userID]; ok {
-    //var userData = tmp.(map[string]interface{})
+		//var userData = tmp.(map[string]interface{})
-    var salt = userData.(map[string]interface{})["_salt"].(string)
+		var salt = userData.(map[string]any)["_salt"].(string)
 
-    if len(username) > 0 {
+		if len(username) > 0 {
-      userData.(map[string]interface{})["_username"] = SHA256(username, salt)
+			userData.(map[string]any)["_username"] = SHA256(username, salt)
-    }
+		}
 
-    if len(password) > 0 {
+		if len(password) > 0 {
-      userData.(map[string]interface{})["_password"] = SHA256(password, salt)
+			userData.(map[string]any)["_password"] = SHA256(password, salt)
-    }
+		}
 
-    err = saveDatabase(data)
+		err = saveDatabase(data)
-  }
+	}
 
-  return
+	return
 }
 
 // GetAllUserData : get all user data
-func GetAllUserData() (allUserData map[string]interface{}, err error) {
+func GetAllUserData() (allUserData map[string]any, err error) {
 
-  err = checkInit()
+	err = checkInit()
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  if len(data) == 0 {
+	if len(data) == 0 {
-    var defaults = make(map[string]interface{})
+		var defaults = make(map[string]any)
-    defaults["dbVersion"] = "1.0"
+		defaults["dbVersion"] = "1.0"
-    defaults["hash"] = "sha256"
+		defaults["hash"] = "sha256"
-    defaults["users"] = make(map[string]interface{})
+		defaults["users"] = make(map[string]any)
-    saveDatabase(defaults)
+		saveDatabase(defaults)
-    data = defaults
+		data = defaults
-  }
+	}
 
-  allUserData = data["users"].(map[string]interface{})
+	allUserData = data["users"].(map[string]any)
-  return
+	return
 }
 
 // CheckTheValidityOfTheTokenFromHTTPHeader : get token from HTTP header
 func CheckTheValidityOfTheTokenFromHTTPHeader(w http.ResponseWriter, r *http.Request) (writer http.ResponseWriter, newToken string, err error) {
-  err = createError(011)
+	err = createError(011)
-  for _, cookie := range r.Cookies() {
+	for _, cookie := range r.Cookies() {
-    if cookie.Name == "Token" {
+		if cookie.Name == "Token" {
-      var token string
+			var token string
-      token, err = CheckTheValidityOfTheToken(cookie.Value)
+			token, err = CheckTheValidityOfTheToken(cookie.Value)
-      //fmt.Println("T", token, err)
+			//fmt.Println("T", token, err)
-      writer = SetCookieToken(w, token)
+			writer = SetCookieToken(w, token)
-      newToken = token
+			newToken = token
-    }
+		}
-  }
+	}
-  //fmt.Println(err)
+	//fmt.Println(err)
-  return
+	return
 }
 
 // Framework tools
 
 func checkInit() (err error) {
-  if initAuthentication == false {
+	if initAuthentication == false {
-    err = createError(000)
+		err = createError(000)
-  }
+	}
 
-  return
+	return
 }
 
-func saveDatabase(tmpMap interface{}) (err error) {
+func saveDatabase(tmpMap any) (err error) {
 
-  jsonString, err := json.MarshalIndent(tmpMap, "", "  ")
+	jsonString, err := json.MarshalIndent(tmpMap, "", "  ")
 
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  err = ioutil.WriteFile(database, []byte(jsonString), 0600)
+	err = ioutil.WriteFile(database, []byte(jsonString), 0600)
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  return
+	return
 }
 
 func loadDatabase() (err error) {
-  jsonString, err := ioutil.ReadFile(database)
+	jsonString, err := ioutil.ReadFile(database)
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  err = json.Unmarshal([]byte(jsonString), &data)
+	err = json.Unmarshal([]byte(jsonString), &data)
-  if err != nil {
+	if err != nil {
-    return
+		return
-  }
+	}
 
-  return
+	return
 }
 
 // SHA256 : password + salt = sha256 string
 func SHA256(secret, salt string) string {
-  key := []byte(secret)
+	key := []byte(secret)
-  h := hmac.New(sha256.New, key)
+	h := hmac.New(sha256.New, key)
-  h.Write([]byte("_remote_db"))
+	h.Write([]byte("_remote_db"))
-  return base64.StdEncoding.EncodeToString(h.Sum(nil))
+	return base64.StdEncoding.EncodeToString(h.Sum(nil))
 }
 
 func randomString(n int) string {
-  const alphanum = "-AbCdEfGhIjKlMnOpQrStUvWxYz0123456789aBcDeFgHiJkLmNoPqRsTuVwXyZ_"
+	const alphanum = "-AbCdEfGhIjKlMnOpQrStUvWxYz0123456789aBcDeFgHiJkLmNoPqRsTuVwXyZ_"
 
-  var bytes = make([]byte, n)
+	var bytes = make([]byte, n)
-  rand.Read(bytes)
+	rand.Read(bytes)
-  for i, b := range bytes {
+	for i, b := range bytes {
-    bytes[i] = alphanum[b%byte(len(alphanum))]
+		bytes[i] = alphanum[b%byte(len(alphanum))]
-  }
+	}
-  return string(bytes)
+	return string(bytes)
 }
 
 func randomID(n int) string {
-  const alphanum = "ABCDEFGHJKLMNOPQRSTUVWXYZ0123456789"
+	const alphanum = "ABCDEFGHJKLMNOPQRSTUVWXYZ0123456789"
 
-  var bytes = make([]byte, n)
+	var bytes = make([]byte, n)
-  rand.Read(bytes)
+	rand.Read(bytes)
-  for i, b := range bytes {
+	for i, b := range bytes {
-    bytes[i] = alphanum[b%byte(len(alphanum))]
+		bytes[i] = alphanum[b%byte(len(alphanum))]
-  }
+	}
-  return string(bytes)
+	return string(bytes)
 }
 
 func createError(errCode int) (err error) {
-  var errMsg string
+	var errMsg string
-  switch errCode {
+	switch errCode {
-  case 000:
+	case 000:
-    errMsg = "Authentication has not yet been initialized"
+		errMsg = "Authentication has not yet been initialized"
-  case 001:
+	case 001:
-    errMsg = "Default user already exists"
+		errMsg = "Default user already exists"
-  case 002:
+	case 002:
-    errMsg = "No user id found for this token"
+		errMsg = "No user id found for this token"
-  case 010:
+	case 010:
-    errMsg = "User authentication failed"
+		errMsg = "User authentication failed"
-  case 011:
+	case 011:
-    errMsg = "Session has expired"
+		errMsg = "Session has expired"
-  case 020:
+	case 020:
-    errMsg = "User already exists"
+		errMsg = "User already exists"
-  case 030:
+	case 030:
-    errMsg = "User data could not be saved"
+		errMsg = "User data could not be saved"
-  case 031:
+	case 031:
-    errMsg = "User data could not be read"
+		errMsg = "User data could not be read"
-  case 032:
+	case 032:
-    errMsg = "User ID was not found"
+		errMsg = "User ID was not found"
-  }
+	}
 
-  err = errors.New(errMsg)
+	err = errors.New(errMsg)
-  return
+	return
 }
 
-func defaultsForNewUser(username, password string) map[string]interface{} {
+func defaultsForNewUser(username, password string) map[string]any {
-  var defaults = make(map[string]interface{})
+	var defaults = make(map[string]any)
-  var salt = randomString(saltLength)
+	var salt = randomString(saltLength)
-  defaults["_username"] = SHA256(username, salt)
+	defaults["_username"] = SHA256(username, salt)
-  defaults["_password"] = SHA256(password, salt)
+	defaults["_password"] = SHA256(password, salt)
-  defaults["_salt"] = salt
+	defaults["_salt"] = salt
-  defaults["_id"] = "id-" + randomID(idLength)
+	defaults["_id"] = "id-" + randomID(idLength)
-  //defaults["_one.time.token"] = randomString(tokenLength)
+	//defaults["_one.time.token"] = randomString(tokenLength)
-  defaults["data"] = make(map[string]interface{})
+	defaults["data"] = make(map[string]any)
 
-  return defaults
+	return defaults
 }
 
 func setToken(id, oldToken string) (newToken string) {
-  delete(tokens, oldToken)
+	delete(tokens, oldToken)
 
 loopToken:
-  newToken = randomString(tokenLength)
+	newToken = randomString(tokenLength)
-  if _, ok := tokens[newToken]; ok {
+	if _, ok := tokens[newToken]; ok {
-    goto loopToken
+		goto loopToken
-  }
+	}
 
-  var tmp = make(map[string]interface{})
+	var tmp = make(map[string]any)
-  tmp["id"] = id
+	tmp["id"] = id
-  tmp["expires"] = time.Now().Local().Add(time.Minute * time.Duration(tokenValidity))
+	tmp["expires"] = time.Now().Local().Add(time.Minute * time.Duration(tokenValidity))
 
-  tokens[newToken] = tmp
+	tokens[newToken] = tmp
 
-  return
+	return
 }
 
-func mapToJSON(tmpMap interface{}) string {
+func mapToJSON(tmpMap any) string {
-  jsonString, err := json.MarshalIndent(tmpMap, "", "  ")
+	jsonString, err := json.MarshalIndent(tmpMap, "", "  ")
-  if err != nil {
+	if err != nil {
-    return "{}"
+		return "{}"
-  }
+	}
-  return string(jsonString)
+	return string(jsonString)
 }
 
 // SetCookieToken : set cookie
 func SetCookieToken(w http.ResponseWriter, token string) http.ResponseWriter {
-  expiration := time.Now().Add(time.Minute * time.Duration(tokenValidity))
+	expiration := time.Now().Add(time.Minute * time.Duration(tokenValidity))
-  cookie := http.Cookie{Name: "Token", Value: token, Expires: expiration}
+	cookie := http.Cookie{Name: "Token", Value: token, Expires: expiration}
-  http.SetCookie(w, &cookie)
+	http.SetCookie(w, &cookie)
-  return w
+	return w
 }

src/internal/m3u-parser/m3u-parser_test.go

@@ -1,84 +1,84 @@
 package m3u
 
 import (
-  "encoding/json"
+	"encoding/json"
-  "fmt"
+	"fmt"
-  "io/ioutil"
+	"io/ioutil"
-  "log"
+	"log"
-  "testing"
+	"testing"
 )
 
 type M3UStream struct {
-  GroupTitle string `json:"group-title,required"`
+	GroupTitle string `json:"group-title,required"`
-  Name       string `json:"name,required"`
+	Name       string `json:"name,required"`
-  TvgID      string `json:"tvg-id,required"`
+	TvgID      string `json:"tvg-id,required"`
-  TvgLogo    string `json:"tvg-logo,required"`
+	TvgLogo    string `json:"tvg-logo,required"`
-  TvgName    string `json:"tvg-name,required"`
+	TvgName    string `json:"tvg-name,required"`
-  URL        string `json:"url,required"`
+	URL        string `json:"url,required"`
-  UUIDKey    string `json:"_uuid.key,omitempty"`
+	UUIDKey    string `json:"_uuid.key,omitempty"`
-  UUIDValue  string `json:"_uuid.value,omitempty"`
+	UUIDValue  string `json:"_uuid.value,omitempty"`
 }
 
 func TestStream1(t *testing.T) {
 
-  var file = "test_list_1.m3u"
+	var file = "test_list_1.m3u"
-  var content, err = ioutil.ReadFile(file)
+	var content, err = ioutil.ReadFile(file)
-  if err != nil {
+	if err != nil {
-    t.Error(err)
+		t.Error(err)
-    return
+		return
-  }
+	}
 
-  streams, err := MakeInterfaceFromM3U(content)
+	streams, err := MakeInterfaceFromM3U(content)
 
-  if err != nil {
+	if err != nil {
-    t.Error(err)
+		t.Error(err)
-  }
+	}
 
-  err = checkStream(streams)
+	err = checkStream(streams)
-  if err != nil {
+	if err != nil {
-    t.Error(err)
+		t.Error(err)
-  }
+	}
 
-  fmt.Println("Streams:", len(streams))
+	fmt.Println("Streams:", len(streams))
-  t.Log(streams)
+	t.Log(streams)
 
 }
 
-func checkStream(streamInterface []interface{}) (err error) {
+func checkStream(streamInterface []any) (err error) {
 
-  for i, s := range streamInterface {
+	for i, s := range streamInterface {
 
-    var stream = s.(map[string]string)
+		var stream = s.(map[string]string)
-    var m3uStream M3UStream
+		var m3uStream M3UStream
 
-    jsonString, err := json.MarshalIndent(stream, "", "  ")
+		jsonString, err := json.MarshalIndent(stream, "", "  ")
 
-    if err == nil {
+		if err == nil {
 
-      err = json.Unmarshal(jsonString, &m3uStream)
+			err = json.Unmarshal(jsonString, &m3uStream)
-      if err == nil {
+			if err == nil {
 
-        log.Print(fmt.Sprintf("Stream:        %d", i))
+				log.Print(fmt.Sprintf("Stream:        %d", i))
-        log.Print(fmt.Sprintf("Name*:         %s", m3uStream.Name))
+				log.Print(fmt.Sprintf("Name*:         %s", m3uStream.Name))
-        log.Print(fmt.Sprintf("URL*:          %s", m3uStream.URL))
+				log.Print(fmt.Sprintf("URL*:          %s", m3uStream.URL))
-        log.Print(fmt.Sprintf("tvg-name:      %s", m3uStream.TvgName))
+				log.Print(fmt.Sprintf("tvg-name:      %s", m3uStream.TvgName))
-        log.Print(fmt.Sprintf("tvg-id**:      %s", m3uStream.TvgID))
+				log.Print(fmt.Sprintf("tvg-id**:      %s", m3uStream.TvgID))
-        log.Print(fmt.Sprintf("tvg-logo:      %s", m3uStream.TvgLogo))
+				log.Print(fmt.Sprintf("tvg-logo:      %s", m3uStream.TvgLogo))
-        log.Print(fmt.Sprintf("group-title**: %s", m3uStream.GroupTitle))
+				log.Print(fmt.Sprintf("group-title**: %s", m3uStream.GroupTitle))
 
-        if len(m3uStream.UUIDKey) > 0 {
+				if len(m3uStream.UUIDKey) > 0 {
-          log.Print(fmt.Sprintf("UUID key***:   %s", m3uStream.UUIDKey))
+					log.Print(fmt.Sprintf("UUID key***:   %s", m3uStream.UUIDKey))
-          log.Print(fmt.Sprintf("UUID value:    %s", m3uStream.UUIDValue))
+					log.Print(fmt.Sprintf("UUID value:    %s", m3uStream.UUIDValue))
-        } else {
+				} else {
-          log.Print(fmt.Sprintf("UUID key:    false"))
+					log.Print(fmt.Sprintf("UUID key:    false"))
-        }
+				}
 
-      }
+			}
 
-    }
+		}
 
-    log.Println(fmt.Sprintf("- - - - - (*: Required) | (**: Nice to have) | (***: Love it) - - - - -"))
+		log.Println(fmt.Sprintf("- - - - - (*: Required) | (**: Nice to have) | (***: Love it) - - - - -"))
-  }
+	}
 
-  return
+	return
 }

src/internal/m3u-parser/xteve_m3uParser.go

@@ -1,186 +1,186 @@
 package m3u
 
 import (
-  "errors"
+	"errors"
-  "fmt"
+	"fmt"
-  "log"
+	"log"
-  "net/url"
+	"net/url"
-  "regexp"
+	"regexp"
-  "strings"
+	"strings"
 )
 
 // MakeInterfaceFromM3U :
-func MakeInterfaceFromM3U(byteStream []byte) (allChannels []interface{}, err error) {
+func MakeInterfaceFromM3U(byteStream []byte) (allChannels []any, err error) {
 
-  var content = string(byteStream)
+	var content = string(byteStream)
-  var channelName string
+	var channelName string
-  var uuids []string
+	var uuids []string
 
-  var parseMetaData = func(channel string) (stream map[string]string) {
+	var parseMetaData = func(channel string) (stream map[string]string) {
 
-    stream = make(map[string]string)
+		stream = make(map[string]string)
-    var exceptForParameter = `[a-z-A-Z=]*(".*?")`
+		var exceptForParameter = `[a-z-A-Z=]*(".*?")`
-    var exceptForChannelName = `,([^\n]*|,[^\r]*)`
+		var exceptForChannelName = `,([^\n]*|,[^\r]*)`
 
-    var lines = strings.Split(strings.Replace(channel, "\r\n", "\n", -1), "\n")
+		var lines = strings.Split(strings.Replace(channel, "\r\n", "\n", -1), "\n")
 
-    // Zeilen mit # und leerer Zeilen entfernen
+		// Zeilen mit # und leerer Zeilen entfernen
-    for i := len(lines) - 1; i >= 0; i-- {
+		for i := len(lines) - 1; i >= 0; i-- {
 
-      if len(lines[i]) == 0 || lines[i][0:1] == "#" {
+			if len(lines[i]) == 0 || lines[i][0:1] == "#" {
-        lines = append(lines[:i], lines[i+1:]...)
+				lines = append(lines[:i], lines[i+1:]...)
-      }
+			}
 
-    }
+		}
 
-    if len(lines) >= 2 {
+		if len(lines) >= 2 {
 
-      for _, line := range lines {
+			for _, line := range lines {
 
-        _, err := url.ParseRequestURI(line)
+				_, err := url.ParseRequestURI(line)
 
-        switch err {
+				switch err {
 
-        case nil:
+				case nil:
-          stream["url"] = strings.Trim(line, "\r\n")
+					stream["url"] = strings.Trim(line, "\r\n")
 
-        default:
+				default:
 
-          var value string
+					var value string
-          // Alle Parameter parsen
+					// Alle Parameter parsen
-          var p = regexp.MustCompile(exceptForParameter)
+					var p = regexp.MustCompile(exceptForParameter)
-          var streamParameter = p.FindAllString(line, -1)
+					var streamParameter = p.FindAllString(line, -1)
 
-          for _, p := range streamParameter {
+					for _, p := range streamParameter {
 
-            line = strings.Replace(line, p, "", 1)
+						line = strings.Replace(line, p, "", 1)
 
-            p = strings.Replace(p, `"`, "", -1)
+						p = strings.Replace(p, `"`, "", -1)
-            var parameter = strings.SplitN(p, "=", 2)
+						var parameter = strings.SplitN(p, "=", 2)
 
-            if len(parameter) == 2 {
+						if len(parameter) == 2 {
 
-              // TVG Key als Kleinbuchstaben speichern
+							// TVG Key als Kleinbuchstaben speichern
-              switch strings.Contains(parameter[0], "tvg") {
+							switch strings.Contains(parameter[0], "tvg") {
 
-              case true:
+							case true:
-                stream[strings.ToLower(parameter[0])] = parameter[1]
+								stream[strings.ToLower(parameter[0])] = parameter[1]
-              case false:
+							case false:
-                stream[parameter[0]] = parameter[1]
+								stream[parameter[0]] = parameter[1]
 
-              }
+							}
 
-              // URL's nicht an die Filterfunktion übergeben
+							// URL's nicht an die Filterfunktion übergeben
-              if !strings.Contains(parameter[1], "://") && len(parameter[1]) > 0 {
+							if !strings.Contains(parameter[1], "://") && len(parameter[1]) > 0 {
-                value = value + parameter[1] + " "
+								value = value + parameter[1] + " "
-              }
+							}
 
-            }
+						}
 
-          }
+					}
 
-          // Kanalnamen parsen
+					// Kanalnamen parsen
-          n := regexp.MustCompile(exceptForChannelName)
+					n := regexp.MustCompile(exceptForChannelName)
-          var name = n.FindAllString(line, 1)
+					var name = n.FindAllString(line, 1)
 
-          if len(name) > 0 {
+					if len(name) > 0 {
-            channelName = name[0]
+						channelName = name[0]
-            channelName = strings.Replace(channelName, `,`, "", 1)
+						channelName = strings.Replace(channelName, `,`, "", 1)
-            channelName = strings.TrimRight(channelName, "\r\n")
+						channelName = strings.TrimRight(channelName, "\r\n")
-            channelName = strings.TrimRight(channelName, " ")
+						channelName = strings.TrimRight(channelName, " ")
-          }
+					}
 
-          if len(channelName) == 0 {
+					if len(channelName) == 0 {
 
-            if v, ok := stream["tvg-name"]; ok {
+						if v, ok := stream["tvg-name"]; ok {
-              channelName = v
+							channelName = v
-            }
+						}
 
-          }
+					}
 
-          channelName = strings.TrimRight(channelName, " ")
+					channelName = strings.TrimRight(channelName, " ")
 
-          // Kanäle ohne Namen werden augelassen
+					// Kanäle ohne Namen werden augelassen
-          if len(channelName) == 0 {
+					if len(channelName) == 0 {
-            return
+						return
-          }
+					}
 
-          stream["name"] = channelName
+					stream["name"] = channelName
-          value = value + channelName
+					value = value + channelName
 
-          stream["_values"] = value
+					stream["_values"] = value
 
-        }
+				}
 
-      }
+			}
 
-    }
+		}
 
-    // Nach eindeutiger ID im Stream suchen
+		// Nach eindeutiger ID im Stream suchen
-    for key, value := range stream {
+		for key, value := range stream {
 
-      if !strings.Contains(strings.ToLower(key), "tvg-id") {
+			if !strings.Contains(strings.ToLower(key), "tvg-id") {
 
-        if strings.Contains(strings.ToLower(key), "id") {
+				if strings.Contains(strings.ToLower(key), "id") {
 
-          if indexOfString(value, uuids) != -1 {
+					if indexOfString(value, uuids) != -1 {
-            log.Println(fmt.Sprintf("Channel: %s - %s = %s ", stream["name"], key, value))
+						log.Println(fmt.Sprintf("Channel: %s - %s = %s ", stream["name"], key, value))
-            break
+						break
-          }
+					}
 
-          uuids = append(uuids, value)
+					uuids = append(uuids, value)
 
-          stream["_uuid.key"] = key
+					stream["_uuid.key"] = key
-          stream["_uuid.value"] = value
+					stream["_uuid.value"] = value
-          break
+					break
 
-        }
+				}
 
-      }
+			}
 
-    }
+		}
 
-    return
+		return
-  }
+	}
 
-  //fmt.Println(content)
+	//fmt.Println(content)
-  if strings.Contains(content, "#EXT-X-TARGETDURATION") || strings.Contains(content, "#EXT-X-MEDIA-SEQUENCE") {
+	if strings.Contains(content, "#EXT-X-TARGETDURATION") || strings.Contains(content, "#EXT-X-MEDIA-SEQUENCE") {
-    err = errors.New("Invalid M3U file, an extended M3U file is required.")
+		err = errors.New("Invalid M3U file, an extended M3U file is required.")
-    return
+		return
-  }
+	}
 
-  if strings.Contains(content, "#EXTM3U") {
+	if strings.Contains(content, "#EXTM3U") {
 
-    var channels = strings.Split(content, "#EXTINF")
+		var channels = strings.Split(content, "#EXTINF")
 
-    channels = append(channels[:0], channels[1:]...)
+		channels = append(channels[:0], channels[1:]...)
 
-    for _, channel := range channels {
+		for _, channel := range channels {
 
-      var stream = parseMetaData(channel)
+			var stream = parseMetaData(channel)
 
-      if len(stream) > 0 && stream != nil {
+			if len(stream) > 0 && stream != nil {
-        allChannels = append(allChannels, stream)
+				allChannels = append(allChannels, stream)
-      }
+			}
 
-    }
+		}
 
-  } else {
+	} else {
 
-    err = errors.New("Invalid M3U file, an extended M3U file is required.")
+		err = errors.New("Invalid M3U file, an extended M3U file is required.")
 
-  }
+	}
 
-  return
+	return
 }
 
 func indexOfString(element string, data []string) int {
 
-  for k, v := range data {
+	for k, v := range data {
-    if element == v {
+		if element == v {
-      return k
+			return k
-    }
+		}
-  }
+	}
 
-  return -1
+	return -1
 }

src/internal/up2date/client/client.go

@@ -22,7 +22,7 @@ type ClientInfo struct {
 	OS     string `json:"os,required"`
 	URL    string `json:"url,required"`
 
-	Response ServerResponse `json:"response,omitempty"`
+	Response ServerResponse `json:"response"`
 }
 
 // ServerResponse : Response from server after client request

src/m3u.go

@@ -13,7 +13,7 @@ import (
 )
 
 // Playlisten parsen
-func parsePlaylist(filename, fileType string) (channels []interface{}, err error) {
+func parsePlaylist(filename, fileType string) (channels []any, err error) {
 
 	content, err := readByteFromFile(filename)
 	var id = strings.TrimSuffix(getFilenameFromPath(filename), path.Ext(getFilenameFromPath(filename)))
@@ -34,7 +34,7 @@ func parsePlaylist(filename, fileType string) (channels []interface{}, err error
 }
 
 // Streams filtern
-func filterThisStream(s interface{}) (status bool) {
+func filterThisStream(s any) (status bool) {
 
 	status = false
 	var stream = s.(map[string]string)

src/plex_api.go

@@ -202,7 +202,7 @@ func getPlexConfig() (baseURL, token string, ready bool) {
 	return baseURL, token, true
 }
 
-func discoverPlexDVRs(baseURL, token string) (dvrs []map[string]interface{}, err error) {
+func discoverPlexDVRs(baseURL, token string) (dvrs []map[string]any, err error) {
 
 	status, body, err := doPlexRequest("GET", baseURL, "/livetv/dvrs", token)
 	if err != nil {
@@ -214,13 +214,13 @@ func discoverPlexDVRs(baseURL, token string) (dvrs []map[string]interface{}, err
 		return
 	}
 
-	var payload = make(map[string]interface{})
+	var payload = make(map[string]any)
 	err = json.Unmarshal(body, &payload)
 	if err != nil {
 		return
 	}
 
-	mediaContainer, ok := payload["MediaContainer"].(map[string]interface{})
+	mediaContainer, ok := payload["MediaContainer"].(map[string]any)
 	if ok == false {
 		err = errors.New("Plex API response missing MediaContainer")
 		return
@@ -228,7 +228,7 @@ func discoverPlexDVRs(baseURL, token string) (dvrs []map[string]interface{}, err
 
 	for _, key := range []string{"Dvr", "DVR", "Directory", "Metadata"} {
 		if raw, found := mediaContainer[key]; found == true {
-			if list, ok := raw.([]interface{}); ok == true {
+			if list, ok := raw.([]any); ok == true {
 				dvrs = convertToPlexMapSlice(list)
 				if len(dvrs) > 0 {
 					return
@@ -241,12 +241,12 @@ func discoverPlexDVRs(baseURL, token string) (dvrs []map[string]interface{}, err
 	return
 }
 
-func convertToPlexMapSlice(list []interface{}) (dvrs []map[string]interface{}) {
+func convertToPlexMapSlice(list []any) (dvrs []map[string]any) {
 
-	dvrs = make([]map[string]interface{}, 0, len(list))
+	dvrs = make([]map[string]any, 0, len(list))
 
 	for _, item := range list {
-		if dvr, ok := item.(map[string]interface{}); ok == true {
+		if dvr, ok := item.(map[string]any); ok == true {
 			dvrs = append(dvrs, dvr)
 		}
 	}
@@ -254,7 +254,7 @@ func convertToPlexMapSlice(list []interface{}) (dvrs []map[string]interface{}) {
 	return
 }
 
-func getPlexReloadEndpoints(dvr map[string]interface{}) (endpoints []string) {
+func getPlexReloadEndpoints(dvr map[string]any) (endpoints []string) {
 
 	endpoints = make([]string, 0, 6)
 	added := make(map[string]bool)
@@ -291,7 +291,7 @@ func getPlexReloadEndpoints(dvr map[string]interface{}) (endpoints []string) {
 	return
 }
 
-func getPlexMapString(data map[string]interface{}, field string) string {
+func getPlexMapString(data map[string]any, field string) string {
 
 	for key, value := range data {
 		if strings.EqualFold(key, field) == false {

src/provider.go

@@ -17,13 +17,13 @@ func getProviderData(fileType, fileID string) (err error) {
 	var fileExtension, serverFileName string
 	var body = make([]byte, 0)
 	var newProvider = false
-	var dataMap = make(map[string]interface{})
+	var dataMap = make(map[string]any)
 
 	var saveDateFromProvider = func(fileSource, serverFileName, id string, body []byte) (err error) {
 
-		var data = make(map[string]interface{})
+		var data = make(map[string]any)
 
-		if value, ok := dataMap[id].(map[string]interface{}); ok {
+		if value, ok := dataMap[id].(map[string]any); ok {
 			data = value
 		} else {
 			data["id.provider"] = id
@@ -65,7 +65,7 @@ func getProviderData(fileType, fileID string) (err error) {
 					}
 
 				case "compatibility":
-					data[key] = make(map[string]interface{})
+					data[key] = make(map[string]any)
 
 				case "counter.download":
 					data[key] = 0.0
@@ -142,7 +142,7 @@ func getProviderData(fileType, fileID string) (err error) {
 
 	for dataID, d := range dataMap {
 
-		var data = d.(map[string]interface{})
+		var data = d.(map[string]any)
 		var fileSource = data["file.source"].(string)
 		newProvider = false
 
@@ -220,8 +220,8 @@ func getProviderData(fileType, fileID string) (err error) {
 				}
 
 				// Fehler Counter um 1 erhöhen
-				var data = make(map[string]interface{})
+				var data = make(map[string]any)
-				if value, ok := dataMap[dataID].(map[string]interface{}); ok {
+				if value, ok := dataMap[dataID].(map[string]any); ok {
 
 					data = value
 					data["counter.error"] = data["counter.error"].(float64) + 1
@@ -238,9 +238,9 @@ func getProviderData(fileType, fileID string) (err error) {
 		// Berechnen der Fehlerquote
 		if newProvider == false {
 
-			if value, ok := dataMap[dataID].(map[string]interface{}); ok {
+			if value, ok := dataMap[dataID].(map[string]any); ok {
 
-				var data = make(map[string]interface{})
+				var data = make(map[string]any)
 				data = value
 
 				if data["counter.error"].(float64) == 0 {

src/struct-hdhr.go

@@ -47,11 +47,7 @@ type LineupStatus struct {
 }
 
 // Lineup : HDHR Lineup /lineup.json
-type Lineup []interface {
+type Lineup []any
-	//GuideName string `json:"GuideName"`
-	//GuideNumber string `json:"GuideNumber"`
-	//URL         string `json:"URL"`
-}
 
 // LineupStream : HDHR einzelner Stream im Lineup
 type LineupStream struct {

src/struct-system.go

@@ -149,18 +149,18 @@ type DataStruct struct {
 	}
 
 	Streams struct {
-		Active   []interface{}
+		Active   []any
-		All      []interface{}
+		All      []any
-		Inactive []interface{}
+		Inactive []any
 	}
 
 	XMLTV struct {
 		Files   []string
-		Mapping map[string]interface{}
+		Mapping map[string]any
 	}
 
 	XEPG struct {
-		Channels  map[string]interface{}
+		Channels  map[string]any
 		XEPGCount int64
 	}
 }
@@ -278,30 +278,30 @@ type SettingsStruct struct {
 	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"`
+		HDHR  map[string]any `json:"hdhr"`
-		M3U   map[string]interface{} `json:"m3u"`
+		M3U   map[string]any `json:"m3u"`
-		XMLTV map[string]interface{} `json:"xmltv"`
+		XMLTV map[string]any `json:"xmltv"`
 	} `json:"files"`
 
-	FilesUpdate               bool                  `json:"files.update"`
+	FilesUpdate               bool          `json:"files.update"`
-	Filter                    map[int64]interface{} `json:"filter"`
+	Filter                    map[int64]any `json:"filter"`
-	Key                       string                `json:"key,omitempty"`
+	Key                       string        `json:"key,omitempty"`
-	Language                  string                `json:"language"`
+	Language                  string        `json:"language"`
-	LogEntriesRAM             int                   `json:"log.entries.ram"`
+	LogEntriesRAM             int           `json:"log.entries.ram"`
-	M3U8AdaptiveBandwidthMBPS int                   `json:"m3u8.adaptive.bandwidth.mbps"`
+	M3U8AdaptiveBandwidthMBPS int           `json:"m3u8.adaptive.bandwidth.mbps"`
-	MappingFirstChannel       float64               `json:"mapping.first.channel"`
+	MappingFirstChannel       float64       `json:"mapping.first.channel"`
-	Port                      string                `json:"port"`
+	Port                      string        `json:"port"`
-	SSDP                      bool                  `json:"ssdp"`
+	SSDP                      bool          `json:"ssdp"`
-	TempPath                  string                `json:"temp.path"`
+	TempPath                  string        `json:"temp.path"`
-	Tuner                     int                   `json:"tuner"`
+	Tuner                     int           `json:"tuner"`
-	Update                    []string              `json:"update"`
+	Update                    []string      `json:"update"`
-	UpdateURL                 string                `json:"update.url,omitempty"`
+	UpdateURL                 string        `json:"update.url,omitempty"`
-	UserAgent                 string                `json:"user.agent"`
+	UserAgent                 string        `json:"user.agent"`
-	UUID                      string                `json:"uuid"`
+	UUID                      string        `json:"uuid"`
-	UDPxy                     string                `json:"udpxy"`
+	UDPxy                     string        `json:"udpxy"`
-	Version                   string                `json:"version"`
+	Version                   string        `json:"version"`
-	XepgReplaceMissingImages  bool                  `json:"xepg.replace.missing.images"`
+	XepgReplaceMissingImages  bool          `json:"xepg.replace.missing.images"`
-	XteveAutoUpdate           bool                  `json:"xteveAutoUpdate"`
+	XteveAutoUpdate           bool          `json:"xteveAutoUpdate"`
 }
 
 // LanguageUI : Sprache für das WebUI

src/struct-webserver.go

@@ -6,11 +6,11 @@ type RequestStruct struct {
 	Cmd string `json:"cmd,required"`
 
 	// Benutzer
-	DeleteUser bool                   `json:"deleteUser,omitempty"`
+	DeleteUser bool           `json:"deleteUser,omitempty"`
-	UserData   map[string]interface{} `json:"userData,omitempty"`
+	UserData   map[string]any `json:"userData,omitempty"`
 
 	// Mapping
-	EpgMapping map[string]interface{} `json:"epgMapping,omitempty"`
+	EpgMapping map[string]any `json:"epgMapping,omitempty"`
 
 	// Restore
 	Base64 string `json:"base64,omitempty"`
@@ -29,7 +29,7 @@ type RequestStruct struct {
 		BackupKeep               *int      `json:"backup.keep,omitempty"`
 		BackupPath               *string   `json:"backup.path,omitempty"`
 		Buffer                   *string   `json:"buffer,omitempty"`
-		BufferSize               *int      `json:"buffer.size.kb, omitempty"`
+		BufferSize               *int      `json:"buffer.size.kb,omitempty"`
 		BufferTimeout            *float64  `json:"buffer.timeout,omitempty"`
 		CacheImages              *bool     `json:"cache.images,omitempty"`
 		EpgSource                *string   `json:"epgSource,omitempty"`
@@ -47,20 +47,20 @@ type RequestStruct struct {
 		XteveAutoUpdate          *bool     `json:"xteveAutoUpdate,omitempty"`
 		SchemeM3U                *string   `json:"scheme.m3u,omitempty"`
 		SchemeXML                *string   `json:"scheme.xml,omitempty"`
-	} `json:"settings,omitempty"`
+	} `json:"settings"`
 
 	// Upload Logo
 	Filename string `json:"filename,omitempty"`
 
 	// Filter
-	Filter map[int64]interface{} `json:"filter,omitempty"`
+	Filter map[int64]any `json:"filter,omitempty"`
 
 	// Dateien (M3U, HDHR, XMLTV)
 	Files struct {
-		HDHR  map[string]interface{} `json:"hdhr,omitempty"`
+		HDHR  map[string]any `json:"hdhr,omitempty"`
-		M3U   map[string]interface{} `json:"m3u,omitempty"`
+		M3U   map[string]any `json:"m3u,omitempty"`
-		XMLTV map[string]interface{} `json:"xmltv,omitempty"`
+		XMLTV map[string]any `json:"xmltv,omitempty"`
-	} `json:"files,omitempty"`
+	} `json:"files"`
 
 	// Wizard
 	Wizard struct {
@@ -68,7 +68,7 @@ type RequestStruct struct {
 		M3U       *string `json:"m3u,omitempty"`
 		Tuner     *int    `json:"tuner,omitempty"`
 		XMLTV     *string `json:"xmltv,omitempty"`
-	} `json:"wizard,omitempty"`
+	} `json:"wizard"`
 }
 
 // ResponseStruct : Antworten an den Client (WEB)
@@ -87,7 +87,7 @@ type ResponseStruct struct {
 		Warnings  int    `json:"warnings"`
 		XEPGCount int64  `json:"xepg"`
 		XML       string `json:"xepg-url,required"`
-	} `json:"clientInfo,omitempty"`
+	} `json:"clientInfo"`
 
 	Data struct {
 		Playlist struct {
@@ -105,20 +105,20 @@ type ResponseStruct struct {
 		}
 	} `json:"data,required"`
 
-	Alert               string                 `json:"alert,omitempty"`
+	Alert               string             `json:"alert,omitempty"`
-	ConfigurationWizard bool                   `json:"configurationWizard,required"`
+	ConfigurationWizard bool               `json:"configurationWizard,required"`
-	Error               string                 `json:"err,omitempty"`
+	Error               string             `json:"err,omitempty"`
-	Log                 WebScreenLogStruct     `json:"log,required"`
+	Log                 WebScreenLogStruct `json:"log,required"`
-	LogoURL             string                 `json:"logoURL,omitempty"`
+	LogoURL             string             `json:"logoURL,omitempty"`
-	OpenLink            string                 `json:"openLink,omitempty"`
+	OpenLink            string             `json:"openLink,omitempty"`
-	OpenMenu            string                 `json:"openMenu,omitempty"`
+	OpenMenu            string             `json:"openMenu,omitempty"`
-	Reload              bool                   `json:"reload,omitempty"`
+	Reload              bool               `json:"reload,omitempty"`
-	Settings            SettingsStruct         `json:"settings,required"`
+	Settings            SettingsStruct     `json:"settings,required"`
-	Status              bool                   `json:"status,required"`
+	Status              bool               `json:"status,required"`
-	Token               string                 `json:"token,omitempty"`
+	Token               string             `json:"token,omitempty"`
-	Users               map[string]interface{} `json:"users,omitempty"`
+	Users               map[string]any     `json:"users,omitempty"`
-	Wizard              int                    `json:"wizard,omitempty"`
+	Wizard              int                `json:"wizard,omitempty"`
-	XEPG                map[string]interface{} `json:"xepg,required"`
+	XEPG                map[string]any     `json:"xepg,required"`
 
 	Notification map[string]Notification `json:"notification,omitempty"`
 }

src/system.go

@@ -59,7 +59,7 @@ func createSystemFiles() (err error) {
 		err = checkFile(filename)
 		if err != nil {
 			// Datei existiert nicht, wird jetzt erstellt
-			err = saveMapToJSONFile(filename, make(map[string]interface{}))
+			err = saveMapToJSONFile(filename, make(map[string]any))
 			if err != nil {
 				return
 			}
@@ -98,12 +98,12 @@ func loadSettings() (settings SettingsStruct, err error) {
 	}
 
 	// Deafult Werte setzten
-	var defaults = make(map[string]interface{})
+	var defaults = make(map[string]any)
-	var dataMap = make(map[string]interface{})
+	var dataMap = make(map[string]any)
 
-	dataMap["xmltv"] = make(map[string]interface{})
+	dataMap["xmltv"] = make(map[string]any)
-	dataMap["m3u"] = make(map[string]interface{})
+	dataMap["m3u"] = make(map[string]any)
-	dataMap["hdhr"] = make(map[string]interface{})
+	dataMap["hdhr"] = make(map[string]any)
 
 	defaultFFmpegPath := ""
 	if len(os.Getenv("XTEVE_CONFIG")) > 0 {
@@ -134,7 +134,7 @@ func loadSettings() (settings SettingsStruct, err error) {
 	defaults["vlc.options"] = System.VLC.DefaultOptions
 	defaults["files"] = dataMap
 	defaults["files.update"] = true
-	defaults["filter"] = make(map[string]interface{})
+	defaults["filter"] = make(map[string]any)
 	defaults["git.branch"] = System.Branch
 	defaults["language"] = "en"
 	defaults["log.entries.ram"] = 500

src/toolchain.go

@@ -159,7 +159,6 @@ func searchFileInOS(file string) (path string) {
 	return
 }
 
-//
 func removeChildItems(dir string) error {
 
 	files, err := filepath.Glob(filepath.Join(dir, "*"))
@@ -180,7 +179,7 @@ func removeChildItems(dir string) error {
 }
 
 // JSON
-func mapToJSON(tmpMap interface{}) string {
+func mapToJSON(tmpMap any) string {
 
 	jsonString, err := json.MarshalIndent(tmpMap, "", "  ")
 	if err != nil {
@@ -190,30 +189,30 @@ func mapToJSON(tmpMap interface{}) string {
 	return string(jsonString)
 }
 
-func jsonToMap(content string) map[string]interface{} {
+func jsonToMap(content string) map[string]any {
 
-	var tmpMap = make(map[string]interface{})
+	var tmpMap = make(map[string]any)
 	json.Unmarshal([]byte(content), &tmpMap)
 
 	return (tmpMap)
 }
 
-func jsonToMapInt64(content string) map[int64]interface{} {
+func jsonToMapInt64(content string) map[int64]any {
 
-	var tmpMap = make(map[int64]interface{})
+	var tmpMap = make(map[int64]any)
 	json.Unmarshal([]byte(content), &tmpMap)
 
 	return (tmpMap)
 }
 
-func jsonToInterface(content string) (tmpMap interface{}, err error) {
+func jsonToInterface(content string) (tmpMap any, err error) {
 
 	err = json.Unmarshal([]byte(content), &tmpMap)
 	return
 
 }
 
-func saveMapToJSONFile(file string, tmpMap interface{}) error {
+func saveMapToJSONFile(file string, tmpMap any) error {
 
 	var filename = getPlatformFile(file)
 	jsonString, err := json.MarshalIndent(tmpMap, "", "  ")
@@ -230,7 +229,7 @@ func saveMapToJSONFile(file string, tmpMap interface{}) error {
 	return nil
 }
 
-func loadJSONFileToMap(file string) (tmpMap map[string]interface{}, err error) {
+func loadJSONFileToMap(file string) (tmpMap map[string]any, err error) {
 
 	f, err := os.Open(getPlatformFile(file))
 	defer f.Close()
@@ -360,7 +359,7 @@ func randomString(n int) string {
 	return string(bytes)
 }
 
-func parseTemplate(content string, tmpMap map[string]interface{}) (result string) {
+func parseTemplate(content string, tmpMap map[string]any) (result string) {
 
 	t := template.Must(template.New("template").Parse(content))
 

src/update.go

@@ -192,7 +192,7 @@ checkVersion:
 			}
 
 			// Neuer Filter (WebUI). Alte Filtereinstellungen werden konvertiert
-			if oldFilter, ok := settingsMap["filter"].([]interface{}); ok {
+			if oldFilter, ok := settingsMap["filter"].([]any); ok {
 				var newFilterMap = convertToNewFilter(oldFilter)
 				settingsMap["filter"] = newFilterMap
 
@@ -252,11 +252,11 @@ checkVersion:
 	return
 }
 
-func convertToNewFilter(oldFilter []interface{}) (newFilterMap map[int]interface{}) {
+func convertToNewFilter(oldFilter []any) (newFilterMap map[int]any) {
 
-	newFilterMap = make(map[int]interface{})
+	newFilterMap = make(map[int]any)
 
-	switch reflect.TypeOf(oldFilter).Kind() {
+	switch reflect.TypeFor[[]interface{}]().Kind() {
 
 	case reflect.Slice:
 		s := reflect.ValueOf(oldFilter)
@@ -285,7 +285,7 @@ func setValueForUUID() (err error) {
 
 	for _, c := range xepg {
 
-		var xepgChannel = c.(map[string]interface{})
+		var xepgChannel = c.(map[string]any)
 
 		if uuidKey, ok := xepgChannel["_uuid.key"].(string); ok {
 

src/webUI.go

@@ -1,6 +1,6 @@
 package src
 
-var webUI = make(map[string]interface{})
+var webUI = make(map[string]any)
 
 func loadHTMLMap() {
 	webUI["html/configuration.html"] = "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"

src/webserver.go

@@ -558,7 +558,7 @@ func WS(w http.ResponseWriter, r *http.Request) {
 		default:
 			fmt.Println("+ + + + + + + + + + +", request.Cmd)
 
-			var requestMap = make(map[string]interface{}) // Debug
+			var requestMap = make(map[string]any) // Debug
 			_ = requestMap
 			if System.Dev == true {
 				fmt.Println(mapToJSON(requestMap))
@@ -591,7 +591,7 @@ func WS(w http.ResponseWriter, r *http.Request) {
 // Web : Web Server /web/
 func Web(w http.ResponseWriter, r *http.Request) {
 
-	var lang = make(map[string]interface{})
+	var lang = make(map[string]any)
 	var err error
 
 	var requestFile = strings.Replace(r.URL.Path, "/web", "html", -1)
@@ -1028,7 +1028,7 @@ func setDefaultResponseData(response ResponseStruct, data bool) (defaults Respon
 
 			defaults.ClientInfo.XEPGCount = Data.XEPG.XEPGCount
 
-			var XEPG = make(map[string]interface{})
+			var XEPG = make(map[string]any)
 
 			if len(Data.Streams.Active) > 0 {
 
@@ -1037,8 +1037,8 @@ func setDefaultResponseData(response ResponseStruct, data bool) (defaults Respon
 
 			} else {
 
-				XEPG["epgMapping"] = make(map[string]interface{})
+				XEPG["epgMapping"] = make(map[string]any)
-				XEPG["xmltvMap"] = make(map[string]interface{})
+				XEPG["xmltvMap"] = make(map[string]any)
 
 			}
 

src/xepg.go

@@ -212,9 +212,9 @@ func updateXEPG(background bool) {
 func createXEPGMapping() {
 
 	Data.XMLTV.Files = getLocalProviderFiles("xmltv")
-	Data.XMLTV.Mapping = make(map[string]interface{})
+	Data.XMLTV.Mapping = make(map[string]any)
 
-	var tmpMap = make(map[string]interface{})
+	var tmpMap = make(map[string]any)
 
 	var friendlyDisplayName = func(channel Channel) (displayName string) {
 		var dn = channel.DisplayName
@@ -255,10 +255,10 @@ func createXEPGMapping() {
 			if err == nil {
 
 				// Daten aus der XML Datei in eine temporäre Map schreiben
-				var xmltvMap = make(map[string]interface{})
+				var xmltvMap = make(map[string]any)
 
 				for _, c := range xmltv.Channel {
-					var channel = make(map[string]interface{})
+					var channel = make(map[string]any)
 
 					channel["id"] = c.ID
 					channel["display-name"] = friendlyDisplayName(*c)
@@ -276,7 +276,7 @@ func createXEPGMapping() {
 		}
 
 		Data.XMLTV.Mapping = tmpMap
-		tmpMap = make(map[string]interface{})
+		tmpMap = make(map[string]any)
 
 	} else {
 
@@ -287,7 +287,7 @@ func createXEPGMapping() {
 	}
 
 	// Auswahl für den Dummy erstellen
-	var dummy = make(map[string]interface{})
+	var dummy = make(map[string]any)
 	var times = []string{"30", "60", "90", "120", "180", "240", "360"}
 
 	for _, i := range times {
@@ -311,7 +311,7 @@ func createXEPGDatabase() (err error) {
 
 	var allChannelNumbers = make([]float64, 0, System.UnfilteredChannelLimit)
 	Data.Cache.Streams.Active = make([]string, 0, System.UnfilteredChannelLimit)
-	Data.XEPG.Channels = make(map[string]interface{}, System.UnfilteredChannelLimit)
+	Data.XEPG.Channels = make(map[string]any, System.UnfilteredChannelLimit)
 
 	Data.XEPG.Channels, err = loadJSONFileToMap(System.File.XEPG)
 	if err != nil {
@@ -554,16 +554,16 @@ func mapping() (err error) {
 
 				for file, xmltvChannels := range Data.XMLTV.Mapping {
 
-					if channel, ok := xmltvChannels.(map[string]interface{})[tvgID]; ok {
+					if channel, ok := xmltvChannels.(map[string]any)[tvgID]; ok {
 
-						if channelID, ok := channel.(map[string]interface{})["id"].(string); ok {
+						if channelID, ok := channel.(map[string]any)["id"].(string); ok {
 
 							xepgChannel.XmltvFile = file
 							xepgChannel.XMapping = channelID
 							xepgChannel.XActive = true
 
 							// Falls in der XMLTV Datei ein Logo existiert, wird dieses verwendet. Falls nicht, dann das Logo aus der M3U Datei
-							if icon, ok := channel.(map[string]interface{})["icon"].(string); ok {
+							if icon, ok := channel.(map[string]any)["icon"].(string); ok {
 								if len(icon) > 0 {
 									xepgChannel.TvgLogo = icon
 								}
@@ -590,9 +590,9 @@ func mapping() (err error) {
 
 			if file != "xTeVe Dummy" {
 
-				if value, ok := Data.XMLTV.Mapping[file].(map[string]interface{}); ok {
+				if value, ok := Data.XMLTV.Mapping[file].(map[string]any); ok {
 
-					if channel, ok := value[mapping].(map[string]interface{}); ok {
+					if channel, ok := value[mapping].(map[string]any); ok {
 
 						// Kanallogo aktualisieren
 						if logo, ok := channel["icon"].(string); ok {
@@ -672,7 +672,7 @@ func createXMLTVFile() (err error) {
 	}
 
 	if len(Data.XMLTV.Files) == 0 && len(Data.Streams.Active) == 0 {
-		Data.XEPG.Channels = make(map[string]interface{})
+		Data.XEPG.Channels = make(map[string]any)
 		return
 	}
 
@@ -844,7 +844,7 @@ func createDummyProgram(xepgChannel XEPGChannelStruct) (dummyXMLTV XMLTV) {
 		return
 	}
 
-	for d := 0; d < 4; d++ {
+	for d := range 4 {
 
 		var epgStartTime = startTime.Add(time.Hour * time.Duration(d*24))