Develop

config/config.go

@@ -52,6 +52,12 @@ var (
 		ManageProjects    string `yaml:"manage_projects"`
 		ManageStore       string `yaml:"manage_store"`
 	}
+
+	Redirects struct {
+		SecurityTab string `yaml:"security"`
+		Profile     string `yaml:"profile"`
+		Project     string `yaml:"project"`
+	}
 )
 
 func Parse() {
@@ -99,6 +105,10 @@ func Parse() {
 		log.Fatalf("error: %v", err)
 	}
 
+	if err := yaml.Unmarshal(read("redirects.yaml"), &Redirects); err != nil {
+		log.Fatalf("error: %v", err)
+	}
+
 	log.Print("Loaded config files")
 }
 

config/redirects.yaml

@@ -0,0 +1,3 @@
+security: /settings?tab=security
+profile: /profile/%s
+project: /projects/%d

internal/controller/http/v1/auth.go

@@ -12,6 +12,7 @@ import (
 	"github.com/swibly/swibly-api/internal/service"
 	"github.com/swibly/swibly-api/pkg/aws"
 	"github.com/swibly/swibly-api/pkg/middleware"
+	"github.com/swibly/swibly-api/pkg/notification"
 	"github.com/swibly/swibly-api/pkg/utils"
 	"github.com/swibly/swibly-api/translations"
 	"golang.org/x/crypto/bcrypt"
@@ -72,6 +73,12 @@ func RegisterHandler(ctx *gin.Context) {
 			log.Print(err)
 			ctx.JSON(http.StatusInternalServerError, gin.H{"error": dict.InternalServerError})
 		} else {
+			service.CreateNotification(dto.CreateNotification{
+				Title:   dict.CategoryAuth,
+				Message: dict.NotificationWelcomeUserRegister,
+				Type:    notification.Information,
+			}, user.ID)
+
 			ctx.JSON(http.StatusOK, gin.H{"token": token})
 		}
 
@@ -150,6 +157,13 @@ func LoginHandler(ctx *gin.Context) {
 
 		ctx.JSON(http.StatusInternalServerError, gin.H{"error": dict.InternalServerError})
 	} else {
+		service.CreateNotification(dto.CreateNotification{
+			Title:    dict.CategoryAuth,
+			Message:  dict.NotificationNewLoginDetected,
+			Type:     notification.Warning,
+			Redirect: &config.Redirects.SecurityTab,
+		}, user.ID)
+
 		ctx.JSON(http.StatusOK, gin.H{"token": token})
 	}
 }

internal/controller/http/v1/component.go

@@ -2,6 +2,7 @@ package v1
 
 import (
 	"errors"
+	"fmt"
 	"log"
 	"net/http"
 	"strconv"
@@ -12,6 +13,7 @@ import (
 	"github.com/swibly/swibly-api/internal/service"
 	"github.com/swibly/swibly-api/internal/service/repository"
 	"github.com/swibly/swibly-api/pkg/middleware"
+	"github.com/swibly/swibly-api/pkg/notification"
 	"github.com/swibly/swibly-api/pkg/utils"
 	"github.com/swibly/swibly-api/translations"
 )
@@ -145,6 +147,12 @@ func CreateComponentHandler(ctx *gin.Context) {
 		return
 	}
 
+	service.CreateNotification(dto.CreateNotification{
+		Title:   dict.CategoryComponent,
+		Message: fmt.Sprintf(dict.NotificationNewComponentCreated, component.Name),
+		Type:    notification.Information,
+	}, issuer.ID)
+
 	ctx.JSON(http.StatusOK, gin.H{"message": dict.ComponentCreated})
 }
 
@@ -251,10 +259,10 @@ func UpdateComponentHandler(ctx *gin.Context) {
 func BuyComponentHandler(ctx *gin.Context) {
 	dict := translations.GetTranslation(ctx)
 
-	issuerID := ctx.Keys["auth_user"].(*dto.UserProfile).ID
-	componentID := ctx.Keys["component_lookup"].(*dto.ComponentInfo).ID
+	issuer := ctx.Keys["auth_user"].(*dto.UserProfile)
+	component := ctx.Keys["component_lookup"].(*dto.ComponentInfo)
 
-	if err := service.Component.Buy(issuerID, componentID); err != nil {
+	if err := service.Component.Buy(issuer.ID, component.ID); err != nil {
 		if errors.Is(err, repository.ErrInsufficientArkhoins) {
 			ctx.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": dict.InsufficientArkhoins})
 			return
@@ -273,6 +281,18 @@ func BuyComponentHandler(ctx *gin.Context) {
 		return
 	}
 
+	service.CreateNotification(dto.CreateNotification{
+		Title:   dict.CategoryComponent,
+		Message: fmt.Sprintf(dict.NotificationYourComponentBought, component.Name, issuer.FirstName+" "+issuer.LastName),
+		Type:    notification.Information,
+	}, component.OwnerID)
+
+	service.CreateNotification(dto.CreateNotification{
+		Title:   dict.CategoryComponent,
+		Message: fmt.Sprintf(dict.NotificationYouBoughtComponent, component.Name),
+		Type:    notification.Information,
+	}, issuer.ID)
+
 	ctx.JSON(http.StatusOK, gin.H{"message": dict.ComponentBought})
 }
 
@@ -316,6 +336,12 @@ func PublishComponentHandler(ctx *gin.Context) {
 		return
 	}
 
+	service.CreateNotification(dto.CreateNotification{
+		Title:   dict.CategoryComponent,
+		Message: fmt.Sprintf(dict.NotificationYourComponentPublished, component.Name),
+		Type:    notification.Warning,
+	}, component.OwnerID)
+
 	ctx.JSON(http.StatusOK, gin.H{"message": dict.ComponentPublished})
 }
 
@@ -373,6 +399,12 @@ func DeleteComponenttForceHandler(ctx *gin.Context) {
 		return
 	}
 
+	service.CreateNotification(dto.CreateNotification{
+		Title:   dict.CategoryComponent,
+		Message: fmt.Sprintf(dict.NotificationDeletedComponentFromTrash, component.Name),
+		Type:    notification.Danger,
+	}, component.OwnerID)
+
 	ctx.JSON(http.StatusOK, gin.H{"message": dict.ComponentDeleted})
 }
 
@@ -392,5 +424,11 @@ func RestoreComponentHandler(ctx *gin.Context) {
 		return
 	}
 
+	service.CreateNotification(dto.CreateNotification{
+		Title:   dict.CategoryComponent,
+		Message: fmt.Sprintf(dict.NotificationRestoredComponentFromTrash, component.Name),
+		Type:    notification.Warning,
+	}, component.OwnerID)
+
 	ctx.JSON(http.StatusOK, gin.H{"message": dict.ComponentRestored})
 }

internal/controller/http/v1/notification.go

@@ -0,0 +1,116 @@
+package v1
+
+import (
+	"errors"
+	"log"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/swibly/swibly-api/internal/model/dto"
+	"github.com/swibly/swibly-api/internal/service"
+	"github.com/swibly/swibly-api/internal/service/repository"
+	"github.com/swibly/swibly-api/pkg/middleware"
+	"github.com/swibly/swibly-api/translations"
+)
+
+func newNotificationRoutes(handler *gin.RouterGroup) {
+	h := handler.Group("/notification")
+	h.Use(middleware.APIKeyHasEnabledUserFetch, middleware.Auth)
+	{
+		h.GET("", GetOwnNotificationsHandler)
+
+		specific := h.Group("/:id")
+		{
+			specific.POST("/read", PostReadNotificationHandler)
+			specific.DELETE("/unread", DeleteUnreadNotificationHandler)
+		}
+	}
+}
+
+func GetOwnNotificationsHandler(ctx *gin.Context) {
+	dict := translations.GetTranslation(ctx)
+
+	page := 1
+	perPage := 10
+	onlyUnread := false
+
+	if i, e := strconv.Atoi(ctx.Query("page")); e == nil && ctx.Query("page") != "" {
+		page = i
+	}
+
+	if i, e := strconv.Atoi(ctx.Query("perpage")); e == nil && ctx.Query("perpage") != "" {
+		perPage = i
+	}
+
+	unreadFlag := strings.ToLower(ctx.Query("unread"))
+	if unreadFlag == "true" || unreadFlag == "t" || unreadFlag == "1" {
+		onlyUnread = true
+	}
+
+	issuer := ctx.Keys["auth_user"].(*dto.UserProfile)
+
+	notifications, err := service.Notification.GetForUser(issuer.ID, onlyUnread, page, perPage)
+	if err != nil {
+		log.Print(err)
+		ctx.JSON(http.StatusInternalServerError, gin.H{"error": dict.InternalServerError})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, notifications)
+}
+
+func PostReadNotificationHandler(ctx *gin.Context) {
+	dict := translations.GetTranslation(ctx)
+	issuer := ctx.Keys["auth_user"].(*dto.UserProfile)
+
+	notificationID, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
+	if err != nil {
+		log.Print(err)
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": dict.NotificationInvalid})
+		return
+	}
+
+	if err := service.Notification.MarkAsRead(*issuer, uint(notificationID)); err != nil {
+		switch {
+		case errors.Is(err, repository.ErrNotificationNotAssigned):
+			ctx.JSON(http.StatusForbidden, gin.H{"error": dict.NotificationNotAssigned})
+		case errors.Is(err, repository.ErrNotificationAlreadyRead):
+			ctx.JSON(http.StatusConflict, gin.H{"error": dict.NotificationAlreadyRead})
+		default:
+			log.Print(err)
+			ctx.JSON(http.StatusInternalServerError, gin.H{"error": dict.InternalServerError})
+		}
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": dict.NotificationMarkedAsRead})
+}
+
+func DeleteUnreadNotificationHandler(ctx *gin.Context) {
+	dict := translations.GetTranslation(ctx)
+	issuer := ctx.Keys["auth_user"].(*dto.UserProfile)
+
+	notificationID, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
+	if err != nil {
+		log.Print(err)
+		ctx.JSON(http.StatusBadRequest, gin.H{"error": dict.NotificationInvalid})
+		return
+	}
+
+	if err := service.Notification.MarkAsUnread(*issuer, uint(notificationID)); err != nil {
+		switch {
+		case errors.Is(err, repository.ErrNotificationNotAssigned):
+			ctx.JSON(http.StatusForbidden, gin.H{"error": dict.NotificationNotAssigned})
+		case errors.Is(err, repository.ErrNotificationNotRead):
+			ctx.JSON(http.StatusConflict, gin.H{"error": dict.NotificationNotRead})
+		default:
+			log.Print(err)
+			ctx.JSON(http.StatusInternalServerError, gin.H{"error": dict.InternalServerError})
+		}
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{"message": dict.NotificationMarkedAsUnread})
+}