add methods in Repository and Model for importing data

kontor-gin/internal/repository/artist.go

@@ -12,6 +12,29 @@ type ArtistRepository struct {
 	db *gorm.DB
 }
 
+func (repository *ArtistRepository) Import(dtos models.ArtistDTOList) {
+	slog.Info("PlayerRepository#Import")
+	for index, dto := range dtos {
+		slog.Info("importing", "index", index, "profile", dto)
+		model := dto.ConvertDTOToModel()
+		existing_item := models.Artist{ID: dto.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}
+
 func NewArtistRepository(db *gorm.DB) *ArtistRepository {
 	repo := &ArtistRepository{db: db}
 	return repo

kontor-gin/internal/repository/assignment.go

@@ -35,3 +35,26 @@ func (repository *AssignmentRepository) GetById(context context.Context, id stri
 	}
 	return assignment, result.Error
 }
+
+func (repository *AssignmentRepository) Import(assignments models.AssignmentDTOList) {
+	slog.Info("AssignmentRepository#Import")
+	for index, assignment := range assignments {
+		slog.Info("importing", "index", index, "profile", assignment)
+		model := assignment.ConvertDTOToModel()
+		existing_item := models.Assignment{ID: assignment.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}

kontor-gin/internal/repository/card.go

@@ -12,6 +12,29 @@ type CardRepository struct {
 	db *gorm.DB
 }
 
+func (repository *CardRepository) Import(dtos models.CardDTOList) {
+	slog.Info("CardRepository#Import")
+	for index, dto := range dtos {
+		slog.Info("importing", "index", index, "profile", dto)
+		model := dto.ConvertDTOToModel()
+		existing_item := models.Card{ID: dto.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}
+
 func NewCardRepository(db *gorm.DB) *CardRepository {
 	repo := &CardRepository{db: db}
 	return repo

kontor-gin/internal/repository/cardset.go

@@ -12,6 +12,29 @@ type CardSetRepository struct {
 	db *gorm.DB
 }
 
+func (repository *CardSetRepository) Import(dtos models.CardSetDTOList) {
+	slog.Info("CardSetRepository#Import")
+	for index, dto := range dtos {
+		slog.Info("importing", "index", index, "profile", dto)
+		model := dto.ConvertDTOToModel()
+		existing_item := models.CardSet{ID: dto.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}
+
 func NewCardSetRepository(db *gorm.DB) *CardSetRepository {
 	repo := &CardSetRepository{db: db}
 	return repo

kontor-gin/internal/repository/comic.go

@@ -12,6 +12,29 @@ type ComicRepository struct {
 	db *gorm.DB
 }
 
+func (repository *ComicRepository) Import(dtos models.ComicDTOList) {
+	slog.Info("ComicRepository#Import")
+	for index, dto := range dtos {
+		slog.Info("importing", "index", index, "profile", dto)
+		model := dto.ConvertDTOToModel()
+		existing_item := models.Comic{ID: dto.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}
+
 func NewComicRepository(db *gorm.DB) *ComicRepository {
 	repo := &ComicRepository{db: db}
 	return repo

kontor-gin/internal/repository/permission.go

@@ -12,6 +12,11 @@ type PermissionRepository struct {
 	db *gorm.DB
 }
 
+func NewPermissionRepository(db *gorm.DB) *PermissionRepository {
+	repository := &PermissionRepository{db: db}
+	return repository
+}
+
 func (repository *PermissionRepository) FindAll(context context.Context) ([]models.Permission, error) {
 
 	var permissions []models.Permission
@@ -22,7 +27,25 @@ func (repository *PermissionRepository) FindAll(context context.Context) ([]mode
 	return permissions, nil
 }
 
-func NewPermissionRepository(db *gorm.DB) *PermissionRepository {
-	repository := &PermissionRepository{db: db}
-	return repository
+func (repository *PermissionRepository) Import(permissions models.PermissionDTOList) {
+	slog.Info("PermissionRepository#Import")
+	for index, permission := range permissions {
+		slog.Info("importing", "index", index, "profile", permission)
+		model := permission.ConvertDTOToModel()
+		existing_item := models.Permission{ID: permission.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
 }

kontor-gin/internal/repository/player.go

@@ -12,6 +12,29 @@ type PlayerRepository struct {
 	db *gorm.DB
 }
 
+func (repository *PlayerRepository) Import(dtos models.PlayerDTOList) {
+	slog.Info("PlayerRepository#Import")
+	for index, dto := range dtos {
+		slog.Info("importing", "index", index, "profile", dto)
+		model := dto.ConvertDTOToModel()
+		existing_item := models.Player{ID: dto.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}
+
 func NewPlayerRepository(db *gorm.DB) *PlayerRepository {
 	repo := &PlayerRepository{db: db}
 	return repo

kontor-gin/internal/repository/profile.go

@@ -36,3 +36,26 @@ func (repository *ProfileRepository) FindProfileByEmail(email string) (*models.P
 	}
 	return &profile, nil
 }
+
+func (repository *ProfileRepository) Import(profiles models.ProfileDTOList) {
+	slog.Info("ProfileRepository#Import")
+	for index, profile := range profiles {
+		slog.Info("importing", "index", index, "profile", profile)
+		model := profile.ConvertDTOToModel()
+		existing_profile := models.Profile{ID: profile.ID}
+		result_existing := repository.db.First(&existing_profile)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}

kontor-gin/internal/repository/publisher.go

@@ -12,6 +12,29 @@ type PublisherRepository struct {
 	db *gorm.DB
 }
 
+func (repository *PublisherRepository) Import(dtos models.PublisherDTOList) {
+	slog.Info("PublisherRepository#Import")
+	for index, dto := range dtos {
+		slog.Info("importing", "index", index, "profile", dto)
+		model := dto.ConvertDTOToModel()
+		existing_item := models.Publisher{ID: dto.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}
+
 func NewPublisherRepository(db *gorm.DB) *PublisherRepository {
 	repo := &PublisherRepository{db: db}
 	return repo

kontor-gin/internal/repository/rooster.go

@@ -12,6 +12,29 @@ type RoosterRepository struct {
 	db *gorm.DB
 }
 
+func (repository *RoosterRepository) Import(dtos models.RoosterDTOList) {
+	slog.Info("RoosterRepository#Import")
+	for index, dto := range dtos {
+		slog.Info("importing", "index", index, "profile", dto)
+		model := dto.ConvertDTOToModel()
+		existing_item := models.Rooster{ID: dto.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}
+
 func NewRoosterRepository(db *gorm.DB) *RoosterRepository {
 	repo := &RoosterRepository{db: db}
 	return repo

kontor-gin/internal/repository/sport.go

@@ -12,6 +12,29 @@ type SportRepository struct {
 	db *gorm.DB
 }
 
+func (repository *SportRepository) Import(sports models.SportDTOList) {
+	slog.Info("SportRepository#Import")
+	for index, sport := range sports {
+		slog.Info("importing", "index", index, "profile", sport)
+		model := sport.ConvertDTOToModel()
+		existing_item := models.Sport{ID: sport.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}
+
 func NewSportRepository(db *gorm.DB) *SportRepository {
 	repo := &SportRepository{db: db}
 	return repo

kontor-gin/internal/repository/team.go

@@ -12,6 +12,29 @@ type TeamRepository struct {
 	db *gorm.DB
 }
 
+func (repository *TeamRepository) Import(dtos models.TeamDTOList) {
+	slog.Info("TeamRepository#Import")
+	for index, dto := range dtos {
+		slog.Info("importing", "index", index, "profile", dto)
+		model := dto.ConvertDTOToModel()
+		existing_item := models.Team{ID: dto.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}
+
 func NewTeamRepository(db *gorm.DB) *TeamRepository {
 	repo := &TeamRepository{db: db}
 	return repo

kontor-gin/internal/repository/vendor.go

@@ -12,6 +12,29 @@ type VendorRepository struct {
 	db *gorm.DB
 }
 
+func (repository *VendorRepository) Import(dtos models.VendorDTOList) {
+	slog.Info("VendorRepository#Import")
+	for index, dto := range dtos {
+		slog.Info("importing", "index", index, "profile", dto)
+		model := dto.ConvertDTOToModel()
+		existing_item := models.Vendor{ID: dto.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}
+
 func NewVendorRepository(db *gorm.DB) *VendorRepository {
 	repo := &VendorRepository{db: db}
 	return repo

kontor-gin/internal/repository/volume.go

@@ -12,6 +12,29 @@ type VolumeRepository struct {
 	db *gorm.DB
 }
 
+func (repository *VolumeRepository) Import(dtos models.VolumeDTOList) {
+	slog.Info("VolumeRepository#Import")
+	for index, dto := range dtos {
+		slog.Info("importing", "index", index, "profile", dto)
+		model := dto.ConvertDTOToModel()
+		existing_item := models.Volume{ID: dto.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}
+
 func NewVolumeRepository(db *gorm.DB) *VolumeRepository {
 	repo := &VolumeRepository{db: db}
 	return repo

kontor-gin/internal/repository/worktype.go

@@ -12,6 +12,29 @@ type WorkTypeRepository struct {
 	db *gorm.DB
 }
 
+func (repository *WorkTypeRepository) Import(dtos models.WorkTypeDTOList) {
+	slog.Info("WorkTypeRepository#Import")
+	for index, dto := range dtos {
+		slog.Info("importing", "index", index, "profile", dto)
+		model := dto.ConvertDTOToModel()
+		existing_item := models.WorkType{ID: dto.ID}
+		result_existing := repository.db.First(&existing_item)
+		if result_existing.Error != nil {
+			slog.Info("check existing id: not found - inserting")
+			result := repository.db.Create(&model)
+			if result.Error != nil {
+				slog.Info("error during import", "error", result.Error.Error())
+			}
+		} else {
+			slog.Info("check existing id: found - updating")
+			result := repository.db.Save(&model)
+			if result.Error != nil {
+				slog.Info("error during updating", "error", result.Error.Error())
+			}
+		}
+	}
+}
+
 func NewWorkTypeRepository(db *gorm.DB) *WorkTypeRepository {
 	repo := &WorkTypeRepository{db: db}
 	return repo