feat: add activity logs

app/database/entity/activity_log_types.entity.go

@@ -0,0 +1,7 @@
+package entity
+
+type ActivityLogTypes struct {
+	ID       uint   `json:"id" gorm:"primaryKey;type:int4;autoIncrement"`
+	Name     string `json:"name" gorm:"type:varchar"`
+	IsActive bool   `json:"is_active" gorm:"type:bool"`
+}

app/database/entity/activity_logs.entity.go

@@ -0,0 +1,12 @@
+package entity
+
+import "time"
+
+type ActivityLogs struct {
+	ID             uint      `json:"id" gorm:"primaryKey;type:int4;autoIncrement"`
+	ActivityTypeId int       `json:"activity_type_id" gorm:"type:int4"`
+	Url            string    `json:"url" gorm:"type:varchar"`
+	ArticleId      *int      `json:"article_id" gorm:"type:int4"`
+	UserId         *uint     `json:"user_id" gorm:"type:int4"`
+	CreatedAt      time.Time `json:"created_at" gorm:"default:now()"`
+}

app/database/index.database.go

@@ -68,6 +68,8 @@ func (_db *Database) MigrateModels() {
 // Models list of models for migration
 func Models() []interface{} {
 	return []interface{}{
+		entity.ActivityLogs{},
+		entity.ActivityLogTypes{},
 		entity.Articles{},
 		entity.ArticleCategories{},
 		article_category_details.ArticleCategoryDetails{},

app/database/seeds/activity_log_types.seeds.go

@@ -0,0 +1,55 @@
+package seeds
+
+import (
+	"go-humas-be/app/database/entity"
+	"gorm.io/gorm"
+)
+
+type ActivityLogsSeeder struct{}
+
+var activityLogTypes = []entity.ActivityLogTypes{
+	{
+		ID:       1,
+		Name:     "Login",
+		IsActive: true,
+	},
+	{
+		ID:       2,
+		Name:     "View",
+		IsActive: true,
+	},
+	{
+		ID:       3,
+		Name:     "Share",
+		IsActive: true,
+	},
+	{
+		ID:       4,
+		Name:     "Like",
+		IsActive: true,
+	},
+	{
+		ID:       5,
+		Name:     "Comment",
+		IsActive: true,
+	},
+}
+
+func (ActivityLogsSeeder) Seed(conn *gorm.DB) error {
+	for _, row := range activityLogTypes {
+		if err := conn.Create(&row).Error; err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (ActivityLogsSeeder) Count(conn *gorm.DB) (int, error) {
+	var count int64
+	if err := conn.Model(&entity.ActivityLogTypes{}).Count(&count).Error; err != nil {
+		return 0, err
+	}
+
+	return int(count), nil
+}

app/module/activity_logs/activity_logs.module.go

@@ -0,0 +1,53 @@
+package activity_logs
+
+import (
+	"github.com/gofiber/fiber/v2"
+	"go-humas-be/app/module/activity_logs/controller"
+	"go-humas-be/app/module/activity_logs/repository"
+	"go-humas-be/app/module/activity_logs/service"
+	"go.uber.org/fx"
+)
+
+// struct of ActivityLogsRouter
+type ActivityLogsRouter struct {
+	App        fiber.Router
+	Controller *controller.Controller
+}
+
+// register bulky of ActivityLogs module
+var NewActivityLogsModule = fx.Options(
+	// register repository of ActivityLogs module
+	fx.Provide(repository.NewActivityLogsRepository),
+
+	// register service of ActivityLogs module
+	fx.Provide(service.NewActivityLogsService),
+
+	// register controller of ActivityLogs module
+	fx.Provide(controller.NewController),
+
+	// register router of ActivityLogs module
+	fx.Provide(NewActivityLogsRouter),
+)
+
+// init ActivityLogsRouter
+func NewActivityLogsRouter(fiber *fiber.App, controller *controller.Controller) *ActivityLogsRouter {
+	return &ActivityLogsRouter{
+		App:        fiber,
+		Controller: controller,
+	}
+}
+
+// register routes of ActivityLogs module
+func (_i *ActivityLogsRouter) RegisterActivityLogsRoutes() {
+	// define controllers
+	activityLogsController := _i.Controller.ActivityLogs
+
+	// define routes
+	_i.App.Route("/activity-logs", func(router fiber.Router) {
+		router.Get("/", activityLogsController.All)
+		router.Get("/:id", activityLogsController.Show)
+		router.Post("/", activityLogsController.Save)
+		router.Put("/:id", activityLogsController.Update)
+		router.Delete("/:id", activityLogsController.Delete)
+	})
+}

app/module/activity_logs/controller/activity_logs.controller.go

@@ -0,0 +1,200 @@
+package controller
+
+import (
+	"github.com/gofiber/fiber/v2"
+	"github.com/rs/zerolog"
+	"go-humas-be/app/module/activity_logs/request"
+	"go-humas-be/app/module/activity_logs/service"
+	"go-humas-be/utils/paginator"
+	utilRes "go-humas-be/utils/response"
+	utilVal "go-humas-be/utils/validator"
+	"strconv"
+)
+
+type activityLogsController struct {
+	activityLogsService service.ActivityLogsService
+	Log                 zerolog.Logger
+}
+
+type ActivityLogsController interface {
+	All(c *fiber.Ctx) error
+	Show(c *fiber.Ctx) error
+	Save(c *fiber.Ctx) error
+	Update(c *fiber.Ctx) error
+	Delete(c *fiber.Ctx) error
+}
+
+func NewActivityLogsController(activityLogsService service.ActivityLogsService, log zerolog.Logger) ActivityLogsController {
+	return &activityLogsController{
+		activityLogsService: activityLogsService,
+		Log:                 log,
+	}
+}
+
+// All get all ActivityLogs
+// @Summary      Get all ActivityLogs
+// @Description  API for getting all ActivityLogs
+// @Tags         ActivityLogs
+// @Security     Bearer
+// @Param 	     req query request.ActivityLogsQueryRequest false "query parameters"
+// @Param 	     req query paginator.Pagination false "pagination parameters"
+// @Success      200  {object}  response.Response
+// @Failure      400  {object}  response.BadRequestError
+// @Failure      401  {object}  response.UnauthorizedError
+// @Failure      500  {object}  response.InternalServerError
+// @Router       /activity-logs [get]
+func (_i *activityLogsController) All(c *fiber.Ctx) error {
+	paginate, err := paginator.Paginate(c)
+	if err != nil {
+		return err
+	}
+
+	reqContext := request.ActivityLogsQueryRequestContext{
+		ActivityTypeId: c.Query("activityTypeId"),
+		Url:            c.Query("url"),
+		ArticleId:      c.Query("articleId"),
+		UserId:         c.Query("userId"),
+	}
+	req := reqContext.ToParamRequest()
+	req.Pagination = paginate
+
+	activityLogsData, paging, err := _i.activityLogsService.All(req)
+	if err != nil {
+		return err
+	}
+
+	return utilRes.Resp(c, utilRes.Response{
+		Success:  true,
+		Messages: utilRes.Messages{"ActivityLogs list successfully retrieved"},
+		Data:     activityLogsData,
+		Meta:     paging,
+	})
+}
+
+// Show get one ActivityLogs
+// @Summary      Get one ActivityLogs
+// @Description  API for getting one ActivityLogs
+// @Tags         ActivityLogs
+// @Security     Bearer
+// @Param        id path int true "ActivityLogs ID"
+// @Success      200  {object}  response.Response
+// @Failure      400  {object}  response.BadRequestError
+// @Failure      401  {object}  response.UnauthorizedError
+// @Failure      500  {object}  response.InternalServerError
+// @Router       /activity-logs/{id} [get]
+func (_i *activityLogsController) Show(c *fiber.Ctx) error {
+	id, err := strconv.ParseUint(c.Params("id"), 10, 0)
+	if err != nil {
+		return err
+	}
+
+	activityLogsData, err := _i.activityLogsService.Show(uint(id))
+	if err != nil {
+		return err
+	}
+
+	return utilRes.Resp(c, utilRes.Response{
+		Success:  true,
+		Messages: utilRes.Messages{"ActivityLogs successfully retrieved"},
+		Data:     activityLogsData,
+	})
+}
+
+// Save create ActivityLogs
+// @Summary      Create ActivityLogs
+// @Description  API for create ActivityLogs
+// @Tags         ActivityLogs
+// @Security     Bearer
+// @Param        Authorization header string false "Insert your access token" default(Bearer <Add access token here>)
+// @Param 	     payload body request.ActivityLogsCreateRequest true "Required payload"
+// @Success      200  {object}  response.Response
+// @Failure      400  {object}  response.BadRequestError
+// @Failure      401  {object}  response.UnauthorizedError
+// @Failure      500  {object}  response.InternalServerError
+// @Router       /activity-logs [post]
+func (_i *activityLogsController) Save(c *fiber.Ctx) error {
+	req := new(request.ActivityLogsCreateRequest)
+	if err := utilVal.ParseAndValidate(c, req); err != nil {
+		return err
+	}
+
+	var authToken *string
+	getTokenFromHeader := c.Get("Authorization")
+	if getTokenFromHeader == "" {
+		authToken = nil
+	} else {
+		authToken = &getTokenFromHeader
+	}
+	dataResult, err := _i.activityLogsService.Save(*req, authToken)
+	if err != nil {
+		return err
+	}
+
+	return utilRes.Resp(c, utilRes.Response{
+		Success:  true,
+		Messages: utilRes.Messages{"ActivityLogs successfully created"},
+		Data:     dataResult,
+	})
+}
+
+// Update update ActivityLogs
+// @Summary      update ActivityLogs
+// @Description  API for update ActivityLogs
+// @Tags         ActivityLogs
+// @Security     Bearer
+// @Param 	     payload body request.ActivityLogsUpdateRequest true "Required payload"
+// @Param        id path int true "ActivityLogs ID"
+// @Success      200  {object}  response.Response
+// @Failure      400  {object}  response.BadRequestError
+// @Failure      401  {object}  response.UnauthorizedError
+// @Failure      500  {object}  response.InternalServerError
+// @Router       /activity-logs/{id} [put]
+func (_i *activityLogsController) Update(c *fiber.Ctx) error {
+	id, err := strconv.ParseUint(c.Params("id"), 10, 0)
+	if err != nil {
+		return err
+	}
+
+	req := new(request.ActivityLogsUpdateRequest)
+	if err := utilVal.ParseAndValidate(c, req); err != nil {
+		return err
+	}
+
+	err = _i.activityLogsService.Update(uint(id), *req)
+	if err != nil {
+		return err
+	}
+
+	return utilRes.Resp(c, utilRes.Response{
+		Success:  true,
+		Messages: utilRes.Messages{"ActivityLogs successfully updated"},
+	})
+}
+
+// Delete delete ActivityLogs
+// @Summary      delete ActivityLogs
+// @Description  API for delete ActivityLogs
+// @Tags         ActivityLogs
+// @Security     Bearer
+// @Param        id path int true "ActivityLogs ID"
+// @Success      200  {object}  response.Response
+// @Failure      400  {object}  response.BadRequestError
+// @Failure      401  {object}  response.UnauthorizedError
+// @Failure      500  {object}  response.InternalServerError
+// @Router       /activity-logs/{id} [delete]
+func (_i *activityLogsController) Delete(c *fiber.Ctx) error {
+	id, err := strconv.ParseUint(c.Params("id"), 10, 0)
+	if err != nil {
+		return err
+	}
+
+	err = _i.activityLogsService.Delete(uint(id))
+	if err != nil {
+		return err
+	}
+
+	return utilRes.Resp(c, utilRes.Response{
+		Success:  true,
+		Messages: utilRes.Messages{"ActivityLogs successfully deleted"},
+	})
+}

app/module/activity_logs/controller/controller.go

@@ -0,0 +1,16 @@
+package controller
+
+import (
+	"github.com/rs/zerolog"
+	"go-humas-be/app/module/activity_logs/service"
+)
+
+type Controller struct {
+	ActivityLogs ActivityLogsController
+}
+
+func NewController(ActivityLogsService service.ActivityLogsService, log zerolog.Logger) *Controller {
+	return &Controller{
+		ActivityLogs: NewActivityLogsController(ActivityLogsService, log),
+	}
+}

app/module/activity_logs/mapper/activity_logs.mapper.go

@@ -0,0 +1,20 @@
+package mapper
+
+import (
+	"go-humas-be/app/database/entity"
+	res "go-humas-be/app/module/activity_logs/response"
+)
+
+func ActivityLogsResponseMapper(activityLogsReq *entity.ActivityLogs) (activityLogsRes *res.ActivityLogsResponse) {
+	if activityLogsReq != nil {
+		activityLogsRes = &res.ActivityLogsResponse{
+			ID:             activityLogsReq.ID,
+			ActivityTypeId: activityLogsReq.ActivityTypeId,
+			Url:            activityLogsReq.Url,
+			ArticleId:      activityLogsReq.ArticleId,
+			UserId:         activityLogsReq.UserId,
+			CreatedAt:      activityLogsReq.CreatedAt,
+		}
+	}
+	return activityLogsRes
+}

app/module/activity_logs/repository/activity_logs.repository.go

@@ -0,0 +1,97 @@
+package repository
+
+import (
+	"fmt"
+	"github.com/rs/zerolog"
+	"go-humas-be/app/database"
+	"go-humas-be/app/database/entity"
+	"go-humas-be/app/module/activity_logs/request"
+	"go-humas-be/utils/paginator"
+	"strings"
+)
+
+type activityLogsRepository struct {
+	DB  *database.Database
+	Log zerolog.Logger
+}
+
+// ActivityLogsRepository define interface of IActivityLogsRepository
+type ActivityLogsRepository interface {
+	GetAll(req request.ActivityLogsQueryRequest) (activityLogss []*entity.ActivityLogs, paging paginator.Pagination, err error)
+	FindOne(id uint) (activityLogs *entity.ActivityLogs, err error)
+	Create(activityLogs *entity.ActivityLogs) (activityLogsReturn *entity.ActivityLogs, err error)
+	Update(id uint, activityLogs *entity.ActivityLogs) (err error)
+	Delete(id uint) (err error)
+}
+
+func NewActivityLogsRepository(db *database.Database, logger zerolog.Logger) ActivityLogsRepository {
+	return &activityLogsRepository{
+		DB:  db,
+		Log: logger,
+	}
+}
+
+// implement interface of IActivityLogsRepository
+func (_i *activityLogsRepository) GetAll(req request.ActivityLogsQueryRequest) (activityLogss []*entity.ActivityLogs, paging paginator.Pagination, err error) {
+	var count int64
+
+	query := _i.DB.DB.Model(&entity.ActivityLogs{})
+
+	if req.ActivityTypeId != nil {
+		query = query.Where("activity_type_id = ?", req.ActivityTypeId)
+	}
+	if req.Url != nil && *req.Url != "" {
+		url := strings.ToLower(*req.Url)
+		query = query.Where("LOWER(url) LIKE ?", "%"+strings.ToLower(url)+"%")
+	}
+	if req.ArticleId != nil {
+		query = query.Where("article_id = ?", req.ArticleId)
+	}
+	if req.UserId != nil {
+		query = query.Where("user_id = ?", req.UserId)
+	}
+	query.Count(&count)
+
+	if req.Pagination.SortBy != "" {
+		direction := "ASC"
+		if req.Pagination.Sort == "desc" {
+			direction = "DESC"
+		}
+		query.Order(fmt.Sprintf("%s %s", req.Pagination.SortBy, direction))
+	}
+
+	req.Pagination.Count = count
+	req.Pagination = paginator.Paging(req.Pagination)
+
+	err = query.Offset(req.Pagination.Offset).Limit(req.Pagination.Limit).Find(&activityLogss).Error
+	if err != nil {
+		return
+	}
+
+	paging = *req.Pagination
+
+	return
+}
+
+func (_i *activityLogsRepository) FindOne(id uint) (activityLogs *entity.ActivityLogs, err error) {
+	if err := _i.DB.DB.First(&activityLogs, id).Error; err != nil {
+		return nil, err
+	}
+
+	return activityLogs, nil
+}
+
+func (_i *activityLogsRepository) Create(activityLogs *entity.ActivityLogs) (activityLogsReturn *entity.ActivityLogs, err error) {
+	result := _i.DB.DB.Create(activityLogs)
+	return activityLogs, result.Error
+}
+
+func (_i *activityLogsRepository) Update(id uint, activityLogs *entity.ActivityLogs) (err error) {
+	return _i.DB.DB.Model(&entity.ActivityLogs{}).
+		Where(&entity.ActivityLogs{ID: id}).
+		Updates(activityLogs).Error
+}
+
+func (_i *activityLogsRepository) Delete(id uint) error {
+	return _i.DB.DB.Delete(&entity.ActivityLogs{}, id).Error
+}

app/module/activity_logs/request/activity_logs.request.go

@@ -0,0 +1,90 @@
+package request
+
+import (
+	"go-humas-be/app/database/entity"
+	"go-humas-be/utils/paginator"
+	"strconv"
+	"time"
+)
+
+type ActivityLogsGeneric interface {
+	ToEntity()
+}
+
+type ActivityLogsQueryRequest struct {
+	ActivityTypeId *int                  `json:"activityTypeId"`
+	Url            *string               `json:"url"`
+	ArticleId      *int                  `json:"articleId"`
+	UserId         *int                  `json:"userId"`
+	Pagination     *paginator.Pagination `json:"pagination"`
+}
+
+type ActivityLogsCreateRequest struct {
+	ActivityTypeId int    `json:"activityTypeId" validate:"required"`
+	Url            string `json:"url" validate:"required"`
+	ArticleId      *int   `json:"articleId"`
+	UserId         *uint  `json:"userId"`
+}
+
+func (req ActivityLogsCreateRequest) ToEntity() *entity.ActivityLogs {
+	return &entity.ActivityLogs{
+		ActivityTypeId: req.ActivityTypeId,
+		Url:            req.Url,
+		ArticleId:      req.ArticleId,
+		UserId:         req.UserId,
+		CreatedAt:      time.Now(),
+	}
+}
+
+type ActivityLogsUpdateRequest struct {
+	ID             uint   `json:"id" validate:"required"`
+	ActivityTypeId int    `json:"activityTypeId" validate:"required"`
+	Url            string `json:"url" validate:"required"`
+	ArticleId      *int   `json:"articleId"`
+	UserId         *uint  `json:"userId"`
+}
+
+func (req ActivityLogsUpdateRequest) ToEntity() *entity.ActivityLogs {
+	return &entity.ActivityLogs{
+		ID:             req.ID,
+		ActivityTypeId: req.ActivityTypeId,
+		Url:            req.Url,
+		ArticleId:      req.ArticleId,
+		UserId:         req.UserId,
+	}
+}
+
+type ActivityLogsQueryRequestContext struct {
+	ActivityTypeId string `json:"activityTypeId"`
+	Url            string `json:"url"`
+	ArticleId      string `json:"articleId"`
+	UserId         string `json:"userId"`
+}
+
+func (req ActivityLogsQueryRequestContext) ToParamRequest() ActivityLogsQueryRequest {
+	var request ActivityLogsQueryRequest
+
+	if activityTypeIdStr := req.ActivityTypeId; activityTypeIdStr != "" {
+		activityTypeId, err := strconv.Atoi(activityTypeIdStr)
+		if err == nil {
+			request.ActivityTypeId = &activityTypeId
+		}
+	}
+	if url := req.Url; url != "" {
+		request.Url = &url
+	}
+	if articleIdStr := req.ArticleId; articleIdStr != "" {
+		articleId, err := strconv.Atoi(articleIdStr)
+		if err == nil {
+			request.ArticleId = &articleId
+		}
+	}
+	if userIdStr := req.UserId; userIdStr != "" {
+		userId, err := strconv.Atoi(userIdStr)
+		if err == nil {
+			request.UserId = &userId
+		}
+	}
+
+	return request
+}

app/module/activity_logs/response/activity_logs.response.go

@@ -0,0 +1,12 @@
+package response
+
+import "time"
+
+type ActivityLogsResponse struct {
+	ID             uint      `json:"id"`
+	ActivityTypeId int       `json:"activityTypeId"`
+	Url            string    `json:"url"`
+	ArticleId      *int      `json:"articleId"`
+	UserId         *uint     `json:"userId"`
+	CreatedAt      time.Time `json:"createdAt"`
+}

app/module/activity_logs/service/activity_logs.service.go

@@ -0,0 +1,84 @@
+package service
+
+import (
+	"github.com/rs/zerolog"
+	"go-humas-be/app/database/entity"
+	"go-humas-be/app/module/activity_logs/mapper"
+	"go-humas-be/app/module/activity_logs/repository"
+	"go-humas-be/app/module/activity_logs/request"
+	"go-humas-be/app/module/activity_logs/response"
+	usersRepository "go-humas-be/app/module/users/repository"
+	"go-humas-be/utils/paginator"
+	utilSvc "go-humas-be/utils/service"
+)
+
+// ActivityLogsService
+type activityLogsService struct {
+	Repo      repository.ActivityLogsRepository
+	UsersRepo usersRepository.UsersRepository
+	Log       zerolog.Logger
+}
+
+// ActivityLogsService define interface of IActivityLogsService
+type ActivityLogsService interface {
+	All(req request.ActivityLogsQueryRequest) (activityLogs []*response.ActivityLogsResponse, paging paginator.Pagination, err error)
+	Show(id uint) (activityLogs *response.ActivityLogsResponse, err error)
+	Save(req request.ActivityLogsCreateRequest, authToken *string) (activityLogs *entity.ActivityLogs, err error)
+	Update(id uint, req request.ActivityLogsUpdateRequest) (err error)
+	Delete(id uint) error
+}
+
+// NewActivityLogsService init ActivityLogsService
+func NewActivityLogsService(repo repository.ActivityLogsRepository, log zerolog.Logger, usersRepo usersRepository.UsersRepository) ActivityLogsService {
+
+	return &activityLogsService{
+		Repo:      repo,
+		Log:       log,
+		UsersRepo: usersRepo,
+	}
+}
+
+// All implement interface of ActivityLogsService
+func (_i *activityLogsService) All(req request.ActivityLogsQueryRequest) (activityLogss []*response.ActivityLogsResponse, paging paginator.Pagination, err error) {
+	results, paging, err := _i.Repo.GetAll(req)
+	if err != nil {
+		return
+	}
+
+	for _, result := range results {
+		activityLogss = append(activityLogss, mapper.ActivityLogsResponseMapper(result))
+	}
+
+	return
+}
+
+func (_i *activityLogsService) Show(id uint) (activityLogs *response.ActivityLogsResponse, err error) {
+	result, err := _i.Repo.FindOne(id)
+	if err != nil {
+		return nil, err
+	}
+
+	return mapper.ActivityLogsResponseMapper(result), nil
+}
+
+func (_i *activityLogsService) Save(req request.ActivityLogsCreateRequest, authToken *string) (activityLogs *entity.ActivityLogs, err error) {
+	_i.Log.Info().Interface("data", req).Msg("")
+
+	newReq := req.ToEntity()
+
+	if authToken != nil {
+		createdBy := utilSvc.GetUserInfo(_i.Log, _i.UsersRepo, *authToken)
+		newReq.UserId = &createdBy.ID
+	}
+
+	return _i.Repo.Create(newReq)
+}
+
+func (_i *activityLogsService) Update(id uint, req request.ActivityLogsUpdateRequest) (err error) {
+	_i.Log.Info().Interface("data", req).Msg("")
+	return _i.Repo.Update(id, req.ToEntity())
+}
+
+func (_i *activityLogsService) Delete(id uint) error {
+	return _i.Repo.Delete(id)
+}

app/router/api.go

@@ -3,6 +3,7 @@ package router
 import (
 	swagger "github.com/arsmn/fiber-swagger/v2"
 	"github.com/gofiber/fiber/v2"
+	"go-humas-be/app/module/activity_logs"
 	"go-humas-be/app/module/article_categories"
 	"go-humas-be/app/module/article_category_details"
 	"go-humas-be/app/module/article_comments"
@@ -29,6 +30,7 @@ type Router struct {
 	App fiber.Router
 	Cfg *config.Config
 
+	ActivityLogsRouter           *activity_logs.ActivityLogsRouter
 	ArticleCategoriesRouter      *article_categories.ArticleCategoriesRouter
 	ArticleCategoryDetailsRouter *article_category_details.ArticleCategoryDetailsRouter
 	ArticleFilesRouter           *article_files.ArticleFilesRouter
@@ -53,6 +55,7 @@ func NewRouter(
 	fiber *fiber.App,
 	cfg *config.Config,
 
+	activityLogsRouter *activity_logs.ActivityLogsRouter,
 	articleCategoriesRouter *article_categories.ArticleCategoriesRouter,
 	articleCategoryDetailsRouter *article_category_details.ArticleCategoryDetailsRouter,
 	articleFilesRouter *article_files.ArticleFilesRouter,
@@ -75,6 +78,7 @@ func NewRouter(
 	return &Router{
 		App:                          fiber,
 		Cfg:                          cfg,
+		ActivityLogsRouter:           activityLogsRouter,
 		ArticleCategoriesRouter:      articleCategoriesRouter,
 		ArticleCategoryDetailsRouter: articleCategoryDetailsRouter,
 		ArticleFilesRouter:           articleFilesRouter,
@@ -107,6 +111,7 @@ func (r *Router) Register() {
 	r.App.Get("/swagger/*", swagger.HandlerDefault)
 
 	// Register routes of modules
+	r.ActivityLogsRouter.RegisterActivityLogsRoutes()
 	r.ArticleCategoriesRouter.RegisterArticleCategoriesRoutes()
 	r.ArticleCategoryDetailsRouter.RegisterArticleCategoryDetailsRoutes()
 	r.ArticleFilesRouter.RegisterArticleFilesRoutes()

config/webserver/webserver.config.go

@@ -121,7 +121,8 @@ func Start(lifecycle fx.Lifecycle, cfg *config.Config, fiber *fiber.App, router
 					// init seed models
 					masterStatusSeeder := seeds.MasterStatusesSeeder{}
 					masterApprovalStatusSeeder := seeds.MasterApprovalStatusesSeeder{}
-					allSeeders := []database.Seeder{masterStatusSeeder, masterApprovalStatusSeeder}
+					activityLogsSeeder := seeds.ActivityLogsSeeder{}
+					allSeeders := []database.Seeder{masterStatusSeeder, masterApprovalStatusSeeder, activityLogsSeeder}
 
 					db.SeedModels(allSeeders)
 				}

docs/swagger/docs.go

@@ -15,6 +15,316 @@ const docTemplate = `{
     "host": "{{.Host}}",
     "basePath": "{{.BasePath}}",
     "paths": {
+        "/activity-logs": {
+            "get": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for getting all ActivityLogs",
+                "tags": [
+                    "ActivityLogs"
+                ],
+                "summary": "Get all ActivityLogs",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "name": "activityTypeId",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "articleId",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "url",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "userId",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "count",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "limit",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "nextPage",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "page",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "previousPage",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "sort",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "sortBy",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "totalPage",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            },
+            "post": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for create ActivityLogs",
+                "tags": [
+                    "ActivityLogs"
+                ],
+                "summary": "Create ActivityLogs",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "default": "Bearer \u003cAdd access token here\u003e",
+                        "description": "Insert your access token",
+                        "name": "Authorization",
+                        "in": "header"
+                    },
+                    {
+                        "description": "Required payload",
+                        "name": "payload",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/request.ActivityLogsCreateRequest"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            }
+        },
+        "/activity-logs/{id}": {
+            "get": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for getting one ActivityLogs",
+                "tags": [
+                    "ActivityLogs"
+                ],
+                "summary": "Get one ActivityLogs",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "ActivityLogs ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            },
+            "put": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for update ActivityLogs",
+                "tags": [
+                    "ActivityLogs"
+                ],
+                "summary": "update ActivityLogs",
+                "parameters": [
+                    {
+                        "description": "Required payload",
+                        "name": "payload",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/request.ActivityLogsUpdateRequest"
+                        }
+                    },
+                    {
+                        "type": "integer",
+                        "description": "ActivityLogs ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            },
+            "delete": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for delete ActivityLogs",
+                "tags": [
+                    "ActivityLogs"
+                ],
+                "summary": "delete ActivityLogs",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "ActivityLogs ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            }
+        },
         "/article-categories": {
             "get": {
                 "security": [
@@ -6896,6 +7206,52 @@ const docTemplate = `{
                 }
             }
         },
+        "request.ActivityLogsCreateRequest": {
+            "type": "object",
+            "required": [
+                "activityTypeId",
+                "url"
+            ],
+            "properties": {
+                "activityTypeId": {
+                    "type": "integer"
+                },
+                "articleId": {
+                    "type": "integer"
+                },
+                "url": {
+                    "type": "string"
+                },
+                "userId": {
+                    "type": "integer"
+                }
+            }
+        },
+        "request.ActivityLogsUpdateRequest": {
+            "type": "object",
+            "required": [
+                "activityTypeId",
+                "id",
+                "url"
+            ],
+            "properties": {
+                "activityTypeId": {
+                    "type": "integer"
+                },
+                "articleId": {
+                    "type": "integer"
+                },
+                "id": {
+                    "type": "integer"
+                },
+                "url": {
+                    "type": "string"
+                },
+                "userId": {
+                    "type": "integer"
+                }
+            }
+        },
         "request.ArticleCategoriesCreateRequest": {
             "type": "object",
             "required": [

docs/swagger/swagger.json

@@ -4,6 +4,316 @@
         "contact": {}
     },
     "paths": {
+        "/activity-logs": {
+            "get": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for getting all ActivityLogs",
+                "tags": [
+                    "ActivityLogs"
+                ],
+                "summary": "Get all ActivityLogs",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "name": "activityTypeId",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "articleId",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "url",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "userId",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "count",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "limit",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "nextPage",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "page",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "previousPage",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "sort",
+                        "in": "query"
+                    },
+                    {
+                        "type": "string",
+                        "name": "sortBy",
+                        "in": "query"
+                    },
+                    {
+                        "type": "integer",
+                        "name": "totalPage",
+                        "in": "query"
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            },
+            "post": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for create ActivityLogs",
+                "tags": [
+                    "ActivityLogs"
+                ],
+                "summary": "Create ActivityLogs",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "default": "Bearer \u003cAdd access token here\u003e",
+                        "description": "Insert your access token",
+                        "name": "Authorization",
+                        "in": "header"
+                    },
+                    {
+                        "description": "Required payload",
+                        "name": "payload",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/request.ActivityLogsCreateRequest"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            }
+        },
+        "/activity-logs/{id}": {
+            "get": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for getting one ActivityLogs",
+                "tags": [
+                    "ActivityLogs"
+                ],
+                "summary": "Get one ActivityLogs",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "ActivityLogs ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            },
+            "put": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for update ActivityLogs",
+                "tags": [
+                    "ActivityLogs"
+                ],
+                "summary": "update ActivityLogs",
+                "parameters": [
+                    {
+                        "description": "Required payload",
+                        "name": "payload",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/request.ActivityLogsUpdateRequest"
+                        }
+                    },
+                    {
+                        "type": "integer",
+                        "description": "ActivityLogs ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            },
+            "delete": {
+                "security": [
+                    {
+                        "Bearer": []
+                    }
+                ],
+                "description": "API for delete ActivityLogs",
+                "tags": [
+                    "ActivityLogs"
+                ],
+                "summary": "delete ActivityLogs",
+                "parameters": [
+                    {
+                        "type": "integer",
+                        "description": "ActivityLogs ID",
+                        "name": "id",
+                        "in": "path",
+                        "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/response.Response"
+                        }
+                    },
+                    "400": {
+                        "description": "Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/response.BadRequestError"
+                        }
+                    },
+                    "401": {
+                        "description": "Unauthorized",
+                        "schema": {
+                            "$ref": "#/definitions/response.UnauthorizedError"
+                        }
+                    },
+                    "500": {
+                        "description": "Internal Server Error",
+                        "schema": {
+                            "$ref": "#/definitions/response.InternalServerError"
+                        }
+                    }
+                }
+            }
+        },
         "/article-categories": {
             "get": {
                 "security": [
@@ -6885,6 +7195,52 @@
                 }
             }
         },
+        "request.ActivityLogsCreateRequest": {
+            "type": "object",
+            "required": [
+                "activityTypeId",
+                "url"
+            ],
+            "properties": {
+                "activityTypeId": {
+                    "type": "integer"
+                },
+                "articleId": {
+                    "type": "integer"
+                },
+                "url": {
+                    "type": "string"
+                },
+                "userId": {
+                    "type": "integer"
+                }
+            }
+        },
+        "request.ActivityLogsUpdateRequest": {
+            "type": "object",
+            "required": [
+                "activityTypeId",
+                "id",
+                "url"
+            ],
+            "properties": {
+                "activityTypeId": {
+                    "type": "integer"
+                },
+                "articleId": {
+                    "type": "integer"
+                },
+                "id": {
+                    "type": "integer"
+                },
+                "url": {
+                    "type": "string"
+                },
+                "userId": {
+                    "type": "integer"
+                }
+            }
+        },
         "request.ArticleCategoriesCreateRequest": {
             "type": "object",
             "required": [

docs/swagger/swagger.yaml

@@ -18,6 +18,37 @@ definitions:
       totalPage:
         type: integer
     type: object
+  request.ActivityLogsCreateRequest:
+    properties:
+      activityTypeId:
+        type: integer
+      articleId:
+        type: integer
+      url:
+        type: string
+      userId:
+        type: integer
+    required:
+    - activityTypeId
+    - url
+    type: object
+  request.ActivityLogsUpdateRequest:
+    properties:
+      activityTypeId:
+        type: integer
+      articleId:
+        type: integer
+      id:
+        type: integer
+      url:
+        type: string
+      userId:
+        type: integer
+    required:
+    - activityTypeId
+    - id
+    - url
+    type: object
   request.ArticleCategoriesCreateRequest:
     properties:
       description:
@@ -749,6 +780,201 @@ definitions:
 info:
   contact: {}
 paths:
+  /activity-logs:
+    get:
+      description: API for getting all ActivityLogs
+      parameters:
+      - in: query
+        name: activityTypeId
+        type: integer
+      - in: query
+        name: articleId
+        type: integer
+      - in: query
+        name: url
+        type: string
+      - in: query
+        name: userId
+        type: integer
+      - in: query
+        name: count
+        type: integer
+      - in: query
+        name: limit
+        type: integer
+      - in: query
+        name: nextPage
+        type: integer
+      - in: query
+        name: page
+        type: integer
+      - in: query
+        name: previousPage
+        type: integer
+      - in: query
+        name: sort
+        type: string
+      - in: query
+        name: sortBy
+        type: string
+      - in: query
+        name: totalPage
+        type: integer
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/response.Response'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/response.BadRequestError'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/response.UnauthorizedError'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.InternalServerError'
+      security:
+      - Bearer: []
+      summary: Get all ActivityLogs
+      tags:
+      - ActivityLogs
+    post:
+      description: API for create ActivityLogs
+      parameters:
+      - default: Bearer <Add access token here>
+        description: Insert your access token
+        in: header
+        name: Authorization
+        type: string
+      - description: Required payload
+        in: body
+        name: payload
+        required: true
+        schema:
+          $ref: '#/definitions/request.ActivityLogsCreateRequest'
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/response.Response'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/response.BadRequestError'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/response.UnauthorizedError'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.InternalServerError'
+      security:
+      - Bearer: []
+      summary: Create ActivityLogs
+      tags:
+      - ActivityLogs
+  /activity-logs/{id}:
+    delete:
+      description: API for delete ActivityLogs
+      parameters:
+      - description: ActivityLogs ID
+        in: path
+        name: id
+        required: true
+        type: integer
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/response.Response'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/response.BadRequestError'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/response.UnauthorizedError'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.InternalServerError'
+      security:
+      - Bearer: []
+      summary: delete ActivityLogs
+      tags:
+      - ActivityLogs
+    get:
+      description: API for getting one ActivityLogs
+      parameters:
+      - description: ActivityLogs ID
+        in: path
+        name: id
+        required: true
+        type: integer
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/response.Response'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/response.BadRequestError'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/response.UnauthorizedError'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.InternalServerError'
+      security:
+      - Bearer: []
+      summary: Get one ActivityLogs
+      tags:
+      - ActivityLogs
+    put:
+      description: API for update ActivityLogs
+      parameters:
+      - description: Required payload
+        in: body
+        name: payload
+        required: true
+        schema:
+          $ref: '#/definitions/request.ActivityLogsUpdateRequest'
+      - description: ActivityLogs ID
+        in: path
+        name: id
+        required: true
+        type: integer
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/response.Response'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/response.BadRequestError'
+        "401":
+          description: Unauthorized
+          schema:
+            $ref: '#/definitions/response.UnauthorizedError'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/response.InternalServerError'
+      security:
+      - Bearer: []
+      summary: update ActivityLogs
+      tags:
+      - ActivityLogs
   /article-categories:
     get:
       description: API for getting all ArticleCategories

main.go

@@ -4,6 +4,7 @@ import (
 	fxzerolog "github.com/efectn/fx-zerolog"
 	"go-humas-be/app/database"
 	"go-humas-be/app/middleware"
+	"go-humas-be/app/module/activity_logs"
 	"go-humas-be/app/module/article_categories"
 	"go-humas-be/app/module/article_category_details"
 	"go-humas-be/app/module/article_comments"
@@ -54,6 +55,7 @@ func main() {
 		fx.Provide(config.NewSmtpConfig),
 
 		// provide modules
+		activity_logs.NewActivityLogsModule,
 		article_categories.NewArticleCategoriesModule,
 		article_category_details.NewArticleCategoryDetailsModule,
 		article_files.NewArticleFilesModule,