arozos-mirror/src/mod/modules/module.go

package modules

import (
	"encoding/json"
	"net/http"
	"path/filepath"
	"sort"
	"strings"

	"imuslab.com/arozos/mod/user"
	"imuslab.com/arozos/mod/utils"
)

type ModuleInfo struct {
	Name         string   //Name of this module. e.g. "Audio"
	Desc         string   //Description for this module
	Group        string   //Group of the module, e.g. "system" / "media" etc
	IconPath     string   //Module icon image path e.g. "Audio/img/function_icon.png"
	Version      string   //Version of the module. Format: [0-9]*.[0-9][0-9].[0-9]
	StartDir     string   //Default starting dir, e.g. "Audio/index.html"
	SupportFW    bool     //Support floatWindow. If yes, floatWindow dir will be loaded
	LaunchFWDir  string   //This link will be launched instead of 'StartDir' if fw mode
	SupportEmb   bool     //Support embedded mode
	LaunchEmb    string   //This link will be launched instead of StartDir / Fw if a file is opened with this module
	InitFWSize   []int    //Floatwindow init size. [0] => Width, [1] => Height
	InitEmbSize  []int    //Embedded mode init size. [0] => Width, [1] => Height
	SupportedExt []string //Supported File Extensions. e.g. ".mp3", ".flac", ".wav"

	//Folder this module was registered from, relative to the startup directory,
	//e.g. "web/Office" or "subservice/demo". AGI scripts in this folder are
	//accessible to users with permission to this module. Never read from or
	//written to JSON, so a module cannot claim another app's folder.
	SourceFolder string `json:"-"`

	//Hidden properties
	allowReload bool //Allow module reload by user
}

type ModuleHandler struct {
	LoadedModule    []*ModuleInfo
	userHandler     *user.UserHandler
	tmpDirectory    string
	extIconRegistry map[string]string // lowercased ext (no dot) --> web-root-relative icon path

	// OnModuleUninstall is an optional hook called when a module is uninstalled.
	// The hook receives the module name and can be used to clean up associated resources
	// (e.g. remove scheduled cron jobs registered by that module).
	OnModuleUninstall func(moduleName string)
}

func NewModuleHandler(userHandler *user.UserHandler, tmpFolderPath string) *ModuleHandler {
	return &ModuleHandler{
		LoadedModule:    []*ModuleInfo{},
		userHandler:     userHandler,
		tmpDirectory:    tmpFolderPath,
		extIconRegistry: map[string]string{},
	}
}

// RegisterExtIcon stores a web-root-relative icon path for the given file extension.
// ext may include or omit a leading dot; it is normalised to lowercase without dot.
func (m *ModuleHandler) RegisterExtIcon(ext, iconPath string) {
	ext = strings.ToLower(strings.TrimPrefix(ext, "."))
	m.extIconRegistry[ext] = iconPath
}

// HandleGetExtIcons serves the extension-to-icon registry as a JSON object.
func (m *ModuleHandler) HandleGetExtIcons(w http.ResponseWriter, r *http.Request) {
	js, _ := json.Marshal(m.extIconRegistry)
	utils.SendJSONResponse(w, string(js))
}

// IsUniversalGroup reports whether modules of the given group are open to
// every user without a permission group grant. Engineering apps are file
// viewers and tools on the user's own files, so they stay as open as the
// Utilities they were split from.
func IsUniversalGroup(group string) bool {
	switch strings.ToLower(strings.TrimSpace(group)) {
	case "utilities", "system tools":
		return true
	}
	return false
}

// Register endpoint. Provide moduleInfo datastructure or unparsed json
func (m *ModuleHandler) RegisterModule(module ModuleInfo) {
	m.LoadedModule = append(m.LoadedModule, &module)

	//Add the module into universal module if every user may use its group
	if IsUniversalGroup(module.Group) {
		m.userHandler.UniversalModules = append(m.userHandler.UniversalModules, module.Name)
	}
}

// Sort the module list
func (m *ModuleHandler) ModuleSortList() {
	sort.Slice(m.LoadedModule, func(i, j int) bool {
		return m.LoadedModule[i].Name < m.LoadedModule[j].Name
	})
}

// Register a module from JSON string
func (m *ModuleHandler) RegisterModuleFromJSON(jsonstring string, allowReload bool) error {
	var thisModuleInfo ModuleInfo
	err := json.Unmarshal([]byte(jsonstring), &thisModuleInfo)
	if err != nil {
		return err
	}

	thisModuleInfo.allowReload = allowReload
	m.RegisterModule(thisModuleInfo)
	return nil
}

// Register a module from AGI script. sourceFolder is the folder of the init.agi
// that registered it (e.g. "web/Office"), empty if unknown.
func (m *ModuleHandler) RegisterModuleFromAGI(sourceFolder string, jsonstring string) error {
	var thisModuleInfo ModuleInfo
	err := json.Unmarshal([]byte(jsonstring), &thisModuleInfo)
	if err != nil {
		return err
	}

	//AGI interface loaded module must allow runtime reload
	thisModuleInfo.allowReload = true
	thisModuleInfo.SourceFolder = sourceFolder
	m.RegisterModule(thisModuleInfo)
	return nil
}

func (m *ModuleHandler) DeregisterModule(moduleName string) {
	newLoadedModuleList := []*ModuleInfo{}
	for _, thisModule := range m.LoadedModule {
		if thisModule.Name != moduleName {
			newLoadedModuleList = append(newLoadedModuleList, thisModule)
		}
	}

	m.LoadedModule = newLoadedModuleList
}

// Get the names of the modules registered from the given source folder,
// e.g. "web/Office" -> Docs, Sheets, Slides. The folder is matched ignoring
// case, like module names in permission checks.
func (m *ModuleHandler) GetModulesFromSourceFolder(folder string) []string {
	result := []string{}
	if folder == "" {
		return result
	}
	folder = filepath.ToSlash(filepath.Clean(folder))
	for _, module := range m.LoadedModule {
		if module.SourceFolder != "" && strings.EqualFold(module.SourceFolder, folder) {
			result = append(result, module.Name)
		}
	}
	return result
}

// Get a list of module names
func (m *ModuleHandler) GetModuleNameList() []string {
	result := []string{}
	for _, module := range m.LoadedModule {
		result = append(result, module.Name)
	}
	return result
}

// GetModuleListJSONForUser returns a JSON string of all modules the given username can access
func (m *ModuleHandler) GetModuleListJSONForUser(username string) string {
	userinfo, err := m.userHandler.GetUserInfoFromUsername(username)
	if err != nil {
		return "[]"
	}
	accessable := []*ModuleInfo{}
	for _, mod := range m.LoadedModule {
		if userinfo.GetModuleAccessPermission(mod.Name) {
			accessable = append(accessable, mod)
		}
	}
	js, _ := json.Marshal(accessable)
	return string(js)
}

// Handle Default Launcher
func (m *ModuleHandler) HandleDefaultLauncher(w http.ResponseWriter, r *http.Request) {
	username, _ := m.userHandler.GetAuthAgent().GetUserName(w, r)
	opr, _ := utils.GetPara(r, "opr") //Operation, accept {get, set, launch}
	ext, _ := utils.GetPara(r, "ext")
	moduleName, _ := utils.GetPara(r, "module")

	ext = strings.ToLower(ext)

	//Check if the default folder exists.
	switch opr {
	case "get":
		//Get the opener for this file type
		value := ""
		err := m.userHandler.GetDatabase().Read("module", "default/"+username+"/"+ext, &value)
		if err != nil {
			utils.SendErrorResponse(w, "No default opener")
			return
		}
		js, _ := json.Marshal(value)
		utils.SendJSONResponse(w, string(js))
		return
	case "launch":
		//Get launch paramter for this extension
		value := ""
		err := m.userHandler.GetDatabase().Read("module", "default/"+username+"/"+ext, &value)
		if err != nil {
			utils.SendErrorResponse(w, "No default opener")
			return
		}
		//Get the launch paramter of this module
		var modInfo *ModuleInfo = nil
		modExists := false
		for _, mod := range m.LoadedModule {
			if mod.Name == value {
				modInfo = mod
				modExists = true
			}
		}

		if !modExists {
			//This module has been removed or not exists anymore
			utils.SendErrorResponse(w, "Default opener no longer exists.")
			return
		} else {
			//Return launch inforamtion
			jsonString, _ := json.Marshal(modInfo)
			utils.SendJSONResponse(w, string(jsonString))
		}

	case "set":
		//Set the opener for this filetype
		if moduleName == "" {
			utils.SendErrorResponse(w, "Missing paratmer 'module'")
			return
		}

		//Check if module name exists
		moduleValid := false
		for _, mod := range m.LoadedModule {
			if mod.Name == moduleName {
				moduleValid = true
			}
		}
		if moduleValid {
			m.userHandler.GetDatabase().Write("module", "default/"+username+"/"+ext, moduleName)
			utils.SendJSONResponse(w, "\"OK\"")
		} else {
			utils.SendErrorResponse(w, "Given module not exists.")
		}

	case "list":
		//List all the values that belongs to default opener
		dbDump, _ := m.userHandler.GetDatabase().ListTable("module")
		results := [][]string{}
		for _, entry := range dbDump {
			key := string(entry[0])
			if strings.Contains(key, "default/"+username+"/") {
				//This is a correct matched entry
				extInfo := strings.Split(key, "/")
				ext := extInfo[len(extInfo)-1:]
				moduleName := ""
				json.Unmarshal(entry[1], &moduleName)
				results = append(results, []string{ext[0], moduleName})
			}
		}

		jsonString, _ := json.Marshal(results)
		utils.SendJSONResponse(w, string(jsonString))
		return
	}
}

func (m *ModuleHandler) ListLoadedModules(w http.ResponseWriter, r *http.Request) {
	userinfo, _ := m.userHandler.GetUserInfoFromRequest(w, r)

	///Parse a list of modules where the user has permission to access
	userAccessableModules := []*ModuleInfo{}
	for _, thisModule := range m.LoadedModule {
		thisModuleName := thisModule.Name
		if userinfo.GetModuleAccessPermission(thisModuleName) {
			userAccessableModules = append(userAccessableModules, thisModule)
		}
	}
	//Return the loaded modules as a list of JSON string
	jsonString, _ := json.Marshal(userAccessableModules)
	utils.SendJSONResponse(w, string(jsonString))
}

func (m *ModuleHandler) GetModuleInfoByID(moduleid string) *ModuleInfo {
	for _, module := range m.LoadedModule {
		if module.Name == moduleid {
			return module
		}
	}
	return nil
}

func (m *ModuleHandler) GetLaunchParameter(w http.ResponseWriter, r *http.Request) {
	moduleName, _ := utils.GetPara(r, "module")
	if moduleName == "" {
		utils.SendErrorResponse(w, "Missing paramter 'module'.")
		return
	}

	//Loop through the modules and see if the module exists.
	var targetLaunchInfo *ModuleInfo = nil
	found := false
	for _, module := range m.LoadedModule {
		thisModuleName := module.Name
		if thisModuleName == moduleName {
			targetLaunchInfo = module
			found = true
		}
	}

	if found {
		jsonString, _ := json.Marshal(targetLaunchInfo)
		utils.SendJSONResponse(w, string(jsonString))
		return
	} else {
		utils.SendErrorResponse(w, "Given module not exists.")
		return
	}

}