refac: stale test entries, failing web tests, Postgre backup bug, Hardcoded MySQL table count, Stale Postgre connection in test, own-scope visibility filter, GetAll ignoring its error, JSON tags in use-case types, 31 copies of DESKTOP_QUERY, ProfileView endpoint paths

internal/infrastructure/persistence/repositories/articleRepository.go

@@ -46,6 +46,9 @@ func (a *ArticleRepository) scoped(filters domain.Filters) *gorm.DB {
 	if filters.SiteID != nil {
 		query = query.Where("site_id = ?", *filters.SiteID)
 	}
+	if filters.VisibleTo != nil {
+		query = query.Where("(is_online = ? OR created_by = ?)", true, *filters.VisibleTo)
+	}
 	switch filters.Status {
 	case domain.StatusOnline:
 		query = query.Where("is_online = ?", true)
@@ -168,6 +171,17 @@ func (a *ArticleRepository) CountByVisibility(onlineOnly bool) (domain.Counts, e
 	return domain.Counts{All: int(online + draft), Online: int(online), Draft: int(draft)}, nil
 }
 
+func (a *ArticleRepository) CountVisibleTo(userID uint32) (domain.Counts, error) {
+	var online, draft int64
+	if err := a.db.Model(&entity.Article{}).Where("is_online = ?", true).Count(&online).Error; err != nil {
+		return domain.Counts{}, err
+	}
+	if err := a.db.Model(&entity.Article{}).Where("is_online = ? AND created_by = ?", false, userID).Count(&draft).Error; err != nil {
+		return domain.Counts{}, err
+	}
+	return domain.Counts{All: int(online + draft), Online: int(online), Draft: int(draft)}, nil
+}
+
 func toDomainArticles(entityArticles []entity.Article) []domain.Article {
 	domainArticles := make([]domain.Article, 0, len(entityArticles))
 	for _, entityArticle := range entityArticles {
@@ -356,11 +370,11 @@ func (a *ArticleRepository) SlugTaken(siteID uint32, slug string, exceptID uint3
 	return articleSlugInUse(a.db, siteID, slug, exceptID)
 }
 
-func (a *ArticleRepository) GetAll() []domain.Article {
+func (a *ArticleRepository) GetAll() ([]domain.Article, error) {
 	var articles []entity.Article
 	err := a.db.Model(&entity.Article{}).Find(&articles).Error
 	if err != nil {
-		return []domain.Article{}
+		return nil, err
 	}
 
 	var domainArticles = make([]domain.Article, 0)
@@ -368,7 +382,7 @@ func (a *ArticleRepository) GetAll() []domain.Article {
 		domainArticles = append(domainArticles, mappers.ArticleToDomain(article))
 	}
 
-	return domainArticles
+	return domainArticles, nil
 }
 
 func (a *ArticleRepository) UpdateBody(id uint32, body string) (domain.Article, error) {

internal/infrastructure/persistence/repositories/entryRepository.go

@@ -71,7 +71,11 @@ func (e *EntryRepository) ListPage(filters domain.Filters) (domain.PageResult, e
 	filters.Page = max(filters.Page, 1)
 	filters.Size = max(filters.Size, 0)
 	scoped := func() *gorm.DB {
-		return e.db.Model(&entity.Entry{}).Where("content_type_id = ?", filters.ContentTypeID)
+		query := e.db.Model(&entity.Entry{}).Where("content_type_id = ?", filters.ContentTypeID)
+		if filters.CreatedBy != nil {
+			query = query.Where("created_by = ?", *filters.CreatedBy)
+		}
+		return query
 	}
 	var total int64
 	if err := scoped().Count(&total).Error; err != nil {

internal/infrastructure/persistence/repositories/inviteRepository.go

@@ -28,16 +28,18 @@ func (i *InviteRepository) Create(invite domainInvite.Invite) (domainInvite.Invi
 	return mappers.InviteToDomain(model), nil
 }
 
-func (i *InviteRepository) GetAll() []domainInvite.Invite {
+func (i *InviteRepository) GetAll() ([]domainInvite.Invite, error) {
 	var invites []entity.Invite
-	i.db.Model(&entity.Invite{}).Find(&invites)
+	if err := i.db.Model(&entity.Invite{}).Find(&invites).Error; err != nil {
+		return nil, err
+	}
 
 	var domainInvites []domainInvite.Invite
 	for _, localInvite := range invites {
 		domainInvites = append(domainInvites, mappers.InviteToDomain(localInvite))
 	}
 
-	return domainInvites
+	return domainInvites, nil
 }
 
 func (i *InviteRepository) Delete(id uint32) error {

internal/infrastructure/persistence/repositories/userRepository.go

@@ -52,16 +52,18 @@ func (u *UserRepository) Delete(id uint32) error {
 	return deleteOrNotFound(result, domainUser.ErrUserNotFound)
 }
 
-func (u *UserRepository) GetAll() []domainUser.User {
+func (u *UserRepository) GetAll() ([]domainUser.User, error) {
 	var users []entity.User
-	u.db.Model(&entity.User{}).Find(&users)
+	if err := u.db.Model(&entity.User{}).Find(&users).Error; err != nil {
+		return nil, err
+	}
 
 	var domainUsers []domainUser.User
 	for _, localUser := range users {
 		domainUsers = append(domainUsers, mappers.UserToDomain(localUser))
 	}
 
-	return domainUsers
+	return domainUsers, nil
 }
 
 func (u *UserRepository) FindByIDs(ids []uint32) ([]domainUser.User, error) {