Mention emby in README, add notices about password resets

setting is jellyfin/substitute_jellyfin_strings.

.gitignore

@@ -6,5 +6,6 @@ data/
 version.go
 notes
 docs/*
+lang/langtostruct.py
 config-payload.json
 !docs/go.mod

README.md

@@ -1,6 +1,6 @@
 # ![jfa-go](images/banner.svg)
 
-jfa-go is a user management app for [Jellyfin](https://github.com/jellyfin/jellyfin) that provides invite-based account creation as well as other features that make one's instance much easier to manage.
+jfa-go is a user management app for [Jellyfin](https://github.com/jellyfin/jellyfin) (and now [Emby](https://emby.media/)) that provides invite-based account creation as well as other features that make one's instance much easier to manage.
 
 I chose to rewrite the python [jellyfin-accounts](https://github.com/hrfee/jellyfin-accounts) in Go mainly as a learning experience, but also to slightly improve speeds and efficiency.
 

api.go

@@ -848,6 +848,11 @@ func parseDT(date string) time.Time {
 	if err == nil {
 		return dt
 	}
+	// emby method
+	dt, err = time.Parse("2006-01-02T15:04:05.0000000+00:00", date)
+	if err == nil {
+		return dt
+	}
 	// magic method
 	// some stored dates from jellyfin have no timezone at the end, if not we assume UTC
 	if date[len(date)-1] != 'Z' {
@@ -884,7 +889,6 @@ func (app *appContext) GetUsers(gc *gin.Context) {
 		if jfUser["LastActivityDate"] != nil {
 			date := parseDT(jfUser["LastActivityDate"].(string))
 			user.LastActive = app.formatDatetime(date)
-			// fmt.Printf("%s: %s, %s, %+v\n", jfUser["Name"].(string), jfUser["LastActivityDate"].(string), user.LastActive, date)
 		}
 		user.ID = jfUser["Id"].(string)
 		user.Name = jfUser["Name"].(string)
@@ -1046,6 +1050,7 @@ func (app *appContext) ApplySettings(gc *gin.Context) {
 		"homescreen": map[string]string{},
 	}
 	for _, id := range req.ApplyTo {
+		fmt.Printf("%+v\n", policy)
 		status, err := app.jf.SetPolicy(id, policy)
 		if !(status == 200 || status == 204) || err != nil {
 			errors["policy"][id] = fmt.Sprintf("%d: %s", status, err)
@@ -1118,6 +1123,18 @@ func (app *appContext) GetConfig(gc *gin.Context) {
 	s.Options = app.lang.langOptions
 	s.Value = app.lang.langOptions[app.lang.chosenIndex]
 	resp.Sections["ui"].Settings["language"] = s
+
+	t := resp.Sections["jellyfin"].Settings["type"]
+	opts := make([]string, len(serverTypes))
+	i := 0
+	for _, v := range serverTypes {
+		opts[i] = v
+		i++
+	}
+	t.Options = opts
+	t.Value = serverTypes[app.config.Section("jellyfin").Key("type").MustString("jellyfin")]
+	resp.Sections["jellyfin"].Settings["type"] = t
+
 	gc.JSON(200, resp)
 }
 
@@ -1147,6 +1164,13 @@ func (app *appContext) ModifyConfig(gc *gin.Context) {
 							break
 						}
 					}
+				} else if section == "jellyfin" && setting == "type" {
+					for k, v := range serverTypes {
+						if v == value.(string) {
+							tempConfig.Section("jellyfin").Key("type").SetValue(k)
+							break
+						}
+					}
 				} else {
 					tempConfig.Section(section).Key(setting).SetValue(value.(string))
 				}

config.go

@@ -82,5 +82,7 @@ func (app *appContext) loadConfig() error {
 
 	app.email = NewEmailer(app)
 
+	substituteStrings = app.config.Section("jellyfin").Key("substitute_jellyfin_strings").MustString("")
+
 	return nil
 }

config/config-base.json

@@ -54,6 +54,26 @@
                     "type": "number",
                     "value": 30,
                     "description": "Timeout of user cache in minutes. Set to 0 to disable."
+                },
+                "type": {
+                    "name": "Server type",
+                    "required": false,
+                    "requires_restart": true,
+                    "type": "select",
+                    "options": [
+                        "jellyfin",
+                        "emby"
+                    ],
+                    "value": "jellyfin",
+                    "description": "Note: Emby integration works is missing some features, such as Password Resets."
+                },
+                "substitute_jellyfin_strings": {
+                    "name": "Substitute occurrences of \"Jellyfin\"",
+                    "required": false,
+                    "requires_restart": true,
+                    "type": "text",
+                    "value": "",
+                    "description": "Optionally substitute occurrences of \"Jellyfin\" in the account creation form with this. May result in bad grammar."
                 }
             }
         },

config/jsontostruct.py

@@ -1,57 +0,0 @@
-import json
-
-with open("config-formatted.json", "r") as f:
-    config = json.load(f)
-
-indent = 0
-
-
-def writeln(ln):
-    global indent
-    if "}" in ln and "{" not in ln:
-        indent -= 1
-    s.write(("\t" * indent) + ln + "\n")
-    if "{" in ln and "}" not in ln:
-        indent += 1
-
-
-with open("configStruct.go", "w") as s:
-    writeln("package main")
-    writeln("")
-    writeln("type Metadata struct{")
-    writeln('Name string `json:"name"`')
-    writeln('Description string `json:"description"`')
-    writeln("}")
-    writeln("")
-    writeln("type Config struct{")
-    if "order" in config:
-        writeln('Order []string `json:"order"`')
-    for section in [x for x in config.keys() if x != "order"]:
-        title = "".join([x.title() for x in section.split("_")])
-        writeln(title + " struct{")
-        if "order" in config[section]:
-            writeln('Order []string `json:"order"`')
-        if "meta" in config[section]:
-            writeln('Meta Metadata `json:"meta"`')
-        for setting in [
-            x for x in config[section].keys() if x != "order" and x != "meta"
-        ]:
-            name = "".join([x.title() for x in setting.split("_")])
-            writeln(name + " struct{")
-            writeln('Name string `json:"name"`')
-            writeln('Required bool `json:"required"`')
-            writeln('Restart bool `json:"requires_restart"`')
-            writeln('Description string `json:"description"`')
-            writeln('Type string `json:"type"`')
-            dt = config[section][setting]["type"]
-            if dt == "select":
-                dt = "string"
-                writeln('Options []string `json:"options"`')
-            elif dt == "number":
-                dt = "int"
-            elif dt != "bool":
-                dt = "string"
-            writeln(f'Value {dt} `json:"value" cfg:"{setting}"`')
-            writeln("} " + f'`json:"{setting}" cfg:"{setting}"`')
-        writeln("} " + f'`json:"{section}"`')
-    writeln("}")

go.mod

@@ -4,7 +4,7 @@ go 1.14
 
 replace github.com/hrfee/jfa-go/docs => ./docs
 
-replace github.com/hrfee/jfa-go/jfapi => ./jfapi
+replace github.com/hrfee/jfa-go/mediabrowser => ./mediabrowser
 
 replace github.com/hrfee/jfa-go/common => ./common
 
@@ -24,9 +24,9 @@ require (
 	github.com/gofrs/uuid v3.3.0+incompatible // indirect
 	github.com/golang/protobuf v1.4.3
 	github.com/google/uuid v1.1.2 // indirect
-	github.com/hrfee/jfa-go/common v0.0.0-20201112212552-b6f3cd7c1f71
+	github.com/hrfee/jfa-go/common v0.0.0-20210105184019-fdc97b4e86cc
 	github.com/hrfee/jfa-go/docs v0.0.0-20201112212552-b6f3cd7c1f71
-	github.com/hrfee/jfa-go/jfapi v0.0.0-20201112212552-b6f3cd7c1f71
+	github.com/hrfee/jfa-go/mediabrowser v0.0.0-20201112212552-b6f3cd7c1f71
 	github.com/hrfee/jfa-go/ombi v0.0.0-20201112212552-b6f3cd7c1f71
 	github.com/jordan-wright/email v4.0.1-0.20200917010138-e1c00e156980+incompatible
 	github.com/json-iterator/go v1.1.10 // indirect

go.sum

@@ -139,6 +139,8 @@ github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/hrfee/jfa-go/jfapi v0.0.0-20210109010027-4aae65518089 h1:WRk+JAywI8V4u+PBQpdvXBX73yCZxgnLwyIiX7xL+Xc=
+github.com/hrfee/jfa-go/jfapi v0.0.0-20210109010027-4aae65518089/go.mod h1:Al1Rd1JGtpS+3KnK8t7+J0CZVDbT86QJrXHR6kZijds=
 github.com/jordan-wright/email v0.0.0-20200602115436-fd8a7622303e h1:OGunVjqY7y4U4laftpEHv+mvZBlr7UGimJXKEGQtg48=
 github.com/jordan-wright/email v0.0.0-20200602115436-fd8a7622303e/go.mod h1:Fy2gCFfZhay8jplf/Csj6cyH/oshQTkLQYZbKkcV+SY=
 github.com/jordan-wright/email v4.0.1-0.20200917010138-e1c00e156980+incompatible h1:CL0ooBNfbNyJTJATno+m0h+zM5bW6v7fKlboKUGP/dI=

jfapi/go.mod

@@ -1,7 +0,0 @@
-module github.com/hrfee/jfa-go/jfapi
-
-go 1.15
-
-replace github.com/hrfee/jfa-go/common => ../common
-
-require github.com/hrfee/jfa-go/common v0.0.0-00010101000000-000000000000

jfapi/jfapi.go

@@ -1,370 +0,0 @@
-package jfapi
-
-import (
-	"bytes"
-	"compress/gzip"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/hrfee/jfa-go/common"
-)
-
-type serverInfo struct {
-	LocalAddress string `json:"LocalAddress"`
-	Name         string `json:"ServerName"`
-	Version      string `json:"Version"`
-	OS           string `json:"OperatingSystem"`
-	ID           string `json:"Id"`
-}
-
-// Jellyfin represents a running Jellyfin instance.
-type Jellyfin struct {
-	Server         string
-	client         string
-	version        string
-	device         string
-	deviceID       string
-	useragent      string
-	auth           string
-	header         map[string]string
-	ServerInfo     serverInfo
-	Username       string
-	password       string
-	Authenticated  bool
-	AccessToken    string
-	userID         string
-	httpClient     *http.Client
-	loginParams    map[string]string
-	userCache      []map[string]interface{}
-	CacheExpiry    time.Time
-	cacheLength    int
-	noFail         bool
-	Hyphens        bool
-	timeoutHandler common.TimeoutHandler
-}
-
-// NewJellyfin returns a new Jellyfin object.
-func NewJellyfin(server, client, version, device, deviceID string, timeoutHandler common.TimeoutHandler, cacheTimeout int) (*Jellyfin, error) {
-	jf := &Jellyfin{}
-	jf.Server = server
-	jf.client = client
-	jf.version = version
-	jf.device = device
-	jf.deviceID = deviceID
-	jf.useragent = fmt.Sprintf("%s/%s", client, version)
-	jf.timeoutHandler = timeoutHandler
-	jf.auth = fmt.Sprintf("MediaBrowser Client=\"%s\", Device=\"%s\", DeviceId=\"%s\", Version=\"%s\"", client, device, deviceID, version)
-	jf.header = map[string]string{
-		"Accept":               "application/json",
-		"Content-type":         "application/json; charset=UTF-8",
-		"X-Application":        jf.useragent,
-		"Accept-Charset":       "UTF-8,*",
-		"Accept-Encoding":      "gzip",
-		"User-Agent":           jf.useragent,
-		"X-Emby-Authorization": jf.auth,
-	}
-	jf.httpClient = &http.Client{
-		Timeout: 10 * time.Second,
-	}
-	infoURL := fmt.Sprintf("%s/System/Info/Public", server)
-	req, _ := http.NewRequest("GET", infoURL, nil)
-	resp, err := jf.httpClient.Do(req)
-	defer jf.timeoutHandler()
-	if err == nil {
-		data, _ := ioutil.ReadAll(resp.Body)
-		json.Unmarshal(data, &jf.ServerInfo)
-	}
-	jf.cacheLength = cacheTimeout
-	jf.CacheExpiry = time.Now()
-	return jf, nil
-}
-
-// Authenticate attempts to authenticate using a username & password
-func (jf *Jellyfin) Authenticate(username, password string) (map[string]interface{}, int, error) {
-	jf.Username = username
-	jf.password = password
-	jf.loginParams = map[string]string{
-		"Username": username,
-		"Pw":       password,
-		"Password": password,
-	}
-	buffer := &bytes.Buffer{}
-	encoder := json.NewEncoder(buffer)
-	encoder.SetEscapeHTML(false)
-	err := encoder.Encode(jf.loginParams)
-	if err != nil {
-		return nil, 0, err
-	}
-	// loginParams, _ := json.Marshal(jf.loginParams)
-	url := fmt.Sprintf("%s/Users/authenticatebyname", jf.Server)
-	req, err := http.NewRequest("POST", url, buffer)
-	defer jf.timeoutHandler()
-	if err != nil {
-		return nil, 0, err
-	}
-	for name, value := range jf.header {
-		req.Header.Add(name, value)
-	}
-	resp, err := jf.httpClient.Do(req)
-	if err != nil || resp.StatusCode != 200 {
-		return nil, resp.StatusCode, err
-	}
-	defer resp.Body.Close()
-	var data io.Reader
-	switch resp.Header.Get("Content-Encoding") {
-	case "gzip":
-		data, _ = gzip.NewReader(resp.Body)
-	default:
-		data = resp.Body
-	}
-	var respData map[string]interface{}
-	json.NewDecoder(data).Decode(&respData)
-	jf.AccessToken = respData["AccessToken"].(string)
-	user := respData["User"].(map[string]interface{})
-	jf.userID = respData["User"].(map[string]interface{})["Id"].(string)
-	jf.auth = fmt.Sprintf("MediaBrowser Client=\"%s\", Device=\"%s\", DeviceId=\"%s\", Version=\"%s\", Token=\"%s\"", jf.client, jf.device, jf.deviceID, jf.version, jf.AccessToken)
-	jf.header["X-Emby-Authorization"] = jf.auth
-	jf.Authenticated = true
-	return user, resp.StatusCode, nil
-}
-
-func (jf *Jellyfin) get(url string, params map[string]string) (string, int, error) {
-	var req *http.Request
-	if params != nil {
-		jsonParams, _ := json.Marshal(params)
-		req, _ = http.NewRequest("GET", url, bytes.NewBuffer(jsonParams))
-	} else {
-		req, _ = http.NewRequest("GET", url, nil)
-	}
-	for name, value := range jf.header {
-		req.Header.Add(name, value)
-	}
-	resp, err := jf.httpClient.Do(req)
-	defer jf.timeoutHandler()
-	if err != nil || resp.StatusCode != 200 {
-		if resp.StatusCode == 401 && jf.Authenticated {
-			jf.Authenticated = false
-			_, _, authErr := jf.Authenticate(jf.Username, jf.password)
-			if authErr == nil {
-				v1, v2, v3 := jf.get(url, params)
-				return v1, v2, v3
-			}
-		}
-		return "", resp.StatusCode, err
-	}
-	defer resp.Body.Close()
-	var data io.Reader
-	encoding := resp.Header.Get("Content-Encoding")
-	switch encoding {
-	case "gzip":
-		data, _ = gzip.NewReader(resp.Body)
-	default:
-		data = resp.Body
-	}
-	buf := new(strings.Builder)
-	io.Copy(buf, data)
-	//var respData map[string]interface{}
-	//json.NewDecoder(data).Decode(&respData)
-	return buf.String(), resp.StatusCode, nil
-}
-
-func (jf *Jellyfin) post(url string, data map[string]interface{}, response bool) (string, int, error) {
-	params, _ := json.Marshal(data)
-	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(params))
-	for name, value := range jf.header {
-		req.Header.Add(name, value)
-	}
-	resp, err := jf.httpClient.Do(req)
-	defer jf.timeoutHandler()
-	if err != nil || resp.StatusCode != 200 {
-		if resp.StatusCode == 401 && jf.Authenticated {
-			jf.Authenticated = false
-			_, _, authErr := jf.Authenticate(jf.Username, jf.password)
-			if authErr == nil {
-				v1, v2, v3 := jf.post(url, data, response)
-				return v1, v2, v3
-			}
-		}
-		return "", resp.StatusCode, err
-	}
-	if response {
-		defer resp.Body.Close()
-		var outData io.Reader
-		switch resp.Header.Get("Content-Encoding") {
-		case "gzip":
-			outData, _ = gzip.NewReader(resp.Body)
-		default:
-			outData = resp.Body
-		}
-		buf := new(strings.Builder)
-		io.Copy(buf, outData)
-		return buf.String(), resp.StatusCode, nil
-	}
-	return "", resp.StatusCode, nil
-}
-
-// DeleteUser deletes the user corresponding to the provided ID.
-func (jf *Jellyfin) DeleteUser(userID string) (int, error) {
-	url := fmt.Sprintf("%s/Users/%s", jf.Server, userID)
-	req, _ := http.NewRequest("DELETE", url, nil)
-	for name, value := range jf.header {
-		req.Header.Add(name, value)
-	}
-	resp, err := jf.httpClient.Do(req)
-	defer jf.timeoutHandler()
-	return resp.StatusCode, err
-}
-
-// GetUsers returns all (visible) users on the Jellyfin instance.
-func (jf *Jellyfin) GetUsers(public bool) ([]map[string]interface{}, int, error) {
-	var result []map[string]interface{}
-	var data string
-	var status int
-	var err error
-	if time.Now().After(jf.CacheExpiry) {
-		if public {
-			url := fmt.Sprintf("%s/users/public", jf.Server)
-			data, status, err = jf.get(url, nil)
-		} else {
-			url := fmt.Sprintf("%s/users", jf.Server)
-			data, status, err = jf.get(url, jf.loginParams)
-		}
-		if err != nil || status != 200 {
-			return nil, status, err
-		}
-		json.Unmarshal([]byte(data), &result)
-		jf.userCache = result
-		jf.CacheExpiry = time.Now().Add(time.Minute * time.Duration(jf.cacheLength))
-		if id, ok := result[0]["Id"]; ok {
-			if id.(string)[8] == '-' {
-				jf.Hyphens = true
-			}
-		}
-		return result, status, nil
-	}
-	return jf.userCache, 200, nil
-}
-
-// UserByName returns the user corresponding to the provided username.
-func (jf *Jellyfin) UserByName(username string, public bool) (map[string]interface{}, int, error) {
-	var match map[string]interface{}
-	find := func() (map[string]interface{}, int, error) {
-		users, status, err := jf.GetUsers(public)
-		if err != nil || status != 200 {
-			return nil, status, err
-		}
-		for _, user := range users {
-			if user["Name"].(string) == username {
-				return user, status, err
-			}
-		}
-		return nil, status, err
-	}
-	match, status, err := find()
-	if match == nil {
-		jf.CacheExpiry = time.Now()
-		match, status, err = find()
-	}
-	return match, status, err
-}
-
-// UserByID returns the user corresponding to the provided ID.
-func (jf *Jellyfin) UserByID(userID string, public bool) (map[string]interface{}, int, error) {
-	if jf.CacheExpiry.After(time.Now()) {
-		for _, user := range jf.userCache {
-			if user["Id"].(string) == userID {
-				return user, 200, nil
-			}
-		}
-	}
-	if public {
-		users, status, err := jf.GetUsers(public)
-		if err != nil || status != 200 {
-			return nil, status, err
-		}
-		for _, user := range users {
-			if user["Id"].(string) == userID {
-				return user, status, nil
-			}
-		}
-		return nil, status, err
-	}
-	var result map[string]interface{}
-	var data string
-	var status int
-	var err error
-	url := fmt.Sprintf("%s/users/%s", jf.Server, userID)
-	data, status, err = jf.get(url, jf.loginParams)
-	if err != nil || status != 200 {
-		return nil, status, err
-	}
-	json.Unmarshal([]byte(data), &result)
-	return result, status, nil
-}
-
-// NewUser creates a new user with the provided username and password.
-func (jf *Jellyfin) NewUser(username, password string) (map[string]interface{}, int, error) {
-	url := fmt.Sprintf("%s/Users/New", jf.Server)
-	stringData := map[string]string{
-		"Name":     username,
-		"Password": password,
-	}
-	data := make(map[string]interface{})
-	for key, value := range stringData {
-		data[key] = value
-	}
-	response, status, err := jf.post(url, data, true)
-	var recv map[string]interface{}
-	json.Unmarshal([]byte(response), &recv)
-	if err != nil || !(status == 200 || status == 204) {
-		return nil, status, err
-	}
-	return recv, status, nil
-}
-
-// SetPolicy sets the access policy for the user corresponding to the provided ID.
-func (jf *Jellyfin) SetPolicy(userID string, policy map[string]interface{}) (int, error) {
-	url := fmt.Sprintf("%s/Users/%s/Policy", jf.Server, userID)
-	_, status, err := jf.post(url, policy, false)
-	if err != nil || status != 200 {
-		return status, err
-	}
-	return status, nil
-}
-
-// SetConfiguration sets the configuration (part of homescreen layout) for the user corresponding to the provided ID.
-func (jf *Jellyfin) SetConfiguration(userID string, configuration map[string]interface{}) (int, error) {
-	url := fmt.Sprintf("%s/Users/%s/Configuration", jf.Server, userID)
-	_, status, err := jf.post(url, configuration, false)
-	return status, err
-}
-
-// GetDisplayPreferences gets the displayPreferences (part of homescreen layout) for the user corresponding to the provided ID.
-func (jf *Jellyfin) GetDisplayPreferences(userID string) (map[string]interface{}, int, error) {
-	url := fmt.Sprintf("%s/DisplayPreferences/usersettings?userId=%s&client=emby", jf.Server, userID)
-	data, status, err := jf.get(url, nil)
-	if err != nil || !(status == 204 || status == 200) {
-		return nil, status, err
-	}
-	var displayprefs map[string]interface{}
-	err = json.Unmarshal([]byte(data), &displayprefs)
-	if err != nil {
-		return nil, status, err
-	}
-	return displayprefs, status, nil
-}
-
-// SetDisplayPreferences sets the displayPreferences (part of homescreen layout) for the user corresponding to the provided ID.
-func (jf *Jellyfin) SetDisplayPreferences(userID string, displayprefs map[string]interface{}) (int, error) {
-	url := fmt.Sprintf("%s/DisplayPreferences/usersettings?userId=%s&client=emby", jf.Server, userID)
-	_, status, err := jf.post(url, displayprefs, false)
-	if err != nil || !(status == 204 || status == 200) {
-		return status, err
-	}
-	return status, nil
-}

main.go

@@ -26,7 +26,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/hrfee/jfa-go/common"
 	_ "github.com/hrfee/jfa-go/docs"
-	"github.com/hrfee/jfa-go/jfapi"
+	"github.com/hrfee/jfa-go/mediabrowser"
 	"github.com/hrfee/jfa-go/ombi"
 	"github.com/lithammer/shortuuid/v3"
 	"github.com/logrusorgru/aurora/v3"
@@ -35,6 +35,13 @@ import (
 	"gopkg.in/ini.v1"
 )
 
+var serverTypes = map[string]string{
+	"jellyfin": "Jellyfin",
+	"emby":     "Emby (experimental)",
+}
+var serverType = mediabrowser.JellyfinServer
+var substituteStrings = ""
+
 // User is used for auth purposes.
 type User struct {
 	UserID   string `json:"id"`
@@ -45,18 +52,19 @@ type User struct {
 // contains everything the application needs, essentially. Wouldn't do this in the future.
 type appContext struct {
 	// defaults         *Config
-	config           *ini.File
+	config         *ini.File
-	configPath       string
+	configPath     string
-	configBasePath   string
+	configBasePath string
-	configBase       settings
+	configBase     settings
-	dataPath         string
+	dataPath       string
-	localPath        string
+	localPath      string
-	cssClass         string
+	cssClass       string
-	jellyfinLogin    bool
+	jellyfinLogin  bool
-	users            []User
+	users          []User
-	invalidTokens    []string
+	invalidTokens  []string
-	jf               *jfapi.Jellyfin
+	// Keeping jf name because I can't think of a better one
-	authJf           *jfapi.Jellyfin
+	jf               *mediabrowser.MediaBrowser
+	authJf           *mediabrowser.MediaBrowser
 	ombi             *ombi.Ombi
 	datePattern      string
 	timePattern      string
@@ -276,12 +284,6 @@ func start(asDaemon, firstCall bool) {
 	if app.loadConfig() != nil {
 		app.err.Fatalf("Failed to load config file \"%s\"", app.configPath)
 	}
-	lang := app.config.Section("ui").Key("language").MustString("en-us")
-	app.storage.lang.FormPath = filepath.Join(app.localPath, "lang", "form", lang+".json")
-	if _, err := os.Stat(app.storage.lang.FormPath); os.IsNotExist(err) {
-		app.storage.lang.FormPath = filepath.Join(app.localPath, "lang", "form", "en-us.json")
-	}
-	app.storage.loadLang()
 	app.version = app.config.Section("jellyfin").Key("version").String()
 	// read from config...
 	debugMode = app.config.Section("ui").Key("debug").MustBool(false)
@@ -439,13 +441,25 @@ func start(asDaemon, firstCall bool) {
 
 		server := app.config.Section("jellyfin").Key("server").String()
 		cacheTimeout := int(app.config.Section("jellyfin").Key("cache_timeout").MustUint(30))
-		app.jf, _ = jfapi.NewJellyfin(
+		stringServerType := app.config.Section("jellyfin").Key("type").String()
+		timeoutHandler := common.NewTimeoutHandler("Jellyfin", server, true)
+		if stringServerType == "emby" {
+			serverType = mediabrowser.EmbyServer
+			timeoutHandler = common.NewTimeoutHandler("Emby", server, true)
+			app.info.Println("Using Emby server type")
+			fmt.Println(aurora.Yellow("WARNING: Emby compatibility is experimental, and support is limited.\nPassword resets are not available."))
+		} else {
+			app.info.Println("Using Jellyfin server type")
+		}
+
+		app.jf, _ = mediabrowser.NewServer(
+			serverType,
 			server,
 			app.config.Section("jellyfin").Key("client").String(),
 			app.config.Section("jellyfin").Key("version").String(),
 			app.config.Section("jellyfin").Key("device").String(),
 			app.config.Section("jellyfin").Key("device_id").String(),
-			common.NewTimeoutHandler("Jellyfin", server, true),
+			timeoutHandler,
 			cacheTimeout,
 		)
 		var status int
@@ -466,7 +480,7 @@ func start(asDaemon, firstCall bool) {
 			}
 			return n
 		}
-		if checkVersion(app.jf.ServerInfo.Version) >= checkVersion("10.7.0") {
+		if serverType == mediabrowser.JellyfinServer && checkVersion(app.jf.ServerInfo.Version) >= checkVersion("10.7.0") {
 			// Get users to check if server uses hyphenated userIDs
 			app.jf.GetUsers(false)
 
@@ -507,7 +521,15 @@ func start(asDaemon, firstCall bool) {
 				}
 			}
 		}
-		app.authJf, _ = jfapi.NewJellyfin(server, "jfa-go", app.version, "auth", "auth", common.NewTimeoutHandler("Jellyfin", server, true), cacheTimeout)
+
+		lang := app.config.Section("ui").Key("language").MustString("en-us")
+		app.storage.lang.FormPath = filepath.Join(app.localPath, "lang", "form", lang+".json")
+		if _, err := os.Stat(app.storage.lang.FormPath); os.IsNotExist(err) {
+			app.storage.lang.FormPath = filepath.Join(app.localPath, "lang", "form", "en-us.json")
+		}
+		app.storage.loadLang()
+
+		app.authJf, _ = mediabrowser.NewServer(serverType, server, "jfa-go", app.version, "auth", "auth", timeoutHandler, cacheTimeout)
 
 		app.loadStrftime()
 
@@ -533,7 +555,7 @@ func start(asDaemon, firstCall bool) {
 		inviteDaemon := newRepeater(time.Duration(60*time.Second), app)
 		go inviteDaemon.run()
 
-		if app.config.Section("password_resets").Key("enabled").MustBool(false) {
+		if app.config.Section("password_resets").Key("enabled").MustBool(false) && serverType == mediabrowser.JellyfinServer {
 			go app.StartPWR()
 		}
 	} else {

mediabrowser/emby.go

@@ -0,0 +1,175 @@
+package mediabrowser
+
+// Almost identical to jfapi, with the most notable change being the password workaround.
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+)
+
+func embyDeleteUser(emby *MediaBrowser, userID string) (int, error) {
+	url := fmt.Sprintf("%s/Users/%s", emby.Server, userID)
+	req, _ := http.NewRequest("DELETE", url, nil)
+	for name, value := range emby.header {
+		req.Header.Add(name, value)
+	}
+	resp, err := emby.httpClient.Do(req)
+	defer emby.timeoutHandler()
+	return resp.StatusCode, err
+}
+
+func embyGetUsers(emby *MediaBrowser, public bool) ([]map[string]interface{}, int, error) {
+	var result []map[string]interface{}
+	var data string
+	var status int
+	var err error
+	if time.Now().After(emby.CacheExpiry) {
+		if public {
+			url := fmt.Sprintf("%s/users/public", emby.Server)
+			data, status, err = emby.get(url, nil)
+		} else {
+			url := fmt.Sprintf("%s/users", emby.Server)
+			data, status, err = emby.get(url, emby.loginParams)
+		}
+		if err != nil || status != 200 {
+			return nil, status, err
+		}
+		json.Unmarshal([]byte(data), &result)
+		emby.userCache = result
+		emby.CacheExpiry = time.Now().Add(time.Minute * time.Duration(emby.cacheLength))
+		if id, ok := result[0]["Id"]; ok {
+			if id.(string)[8] == '-' {
+				emby.Hyphens = true
+			}
+		}
+		return result, status, nil
+	}
+	return emby.userCache, 200, nil
+}
+
+func embyUserByName(emby *MediaBrowser, username string, public bool) (map[string]interface{}, int, error) {
+	var match map[string]interface{}
+	find := func() (map[string]interface{}, int, error) {
+		users, status, err := emby.GetUsers(public)
+		if err != nil || status != 200 {
+			return nil, status, err
+		}
+		for _, user := range users {
+			if user["Name"].(string) == username {
+				return user, status, err
+			}
+		}
+		return nil, status, err
+	}
+	match, status, err := find()
+	if match == nil {
+		emby.CacheExpiry = time.Now()
+		match, status, err = find()
+	}
+	return match, status, err
+}
+
+func embyUserByID(emby *MediaBrowser, userID string, public bool) (map[string]interface{}, int, error) {
+	if emby.CacheExpiry.After(time.Now()) {
+		for _, user := range emby.userCache {
+			if user["Id"].(string) == userID {
+				return user, 200, nil
+			}
+		}
+	}
+	if public {
+		users, status, err := emby.GetUsers(public)
+		if err != nil || status != 200 {
+			return nil, status, err
+		}
+		for _, user := range users {
+			if user["Id"].(string) == userID {
+				return user, status, nil
+			}
+		}
+		return nil, status, err
+	}
+	var result map[string]interface{}
+	var data string
+	var status int
+	var err error
+	url := fmt.Sprintf("%s/users/%s", emby.Server, userID)
+	data, status, err = emby.get(url, emby.loginParams)
+	if err != nil || status != 200 {
+		return nil, status, err
+	}
+	json.Unmarshal([]byte(data), &result)
+	return result, status, nil
+}
+
+// Since emby doesn't allow one to specify a password on user creation, we:
+// Create the account
+// Immediately disable it
+// Set password
+// Reeenable it
+func embyNewUser(emby *MediaBrowser, username, password string) (map[string]interface{}, int, error) {
+	url := fmt.Sprintf("%s/Users/New", emby.Server)
+	data := map[string]interface{}{
+		"Name": username,
+	}
+	response, status, err := emby.post(url, data, true)
+	var recv map[string]interface{}
+	json.Unmarshal([]byte(response), &recv)
+	if err != nil || !(status == 200 || status == 204) {
+		return nil, status, err
+	}
+	// Step 2: Set password
+	id := recv["Id"].(string)
+	url = fmt.Sprintf("%s/Users/%s/Password", emby.Server, id)
+	data = map[string]interface{}{
+		"Id":        id,
+		"CurrentPw": "",
+		"NewPw":     password,
+	}
+	_, status, err = emby.post(url, data, false)
+	// Step 3: If setting password errored, try to delete the account
+	if err != nil || !(status == 200 || status == 204) {
+		_, err = emby.DeleteUser(id)
+	}
+	return recv, status, nil
+}
+
+func embySetPolicy(emby *MediaBrowser, userID string, policy map[string]interface{}) (int, error) {
+	url := fmt.Sprintf("%s/Users/%s/Policy", emby.Server, userID)
+	_, status, err := emby.post(url, policy, false)
+	if err != nil || status != 200 {
+		return status, err
+	}
+	return status, nil
+}
+
+func embySetConfiguration(emby *MediaBrowser, userID string, configuration map[string]interface{}) (int, error) {
+	url := fmt.Sprintf("%s/Users/%s/Configuration", emby.Server, userID)
+	_, status, err := emby.post(url, configuration, false)
+	return status, err
+}
+
+func embyGetDisplayPreferences(emby *MediaBrowser, userID string) (map[string]interface{}, int, error) {
+	url := fmt.Sprintf("%s/DisplayPreferences/usersettings?userId=%s&client=emby", emby.Server, userID)
+	data, status, err := emby.get(url, nil)
+	if err != nil || !(status == 204 || status == 200) {
+		return nil, status, err
+	}
+	var displayprefs map[string]interface{}
+	err = json.Unmarshal([]byte(data), &displayprefs)
+	if err != nil {
+		return nil, status, err
+	}
+	return displayprefs, status, nil
+}
+
+func embySetDisplayPreferences(emby *MediaBrowser, userID string, displayprefs map[string]interface{}) (int, error) {
+	url := fmt.Sprintf("%s/DisplayPreferences/usersettings?userId=%s&client=emby", emby.Server, userID)
+	_, status, err := emby.post(url, displayprefs, false)
+	if err != nil || !(status == 204 || status == 200) {
+		return status, err
+	}
+	return status, nil
+}

mediabrowser/go.mod

@@ -0,0 +1,7 @@
+module github.com/hrfee/jfa-go/mediabrowser
+
+go 1.15
+
+replace github.com/hrfee/jfa-go/common => ../common
+
+require github.com/hrfee/jfa-go/common v0.0.0-20210105184019-fdc97b4e86cc

mediabrowser/jfapi.go

@@ -0,0 +1,160 @@
+package mediabrowser
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+)
+
+func jfDeleteUser(jf *MediaBrowser, userID string) (int, error) {
+	url := fmt.Sprintf("%s/Users/%s", jf.Server, userID)
+	req, _ := http.NewRequest("DELETE", url, nil)
+	for name, value := range jf.header {
+		req.Header.Add(name, value)
+	}
+	resp, err := jf.httpClient.Do(req)
+	defer jf.timeoutHandler()
+	return resp.StatusCode, err
+}
+
+func jfGetUsers(jf *MediaBrowser, public bool) ([]map[string]interface{}, int, error) {
+	var result []map[string]interface{}
+	var data string
+	var status int
+	var err error
+	if time.Now().After(jf.CacheExpiry) {
+		if public {
+			url := fmt.Sprintf("%s/users/public", jf.Server)
+			data, status, err = jf.get(url, nil)
+		} else {
+			url := fmt.Sprintf("%s/users", jf.Server)
+			data, status, err = jf.get(url, jf.loginParams)
+		}
+		if err != nil || status != 200 {
+			return nil, status, err
+		}
+		json.Unmarshal([]byte(data), &result)
+		jf.userCache = result
+		jf.CacheExpiry = time.Now().Add(time.Minute * time.Duration(jf.cacheLength))
+		if id, ok := result[0]["Id"]; ok {
+			if id.(string)[8] == '-' {
+				jf.Hyphens = true
+			}
+		}
+		return result, status, nil
+	}
+	return jf.userCache, 200, nil
+}
+
+func jfUserByName(jf *MediaBrowser, username string, public bool) (map[string]interface{}, int, error) {
+	var match map[string]interface{}
+	find := func() (map[string]interface{}, int, error) {
+		users, status, err := jf.GetUsers(public)
+		if err != nil || status != 200 {
+			return nil, status, err
+		}
+		for _, user := range users {
+			if user["Name"].(string) == username {
+				return user, status, err
+			}
+		}
+		return nil, status, err
+	}
+	match, status, err := find()
+	if match == nil {
+		jf.CacheExpiry = time.Now()
+		match, status, err = find()
+	}
+	return match, status, err
+}
+
+func jfUserByID(jf *MediaBrowser, userID string, public bool) (map[string]interface{}, int, error) {
+	if jf.CacheExpiry.After(time.Now()) {
+		for _, user := range jf.userCache {
+			if user["Id"].(string) == userID {
+				return user, 200, nil
+			}
+		}
+	}
+	if public {
+		users, status, err := jf.GetUsers(public)
+		if err != nil || status != 200 {
+			return nil, status, err
+		}
+		for _, user := range users {
+			if user["Id"].(string) == userID {
+				return user, status, nil
+			}
+		}
+		return nil, status, err
+	}
+	var result map[string]interface{}
+	var data string
+	var status int
+	var err error
+	url := fmt.Sprintf("%s/users/%s", jf.Server, userID)
+	data, status, err = jf.get(url, jf.loginParams)
+	if err != nil || status != 200 {
+		return nil, status, err
+	}
+	json.Unmarshal([]byte(data), &result)
+	return result, status, nil
+}
+
+func jfNewUser(jf *MediaBrowser, username, password string) (map[string]interface{}, int, error) {
+	url := fmt.Sprintf("%s/Users/New", jf.Server)
+	stringData := map[string]string{
+		"Name":     username,
+		"Password": password,
+	}
+	data := make(map[string]interface{})
+	for key, value := range stringData {
+		data[key] = value
+	}
+	response, status, err := jf.post(url, data, true)
+	var recv map[string]interface{}
+	json.Unmarshal([]byte(response), &recv)
+	if err != nil || !(status == 200 || status == 204) {
+		return nil, status, err
+	}
+	return recv, status, nil
+}
+
+func jfSetPolicy(jf *MediaBrowser, userID string, policy map[string]interface{}) (int, error) {
+	url := fmt.Sprintf("%s/Users/%s/Policy", jf.Server, userID)
+	_, status, err := jf.post(url, policy, false)
+	if err != nil || status != 200 {
+		return status, err
+	}
+	return status, nil
+}
+
+func jfSetConfiguration(jf *MediaBrowser, userID string, configuration map[string]interface{}) (int, error) {
+	url := fmt.Sprintf("%s/Users/%s/Configuration", jf.Server, userID)
+	_, status, err := jf.post(url, configuration, false)
+	return status, err
+}
+
+func jfGetDisplayPreferences(jf *MediaBrowser, userID string) (map[string]interface{}, int, error) {
+	url := fmt.Sprintf("%s/DisplayPreferences/usersettings?userId=%s&client=emby", jf.Server, userID)
+	data, status, err := jf.get(url, nil)
+	if err != nil || !(status == 204 || status == 200) {
+		return nil, status, err
+	}
+	var displayprefs map[string]interface{}
+	err = json.Unmarshal([]byte(data), &displayprefs)
+	if err != nil {
+		return nil, status, err
+	}
+	return displayprefs, status, nil
+}
+
+func jfSetDisplayPreferences(jf *MediaBrowser, userID string, displayprefs map[string]interface{}) (int, error) {
+	url := fmt.Sprintf("%s/DisplayPreferences/usersettings?userId=%s&client=emby", jf.Server, userID)
+	_, status, err := jf.post(url, displayprefs, false)
+	if err != nil || !(status == 204 || status == 200) {
+		return status, err
+	}
+	return status, nil
+}

mediabrowser/mediabrowser.go

@@ -0,0 +1,288 @@
+package mediabrowser
+
+import (
+	"bytes"
+	"compress/gzip"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/hrfee/jfa-go/common"
+)
+
+type serverType bool
+
+var JellyfinServer serverType = false
+var EmbyServer serverType = true
+
+type serverInfo struct {
+	LocalAddress string `json:"LocalAddress"`
+	Name         string `json:"ServerName"`
+	Version      string `json:"Version"`
+	OS           string `json:"OperatingSystem"`
+	ID           string `json:"Id"`
+}
+
+// MediaBrowser is an api instance of Jellyfin/Emby.
+type MediaBrowser struct {
+	Server         string
+	client         string
+	version        string
+	device         string
+	deviceID       string
+	useragent      string
+	auth           string
+	header         map[string]string
+	ServerInfo     serverInfo
+	Username       string
+	password       string
+	Authenticated  bool
+	AccessToken    string
+	userID         string
+	httpClient     *http.Client
+	loginParams    map[string]string
+	userCache      []map[string]interface{}
+	CacheExpiry    time.Time
+	cacheLength    int
+	noFail         bool
+	Hyphens        bool
+	serverType     serverType
+	timeoutHandler common.TimeoutHandler
+}
+
+// NewServer returns a new Jellyfin object.
+func NewServer(st serverType, server, client, version, device, deviceID string, timeoutHandler common.TimeoutHandler, cacheTimeout int) (*MediaBrowser, error) {
+	mb := &MediaBrowser{}
+	mb.serverType = st
+	mb.Server = server
+	mb.client = client
+	mb.version = version
+	mb.device = device
+	mb.deviceID = deviceID
+	mb.useragent = fmt.Sprintf("%s/%s", client, version)
+	mb.timeoutHandler = timeoutHandler
+	mb.auth = fmt.Sprintf("MediaBrowser Client=\"%s\", Device=\"%s\", DeviceId=\"%s\", Version=\"%s\"", client, device, deviceID, version)
+	mb.header = map[string]string{
+		"Accept":               "application/json",
+		"Content-type":         "application/json; charset=UTF-8",
+		"X-Application":        mb.useragent,
+		"Accept-Charset":       "UTF-8,*",
+		"Accept-Encoding":      "gzip",
+		"User-Agent":           mb.useragent,
+		"X-Emby-Authorization": mb.auth,
+	}
+	mb.httpClient = &http.Client{
+		Timeout: 10 * time.Second,
+	}
+	infoURL := fmt.Sprintf("%s/System/Info/Public", server)
+	req, _ := http.NewRequest("GET", infoURL, nil)
+	resp, err := mb.httpClient.Do(req)
+	defer mb.timeoutHandler()
+	if err == nil {
+		data, _ := ioutil.ReadAll(resp.Body)
+		json.Unmarshal(data, &mb.ServerInfo)
+	}
+	mb.cacheLength = cacheTimeout
+	mb.CacheExpiry = time.Now()
+	return mb, nil
+}
+
+func (mb *MediaBrowser) get(url string, params map[string]string) (string, int, error) {
+	var req *http.Request
+	if params != nil {
+		jsonParams, _ := json.Marshal(params)
+		req, _ = http.NewRequest("GET", url, bytes.NewBuffer(jsonParams))
+	} else {
+		req, _ = http.NewRequest("GET", url, nil)
+	}
+	for name, value := range mb.header {
+		req.Header.Add(name, value)
+	}
+	resp, err := mb.httpClient.Do(req)
+	defer mb.timeoutHandler()
+	if err != nil || resp.StatusCode != 200 {
+		if resp.StatusCode == 401 && mb.Authenticated {
+			mb.Authenticated = false
+			_, _, authErr := mb.Authenticate(mb.Username, mb.password)
+			if authErr == nil {
+				v1, v2, v3 := mb.get(url, params)
+				return v1, v2, v3
+			}
+		}
+		return "", resp.StatusCode, err
+	}
+	defer resp.Body.Close()
+	var data io.Reader
+	encoding := resp.Header.Get("Content-Encoding")
+	switch encoding {
+	case "gzip":
+		data, _ = gzip.NewReader(resp.Body)
+	default:
+		data = resp.Body
+	}
+	buf := new(strings.Builder)
+	io.Copy(buf, data)
+	//var respData map[string]interface{}
+	//json.NewDecoder(data).Decode(&respData)
+	return buf.String(), resp.StatusCode, nil
+}
+
+func (mb *MediaBrowser) post(url string, data map[string]interface{}, response bool) (string, int, error) {
+	params, _ := json.Marshal(data)
+	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(params))
+	for name, value := range mb.header {
+		req.Header.Add(name, value)
+	}
+	resp, err := mb.httpClient.Do(req)
+	defer mb.timeoutHandler()
+	if err != nil || resp.StatusCode != 200 {
+		if resp.StatusCode == 401 && mb.Authenticated {
+			mb.Authenticated = false
+			_, _, authErr := mb.Authenticate(mb.Username, mb.password)
+			if authErr == nil {
+				v1, v2, v3 := mb.post(url, data, response)
+				return v1, v2, v3
+			}
+		}
+		return "", resp.StatusCode, err
+	}
+	if response {
+		defer resp.Body.Close()
+		var outData io.Reader
+		switch resp.Header.Get("Content-Encoding") {
+		case "gzip":
+			outData, _ = gzip.NewReader(resp.Body)
+		default:
+			outData = resp.Body
+		}
+		buf := new(strings.Builder)
+		io.Copy(buf, outData)
+		return buf.String(), resp.StatusCode, nil
+	}
+	return "", resp.StatusCode, nil
+}
+
+// Authenticate attempts to authenticate using a username & password
+func (mb *MediaBrowser) Authenticate(username, password string) (map[string]interface{}, int, error) {
+	mb.Username = username
+	mb.password = password
+	mb.loginParams = map[string]string{
+		"Username": username,
+		"Pw":       password,
+		"Password": password,
+	}
+	buffer := &bytes.Buffer{}
+	encoder := json.NewEncoder(buffer)
+	encoder.SetEscapeHTML(false)
+	err := encoder.Encode(mb.loginParams)
+	if err != nil {
+		return nil, 0, err
+	}
+	// loginParams, _ := json.Marshal(jf.loginParams)
+	url := fmt.Sprintf("%s/Users/authenticatebyname", mb.Server)
+	req, err := http.NewRequest("POST", url, buffer)
+	defer mb.timeoutHandler()
+	if err != nil {
+		return nil, 0, err
+	}
+	for name, value := range mb.header {
+		req.Header.Add(name, value)
+	}
+	resp, err := mb.httpClient.Do(req)
+	if err != nil || resp.StatusCode != 200 {
+		return nil, resp.StatusCode, err
+	}
+	defer resp.Body.Close()
+	var data io.Reader
+	switch resp.Header.Get("Content-Encoding") {
+	case "gzip":
+		data, _ = gzip.NewReader(resp.Body)
+	default:
+		data = resp.Body
+	}
+	var respData map[string]interface{}
+	json.NewDecoder(data).Decode(&respData)
+	mb.AccessToken = respData["AccessToken"].(string)
+	user := respData["User"].(map[string]interface{})
+	mb.userID = respData["User"].(map[string]interface{})["Id"].(string)
+	mb.auth = fmt.Sprintf("MediaBrowser Client=\"%s\", Device=\"%s\", DeviceId=\"%s\", Version=\"%s\", Token=\"%s\"", mb.client, mb.device, mb.deviceID, mb.version, mb.AccessToken)
+	mb.header["X-Emby-Authorization"] = mb.auth
+	mb.Authenticated = true
+	return user, resp.StatusCode, nil
+}
+
+// DeleteUser deletes the user corresponding to the provided ID.
+func (mb *MediaBrowser) DeleteUser(userID string) (int, error) {
+	if mb.serverType == JellyfinServer {
+		return jfDeleteUser(mb, userID)
+	}
+	return embyDeleteUser(mb, userID)
+}
+
+// GetUsers returns all (visible) users on the Emby instance.
+func (mb *MediaBrowser) GetUsers(public bool) ([]map[string]interface{}, int, error) {
+	if mb.serverType == JellyfinServer {
+		return jfGetUsers(mb, public)
+	}
+	return embyGetUsers(mb, public)
+}
+
+// UserByName returns the user corresponding to the provided username.
+func (mb *MediaBrowser) UserByName(username string, public bool) (map[string]interface{}, int, error) {
+	if mb.serverType == JellyfinServer {
+		return jfUserByName(mb, username, public)
+	}
+	return embyUserByName(mb, username, public)
+}
+
+// UserByID returns the user corresponding to the provided ID.
+func (mb *MediaBrowser) UserByID(userID string, public bool) (map[string]interface{}, int, error) {
+	if mb.serverType == JellyfinServer {
+		return jfUserByID(mb, userID, public)
+	}
+	return embyUserByID(mb, userID, public)
+}
+
+// NewUser creates a new user with the provided username and password.
+func (mb *MediaBrowser) NewUser(username, password string) (map[string]interface{}, int, error) {
+	if mb.serverType == JellyfinServer {
+		return jfNewUser(mb, username, password)
+	}
+	return embyNewUser(mb, username, password)
+}
+
+// SetPolicy sets the access policy for the user corresponding to the provided ID.
+func (mb *MediaBrowser) SetPolicy(userID string, policy map[string]interface{}) (int, error) {
+	if mb.serverType == JellyfinServer {
+		return jfSetPolicy(mb, userID, policy)
+	}
+	return embySetPolicy(mb, userID, policy)
+}
+
+// SetConfiguration sets the configuration (part of homescreen layout) for the user corresponding to the provided ID.
+func (mb *MediaBrowser) SetConfiguration(userID string, configuration map[string]interface{}) (int, error) {
+	if mb.serverType == JellyfinServer {
+		return jfSetConfiguration(mb, userID, configuration)
+	}
+	return embySetConfiguration(mb, userID, configuration)
+}
+
+// GetDisplayPreferences gets the displayPreferences (part of homescreen layout) for the user corresponding to the provided ID.
+func (mb *MediaBrowser) GetDisplayPreferences(userID string) (map[string]interface{}, int, error) {
+	if mb.serverType == JellyfinServer {
+		return jfGetDisplayPreferences(mb, userID)
+	}
+	return embyGetDisplayPreferences(mb, userID)
+}
+
+// SetDisplayPreferences sets the displayPreferences (part of homescreen layout) for the user corresponding to the provided ID.
+func (mb *MediaBrowser) SetDisplayPreferences(userID string, displayprefs map[string]interface{}) (int, error) {
+	if mb.serverType == JellyfinServer {
+		return jfSetDisplayPreferences(mb, userID, displayprefs)
+	}
+	return embySetDisplayPreferences(mb, userID, displayprefs)
+}

setup.go

@@ -3,7 +3,7 @@ package main
 import (
 	"github.com/gin-gonic/gin"
 	"github.com/hrfee/jfa-go/common"
-	"github.com/hrfee/jfa-go/jfapi"
+	"github.com/hrfee/jfa-go/mediabrowser"
 )
 
 type testReq struct {
@@ -15,7 +15,7 @@ type testReq struct {
 func (app *appContext) TestJF(gc *gin.Context) {
 	var req testReq
 	gc.BindJSON(&req)
-	tempjf, _ := jfapi.NewJellyfin(req.Host, "jfa-go-setup", app.version, "auth", "auth", common.NewTimeoutHandler("authJF", req.Host, true), 30)
+	tempjf, _ := mediabrowser.NewServer(mediabrowser.JellyfinServer, req.Host, "jfa-go-setup", app.version, "auth", "auth", common.NewTimeoutHandler("authJF", req.Host, true), 30)
 	_, status, err := tempjf.Authenticate(req.Username, req.Password)
 	if !(status == 200 || status == 204) || err != nil {
 		app.info.Printf("Auth failed with code %d (%s)", status, err)

storage.go

@@ -58,6 +58,21 @@ func (st *Storage) storeInvites() error {
 }
 
 func (st *Storage) loadLang() error {
+	if substituteStrings != "" {
+		var file []byte
+		var err error
+		file, err = ioutil.ReadFile(st.lang.FormPath)
+		if err != nil {
+			file = []byte("{}")
+		}
+		// Replace Jellyfin with emby on form
+		file = []byte(strings.ReplaceAll(string(file), "Jellyfin", substituteStrings))
+		err = json.Unmarshal(file, &st.lang.Form)
+		if err != nil {
+			log.Printf("ERROR: Failed to read \"%s\": %s", st.lang.FormPath, err)
+		}
+		return err
+	}
 	err := loadJSON(st.lang.FormPath, &st.lang.Form)
 	if err != nil {
 		return err