kontor/kontor-gin/internal/cmd/import.go

package cmd

import (
	"kontor-api-gin/internal/api"
	"kontor-api-gin/internal/config"
	"kontor-api-gin/internal/models"
	"kontor-api-gin/internal/repository"
	"log"
	"log/slog"

	"github.com/spf13/cobra"
)

var importCmd = &cobra.Command{
	Use:   "import",
	Short: "Import Kontor Database",
	Long:  "Import Kontor Database from given file",
	// Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		slog.Info("import kontor")
		slog.Info("Verbosity level", "level", config.Verbose)
		data := api.ExportData{}
		err := api.ReadJson(&data, config.FileName)
		if err != nil {
			slog.Info("Error importing data", "Error", err.Error())
		}
		db, err := config.NewDB(config.Config.DB)
		if err != nil {
			log.Fatal(err)
		}
		if config.Config.DB.Type == "sqlite" {
			if err := db.AutoMigrate(
				models.Profile{},
				models.Permission{},
				models.Assignment{},
				models.Sport{},
				models.Player{},
				models.Team{},
				models.Position{},
				models.Rooster{},
				models.Vendor{},
				models.CardSet{},
				models.Card{},
				models.Artist{},
				models.Publisher{},
				models.WorkType{},
				models.Comic{},
				models.Volume{},
				models.StoryArc{},
				models.Issue{},
				models.TradePaperback{},
				models.ComicWork{},
				models.IssueWork{},
				models.Article{},
				models.BookshelfPublisher{},
				models.Book{},
				models.Author{},
				models.ArticleAuthor{},
				models.BookAuthor{},
				models.MediaArticle{},
				models.MediaVideo{},
				models.MediaLoFi{},
				models.MediaMusic{},
				models.MediaFile{},
				models.MediaActor{},
				models.MediaActorFile{},
				models.Token{},
				models.MailAccount{},
				models.Mail{},
			); err != nil {
				log.Fatal(err)
			}
		}
		profileRepository := repository.NewProfileRepository(db)
		profileRepository.Import(data.Profile)
		permissionRepository := repository.NewPermissionRepository(db)
		permissionRepository.Import(data.Permission)
		assignmentRepository := repository.NewAssignmentRepository(db)
		assignmentRepository.Import(data.Assignment)
		sportRepository := repository.NewSportRepository(db)
		sportRepository.Import(data.Sport)
		playerRepository := repository.NewPlayerRepository(db)
		playerRepository.Import(data.Player)
		teamRepository := repository.NewTeamRepository(db)
		teamRepository.Import(data.Team)
		roosterRepository := repository.NewRoosterRepository(db)
		roosterRepository.Import(data.Rooster)
		vendorRepository := repository.NewVendorRepository(db)
		vendorRepository.Import(data.Vendor)
		cardSetRepository := repository.NewCardSetRepository(db)
		cardSetRepository.Import(data.CardSet)
		cardRepository := repository.NewCardRepository(db)
		cardRepository.Import(data.Card)
		artistRepository := repository.NewArtistRepository(db)
		artistRepository.Import(data.Artist)
		publisherRepository := repository.NewPublisherRepository(db)
		publisherRepository.Import(data.Publisher)
		workTypeRepository := repository.NewWorkTypeRepository(db)
		workTypeRepository.Import(data.Worktype)
		comicRepository := repository.NewComicRepository(db)
		comicRepository.Import(data.Comic)
		volumeRepository := repository.NewVolumeRepository(db)
		volumeRepository.Import(data.Volume)
		storyArcRepository := repository.NewStoryArcRepository(db)
		storyArcRepository.Import(data.StoryArc)
		issueRepository := repository.NewIssueRepository(db)
		issueRepository.Import(data.Issue)
		tradePaperbackRepository := repository.NewTradePaperbackRepository(db)
		tradePaperbackRepository.Import(data.TradePaperback)
		comicWorkRepository := repository.NewComicworkRepository(db)
		comicWorkRepository.Import(data.ComicWork)
		issueWorkRepository := repository.NewIssueworkRepository(db)
		issueWorkRepository.Import(data.IssueWork)
		articleRepository := repository.NewArticleRepository(db)
		articleRepository.Import(data.Article)
		bookshelfPublisherRepository := repository.NewBookshelfPublisherRepository(db)
		bookshelfPublisherRepository.Import(data.BookshelfPublisher)
		bookRepository := repository.NewBookRepository(db)
		bookRepository.Import(data.Book)
		authorRepository := repository.NewAuthorRepository(db)
		authorRepository.Import(data.Author)
		articleAuthorRepository := repository.NewArticleAuthorRepository(db)
		articleAuthorRepository.Import(data.ArticleAuthor)
		bookAuthorRepository := repository.NewBookAuthorRepository(db)
		bookAuthorRepository.Import(data.BookAuthor)
		mediaArticleRepository := repository.NewMediaArticleRepository(db)
		mediaArticleRepository.Import(data.MediaArticle)
		mediaVideoRepository := repository.NewMediaVideoRepository(db)
		mediaVideoRepository.Import(data.MediaVideo)
		mediaLoFiRepository := repository.NewMediaLoFiRepository(db)
		mediaLoFiRepository.Import(data.MediaLoFi)
		mediaMusicRepository := repository.NewMediaMusicRepository(db)
		mediaMusicRepository.Import(data.MediaMusic)
		mediaFileRepository := repository.NewMediaFileRepository(db)
		mediaFileRepository.Import(data.MediaFile)
		mediaActorRepository := repository.NewMediaActorRepository(db)
		mediaActorRepository.Import(data.MediaActor)
		mediaActorFileRepository := repository.NewMediaActorFileRepository(db)
		mediaActorFileRepository.Import(data.MediaActorFile)
		tokenRepository := repository.NewTokenRepository(db)
		tokenRepository.Import(data.Token)
		mailAccountRepository := repository.NewMailAccountRepository(db)
		mailAccountRepository.Import(data.MailAccount)
		mailRepository := repository.NewMailRepository(db)
		mailRepository.Import(data.Mail)

		slog.Info("importing Profiles", "count", len(data.Profile))
		slog.Info("importing Permissions", "count", len(data.Permission))
		slog.Info("importing Assignments", "count", len(data.Assignment))
		slog.Info("importing MediaFiles", "count", len(data.MediaFile))
		slog.Info("importing MediaLofis", "count", len(data.MediaLoFi))
		slog.Info("importing MediaLofi", "media_lofi", data.MediaLoFi[0])
		slog.Info("import kontor finished")
	},
}

func init() {
	rootCmd.AddCommand(importCmd)
}