feat: order action per status change

app/actions/orderStatusActions/examples.go

@@ -0,0 +1,122 @@
+package orderStatusActions
+
+import (
+	"log"
+
+	"git.ma-al.com/goc_daniel/b2b/app/model/enums"
+)
+
+func init() {
+	GlobalRegistry.Register(enums.OrderStatusConfirmed, ActionChain{
+		SendOrderConfirmationEmail,
+		NotifyInventorySystem,
+	})
+
+	GlobalRegistry.Register(enums.OrderStatusProcessing, ActionChain{
+		NotifyWarehouse,
+		ReserveInventory,
+	})
+
+	GlobalRegistry.Register(enums.OrderStatusShipped, ActionChain{
+		NotifyWarehouseShipped,
+		GenerateTrackingNumber,
+		SendShippingNotificationEmail,
+	})
+
+	GlobalRegistry.Register(enums.OrderStatusDelivered, ActionChain{
+		SendDeliveryConfirmationEmail,
+		NotifyFulfillmentComplete,
+	})
+
+	GlobalRegistry.Register(enums.OrderStatusCancelled, ActionChain{
+		SendCancellationEmail,
+		ReleaseInventory,
+		ProcessRefund,
+	})
+
+	GlobalRegistry.Register(enums.OrderStatusReturned, ActionChain{
+		SendReturnConfirmationEmail,
+		NotifyReturnsDepartment,
+	})
+
+	GlobalRegistry.Register(enums.OrderStatusRefunded, ActionChain{
+		NotifyRefundProcessed,
+	})
+
+	GlobalRegistry.Register(enums.OrderStatusPending, ActionChain{})
+}
+
+var SendOrderConfirmationEmail = WithID("send_order_confirmation_email", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Sending order confirmation email for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var NotifyInventorySystem = WithID("notify_inventory_system", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Notifying inventory system for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var NotifyWarehouse = WithID("notify_warehouse", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Notifying warehouse for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var ReserveInventory = WithID("reserve_inventory", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Reserving inventory for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var NotifyWarehouseShipped = WithID("notify_warehouse_shipped", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Notifying warehouse of shipment for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var GenerateTrackingNumber = WithID("generate_tracking_number", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Generating tracking number for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var SendShippingNotificationEmail = WithID("send_shipping_notification_email", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Sending shipping notification email for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var SendDeliveryConfirmationEmail = WithID("send_delivery_confirmation_email", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Sending delivery confirmation email for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var NotifyFulfillmentComplete = WithID("notify_fulfillment_complete", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Notifying fulfillment complete for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var SendCancellationEmail = WithID("send_cancellation_email", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Sending cancellation email for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var ReleaseInventory = WithID("release_inventory", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Releasing inventory for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var ProcessRefund = WithID("process_refund", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Processing refund for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var SendReturnConfirmationEmail = WithID("send_return_confirmation_email", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Sending return confirmation email for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var NotifyReturnsDepartment = WithID("notify_returns_department", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Notifying returns department for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})
+
+var NotifyRefundProcessed = WithID("notify_refund_processed", func(actionCtx ActionContext) ActionResult {
+	log.Printf("Notifying refund processed for order %d", actionCtx.OrderId)
+	return ActionResult{Err: nil}
+})

app/actions/orderStatusActions/pending.go

@@ -0,0 +1,21 @@
+package orderStatusActions
+
+import (
+	"fmt"
+
+	"git.ma-al.com/goc_daniel/b2b/app/model/enums"
+)
+
+func init() {
+	var sendNewOrderEmail = WithID("send_new_order_email", func(actionCtx ActionContext) ActionResult {
+
+		if actionCtx.EmailService == nil {
+			return ActionResult{Err: fmt.Errorf("emailService not provided")}
+		}
+		return ActionResult{Err: actionCtx.EmailService.SendNewOrderPlacedNotification(*actionCtx.UserId)}
+	})
+
+	GlobalRegistry.Register(enums.OrderStatusPending, ActionChain{
+		sendNewOrderEmail,
+	})
+}

app/actions/orderStatusActions/registry.go

@@ -0,0 +1,85 @@
+package orderStatusActions
+
+import (
+	"log"
+
+	"git.ma-al.com/goc_daniel/b2b/app/model"
+	"git.ma-al.com/goc_daniel/b2b/app/model/enums"
+	"git.ma-al.com/goc_daniel/b2b/app/service/emailService"
+)
+
+var GlobalRegistry = make(ActionRegistry)
+
+type ActionID string
+
+type ActionContext struct {
+	OrderId      uint
+	Order        *model.CustomerOrder
+	UserId       *uint
+	EmailService *emailService.EmailService
+}
+
+type ActionResult struct {
+	Err      error
+	Metadata map[string]any
+}
+
+type OrderAction interface {
+	ID() ActionID
+	Execute(actionCtx ActionContext) ActionResult
+}
+
+type ActionChain []OrderAction
+
+func (c ActionChain) Execute(actionCtx ActionContext) []ActionResult {
+	results := make([]ActionResult, 0, len(c))
+	for _, action := range c {
+		result := action.Execute(actionCtx)
+		results = append(results, result)
+		if result.Err != nil {
+			log.Printf("action %s failed for order %d: %v", action.ID(), actionCtx.OrderId, result.Err)
+		}
+	}
+	return results
+}
+
+type ActionRegistry map[enums.OrderStatus]ActionChain
+
+func (r ActionRegistry) Register(status enums.OrderStatus, chain ActionChain) {
+	r[status] = chain
+}
+
+func (r ActionRegistry) ExecuteForStatus(status enums.OrderStatus, actionCtx ActionContext) []ActionResult {
+	chain, exists := r[status]
+	if !exists {
+		return nil
+	}
+	return chain.Execute(actionCtx)
+}
+
+type ActionFunc func(actionCtx ActionContext) ActionResult
+
+func (f ActionFunc) ID() ActionID {
+	return "anonymous"
+}
+
+func (f ActionFunc) Execute(actionCtx ActionContext) ActionResult {
+	return f(actionCtx)
+}
+
+type actionAdapter struct {
+	id ActionID
+	fn ActionFunc
+}
+
+func (a *actionAdapter) ID() ActionID {
+	return a.id
+}
+
+func (a *actionAdapter) Execute(actionCtx ActionContext) ActionResult {
+	return a.fn(actionCtx)
+}
+
+func WithID(id ActionID, fn ActionFunc) OrderAction {
+	return &actionAdapter{id: id, fn: fn}
+}

app/delivery/web/api/restricted/carts.go

@@ -28,12 +28,12 @@ func NewCartsHandler() *CartsHandler {
 func CartsHandlerRoutes(r fiber.Router) fiber.Router {
 	handler := NewCartsHandler()
 
-	r.Get("/add-new-cart", handler.AddNewCart)
+	r.Post("/add-new-cart", handler.AddNewCart)
 	r.Delete("/remove-cart", handler.RemoveCart)
-	r.Get("/change-cart-name", handler.ChangeCartName)
+	r.Patch("/change-cart-name", handler.ChangeCartName)
 	r.Get("/retrieve-carts-info", handler.RetrieveCartsInfo)
 	r.Get("/retrieve-cart", handler.RetrieveCart)
-	r.Get("/add-product-to-cart", handler.AddProduct)
+	r.Post("/add-product-to-cart", handler.AddProduct)
 	r.Delete("/remove-product-from-cart", handler.RemoveProduct)
 
 	return r

app/delivery/web/api/restricted/orders.go

@@ -2,8 +2,12 @@ package restricted
 
 import (
 	"strconv"
+	"strings"
 
+	"git.ma-al.com/goc_daniel/b2b/app/delivery/middleware"
+	"git.ma-al.com/goc_daniel/b2b/app/delivery/middleware/perms"
 	"git.ma-al.com/goc_daniel/b2b/app/model"
+	"git.ma-al.com/goc_daniel/b2b/app/model/enums"
 	"git.ma-al.com/goc_daniel/b2b/app/service/orderService"
 	"git.ma-al.com/goc_daniel/b2b/app/utils/i18n"
 	"git.ma-al.com/goc_daniel/b2b/app/utils/localeExtractor"
@@ -31,7 +35,7 @@ func OrdersHandlerRoutes(r fiber.Router) fiber.Router {
 	r.Get("/list", handler.ListOrders)
 	r.Post("/place-new-order", handler.PlaceNewOrder)
 	r.Post("/change-order-address", handler.ChangeOrderAddress)
-	r.Get("/change-order-status", handler.ChangeOrderStatus)
+	r.Patch("/change-order-status", middleware.Require(perms.OrdersModifyAll), handler.ChangeOrderStatus)
 
 	return r
 }
@@ -97,7 +101,13 @@ func (h *OrdersHandler) PlaceNewOrder(c fiber.Ctx) error {
 
 	name := c.Query("name")
 
-	err = h.ordersService.PlaceNewOrder(userID, uint(cart_id), name, uint(country_id), address_info)
+	originalUserId, ok := localeExtractor.GetOriginalUserID(c)
+	if !ok {
+		return c.Status(responseErrors.GetErrorStatus(responseErrors.ErrInvalidBody)).
+			JSON(response.Make(nullable.GetNil(""), 0, responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody)))
+	}
+
+	err = h.ordersService.PlaceNewOrder(userID, uint(cart_id), name, uint(country_id), address_info, originalUserId)
 	if err != nil {
 		return c.Status(responseErrors.GetErrorStatus(err)).
 			JSON(response.Make(nullable.GetNil(""), 0, responseErrors.GetErrorCode(c, err)))
@@ -146,22 +156,19 @@ func (h *OrdersHandler) ChangeOrderAddress(c fiber.Ctx) error {
 // we base permissions and user based on target user only.
 // TODO: well, permissions and all that.
 func (h *OrdersHandler) ChangeOrderStatus(c fiber.Ctx) error {
-	user, ok := localeExtractor.GetCustomer(c)
+	userId, ok := localeExtractor.GetUserID(c)
 	if !ok {
 		return c.Status(responseErrors.GetErrorStatus(responseErrors.ErrInvalidBody)).
 			JSON(response.Make(nullable.GetNil(""), 0, responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody)))
 	}
 
-	order_id_attribute := c.Query("order_id")
-	order_id, err := strconv.Atoi(order_id_attribute)
+	order_id, err := strconv.Atoi(c.Query("order_id"))
 	if err != nil {
 		return c.Status(responseErrors.GetErrorStatus(responseErrors.ErrBadAttribute)).
 			JSON(response.Make(nullable.GetNil(""), 0, responseErrors.GetErrorCode(c, responseErrors.ErrBadAttribute)))
 	}
 
-	status := c.Query("status")
-
-	err = h.ordersService.ChangeOrderStatus(user, uint(order_id), status)
+	err = h.ordersService.ChangeOrderStatus(userId, uint(order_id), enums.OrderStatus(strings.ToUpper(c.Query("status"))))
 	if err != nil {
 		return c.Status(responseErrors.GetErrorStatus(err)).
 			JSON(response.Make(nullable.GetNil(""), 0, responseErrors.GetErrorCode(c, err)))

app/model/enums/orderStatus.go

@@ -0,0 +1,16 @@
+package enums
+
+type OrderStatus string
+
+const (
+	OrderStatusPending        OrderStatus = "PENDING"
+	OrderStatusConfirmed      OrderStatus = "CONFIRMED"
+	OrderStatusProcessing     OrderStatus = "PROCESSING"
+	OrderStatusShipped        OrderStatus = "SHIPPED"
+	OrderStatusOutForDelivery OrderStatus = "OUT_FOR_DELIVERY"
+	OrderStatusDelivered      OrderStatus = "DELIVERED"
+	OrderStatusCancelled      OrderStatus = "CANCELLED"
+	OrderStatusReturned       OrderStatus = "RETURNED"
+	OrderStatusRefunded       OrderStatus = "REFUNDED"
+	OrderStatusFailed         OrderStatus = "FAILED"
+)

app/model/order.go

@@ -1,14 +1,16 @@
 package model
 
+import "git.ma-al.com/goc_daniel/b2b/app/model/enums"
+
 type CustomerOrder struct {
-	OrderID         uint             `gorm:"column:order_id;primaryKey;autoIncrement" json:"order_id"`
-	UserID          uint             `gorm:"column:user_id;not null;index" json:"user_id"`
-	Name            string           `gorm:"column:name;not null" json:"name"`
-	CountryID       uint             `gorm:"column:country_id;not null" json:"country_id"`
-	AddressString   string           `gorm:"column:address_string;not null" json:"address_string"`
-	AddressUnparsed *AddressUnparsed `gorm:"-" json:"address_unparsed"`
-	Status          string           `gorm:"column:status;size:50;not null" json:"status"`
-	Products        []OrderProduct   `gorm:"foreignKey:OrderID;references:OrderID" json:"products"`
+	OrderID         uint              `gorm:"column:order_id;primaryKey;autoIncrement" json:"order_id"`
+	UserID          uint              `gorm:"column:user_id;not null;index" json:"user_id"`
+	Name            string            `gorm:"column:name;not null" json:"name"`
+	CountryID       uint              `gorm:"column:country_id;not null" json:"country_id"`
+	AddressString   string            `gorm:"column:address_string;not null" json:"address_string"`
+	AddressUnparsed *AddressUnparsed  `gorm:"-" json:"address_unparsed"`
+	Status          enums.OrderStatus `gorm:"column:status;size:50;not null" json:"status"`
+	Products        []OrderProduct    `gorm:"foreignKey:OrderID;references:OrderID" json:"products"`
 }
 
 func (CustomerOrder) TableName() string {

app/model/orderStatusHistory.go

@@ -0,0 +1,20 @@
+package model
+
+import (
+	"time"
+
+	"git.ma-al.com/goc_daniel/b2b/app/model/enums"
+)
+
+type OrderStatusHistory struct {
+	Id        uint               `gorm:"column:id;primaryKey;autoIncrement"`
+	OrderId   uint               `gorm:"column:order_id;not null;index:idx_order_status_history_order"`
+	OldStatus *enums.OrderStatus `gorm:"column:old_status;type:varchar(50)"`
+	NewStatus enums.OrderStatus  `gorm:"column:new_status;type:varchar(50);not null"`
+	CreatedAt time.Time          `gorm:"column:created_at;not null;autoCreateTime"`
+	UserId    uint               `gorm:"column:user_id;index:idx_order_status_history_user;not null"`
+}
+
+func (OrderStatusHistory) TableName() string {
+	return "b2b_order_status_history"
+}

app/repos/ordersRepo/ordersRepo.go

@@ -3,17 +3,19 @@ package ordersRepo
 import (
 	"git.ma-al.com/goc_daniel/b2b/app/db"
 	"git.ma-al.com/goc_daniel/b2b/app/model"
-	constdata "git.ma-al.com/goc_daniel/b2b/app/utils/const_data"
+	"git.ma-al.com/goc_daniel/b2b/app/model/enums"
 	"git.ma-al.com/goc_daniel/b2b/app/utils/query/filters"
 	"git.ma-al.com/goc_daniel/b2b/app/utils/query/find"
 )
 
 type UIOrdersRepo interface {
 	UserHasOrder(user_id uint, order_id uint) (bool, error)
+	Get(orderId uint) (*model.CustomerOrder, error)
 	Find(user_id uint, p find.Paging, filt *filters.FiltersList) (*find.Found[model.CustomerOrder], error)
-	PlaceNewOrder(cart *model.CustomerCart, name string, country_id uint, address_info string) error
+	PlaceNewOrder(cart *model.CustomerCart, name string, country_id uint, address_info string, originalUserId uint) (*model.CustomerOrder, error)
 	ChangeOrderAddress(order_id uint, country_id uint, address_info string) error
-	ChangeOrderStatus(order_id uint, status string) error
+	ChangeOrderStatus(orderId uint, newStatus enums.OrderStatus, userId uint) error
+	GetOrderStatus(orderID uint) (enums.OrderStatus, error)
 }
 
 type OrdersRepo struct{}
@@ -35,6 +37,18 @@ func (repo *OrdersRepo) UserHasOrder(user_id uint, order_id uint) (bool, error)
 	return amt >= 1, err
 }
 
+func (repo *OrdersRepo) Get(orderId uint) (*model.CustomerOrder, error) {
+	var order model.CustomerOrder
+
+	err := db.Get().
+		Model(&model.CustomerOrder{}).
+		Preload("Products").
+		Where("order_id = ?", orderId).
+		First(&order).Error
+
+	return &order, err
+}
+
 func (repo *OrdersRepo) Find(user_id uint, p find.Paging, filt *filters.FiltersList) (*find.Found[model.CustomerOrder], error) {
 	var list []model.CustomerOrder
 	var total int64
@@ -69,13 +83,13 @@ func (repo *OrdersRepo) Find(user_id uint, p find.Paging, filt *filters.FiltersL
 	}, nil
 }
 
-func (repo *OrdersRepo) PlaceNewOrder(cart *model.CustomerCart, name string, country_id uint, address_info string) error {
+func (repo *OrdersRepo) PlaceNewOrder(cart *model.CustomerCart, name string, country_id uint, address_info string, originalUserId uint) (*model.CustomerOrder, error) {
 	order := model.CustomerOrder{
 		UserID:        cart.UserID,
 		Name:          name,
 		CountryID:     country_id,
 		AddressString: address_info,
-		Status:        constdata.NEW_ORDER_STATUS,
+		Status:        enums.OrderStatusPending,
 		Products:      make([]model.OrderProduct, 0, len(cart.Products)),
 	}
 
@@ -86,8 +100,30 @@ func (repo *OrdersRepo) PlaceNewOrder(cart *model.CustomerCart, name string, cou
 			Amount:             product.Amount,
 		})
 	}
+	tx := db.Get().Begin()
+	err := tx.Create(&order).Error
+	if err != nil {
+		tx.Rollback()
+		return nil, err
+	}
+	history := model.OrderStatusHistory{
+		OrderId:   order.OrderID,
+		OldStatus: nil,
+		NewStatus: enums.OrderStatusPending,
+		UserId:    originalUserId,
+	}
 
-	return db.DB.Create(&order).Error
+	err = tx.Create(&history).Error
+	if err != nil {
+		tx.Rollback()
+		return nil, err
+	}
+	err = tx.Commit().Error
+	if err != nil {
+		return nil, err
+	}
+
+	return &order, nil
 }
 
 func (repo *OrdersRepo) ChangeOrderAddress(order_id uint, country_id uint, address_info string) error {
@@ -101,10 +137,48 @@ func (repo *OrdersRepo) ChangeOrderAddress(order_id uint, country_id uint, addre
 		Error
 }
 
-func (repo *OrdersRepo) ChangeOrderStatus(order_id uint, status string) error {
-	return db.DB.
-		Table("b2b_customer_orders").
-		Where("order_id = ?", order_id).
-		Update("status", status).
-		Error
+func (repo *OrdersRepo) ChangeOrderStatus(orderID uint, newStatus enums.OrderStatus, userId uint) error {
+	tx := db.Get().Begin()
+
+	var currentStatus enums.OrderStatus
+	err := tx.Table("b2b_customer_orders").
+		Select("status").
+		Where("order_id = ?", orderID).
+		Scan(&currentStatus).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	err = tx.Table("b2b_customer_orders").
+		Where("order_id = ?", orderID).
+		Update("status", string(newStatus)).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	history := model.OrderStatusHistory{
+		OrderId:   orderID,
+		OldStatus: &currentStatus,
+		NewStatus: newStatus,
+		UserId:    userId,
+	}
+
+	err = tx.Create(&history).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	return tx.Commit().Error
+}
+
+func (repo *OrdersRepo) GetOrderStatus(orderID uint) (enums.OrderStatus, error) {
+	var status enums.OrderStatus
+	err := db.DB.Table("b2b_customer_orders").
+		Select("status").
+		Where("order_id = ?", orderID).
+		Scan(&status).Error
+	return status, err
 }

app/service/emailService/email.go

@@ -122,7 +122,7 @@ func (s *EmailService) SendNewOrderPlacedNotification(userID uint) error {
 	if s.config.AdminEmail == "" {
 		return nil // No admin email configured
 	}
-
+	fmt.Printf("userID: %v\n", userID)
 	subject := "New Order Created"
 	body := s.newOrderPlacedTemplate(userID)
 

app/service/orderService/orderService.go

@@ -4,8 +4,10 @@ import (
 	"fmt"
 	"strconv"
 
+	"git.ma-al.com/goc_daniel/b2b/app/actions/orderStatusActions"
 	"git.ma-al.com/goc_daniel/b2b/app/delivery/middleware/perms"
 	"git.ma-al.com/goc_daniel/b2b/app/model"
+	"git.ma-al.com/goc_daniel/b2b/app/model/enums"
 	"git.ma-al.com/goc_daniel/b2b/app/repos/cartsRepo"
 	"git.ma-al.com/goc_daniel/b2b/app/repos/ordersRepo"
 	"git.ma-al.com/goc_daniel/b2b/app/service/addressesService"
@@ -20,6 +22,7 @@ type OrderService struct {
 	cartsRepo        cartsRepo.UICartsRepo
 	addressesService *addressesService.AddressesService
 	emailService     *emailService.EmailService
+	actionRegistry   *orderStatusActions.ActionRegistry
 }
 
 func New() *OrderService {
@@ -28,9 +31,23 @@ func New() *OrderService {
 		cartsRepo:        cartsRepo.New(),
 		addressesService: addressesService.New(),
 		emailService:     emailService.NewEmailService(),
+		actionRegistry:   &orderStatusActions.GlobalRegistry,
 	}
 }
 
+var ValidStatuses = map[enums.OrderStatus]bool{
+	enums.OrderStatusPending:        true,
+	enums.OrderStatusConfirmed:      true,
+	enums.OrderStatusProcessing:     true,
+	enums.OrderStatusShipped:        true,
+	enums.OrderStatusOutForDelivery: true,
+	enums.OrderStatusDelivered:      true,
+	enums.OrderStatusCancelled:      true,
+	enums.OrderStatusReturned:       true,
+	enums.OrderStatusRefunded:       true,
+	enums.OrderStatusFailed:         true,
+}
+
 func (s *OrderService) Find(user *model.Customer, p find.Paging, filt *filters.FiltersList) (*find.Found[model.CustomerOrder], error) {
 	if !user.HasPermission(perms.OrdersViewAll) {
 		// append filter to view only this user's orders
@@ -56,7 +73,7 @@ func (s *OrderService) Find(user *model.Customer, p find.Paging, filt *filters.F
 	return list, nil
 }
 
-func (s *OrderService) PlaceNewOrder(user_id uint, cart_id uint, name string, country_id uint, address_info string) error {
+func (s *OrderService) PlaceNewOrder(user_id uint, cart_id uint, name string, country_id uint, address_info string, originalUserId uint) error {
 	_, err := s.addressesService.ValidateAddressJson(address_info, country_id)
 	if err != nil {
 		return err
@@ -83,7 +100,7 @@ func (s *OrderService) PlaceNewOrder(user_id uint, cart_id uint, name string, co
 	}
 
 	// all checks passed
-	err = s.ordersRepo.PlaceNewOrder(cart, name, country_id, address_info)
+	order, err := s.ordersRepo.PlaceNewOrder(cart, name, country_id, address_info, originalUserId)
 	if err != nil {
 		return err
 	}
@@ -96,16 +113,8 @@ func (s *OrderService) PlaceNewOrder(user_id uint, cart_id uint, name string, co
 		_ = err
 	}
 
-	// send email to admin
-	go func(user_id uint) {
-		err := s.emailService.SendNewOrderPlacedNotification(user_id)
-		if err != nil {
-			// Log error but don't fail placing order
-			_ = err
-		}
-	}(user_id)
+	return s.ChangeOrderStatus(user_id, order.OrderID, enums.OrderStatusPending)
 
-	return nil
 }
 
 func (s *OrderService) ChangeOrderAddress(user *model.Customer, order_id uint, country_id uint, address_info string) error {
@@ -128,18 +137,33 @@ func (s *OrderService) ChangeOrderAddress(user *model.Customer, order_id uint, c
 	return s.ordersRepo.ChangeOrderAddress(order_id, country_id, address_info)
 }
 
-// This is obiously just an initial version of this function
-func (s *OrderService) ChangeOrderStatus(user *model.Customer, order_id uint, status string) error {
-	if !user.HasPermission(perms.OrdersModifyAll) {
-		exists, err := s.ordersRepo.UserHasOrder(user.ID, order_id)
-		if err != nil {
-			return err
-		}
-
-		if !exists {
-			return responseErrors.ErrUserHasNoSuchOrder
-		}
+func (s *OrderService) ChangeOrderStatus(userId, orderId uint, newStatus enums.OrderStatus) error {
+	order, err := s.ordersRepo.Get(orderId)
+	if err != nil {
+		return err
+	}
+	if order == nil {
+		return responseErrors.ErrOrderNotFound
 	}
 
-	return s.ordersRepo.ChangeOrderStatus(order_id, status)
+	if !ValidStatuses[newStatus] {
+		return responseErrors.ErrInvalidStatus
+	}
+
+	err = s.ordersRepo.ChangeOrderStatus(order.OrderID, newStatus, userId)
+	if err != nil {
+		return err
+	}
+
+	actionCtx := orderStatusActions.ActionContext{
+		Order:        order,
+		UserId:       &userId,
+		EmailService: s.emailService,
+	}
+
+	go func() {
+		_ = s.actionRegistry.ExecuteForStatus(newStatus, actionCtx)
+	}()
+
+	return nil
 }

app/utils/localeExtractor/localeExtractor.go

@@ -14,6 +14,14 @@ func GetLangID(c fiber.Ctx) (uint, bool) {
 	return user_locale.OriginalUser.LangID, true
 }
 
+func GetOriginalUserID(c fiber.Ctx) (uint, bool) {
+	user_locale, ok := c.Locals(constdata.USER_LOCALE).(*model.UserLocale)
+	if !ok || user_locale.OriginalUser == nil {
+		return 0, false
+	}
+	return user_locale.OriginalUser.ID, true
+}
+
 func GetUserID(c fiber.Ctx) (uint, bool) {
 	user_locale, ok := c.Locals(constdata.USER_LOCALE).(*model.UserLocale)
 	if !ok || user_locale.User == nil {

app/utils/responseErrors/responseErrors.go

@@ -71,6 +71,8 @@ var (
 	// Typed errors for orders handler
 	ErrEmptyCart          = errors.New("the cart is empty")
 	ErrUserHasNoSuchOrder = errors.New("user does not have order with given id")
+	ErrInvalidStatus      = errors.New("invalid order status")
+	ErrOrderNotFound      = errors.New("order not found")
 
 	// Typed errors for price reduction handler
 	ErrInvalidReductionType  = errors.New("invalid reduction type: must be 'amount' or 'percentage'")
@@ -314,7 +316,8 @@ func GetErrorStatus(err error) int {
 		errors.Is(err, ErrMaxAmtOfAddressesReached),
 		errors.Is(err, ErrUserHasNoSuchAddress),
 		errors.Is(err, ErrInvalidCountryID),
-		errors.Is(err, ErrInvalidAddressJSON):
+		errors.Is(err, ErrInvalidAddressJSON),
+		errors.Is(err, ErrInvalidStatus):
 		return fiber.StatusBadRequest
 	case errors.Is(err, ErrSpecificPriceNotFound):
 		return fiber.StatusNotFound