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 (a *AS) LoginAS(ctx core.CommandContext) core.Result {
var err error
args := ctx.Args
handshakeS, err := util.GetArg(args, "hs", true, err)
handshake, err := util.CastBool(handshakeS, err)
pVer, err := util.GetArg(args, "p", true, err)
_, err = util.GetArg(args, "c", true, err)
_, err = util.GetArg(args, "v", true, err)
userS, err := util.GetArg(args, "u", true, err)
timestampS, err := util.GetArg(args, "t", true, err)
timestamp, err := util.CastInt64(timestampS, err)
authMsg, err := util.GetArg(args, "a", true, err)
if err != nil {
return errorAS(StatusFailed, err)
}
if !*handshake {
return errorAS(StatusFailed, errrs.New("this URL is only for handshake"+
" requests, hs must be true"))
}
if *pVer != "1.2.1" {
return errorAS(StatusFailed, errrs.New("Protocol version must be 1.2.1"))
}
//TODO maybe check audioscrobbler client id and version
// check timestamp
timestampReal := time.Now().Unix()
if util.Abs(timestampReal-*timestamp) > 120 {
return errorAS(StatusBadTime, nil)
}
// get user
user, err := a.db.GetUserByName(*userS)
if user == nil {
logger.Log.Println("incorrect auth from unknown user ", *userS)
return errorAS(StatusBadAuth, nil)
}
// check auth
// md5(md5(auth_token) + timestamp)
md5Token := fmt.Sprintf("%x", md5.Sum([]byte(user.AuthToken)))
correctStr := fmt.Sprintf("%s%d", md5Token, *timestamp)
correctAuthMsg := fmt.Sprintf("%x", md5.Sum([]byte(correctStr)))
if correctAuthMsg != *authMsg {
logger.Log.Println("incorrect auth from", user.Name, "with", *authMsg,
"instead of", correctAuthMsg)
return errorAS(StatusBadAuth, nil)
}
return core.Result{StatusOK, []interface{}{user.AuthToken, a.nowPlayingURL,
a.submissionURL}, nil, true}
}
func (db *DB) TrackPlayed(ctx core.CommandContext) core.Result {
args := ctx.Args
tracks, err := db.GetItem(args)
lengthS, err := util.GetArg(args, "length", true, err)
length_playedS, err := util.GetArg(args, "length_played", true, err)
scrobbledS, err := util.GetArg(args, "scrobbled", true, err)
length, err := util.CastFloat(lengthS, err)
length_played, err := util.CastFloat(length_playedS, err)
scrobbled, err := util.CastBool(scrobbledS, err)
if err != nil {
return core.Result{Status: core.StatusError, Error: err}
}
if len(tracks) == 0 {
//TODO insert track
return core.Result{Status: core.StatusItemNotFound}
}
if len(tracks) > 1 {
return core.Result{Status: core.StatusQueryNotUnique, Result: tracks}
}
track := tracks[0]
// update stats
x := float64(*length_played / *length)
tu := float64(config.Current.ListenedUpperThreshold)
tl := float64(config.Current.ListenedLowerThreshold)
scoreAdd := float32(math.Min(1, math.Max(0, (x-tl)/(tu-tl))))
//TODO test this
track.PlayCount++
if scoreAdd > 0 {
track.PlayScore += scoreAdd
track.ScoredCount++
}
if *scrobbled {
track.ScrobbleCount++
}
err = db.db.Save(track).Error
if err != nil {
return core.Result{Status: core.StatusError, Error: err}
}
return core.Result{Status: core.StatusOK, Result: tracks}
}
