func (s *Sync) Start(c core.Core, db *db.DB) { s.core = c s.db = db s.config = config.Current.Plugins[PluginName].(*Config) c.RegisterCommand(core.Command{[]string{"sync", "s"}, "Syncs media with a device or folder. By default, lossles files are converted to MP3 V0.", map[string]string{ "path": "Target path", "convert": "boolean, default is true"}, core.AuthAdmin, func(ctx core.CommandContext) core.Result { args := ctx.Args var err error pathS, err := util.GetArg(args, "path", true, err) convertS, err := util.GetArg(args, "convert", true, err) doConvert, err := util.CastBool(convertS, err) if err != nil { return core.ResultByError(err) } convert := true if doConvert != nil { convert = *doConvert } return core.ResultByError(s.Sync(*pathS, convert)) }}) }
func (db *DB) initList(c core.Core) { c.RegisterCommand(core.Command{ []string{"list", "ls"}, "Searches and lists items from the database", map[string]string{ "text": "(Optional) Search string for full text search", "query": "(Optional) Input for SQL-ish query", "tags": "(Optional) Comma-separated list of tags to include", }, core.AuthGuest, db.list}) }
func (db *DB) initLogic(c core.Core) { c.RegisterCommand(core.Command{ []string{"trackplayed"}, "Inserts a track playback into the database statistics", map[string]string{ "title": "Title", "artist": "Artist", "album": "Album", "album_artist": "Album Artist", "length": "Track length in ms", "date": "Time the listening occurred, as Unix timestamp", "length_played": "The time the track was listened to (when fully played: length) in ms", "scrobbled": "Whether the track was scrobbled to last.fm/libre.fm"}, core.AuthUser, db.TrackPlayed}) }
func (d *DB) initStats(c core.Core) { c.RegisterCommand(core.Command{ []string{"stats"}, "Prints some statistics about the database", map[string]string{}, core.AuthUser, func(_ core.CommandContext) core.Result { res := map[string]interface{}{ "items_total": d.TitlesTotal(), "folders_total": d.FoldersTotal(), "items_per_folder": d.AvgFilesPerFolder(), } //TODO more stats //TODO stats per user level return core.Result{Status: core.StatusOK, Result: res} }}) }
func (p *IPod) Start(c core.Core, db *db.DB, s *sync.Sync) { p.core = c p.db = db p.sync = s p.config = config.Current.Plugins[PluginName].(*Config) c.RegisterCommand(core.Command{[]string{"ipod"}, "Syncs media with an iPod device. By default, Lossles files are converted to MP3 V0.", map[string]string{"mountpoint": "mountpoint of the iPod"}, core.AuthAdmin, func(ctx core.CommandContext) core.Result { path, err := util.GetArg(ctx.Args, "mountpoint", true, nil) if err != nil { return core.ResultByError(err) } return core.ResultByError(p.Sync(*path)) }}) }
func (d *DB) Open(c core.Core) error { if d.open { return errrs.New("DB is already opened!") } d.c = c var err error file := config.Current.DbFile d.db, err = gorm.Open("sqlite3", file) if err != nil { return err } d.open = true d.db.LogMode(true) if err := d.checkTables(); err != nil { return err } err = d.checkSanity() if err != nil { //TODO what now? return err } d.initStats(c) d.initLogic(c) // hear the difference? d.initLogin(c) // it's subtle but it could save your life d.initList(c) c.RegisterCommand(core.Command{ []string{"rescan"}, "Refreshes the database by re-scanning the media folder.", map[string]string{}, core.AuthAdmin, func(_ core.CommandContext) core.Result { go d.Update() return core.ResultOK }}) return nil }
func (a *AS) Start(c core.Core, d *db.DB) { a.db = d //TODO get base url baseURL := "http://localhost/api/" a.nowPlayingURL = baseURL + "as_nowplaying" a.submissionURL = baseURL + "as_scrobble" c.RegisterCommand(core.Command{ []string{"audioscrobbler", "as"}, `Interface for clients using the Last.fm Submissions Protocol v1.2.1. In your favourite scrobbler, use this as handshake URL: http://cfmedias-server-ip/api/audioscrobbler/?hs=true See also http://www.last.fm/api/submissions.`, map[string]string{ "hs": "hs=true marks a handshake request. requires p, c, v, u, t, a.", "p": "must be 1.2.1", "c": "identifier for the client software", "v": "version of the client software", "u": "username", "t": "timestamp of the request", "a": "authentication message: md5(md5(auth_token) + timestamp)", "__response": `The server will respond with: OK <session ID> <url to be used for a now-playing request> <url to be used for a submission request> or one of these: BANNED: Your client is doing bad things and is therefore banned. BADAUTH: Authentication details are incorrect. BADTIME: Time difference between server and client time too high. Correct your system clock. FAILED <reason>: Your request failed for the specified reason.`}, core.AuthGuest, a.LoginAS}) }
func (db *DB) initLogin(c core.Core) { c.RegisterCommand(core.Command{ []string{"create_user"}, "Creates a user in the database", map[string]string{ "name": "Username", "email": "E-Mail", "auth_level": fmt.Sprintf("User Rank: Guest(%d), User(%d), "+ "Admin(%d), Root(%d)", core.AuthGuest, core.AuthUser, core.AuthAdmin, core.AuthRoot), "password": "******"}, core.AuthAdmin, func(ctx core.CommandContext) core.Result { args := ctx.Args var err error name, err := util.GetArg(args, "name", true, err) email, err := util.GetArg(args, "email", true, err) authLevelS, err := util.GetArg(args, "auth_level", true, err) password, err := util.GetArg(args, "password", true, err) authLevelI, err := util.CastUint(authLevelS, err) if err != nil { return core.Result{Status: core.StatusError, Error: err} } authLevel := core.AuthLevel(*authLevelI) if authLevel >= ctx.AuthLevel { return core.ResultByError(errrs.New("You cannot create a user" + " with that level!")) } user, err := db.CreateUser(*name, *email, authLevel, *password) if err == nil { return core.Result{Status: core.StatusOK, Result: user} } return core.Result{Status: core.StatusError, Error: err} }}) c.RegisterCommand(core.Command{ []string{"login"}, "Logs in with user/password and returns the auth token", map[string]string{ "name": "Username", "password": "******"}, core.AuthGuest, func(ctx core.CommandContext) core.Result { args := ctx.Args var err error name, err := util.GetArg(args, "name", true, err) password, err := util.GetArg(args, "password", true, err) if err != nil { return core.ResultByError(err) } success, authToken, err := db.Login(*name, *password) if err == nil && success { return core.Result{Status: core.StatusOK, Result: map[string]string{"auth_token": authToken}} } if err == nil { return core.Result{Status: core.StatusError, Error: errrs.New("Wrong username or password")} } return core.Result{Status: core.StatusError, Error: err} }}) c.RegisterCommand(core.Command{ []string{"change_authtoken", "logout"}, `Changes the authentication token of the user, thereby logging out all clients`, map[string]string{ "name": `(Optional) username of the user to log out. Leave empty to use current user`, }, core.AuthUser, func(ctx core.CommandContext) core.Result { args := ctx.Args var err error name, err := util.GetArg(args, "name", false, err) if err != nil { return core.ResultByError(err) } var user *User if name != nil { if ctx.AuthLevel < core.AuthAdmin { return core.ResultByError(core.ErrorNotAllowed) } user, err = db.GetUserByName(*name) } else { if ctx.UserId == nil { return core.ResultByError(core.ErrorNotLoggedIn) } user, err = db.GetUser(*ctx.UserId) } if user == nil { return core.ResultByError(core.ErrorUserNotFound) } _, err = db.ChangeAuthToken(user) return core.ResultByError(err) }}) }