293 lines
8.7 KiB
Go
293 lines
8.7 KiB
Go
package persistence
|
|
|
|
import (
|
|
domain "RenewCMS/internal/domain/article"
|
|
"RenewCMS/internal/infrastructure/persistence/mappers"
|
|
entity "RenewCMS/internal/infrastructure/persistence/models"
|
|
|
|
"strings"
|
|
"unicode"
|
|
|
|
"golang.org/x/text/runes"
|
|
"golang.org/x/text/transform"
|
|
"golang.org/x/text/unicode/norm"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
type ArticleRepository struct {
|
|
db *gorm.DB
|
|
}
|
|
|
|
func NewArticleRepository(db *gorm.DB) *ArticleRepository {
|
|
return &ArticleRepository{db}
|
|
}
|
|
|
|
func (a *ArticleRepository) FindByFilters(filters domain.Filters) ([]domain.Article, error) {
|
|
query := a.db.Model(&entity.Article{})
|
|
|
|
if filters.IsOnline != nil {
|
|
query = query.Where("is_online = ?", *filters.IsOnline)
|
|
}
|
|
|
|
var entityArticles []entity.Article
|
|
err := query.Find(&entityArticles).Error
|
|
|
|
return toDomainArticles(entityArticles), err
|
|
}
|
|
|
|
func (a *ArticleRepository) scoped(filters domain.Filters) *gorm.DB {
|
|
query := a.db.Model(&entity.Article{})
|
|
if filters.IsOnline != nil {
|
|
query = query.Where("is_online = ?", *filters.IsOnline)
|
|
}
|
|
if filters.SiteID != nil {
|
|
query = query.Where("site_id = ?", *filters.SiteID)
|
|
}
|
|
switch filters.Status {
|
|
case domain.StatusOnline:
|
|
query = query.Where("is_online = ?", true)
|
|
case domain.StatusDraft:
|
|
query = query.Where("is_online = ?", false)
|
|
}
|
|
return query
|
|
}
|
|
|
|
var sortColumns = map[domain.SortField]string{
|
|
domain.SortByTitle: "LOWER(title)",
|
|
domain.SortByStatus: "is_online",
|
|
domain.SortByCreatedAt: "created_at",
|
|
domain.SortByUpdatedAt: "updated_at",
|
|
}
|
|
|
|
var sortDirections = map[domain.SortDirection]string{
|
|
domain.SortAsc: "ASC",
|
|
domain.SortDesc: "DESC",
|
|
}
|
|
|
|
func orderClause(sort domain.Sort) string {
|
|
column, ok := sortColumns[sort.Field]
|
|
direction, directionOk := sortDirections[sort.Direction]
|
|
if !ok || !directionOk {
|
|
column, direction = sortColumns[domain.SortByUpdatedAt], sortDirections[domain.SortDesc]
|
|
}
|
|
return column + " " + direction + ", id DESC"
|
|
}
|
|
|
|
func (a *ArticleRepository) FindPage(filters domain.Filters) (domain.PageResult, error) {
|
|
filters.Page = max(filters.Page, 1)
|
|
filters.Size = max(filters.Size, 0)
|
|
filters.Q = strings.TrimSpace(filters.Q)
|
|
if filters.Q != "" {
|
|
return a.findMatchingTitle(filters)
|
|
}
|
|
var total int64
|
|
if err := a.scoped(filters).Count(&total).Error; err != nil {
|
|
return domain.PageResult{}, err
|
|
}
|
|
var entityArticles []entity.Article
|
|
err := a.scoped(filters).Order(orderClause(filters.Sort)).Limit(filters.Size).Offset((filters.Page - 1) * filters.Size).Find(&entityArticles).Error
|
|
if err != nil {
|
|
return domain.PageResult{}, err
|
|
}
|
|
return domain.PageResult{Items: toDomainArticles(entityArticles), Total: int(total)}, nil
|
|
}
|
|
|
|
func (a *ArticleRepository) findMatchingTitle(filters domain.Filters) (domain.PageResult, error) {
|
|
var candidates []entity.Article
|
|
if err := a.scoped(filters).Select("id", "title").Order(orderClause(filters.Sort)).Find(&candidates).Error; err != nil {
|
|
return domain.PageResult{}, err
|
|
}
|
|
needle := foldForSearch(filters.Q)
|
|
matchingIds := make([]uint32, 0)
|
|
for _, candidate := range candidates {
|
|
if strings.Contains(foldForSearch(candidate.Title), needle) {
|
|
matchingIds = append(matchingIds, candidate.ID)
|
|
}
|
|
}
|
|
start := min((filters.Page-1)*filters.Size, len(matchingIds))
|
|
end := min(start+filters.Size, len(matchingIds))
|
|
pageIds := matchingIds[start:end]
|
|
page := domain.PageResult{Items: []domain.Article{}, Total: len(matchingIds)}
|
|
if len(pageIds) == 0 {
|
|
return page, nil
|
|
}
|
|
var entityArticles []entity.Article
|
|
if err := a.db.Model(&entity.Article{}).Where("id IN ?", pageIds).Find(&entityArticles).Error; err != nil {
|
|
return domain.PageResult{}, err
|
|
}
|
|
byId := make(map[uint32]entity.Article, len(entityArticles))
|
|
for _, entityArticle := range entityArticles {
|
|
byId[entityArticle.ID] = entityArticle
|
|
}
|
|
ordered := make([]entity.Article, 0, len(pageIds))
|
|
for _, id := range pageIds {
|
|
if entityArticle, found := byId[id]; found {
|
|
ordered = append(ordered, entityArticle)
|
|
}
|
|
}
|
|
page.Items = toDomainArticles(ordered)
|
|
return page, nil
|
|
}
|
|
|
|
func (a *ArticleRepository) CountByVisibility(onlineOnly bool) (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 !onlineOnly {
|
|
if err := a.db.Model(&entity.Article{}).Where("is_online = ?", false).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 {
|
|
domainArticles = append(domainArticles, mappers.ArticleToDomain(entityArticle))
|
|
}
|
|
return domainArticles
|
|
}
|
|
|
|
func foldForSearch(value string) string {
|
|
folder := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
|
|
folded, _, err := transform.String(folder, value)
|
|
if err != nil {
|
|
return strings.ToLower(value)
|
|
}
|
|
return strings.ToLower(folded)
|
|
}
|
|
|
|
func (a *ArticleRepository) Get(id uint32) (domain.Article, error) {
|
|
var article entity.Article
|
|
err := a.db.Model(&entity.Article{}).First(&article, id).Error
|
|
if err != nil {
|
|
return domain.Article{}, mapNotFoundErr(err, domain.ErrArticleNotFound)
|
|
}
|
|
|
|
return mappers.ArticleToDomain(article), nil
|
|
}
|
|
|
|
func (a *ArticleRepository) GetByName(name string) (domain.Article, error) {
|
|
var article entity.Article
|
|
err := a.db.Model(&entity.Article{}).Where("title = ?", name).First(&article).Error
|
|
if err != nil {
|
|
return domain.Article{}, mapNotFoundErr(err, domain.ErrArticleNotFound)
|
|
}
|
|
|
|
return mappers.ArticleToDomain(article), nil
|
|
}
|
|
|
|
func (a *ArticleRepository) Create(article domain.Article) (domain.Article, error) {
|
|
created := entity.Article{
|
|
Title: article.Title,
|
|
Body: article.Body,
|
|
IsOnline: article.IsOnline,
|
|
SiteID: article.SiteID,
|
|
}
|
|
err := a.db.Transaction(func(tx *gorm.DB) error {
|
|
if article.SiteID != 0 {
|
|
if _, err := lockSite(tx, article.SiteID); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return tx.Create(&created).Error
|
|
})
|
|
if err != nil {
|
|
return domain.Article{}, err
|
|
}
|
|
return mappers.ArticleToDomain(created), nil
|
|
}
|
|
|
|
func (a *ArticleRepository) GetAll() []domain.Article {
|
|
var articles []entity.Article
|
|
err := a.db.Model(&entity.Article{}).Find(&articles).Error
|
|
if err != nil {
|
|
return []domain.Article{}
|
|
}
|
|
|
|
var domainArticles = make([]domain.Article, 0)
|
|
for _, article := range articles {
|
|
domainArticles = append(domainArticles, mappers.ArticleToDomain(article))
|
|
}
|
|
|
|
return domainArticles
|
|
}
|
|
|
|
func (a *ArticleRepository) UpdateBody(id uint32, body string) (domain.Article, error) {
|
|
var localArticle entity.Article
|
|
err := a.db.Model(&entity.Article{}).First(&localArticle, id).Error
|
|
if err != nil {
|
|
return domain.Article{}, mapNotFoundErr(err, domain.ErrArticleNotFound)
|
|
}
|
|
|
|
localArticle.Body = body
|
|
err = a.db.Save(&localArticle).Error
|
|
if err != nil {
|
|
return domain.Article{}, err
|
|
}
|
|
|
|
newArticle := mappers.ArticleToDomain(localArticle)
|
|
|
|
return newArticle, nil
|
|
}
|
|
|
|
func (a *ArticleRepository) Update(id uint32, update domain.Update) (domain.Article, error) {
|
|
var localArticle entity.Article
|
|
err := a.db.Transaction(func(tx *gorm.DB) error {
|
|
if update.SiteID != nil {
|
|
if _, err := lockSite(tx, *update.SiteID); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err := tx.Model(&entity.Article{}).First(&localArticle, id).Error; err != nil {
|
|
return mapNotFoundErr(err, domain.ErrArticleNotFound)
|
|
}
|
|
if update.Body != nil {
|
|
localArticle.Body = *update.Body
|
|
}
|
|
if update.SiteID != nil {
|
|
localArticle.SiteID = *update.SiteID
|
|
}
|
|
return tx.Save(&localArticle).Error
|
|
})
|
|
if err != nil {
|
|
return domain.Article{}, err
|
|
}
|
|
return mappers.ArticleToDomain(localArticle), nil
|
|
}
|
|
|
|
func (a *ArticleRepository) UpdateIsOnline(id uint32, isOnline bool) (domain.Article, error) {
|
|
var localArticle entity.Article
|
|
err := a.db.Model(&entity.Article{}).First(&localArticle, id).Error
|
|
if err != nil {
|
|
return domain.Article{}, mapNotFoundErr(err, domain.ErrArticleNotFound)
|
|
}
|
|
|
|
localArticle.IsOnline = isOnline
|
|
err = a.db.Save(&localArticle).Error
|
|
if err != nil {
|
|
return domain.Article{}, err
|
|
}
|
|
|
|
return mappers.ArticleToDomain(localArticle), nil
|
|
}
|
|
|
|
func (a *ArticleRepository) Delete(id uint32) error {
|
|
result := a.db.Delete(&entity.Article{}, id)
|
|
return deleteOrNotFound(result, domain.ErrArticleNotFound)
|
|
}
|
|
|
|
func (a *ArticleRepository) FindByBodyContaining(filename string) ([]domain.Article, error) {
|
|
var entityArticles []entity.Article
|
|
err := a.db.Model(&entity.Article{}).Where("body LIKE ? ESCAPE '!'", containsPattern(filename)).Order("id asc").Find(&entityArticles).Error
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return toDomainArticles(entityArticles), nil
|
|
}
|
|
|
|
var _ domain.Repository = &ArticleRepository{}
|