Verrückter Anilist Import

Bestes Feature 2k16.
Hashtag Make Grilist Great Again.

2 files changed, 237 insertions, 44 deletions

diff --git a/modules/grils/grils.go b/modules/grils/grils.go
index 0ba4c61..0fac5df 100644
--- a/modules/grils/grils.go
+++ b/modules/grils/grils.go
@@ -4,9 +4,7 @@ import (
         "fmt"
         "log"
         "net/http"
-        "regexp"
         "strconv"
-        "strings"
         "time"
 
         "fagott.pw/charakterin"
@@ -20,20 +18,6 @@ import (
         "github.com/julienschmidt/httprouter"
 )
 
-var (
-        pgArrayReg = regexp.MustCompile(`(((?P<value>(([^",\\{}\s(NULL)])+|"([^"\\]|\\"|\\\\)*")))(,)?)`)
-        pgValueIdx int
-)
-
-func findIdx() {
-        for i, subexp := range pgArrayReg.SubexpNames() {
-                if subexp == "value" {
-                        pgValueIdx = i
-                        break
-                }
-        }
-}
-
 type GrilsModule struct {
         g *grilist.Grilist
         c *cache.Cache
@@ -44,7 +28,6 @@ func (m *GrilsModule) Name() string {
 }
 
 func (m *GrilsModule) Init(g *grilist.Grilist) {
-        findIdx()
         m.g = g
         m.g.Router.GET("/gril/:id", m.viewGril)
         m.g.Router.GET("/gril/:id/*rest", m.viewGril)
@@ -77,8 +60,8 @@ func (m *GrilsModule) getGrils(whereClause string, params ...interface{}) ([]*mo
                         gril.KanjiName = *kanjiName
                 }
 
-                gril.Tags = pgArray(tags)
-                gril.OtherNames = pgArray(otherNames)
+                gril.Tags = util.PGArray(tags)
+                gril.OtherNames = util.PGArray(otherNames)
 
                 m.c.Insert(gril.ID, gril)
 
@@ -285,17 +268,6 @@ func (m *GrilsModule) viewGril(w http.ResponseWriter, r *http.Request, p httprou
         })
 }
 
-func pgArray(array []byte) []string {
-        var results []string
-        matches := pgArrayReg.FindAllStringSubmatch(string(array), -1)
-        for _, match := range matches {
-                s := match[pgValueIdx]
-                s = strings.Trim(s, "\"")
-                results = append(results, s)
-        }
-        return results
-}
-
 func New() *GrilsModule {
         return &GrilsModule{}
 }
diff --git a/modules/lists/lists.go b/modules/lists/lists.go
index 65919e8..387e48a 100644
--- a/modules/lists/lists.go
+++ b/modules/lists/lists.go
@@ -13,12 +13,14 @@ import (
 
         "fagott.pw/charakterin"
         "fagott.pw/grilist/cache"
+        "fagott.pw/grilist/dataimport"
         "fagott.pw/grilist/eventlogging"
         "fagott.pw/grilist/frontend"
         "fagott.pw/grilist/grilist"
         "fagott.pw/grilist/models"
         "fagott.pw/grilist/modules/grils"
         "fagott.pw/grilist/util"
+
         "github.com/julienschmidt/httprouter"
 )
 
@@ -66,6 +68,9 @@ func (m *Module) Init(g *grilist.Grilist) {
         m.g.Router.GET("/list/:id/delete", m.deleteList)
 
         m.g.Router.GET("/api/lists/user", m.APIgetUserLists)
+        m.g.Router.GET("/api/import/anilist/favourites", m.apiAnilistGetFavourites)
+        m.g.Router.GET("/api/import/anilist/translate", m.apiAnilistTranslate)
+        m.g.Router.GET("/api/import/anilist/assign", m.apiAnilistAssign)
 
         m.c = cache.New()
 }
@@ -78,7 +83,6 @@ func (m *Module) getListGrils(list *models.List) error {
 
         defer rows.Close()
         list.Grils = list.Grils[:0]
-        var ids []int
         for rows.Next() {
                 var grilID int
                 lg := &models.ListGril{}
@@ -87,21 +91,16 @@ func (m *Module) getListGrils(list *models.List) error {
                         log.Println("error scanning row in getListGrils:", err)
                         continue
                 }
-                ids = append(ids, grilID)
 
-                list.Grils = append(list.Grils, lg)
-        }
-
-        // grils holen
-        grils, err := m.grils.FromIDs(ids)
-        if err != nil {
-                return err
-        }
+                gril, err := m.grils.FromID(grilID)
+                if err != nil {
+                        log.Println("error getting listGril:", err)
+                        continue
+                }
+                lg.Gril = gril
 
-        for id, gril := range grils {
-                list.Grils[id].Gril = gril
+                list.Grils = append(list.Grils, lg)
         }
-
         sort.Sort(ListGrils(list.Grils))
         return nil
 }
@@ -267,6 +266,18 @@ func (m *Module) viewList(w http.ResponseWriter, r *http.Request, p httprouter.P
         data := m.g.Renderer.DefaultData()
         data["user"] = user
         data["list"] = list
+        data["mergeTemplateCard"] = frontend.Card{
+                Image: "/assets/img/placeholder.png",
+                Actions: []frontend.Action{
+                        frontend.Action{
+                                Name:   "Anguckieren",
+                                Target: "_blank",
+                        },
+                        frontend.Action{
+                                Name: "Auswählen",
+                        },
+                },
+        }
         if user != nil && user.ID == list.Owner.ID {
                 data["isOwner"] = true
         } else {
@@ -526,7 +537,7 @@ func (m *Module) addGrilToList(w http.ResponseWriter, r *http.Request, p httprou
         }
 
         // rein in die DB damit
-        _, err = m.g.DB.Query(`INSERT INTO grilist.lists_grils(list_id, gril_id, "order") VALUES($1, $2, $3)`, listID, grilID, rank)
+        _, err = m.g.DB.Exec(`INSERT INTO grilist.lists_grils(list_id, gril_id, "order") VALUES($1, $2, $3)`, listID, grilID, rank)
         if err != nil {
                 log.Println("error inserting gril into list:", err)
                 http.Error(w, "could not insert gril", 500)
@@ -725,6 +736,216 @@ func (m *Module) removeGrilFromList(w http.ResponseWriter, r *http.Request, p ht
         })
 }
 
+func (m *Module) apiAnilistGetFavourites(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+        el := m.g.EventLogger(r)
+        user, err := m.g.Charakterin.GetUserFromRequest(r)
+        if err != nil {
+                http.Error(w, "Unauthorized", 401)
+                return
+        }
+
+        if user.AnilistClient == nil || !user.AnilistClient.IsCoupled {
+                http.Error(w, "Anilist not enabled", 500)
+                return
+        }
+
+        aniUser, err := user.AnilistClient.User()
+        if err != nil {
+                http.Error(w, fmt.Sprintf("%v", err), 500)
+                return
+        }
+
+        favs, err := user.AnilistClient.Favourites(aniUser.ID)
+        if err != nil {
+                http.Error(w, fmt.Sprintf("%v", err), 500)
+                return
+        }
+
+        el.FavImportAnilist(user, eventlogging.FavImportAnilistData{
+                Favourites: favs,
+        })
+
+        idList := "("
+        ids := []*models.ForeignID{}
+        idMap := map[int]*models.ForeignID{}
+        for _, v := range favs.Characters {
+                id := &models.ForeignID{
+                        ID: v.ID,
+                }
+                ids = append(ids, id)
+                idMap[v.ID] = id
+                idList += strconv.Itoa(v.ID) + ","
+        }
+        idList = idList[:len(idList)-1] + ")"
+        rows, err := m.g.DB.Query(fmt.Sprintf("SELECT source_id, gril_id FROM grils_id_mappings WHERE source = $1 AND source_id in %s;", idList), models.DataSourceAnilist)
+        if err != nil {
+                http.Error(w, fmt.Sprintf("%v", err), 500)
+                return
+        }
+        defer rows.Close()
+        for rows.Next() {
+                var sID int
+                var id int
+                if err := rows.Scan(&sID, &id); err != nil {
+                        http.Error(w, fmt.Sprintf("%v", err), 500)
+                        return
+                }
+                idMap[sID].Mapped = id
+        }
+
+        idsData, err := json.Marshal(ids)
+        if err != nil {
+                http.Error(w, fmt.Sprintf("%v", err), 500)
+                return
+        }
+
+        w.WriteHeader(200)
+        w.Write(idsData)
+}
+
+func (m *Module) apiAnilistTranslate(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+        el := m.g.EventLogger(r)
+        user, err := m.g.Charakterin.GetUserFromRequest(r)
+        if err != nil {
+                http.Error(w, "Unauthorized", 401)
+                return
+        }
+
+        if user.AnilistClient == nil || !user.AnilistClient.IsCoupled {
+                http.Error(w, "Anilist not enabled", 500)
+                return
+        }
+
+        idParam := r.URL.Query().Get("id")
+        id, err := strconv.Atoi(idParam)
+        if err != nil {
+                http.Error(w, "invalid gril ID (type mismatch)", 400)
+                return
+        }
+
+        grilID := dataimport.FindGrilInDatabase(id, models.DataSourceAnilist)
+        if grilID != nil {
+                log.Println("Found gril by mapping")
+                data, err := json.Marshal(models.Merge{
+                        Targets: []models.MergeGril{
+                                models.MergeGril{
+                                        ID: *grilID,
+                                },
+                        },
+                })
+                if err != nil {
+                        http.Error(w, fmt.Sprintf("%v", err), 500)
+                        return
+                }
+                w.WriteHeader(200)
+                w.Write(data)
+                return
+        }
+
+        char, err := user.AnilistClient.CharacterPage(id)
+        if err != nil {
+                http.Error(w, fmt.Sprintf("%v", err), 500)
+                return
+        }
+
+        el.AnilistCharacterPage(user, eventlogging.AnilistCharacterPageData{
+                CharacterPage: char,
+        })
+
+        aniGril := dataimport.ConvertGrilAnilist(char)
+        similarGrils, err := dataimport.FindSimilarGrils(aniGril, models.DataSourceAnilist)
+        if err != nil {
+                http.Error(w, fmt.Sprintf("%v", err), 500)
+                return
+        }
+
+        merge := models.Merge{
+                ID:       char.ID,
+                Name:     aniGril.RomajiName,
+                ImageURL: char.ThumbURL,
+                Targets:  []models.MergeGril{},
+        }
+        for _, sg := range similarGrils {
+                merge.Targets = append(merge.Targets, models.MergeGril{
+                        ID:       sg.ID,
+                        Name:     sg.RomajiName,
+                        ImageURL: sg.ImagePath(true),
+                })
+        }
+
+        switch len(merge.Targets) {
+        case 0:
+                var iID int
+                if iID, err = dataimport.InsertGril(aniGril, models.DataSourceAnilist); err != nil {
+                        http.Error(w, fmt.Sprintf("Import: %v", err), 500)
+                        return
+                }
+                merge.Targets = append(merge.Targets, models.MergeGril{
+                        ID: iID,
+                })
+                el.FavImportAnilistCreated(user, eventlogging.FavImportAnilistCreatedData{
+                        AnilistID:  aniGril.ID,
+                        AssignedID: iID,
+                })
+        case 1:
+                if err := dataimport.AssignGril(char.ID, merge.Targets[0].ID, models.DataSourceAnilist); err != nil {
+                        http.Error(w, fmt.Sprintf("Assign: %v", err), 500)
+                        return
+                }
+                el.FavImportAnilistAssigned(user, eventlogging.FavImportAnilistAssignedData{
+                        AnilistID:  char.ID,
+                        AssignedID: merge.Targets[0].ID,
+                })
+        }
+
+        data, err := json.Marshal(merge)
+        if err != nil {
+                http.Error(w, fmt.Sprintf("%v", err), 500)
+                return
+        }
+
+        w.WriteHeader(200)
+        w.Write(data)
+}
+
+func (m *Module) apiAnilistAssign(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+        el := m.g.EventLogger(r)
+        user, err := m.g.Charakterin.GetUserFromRequest(r)
+        if err != nil {
+                http.Error(w, "Unauthorized", 401)
+                return
+        }
+
+        if user.AnilistClient == nil || !user.AnilistClient.IsCoupled {
+                http.Error(w, "Anilist not enabled", 500)
+                return
+        }
+
+        idParam := r.URL.Query().Get("id")
+        id, err := strconv.Atoi(idParam)
+        if err != nil {
+                http.Error(w, "invalid gril ID (type mismatch)", 400)
+                return
+        }
+        targetParam := r.URL.Query().Get("target")
+        target, err := strconv.Atoi(targetParam)
+        if err != nil {
+                http.Error(w, "invalid target ID (type mismatch)", 400)
+                return
+        }
+
+        if err := dataimport.AssignGril(id, target, models.DataSourceAnilist); err != nil {
+                http.Error(w, fmt.Sprintf("%v", err), 500)
+                return
+        }
+        w.WriteHeader(200)
+        w.Write([]byte("OK"))
+        el.FavImportAnilistAssigned(user, eventlogging.FavImportAnilistAssignedData{
+                AnilistID:  id,
+                AssignedID: target,
+        })
+}
+
 func (m *Module) APIgetUserLists(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
         user, err := m.g.Charakterin.GetUserFromRequest(r)
         if err != nil {