Verrückter Anilist Import

Bestes Feature 2k16.
Hashtag Make Grilist Great Again.

5 files changed, 227 insertions, 0 deletions

diff --git a/dataimport/converter.go b/dataimport/converter.go
new file mode 100644
index 0000000..6a44384
--- /dev/null
+++ b/dataimport/converter.go
@@ -0,0 +1,56 @@
+package dataimport
+
+import (
+        "fmt"
+        "strings"
+
+        "fagott.pw/goanilist"
+        "fagott.pw/grilist/models"
+)
+
+func ConvertGrilAnilist(char *goanilist.CharacterPageResult) *ImporterGril {
+        gril := &ImporterGril{}
+        gril.ID = char.ID
+        gril.KanjiName = char.JapaneseName
+        gril.RomajiName = strings.TrimSpace(fmt.Sprintf("%s %s", char.GivenName, char.FamilyName))
+        gril.Order = char.Order
+        if char.AlternativeName != "" {
+                gril.OtherNames = append(gril.OtherNames, char.AlternativeName)
+        }
+        if char.ImageURL != "" {
+                gril.Images = append(gril.Images, Image{
+                        Type: ImageTypeFull,
+                        URL:  char.ImageURL,
+                })
+        }
+        if char.ThumbURL != "" {
+                gril.Images = append(gril.Images, Image{
+                        Type: ImageTypeThumbnail,
+                        URL:  char.ThumbURL,
+                })
+        }
+        for _, anime := range char.Anime {
+                gril.Series = append(gril.Series, ConvertSeriesAnilist(anime.SeriesResult))
+        }
+        for _, manga := range char.Manga {
+                gril.Series = append(gril.Series, ConvertSeriesAnilist(manga.SeriesResult))
+        }
+        return gril
+}
+
+func ConvertSeriesTypeAnilist(seriesType string) models.SeriesType {
+        switch seriesType {
+        }
+        return models.SeriesTypeUnknown
+}
+
+func ConvertSeriesAnilist(series goanilist.SeriesResult) models.Series {
+        return models.Series{
+                ID:         series.ID,
+                Type:       ConvertSeriesTypeAnilist(series.Type),
+                Name:       series.TitleEnglish,
+                KanjiName:  series.TitleJapanese,
+                RomajiName: series.TitleRomaji,
+                OtherNames: series.Synonyms,
+        }
+}
diff --git a/dataimport/dataimport.go b/dataimport/dataimport.go
new file mode 100644
index 0000000..4966e25
--- /dev/null
+++ b/dataimport/dataimport.go
@@ -0,0 +1,9 @@
+package dataimport
+
+import "database/sql"
+
+var database *sql.DB
+
+func Init(db *sql.DB) {
+        database = db
+}
diff --git a/dataimport/finder.go b/dataimport/finder.go
new file mode 100644
index 0000000..5b704a4
--- /dev/null
+++ b/dataimport/finder.go
@@ -0,0 +1,87 @@
+package dataimport
+
+import (
+        "strings"
+
+        "fagott.pw/grilist/models"
+        "fagott.pw/grilist/util"
+)
+
+func FindGrilInDatabase(id int, dataSource models.DataSource) *int {
+        var grilID *int
+        _ = database.QueryRow("SELECT gril_id FROM grilist.grils_id_mappings WHERE source = $1 AND source_id = $2;", dataSource, id).Scan(&grilID)
+        return grilID
+}
+
+func compareAnimeNames(a, b string) bool {
+        normalize := func(str string) string {
+                return util.NormalizeString(strings.TrimSpace(strings.Replace(strings.ToLower(str), " ", "", -1)))
+        }
+        return normalize(a) == normalize(b)
+}
+
+func FindSimilarGrils(iGril *ImporterGril, dataSource models.DataSource) ([]*models.Gril, error) {
+        rows, err := database.Query("SELECT id, name, appearance_id, appearance_names, source_id FROM grilist.get_grils_for_merge($1, $2);", iGril.RomajiName, dataSource)
+        if err != nil {
+                return nil, err
+        }
+        defer rows.Close()
+
+        grils := []*models.Gril{}
+        var gril *models.Gril
+
+        for rows.Next() {
+                var id int
+                var name string
+                var aID *int
+                var aNamesData *[]byte
+                var sID *int
+                if err := rows.Scan(&id, &name, &aID, &aNamesData, &sID); err != nil {
+                        return nil, err
+                }
+                if gril == nil || gril.ID != id {
+                        gril = &models.Gril{
+                                ID:         id,
+                                RomajiName: name,
+                        }
+                        grils = append(grils, gril)
+                }
+                if aID != nil && aNamesData != nil {
+                        series := models.Series{
+                                ID: *aID,
+                        }
+                        aNames := util.PGArray(*aNamesData)
+                        series.RomajiName = aNames[0]
+                        series.OtherNames = aNames
+                        if sID != nil {
+                                series.ForeignIDs[dataSource] = *sID
+                        }
+                        gril.Series = append(gril.Series, series)
+                }
+        }
+        mGrils := []*models.Gril{}
+        for _, gril := range grils {
+                matches := false
+                for _, series := range gril.Series {
+                        gril.Series = append(gril.Series, series)
+                        for _, anime := range iGril.Series {
+                                if id, ok := series.ForeignIDs[dataSource]; ok && id == anime.ID {
+                                        matches = true
+                                        continue
+                                }
+                                for _, name := range series.OtherNames {
+                                        matches = matches || compareAnimeNames(name, anime.RomajiName)
+                                        matches = matches || compareAnimeNames(name, anime.KanjiName)
+                                        matches = matches || compareAnimeNames(name, anime.FuriganaName)
+                                        for _, syn := range anime.OtherNames {
+                                                matches = matches || compareAnimeNames(name, syn)
+                                        }
+                                }
+                        }
+                }
+                if matches {
+                        mGrils = append(mGrils, gril)
+                }
+        }
+        return mGrils, nil
+}
diff --git a/dataimport/importer.go b/dataimport/importer.go
new file mode 100644
index 0000000..0d121e5
--- /dev/null
+++ b/dataimport/importer.go
@@ -0,0 +1,52 @@
+package dataimport
+
+import (
+        "log"
+
+        "fagott.pw/grilist/models"
+)
+
+func logErr(err error) {
+        if err != nil {
+                log.Printf("IMPORT ERROR: %v\n", err)
+        }
+}
+
+func AssignGril(foreign int, id int, dataSource models.DataSource) error {
+        _, err := database.Exec("INSERT INTO grilist.grils_id_mappings (gril_id, source, source_id) VALUES ($1, $2, $3);", id, models.DataSourceAnilist, foreign)
+        if err != nil {
+                return err
+        }
+        return nil
+}
+
+func InsertGril(g *ImporterGril, dataSource models.DataSource) (int, error) {
+        var dbID int
+        if err := database.QueryRow("INSERT INTO grilist.grils (age) VALUES (NULL) RETURNING id;").Scan(&dbID); err != nil {
+                return 0, err
+        }
+        if err := AssignGril(g.ID, dbID, dataSource); err != nil {
+                return 0, err
+        }
+        if g.Gril.KanjiName != "" {
+                _, err := database.Exec(`INSERT INTO
+                grilist.gril_names (gril_id, name, name_type)
+                VALUES ($1, $2, $3);`, dbID, g.KanjiName,
+                        0)
+                logErr(err)
+        }
+        if g.Gril.RomajiName != "" {
+                _, err := database.Exec(`INSERT INTO
+                grilist.gril_names (gril_id, name, name_type)
+                VALUES ($1, $2, $3);`, dbID, g.RomajiName,
+                        1)
+                logErr(err)
+        }
+        for _, v := range g.OtherNames {
+                _, err := database.Exec(`INSERT INTO
+                grilist.gril_names (gril_id, name, name_type)
+                VALUES ($1, $2, $3);`, dbID, v, 2)
+                logErr(err)
+        }
+        return dbID, nil
+}
diff --git a/dataimport/types.go b/dataimport/types.go
new file mode 100644
index 0000000..82e3b9a
--- /dev/null
+++ b/dataimport/types.go
@@ -0,0 +1,23 @@
+package dataimport
+
+import "fagott.pw/grilist/models"
+
+type ImporterGril struct {
+        models.Gril
+        Order  int
+        Images []Image
+}
+
+type ImageType int
+
+const (
+        ImageTypeThumbnail ImageType = iota
+        ImageTypeThumbnailSmall
+        ImageTypeFull
+        ImageTypeBanner
+)
+
+type Image struct {
+        URL  string
+        Type ImageType
+}