Kain344/History_Api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

UPDATE: Entity, Geo, Wiki
Some checks failed
Build and Release / release (push) Failing after 1m7s
Details

Browse Source
This commit is contained in:
Azen Kain
2026-04-22 17:45:09 +07:00
parent f127e2f029
commit adb65d8292
50 changed files with 3354 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

205
internal/repositories/entityRepository.go Normal file
View File

@@ -0,0 +1,205 @@
package repositories
import (
"context"
"crypto/md5"
"encoding/json"
"fmt"
"github.com/jackc/pgx/v5/pgtype"
"history-api/internal/gen/sqlc"
"history-api/internal/models"
"history-api/pkg/cache"
"history-api/pkg/constants"
"history-api/pkg/convert"
)
type EntityRepository interface {
GetByID(ctx context.Context, id pgtype.UUID) (*models.EntityEntity, error)
GetByIDs(ctx context.Context, ids []string) ([]*models.EntityEntity, error)
Search(ctx context.Context, params sqlc.SearchEntitiesParams) ([]*models.EntityEntity, error)
Create(ctx context.Context, params sqlc.CreateEntityParams) (*models.EntityEntity, error)
Update(ctx context.Context, params sqlc.UpdateEntityParams) (*models.EntityEntity, error)
Delete(ctx context.Context, id pgtype.UUID) error
}
type entityRepository struct {
q *sqlc.Queries
c cache.Cache
}
func NewEntityRepository(db sqlc.DBTX, c cache.Cache) EntityRepository {
return &entityRepository{
q: sqlc.New(db),
c: c,
}
}
func (r *entityRepository) generateQueryKey(prefix string, params any) string {
b, _ := json.Marshal(params)
hash := fmt.Sprintf("%x", md5.Sum(b))
return fmt.Sprintf("%s:%s", prefix, hash)
}
func (r *entityRepository) getByIDsWithFallback(ctx context.Context, ids []string) ([]*models.EntityEntity, error) {
if len(ids) == 0 {
return []*models.EntityEntity{}, nil
}
keys := make([]string, len(ids))
for i, id := range ids {
keys[i] = fmt.Sprintf("entity:id:%s", id)
}
raws := r.c.MGet(ctx, keys...)
var entities []*models.EntityEntity
missingToCache := make(map[string]any)
for i, b := range raws {
if len(b) > 0 {
var e models.EntityEntity
if err := json.Unmarshal(b, &e); err == nil {
entities = append(entities, &e)
}
} else {
pgId := pgtype.UUID{}
err := pgId.Scan(ids[i])
if err != nil {
continue
}
dbEntity, err := r.GetByID(ctx, pgId)
if err == nil && dbEntity != nil {
entities = append(entities, dbEntity)
missingToCache[keys[i]] = dbEntity
}
}
}
if len(missingToCache) > 0 {
_ = r.c.MSet(ctx, missingToCache, constants.NormalCacheDuration)
}
return entities, nil
}
func (r *entityRepository) GetByIDs(ctx context.Context, ids []string) ([]*models.EntityEntity, error) {
return r.getByIDsWithFallback(ctx, ids)
}
func (r *entityRepository) GetByID(ctx context.Context, id pgtype.UUID) (*models.EntityEntity, error) {
cacheId := fmt.Sprintf("entity:id:%s", convert.UUIDToString(id))
var entity models.EntityEntity
err := r.c.Get(ctx, cacheId, &entity)
if err == nil {
_ = r.c.Set(ctx, cacheId, entity, constants.NormalCacheDuration)
return &entity, nil
}
row, err := r.q.GetEntityById(ctx, id)
if err != nil {
return nil, err
}
entity = models.EntityEntity{
ID: convert.UUIDToString(row.ID),
Name: row.Name,
Description: convert.TextToString(row.Description),
ThumbnailUrl: convert.TextToString(row.ThumbnailUrl),
IsDeleted: row.IsDeleted,
CreatedAt: convert.TimeToPtr(row.CreatedAt),
UpdatedAt: convert.TimeToPtr(row.UpdatedAt),
}
_ = r.c.Set(ctx, cacheId, entity, constants.NormalCacheDuration)
return &entity, nil
}
func (r *entityRepository) Search(ctx context.Context, params sqlc.SearchEntitiesParams) ([]*models.EntityEntity, error) {
queryKey := r.generateQueryKey("entity:search", params)
var cachedIDs []string
if err := r.c.Get(ctx, queryKey, &cachedIDs); err == nil && len(cachedIDs) > 0 {
return r.getByIDsWithFallback(ctx, cachedIDs)
}
rows, err := r.q.SearchEntities(ctx, params)
if err != nil {
return nil, err
}
var entities []*models.EntityEntity
var ids []string
entityToCache := make(map[string]any)
for _, row := range rows {
entity := &models.EntityEntity{
ID: convert.UUIDToString(row.ID),
Name: row.Name,
Description: convert.TextToString(row.Description),
ThumbnailUrl: convert.TextToString(row.ThumbnailUrl),
IsDeleted: row.IsDeleted,
CreatedAt: convert.TimeToPtr(row.CreatedAt),
UpdatedAt: convert.TimeToPtr(row.UpdatedAt),
}
ids = append(ids, entity.ID)
entities = append(entities, entity)
entityToCache[fmt.Sprintf("entity:id:%s", entity.ID)] = entity
}
if len(entityToCache) > 0 {
_ = r.c.MSet(ctx, entityToCache, constants.NormalCacheDuration)
}
if len(ids) > 0 {
_ = r.c.Set(ctx, queryKey, ids, constants.ListCacheDuration)
}
return entities, nil
}
func (r *entityRepository) Create(ctx context.Context, params sqlc.CreateEntityParams) (*models.EntityEntity, error) {
row, err := r.q.CreateEntity(ctx, params)
if err != nil {
return nil, err
}
entity := models.EntityEntity{
ID: convert.UUIDToString(row.ID),
Name: row.Name,
Description: convert.TextToString(row.Description),
ThumbnailUrl: convert.TextToString(row.ThumbnailUrl),
IsDeleted: row.IsDeleted,
CreatedAt: convert.TimeToPtr(row.CreatedAt),
UpdatedAt: convert.TimeToPtr(row.UpdatedAt),
}
_ = r.c.Set(ctx, fmt.Sprintf("entity:id:%s", entity.ID), entity, constants.NormalCacheDuration)
go func() {
_ = r.c.DelByPattern(context.Background(), "entity:search*")
}()
return &entity, nil
}
func (r *entityRepository) Update(ctx context.Context, params sqlc.UpdateEntityParams) (*models.EntityEntity, error) {
row, err := r.q.UpdateEntity(ctx, params)
if err != nil {
return nil, err
}
entity := models.EntityEntity{
ID: convert.UUIDToString(row.ID),
Name: row.Name,
Description: convert.TextToString(row.Description),
ThumbnailUrl: convert.TextToString(row.ThumbnailUrl),
IsDeleted: row.IsDeleted,
CreatedAt: convert.TimeToPtr(row.CreatedAt),
UpdatedAt: convert.TimeToPtr(row.UpdatedAt),
}
_ = r.c.Set(ctx, fmt.Sprintf("entity:id:%s", entity.ID), entity, constants.NormalCacheDuration)
return &entity, nil
}
func (r *entityRepository) Delete(ctx context.Context, id pgtype.UUID) error {
err := r.q.DeleteEntity(ctx, id)
if err != nil {
return err
}
_ = r.c.Del(ctx, fmt.Sprintf("entity:id:%s", convert.UUIDToString(id)))
return nil
}

266
internal/repositories/geometryRepository.go Normal file
View File

@@ -0,0 +1,266 @@
package repositories
import (
"context"
"crypto/md5"
"encoding/json"
"fmt"
"github.com/jackc/pgx/v5/pgtype"
"history-api/internal/dtos/response"
"history-api/internal/gen/sqlc"
"history-api/internal/models"
"history-api/pkg/cache"
"history-api/pkg/constants"
"history-api/pkg/convert"
)
type GeometryRepository interface {
GetByID(ctx context.Context, id pgtype.UUID) (*models.GeometryEntity, error)
GetByIDs(ctx context.Context, ids []string) ([]*models.GeometryEntity, error)
Search(ctx context.Context, params sqlc.SearchGeometriesParams) ([]*models.GeometryEntity, error)
Create(ctx context.Context, params sqlc.CreateGeometryParams) (*models.GeometryEntity, error)
Update(ctx context.Context, params sqlc.UpdateGeometryParams) (*models.GeometryEntity, error)
Delete(ctx context.Context, id pgtype.UUID) error
CreateEntityGeometries(ctx context.Context, params sqlc.CreateEntityGeometriesParams) error
BulkDeleteEntityGeometriesByEntityId(ctx context.Context, entityId pgtype.UUID) error
}
type geometryRepository struct {
q *sqlc.Queries
c cache.Cache
}
func NewGeometryRepository(db sqlc.DBTX, c cache.Cache) GeometryRepository {
return &geometryRepository{
q: sqlc.New(db),
c: c,
}
}
func (r *geometryRepository) generateQueryKey(prefix string, params any) string {
b, _ := json.Marshal(params)
hash := fmt.Sprintf("%x", md5.Sum(b))
return fmt.Sprintf("%s:%s", prefix, hash)
}
func (r *geometryRepository) getByIDsWithFallback(ctx context.Context, ids []string) ([]*models.GeometryEntity, error) {
if len(ids) == 0 {
return []*models.GeometryEntity{}, nil
}
keys := make([]string, len(ids))
for i, id := range ids {
keys[i] = fmt.Sprintf("geometry:id:%s", id)
}
raws := r.c.MGet(ctx, keys...)
var geometries []*models.GeometryEntity
missingToCache := make(map[string]any)
for i, b := range raws {
if len(b) > 0 {
var g models.GeometryEntity
if err := json.Unmarshal(b, &g); err == nil {
geometries = append(geometries, &g)
}
} else {
pgId := pgtype.UUID{}
err := pgId.Scan(ids[i])
if err != nil {
continue
}
dbGeometry, err := r.GetByID(ctx, pgId)
if err == nil && dbGeometry != nil {
geometries = append(geometries, dbGeometry)
missingToCache[keys[i]] = dbGeometry
}
}
}
if len(missingToCache) > 0 {
_ = r.c.MSet(ctx, missingToCache, constants.NormalCacheDuration)
}
return geometries, nil
}
func (r *geometryRepository) GetByIDs(ctx context.Context, ids []string) ([]*models.GeometryEntity, error) {
return r.getByIDsWithFallback(ctx, ids)
}
func (r *geometryRepository) GetByID(ctx context.Context, id pgtype.UUID) (*models.GeometryEntity, error) {
cacheId := fmt.Sprintf("geometry:id:%s", convert.UUIDToString(id))
var geometry models.GeometryEntity
err := r.c.Get(ctx, cacheId, &geometry)
if err == nil {
_ = r.c.Set(ctx, cacheId, geometry, constants.NormalCacheDuration)
return &geometry, nil
}
row, err := r.q.GetGeometryById(ctx, id)
if err != nil {
return nil, err
}
geometry = models.GeometryEntity{
ID: convert.UUIDToString(row.ID),
GeoType: row.GeoType,
DrawGeometry: row.DrawGeometry,
Binding: row.Binding,
TimeStart: convert.Int4ToInt32(row.TimeStart),
TimeEnd: convert.Int4ToInt32(row.TimeEnd),
Bbox: &response.Bbox{
MinLng: row.MinLng,
MinLat: row.MinLat,
MaxLng: row.MaxLng,
MaxLat: row.MaxLat,
},
IsDeleted: row.IsDeleted,
CreatedAt: convert.TimeToPtr(row.CreatedAt),
UpdatedAt: convert.TimeToPtr(row.UpdatedAt),
}
_ = r.c.Set(ctx, cacheId, geometry, constants.NormalCacheDuration)
return &geometry, nil
}
func (r *geometryRepository) Search(ctx context.Context, params sqlc.SearchGeometriesParams) ([]*models.GeometryEntity, error) {
queryKey := r.generateQueryKey("geometry:search", params)
var cachedIDs []string
if err := r.c.Get(ctx, queryKey, &cachedIDs); err == nil && len(cachedIDs) > 0 {
return r.getByIDsWithFallback(ctx, cachedIDs)
}
rows, err := r.q.SearchGeometries(ctx, params)
if err != nil {
return nil, err
}
var geometries []*models.GeometryEntity
var ids []string
geometryToCache := make(map[string]any)
for _, row := range rows {
geometry := &models.GeometryEntity{
ID: convert.UUIDToString(row.ID),
GeoType: row.GeoType,
DrawGeometry: row.DrawGeometry,
Binding: row.Binding,
TimeStart: convert.Int4ToInt32(row.TimeStart),
TimeEnd: convert.Int4ToInt32(row.TimeEnd),
Bbox: &response.Bbox{
MinLng: row.MinLng,
MinLat: row.MinLat,
MaxLng: row.MaxLng,
MaxLat: row.MaxLat,
},
IsDeleted: row.IsDeleted,
CreatedAt: convert.TimeToPtr(row.CreatedAt),
UpdatedAt: convert.TimeToPtr(row.UpdatedAt),
}
ids = append(ids, geometry.ID)
geometries = append(geometries, geometry)
geometryToCache[fmt.Sprintf("geometry:id:%s", geometry.ID)] = geometry
}
if len(geometryToCache) > 0 {
_ = r.c.MSet(ctx, geometryToCache, constants.NormalCacheDuration)
}
if len(ids) > 0 {
_ = r.c.Set(ctx, queryKey, ids, constants.ListCacheDuration)
}
return geometries, nil
}
func (r *geometryRepository) Create(ctx context.Context, params sqlc.CreateGeometryParams) (*models.GeometryEntity, error) {
row, err := r.q.CreateGeometry(ctx, params)
if err != nil {
return nil, err
}
geometry := models.GeometryEntity{
ID: convert.UUIDToString(row.ID),
GeoType: row.GeoType,
DrawGeometry: row.DrawGeometry,
Binding: row.Binding,
TimeStart: convert.Int4ToInt32(row.TimeStart),
TimeEnd: convert.Int4ToInt32(row.TimeEnd),
Bbox: &response.Bbox{
MinLng: row.MinLng,
MinLat: row.MinLat,
MaxLng: row.MaxLng,
MaxLat: row.MaxLat,
},
IsDeleted: row.IsDeleted,
CreatedAt: convert.TimeToPtr(row.CreatedAt),
UpdatedAt: convert.TimeToPtr(row.UpdatedAt),
}
_ = r.c.Set(ctx, fmt.Sprintf("geometry:id:%s", geometry.ID), geometry, constants.NormalCacheDuration)
go func() {
bgCtx := context.Background()
_ = r.c.DelByPattern(bgCtx, "geometry:search*")
}()
return &geometry, nil
}
func (r *geometryRepository) Update(ctx context.Context, params sqlc.UpdateGeometryParams) (*models.GeometryEntity, error) {
row, err := r.q.UpdateGeometry(ctx, params)
if err != nil {
return nil, err
}
geometry := models.GeometryEntity{
ID: convert.UUIDToString(row.ID),
GeoType: row.GeoType,
DrawGeometry: row.DrawGeometry,
Binding: row.Binding,
TimeStart: convert.Int4ToInt32(row.TimeStart),
TimeEnd: convert.Int4ToInt32(row.TimeEnd),
Bbox: &response.Bbox{
MinLng: row.MinLng,
MinLat: row.MinLat,
MaxLng: row.MaxLng,
MaxLat: row.MaxLat,
},
IsDeleted: row.IsDeleted,
CreatedAt: convert.TimeToPtr(row.CreatedAt),
UpdatedAt: convert.TimeToPtr(row.UpdatedAt),
}
_ = r.c.Set(ctx, fmt.Sprintf("geometry:id:%s", geometry.ID), geometry, constants.NormalCacheDuration)
return &geometry, nil
}
func (r *geometryRepository) Delete(ctx context.Context, id pgtype.UUID) error {
err := r.q.DeleteGeometry(ctx, id)
if err != nil {
return err
}
_ = r.c.Del(ctx, fmt.Sprintf("geometry:id:%s", convert.UUIDToString(id)))
return nil
}
func (r *geometryRepository) CreateEntityGeometries(ctx context.Context, params sqlc.CreateEntityGeometriesParams) error {
err := r.q.CreateEntityGeometries(ctx, params)
if err != nil {
return err
}
return err
}
func (r *geometryRepository) BulkDeleteEntityGeometriesByEntityId(ctx context.Context, entityId pgtype.UUID) error {
geometryIDs, err := r.q.BulkDeleteEntityGeometriesByEntityId(ctx, entityId)
if err != nil {
return err
}
if len(geometryIDs) > 0 {
keys := make([]string, len(geometryIDs))
for i, id := range geometryIDs {
keys[i] = fmt.Sprintf("geometry:id:%s", convert.UUIDToString(id))
}
go func() {
_ = r.c.Del(context.Background(), keys...)
}()
}
return nil
}

5
internal/repositories/roleRepository.go
View File

@@ -148,8 +148,9 @@ func (r *roleRepository) Create(ctx context.Context, name string) (*models.RoleE
if err != nil {
return nil, err
}
go func() {
bgCtx := context.Background()
go func() {
bgCtx := context.Background()
_ = r.c.DelByPattern(bgCtx, "role:all*")
}()

3
internal/repositories/verificationRepository.go
View File

@@ -225,8 +225,7 @@ func (v *verificationRepository) BulkVerificationMediaByMediaId(ctx context.Cont
}
go func() {
bgCtx := context.Background()
_ = v.c.Del(bgCtx, listCacheId...)
_ = v.c.Del(context.Background(), listCacheId...)
}()
return nil

233
internal/repositories/wikiRepository.go Normal file
View File

@@ -0,0 +1,233 @@
package repositories
import (
"context"
"crypto/md5"
"encoding/json"
"fmt"
"github.com/jackc/pgx/v5/pgtype"
"history-api/internal/gen/sqlc"
"history-api/internal/models"
"history-api/pkg/cache"
"history-api/pkg/constants"
"history-api/pkg/convert"
)
type WikiRepository interface {
GetByID(ctx context.Context, id pgtype.UUID) (*models.WikiEntity, error)
GetByIDs(ctx context.Context, ids []string) ([]*models.WikiEntity, error)
Search(ctx context.Context, params sqlc.SearchWikisParams) ([]*models.WikiEntity, error)
Create(ctx context.Context, params sqlc.CreateWikiParams) (*models.WikiEntity, error)
Update(ctx context.Context, params sqlc.UpdateWikiParams) (*models.WikiEntity, error)
Delete(ctx context.Context, id pgtype.UUID) error
CreateEntityWikis(ctx context.Context, params sqlc.CreateEntityWikisParams) error
BulkDeleteEntityWikisByEntityId(ctx context.Context, entityId pgtype.UUID) error
}
type wikiRepository struct {
q *sqlc.Queries
c cache.Cache
}
func NewWikiRepository(db sqlc.DBTX, c cache.Cache) WikiRepository {
return &wikiRepository{
q: sqlc.New(db),
c: c,
}
}
func (r *wikiRepository) generateQueryKey(prefix string, params any) string {
b, _ := json.Marshal(params)
hash := fmt.Sprintf("%x", md5.Sum(b))
return fmt.Sprintf("%s:%s", prefix, hash)
}
func (r *wikiRepository) getByIDsWithFallback(ctx context.Context, ids []string) ([]*models.WikiEntity, error) {
if len(ids) == 0 {
return []*models.WikiEntity{}, nil
}
keys := make([]string, len(ids))
for i, id := range ids {
keys[i] = fmt.Sprintf("wiki:id:%s", id)
}
raws := r.c.MGet(ctx, keys...)
var wikis []*models.WikiEntity
missingToCache := make(map[string]any)
for i, b := range raws {
if len(b) > 0 {
var w models.WikiEntity
if err := json.Unmarshal(b, &w); err == nil {
wikis = append(wikis, &w)
}
} else {
pgId := pgtype.UUID{}
err := pgId.Scan(ids[i])
if err != nil {
continue
}
dbWiki, err := r.GetByID(ctx, pgId)
if err == nil && dbWiki != nil {
wikis = append(wikis, dbWiki)
missingToCache[keys[i]] = dbWiki
}
}
}
if len(missingToCache) > 0 {
_ = r.c.MSet(ctx, missingToCache, constants.NormalCacheDuration)
}
return wikis, nil
}
func (r *wikiRepository) GetByIDs(ctx context.Context, ids []string) ([]*models.WikiEntity, error) {
return r.getByIDsWithFallback(ctx, ids)
}
func (r *wikiRepository) GetByID(ctx context.Context, id pgtype.UUID) (*models.WikiEntity, error) {
cacheId := fmt.Sprintf("wiki:id:%s", convert.UUIDToString(id))
var wiki models.WikiEntity
err := r.c.Get(ctx, cacheId, &wiki)
if err == nil {
_ = r.c.Set(ctx, cacheId, wiki, constants.NormalCacheDuration)
return &wiki, nil
}
row, err := r.q.GetWikiById(ctx, id)
if err != nil {
return nil, err
}
wiki = models.WikiEntity{
ID: convert.UUIDToString(row.ID),
Title: convert.TextToString(row.Title),
Content: convert.TextToString(row.Content),
IsDeleted: row.IsDeleted,
CreatedAt: convert.TimeToPtr(row.CreatedAt),
UpdatedAt: convert.TimeToPtr(row.UpdatedAt),
}
_ = r.c.Set(ctx, cacheId, wiki, constants.NormalCacheDuration)
return &wiki, nil
}
func (r *wikiRepository) Search(ctx context.Context, params sqlc.SearchWikisParams) ([]*models.WikiEntity, error) {
queryKey := r.generateQueryKey("wiki:search", params)
var cachedIDs []string
if err := r.c.Get(ctx, queryKey, &cachedIDs); err == nil && len(cachedIDs) > 0 {
return r.getByIDsWithFallback(ctx, cachedIDs)
}
rows, err := r.q.SearchWikis(ctx, params)
if err != nil {
return nil, err
}
var wikis []*models.WikiEntity
var ids []string
wikiToCache := make(map[string]any)
for _, row := range rows {
wiki := &models.WikiEntity{
ID: convert.UUIDToString(row.ID),
Title: convert.TextToString(row.Title),
Content: convert.TextToString(row.Content),
IsDeleted: row.IsDeleted,
CreatedAt: convert.TimeToPtr(row.CreatedAt),
UpdatedAt: convert.TimeToPtr(row.UpdatedAt),
}
ids = append(ids, wiki.ID)
wikis = append(wikis, wiki)
wikiToCache[fmt.Sprintf("wiki:id:%s", wiki.ID)] = wiki
}
if len(wikiToCache) > 0 {
_ = r.c.MSet(ctx, wikiToCache, constants.NormalCacheDuration)
}
if len(ids) > 0 {
_ = r.c.Set(ctx, queryKey, ids, constants.ListCacheDuration)
}
return wikis, nil
}
func (r *wikiRepository) Create(ctx context.Context, params sqlc.CreateWikiParams) (*models.WikiEntity, error) {
row, err := r.q.CreateWiki(ctx, params)
if err != nil {
return nil, err
}
wiki := models.WikiEntity{
ID: convert.UUIDToString(row.ID),
Title: convert.TextToString(row.Title),
Content: convert.TextToString(row.Content),
IsDeleted: row.IsDeleted,
CreatedAt: convert.TimeToPtr(row.CreatedAt),
UpdatedAt: convert.TimeToPtr(row.UpdatedAt),
}
_ = r.c.Set(ctx, fmt.Sprintf("wiki:id:%s", wiki.ID), wiki, constants.NormalCacheDuration)
go func() {
bgCtx := context.Background()
_ = r.c.DelByPattern(bgCtx, "wiki:search*")
}()
return &wiki, nil
}
func (r *wikiRepository) Update(ctx context.Context, params sqlc.UpdateWikiParams) (*models.WikiEntity, error) {
row, err := r.q.UpdateWiki(ctx, params)
if err != nil {
return nil, err
}
wiki := models.WikiEntity{
ID: convert.UUIDToString(row.ID),
Title: convert.TextToString(row.Title),
Content: convert.TextToString(row.Content),
IsDeleted: row.IsDeleted,
CreatedAt: convert.TimeToPtr(row.CreatedAt),
UpdatedAt: convert.TimeToPtr(row.UpdatedAt),
}
_ = r.c.Set(ctx, fmt.Sprintf("wiki:id:%s", wiki.ID), wiki, constants.NormalCacheDuration)
return &wiki, nil
}
func (r *wikiRepository) Delete(ctx context.Context, id pgtype.UUID) error {
err := r.q.DeleteWiki(ctx, id)
if err != nil {
return err
}
_ = r.c.Del(ctx, fmt.Sprintf("wiki:id:%s", convert.UUIDToString(id)))
go func() {
_ = r.c.DelByPattern(context.Background(), "wiki:search*")
}()
return nil
}
func (r *wikiRepository) CreateEntityWikis(ctx context.Context, params sqlc.CreateEntityWikisParams) error {
err := r.q.CreateEntityWikis(ctx, params)
if err != nil {
return err
}
return nil
}
func (r *wikiRepository) BulkDeleteEntityWikisByEntityId(ctx context.Context, entityId pgtype.UUID) error {
wikiIDs, err := r.q.BulkDeleteEntityWikisByEntityId(ctx, entityId)
if err != nil {
return err
}
if len(wikiIDs) > 0 {
keys := make([]string, len(wikiIDs))
for i, id := range wikiIDs {
keys[i] = fmt.Sprintf("wiki:id:%s", convert.UUIDToString(id))
}
go func() {
_ = r.c.Del(context.Background(), keys...)
}()
}
return nil
}