Merge pull request #29 from traPtitech/feat/owners

Author: kavos113

model/ownership.go

@@ -1,5 +1,11 @@
 package model
 
+import (
+	"errors"
+
+	"gorm.io/gorm"
+)
+
 type Ownership struct {
 	GormModel
 	ItemID      int           `gorm:"type:int;not null" json:"itemId"`
@@ -9,6 +15,101 @@ type Ownership struct {
 	Transaction []Transaction `gorm:"foreignKey:ownership_id;references:id"`
 }
 
+type OwnershipPayload struct {
+	ItemID     int    `json:"itemId"`
+	UserID     string `json:"userId"`
+	Rentalable bool   `json:"rentalable"`
+	Memo       string `json:"memo"`
+}
+
 func (Ownership) TableName() string {
 	return "ownerships"
 }
+
+func CreateOwnership(ownership OwnershipPayload) (Ownership, error) {
+	o := Ownership{
+		ItemID:     ownership.ItemID,
+		UserID:     ownership.UserID,
+		Rentalable: ownership.Rentalable,
+		Memo:       ownership.Memo,
+	}
+	err := db.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Create(&o).Error; err != nil {
+			return err
+		}
+
+		return nil
+	})
+	if err != nil {
+		return Ownership{}, err
+	}
+
+	return o, nil
+}
+
+func UpdateOwnership(ownershipId int, ownership OwnershipPayload) (Ownership, error) {
+	ownershipOld, err := GetOwnership(ownershipId)
+	if err != nil {
+		return Ownership{}, err
+	}
+
+	if ownershipOld.UserID != ownership.UserID {
+		return Ownership{}, errors.New("編集する権限がありません")
+	}
+
+	o := Ownership{
+		ItemID:      ownership.ItemID,
+		UserID:      ownership.UserID,
+		Rentalable:  ownership.Rentalable,
+		Memo:        ownership.Memo,
+		Transaction: ownershipOld.Transaction,
+	}
+	err = db.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Model(&Ownership{}).Where("id = ?", ownershipId).Updates(map[string]interface{}{
+			"rentalable": o.Rentalable,
+			"memo":       o.Memo,
+		}).Error; err != nil {
+			return err
+		}
+		return nil
+	})
+	if err != nil {
+		return Ownership{}, err
+	}
+
+	return o, nil
+}
+
+func DeleteOwnership(ownershipId int, userId string) error {
+	ownershipOld, err := GetOwnership(ownershipId)
+	if err != nil {
+		return err
+	}
+
+	if ownershipOld.UserID != userId {
+		return errors.New("削除する権限がありません")
+	}
+
+	err = db.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Where("ownership_id = ?", ownershipId).Delete(&Transaction{}).Error; err != nil {
+			return err
+		}
+		if err := tx.Delete(&Ownership{}, ownershipId).Error; err != nil {
+			return err
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func GetOwnership(ownershipId int) (*Ownership, error) {
+	var o Ownership
+	if err := db.Preload("Transaction").First(&o, ownershipId).Error; err != nil {
+		return nil, err
+	}
+	return &o, nil
+}

model/ownership_test.go

@@ -0,0 +1,132 @@
+package model
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestOwnershipTableName(t *testing.T) {
+	t.Parallel()
+	assert.Equal(t, "ownerships", (&Ownership{}).TableName())
+}
+
+func TestGetOwnership(t *testing.T) {
+	PrepareTestDatabase()
+
+	t.Run("failure", func(t *testing.T) {
+		t.Parallel()
+		assert := assert.New(t)
+
+		res, err := GetOwnership(-1)
+		assert.Error(err)
+		assert.Empty(res)
+	})
+
+	t.Run("success", func(t *testing.T) {
+		t.Parallel()
+		assert := assert.New(t)
+
+		res, err := GetOwnership(1)
+		assert.NoError(err)
+		assert.NotEmpty(res)
+		assert.Equal(res.UserID, "s9")
+		assert.Equal(res.ItemID, 1)
+		assert.Equal(res.Rentalable, true)
+		assert.Equal(res.Memo, "memo1")
+		assert.Equal(4, len(res.Transaction))
+	})
+}
+
+func TestCreateOwnership(t *testing.T) {
+	PrepareTestDatabase()
+
+	t.Run("success", func(t *testing.T) {
+		assert := assert.New(t)
+
+		payload := OwnershipPayload{
+			ItemID:     1,
+			UserID:     "new_user",
+			Rentalable: true,
+			Memo:       "created by test",
+		}
+		created, err := CreateOwnership(payload)
+		assert.NoError(err)
+		assert.NotZero(created.ID)
+		assert.Equal(payload.ItemID, created.ItemID)
+		assert.Equal(payload.UserID, created.UserID)
+		assert.Equal(payload.Rentalable, created.Rentalable)
+		assert.Equal(payload.Memo, created.Memo)
+
+		fetched, err := GetOwnership(created.ID)
+		assert.NoError(err)
+		assert.Equal(created.ID, fetched.ID)
+		assert.Equal(created.UserID, fetched.UserID)
+	})
+}
+
+func TestUpdateOwnership(t *testing.T) {
+	PrepareTestDatabase()
+
+	t.Run("failure: not found", func(t *testing.T) {
+		assert := assert.New(t)
+		_, err := UpdateOwnership(-1, OwnershipPayload{})
+		assert.Error(err)
+	})
+
+	t.Run("failure: unauthorized", func(t *testing.T) {
+		assert := assert.New(t)
+		_, err := UpdateOwnership(1, OwnershipPayload{
+			ItemID:     1,
+			UserID:     "different_user",
+			Rentalable: false,
+			Memo:       "new_memo",
+		})
+		assert.Error(err)
+	})
+
+	t.Run("success", func(t *testing.T) {
+		assert := assert.New(t)
+		updated, err := UpdateOwnership(1, OwnershipPayload{
+			ItemID:     1,
+			UserID:     "s9",
+			Rentalable: false,
+			Memo:       "updated",
+		})
+		assert.NoError(err)
+		assert.Equal("s9", updated.UserID)
+		assert.Equal(false, updated.Rentalable)
+		assert.Equal("updated", updated.Memo)
+
+		fetched, err := GetOwnership(1)
+		assert.NoError(err)
+		assert.Equal("updated", fetched.Memo)
+		assert.Equal(false, fetched.Rentalable)
+	})
+}
+
+func TestDeleteOwnership(t *testing.T) {
+	PrepareTestDatabase()
+
+	t.Run("failure: not found", func(t *testing.T) {
+		assert := assert.New(t)
+		err := DeleteOwnership(-1, "someone")
+		assert.Error(err)
+	})
+
+	t.Run("failure: unauthorized", func(t *testing.T) {
+		assert := assert.New(t)
+		err := DeleteOwnership(1, "different_user")
+		assert.Error(err)
+	})
+
+	t.Run("success", func(t *testing.T) {
+		assert := assert.New(t)
+		err := DeleteOwnership(1, "s9")
+		assert.NoError(err)
+
+		res, err := GetOwnership(1)
+		assert.Error(err)
+		assert.Empty(res)
+	})
+}

router/owners.go

@@ -2,21 +2,75 @@ package router
 
 import (
 	"net/http"
+	"strconv"
 
 	"github.com/labstack/echo/v4"
+	"github.com/traPtitech/booQ-v3/model"
 )
 
 // PostOwners POST /items/:id/owners
 func PostOwners(c echo.Context) error {
-	return echo.NewHTTPError(http.StatusNotImplemented, "Not Implemented")
+	itemId, err := strconv.Atoi(c.Param("id"))
+	if err != nil {
+		return invalidRequest(c, err)
+	}
+
+	owner := model.OwnershipPayload{}
+	if err := c.Bind(&owner); err != nil {
+		return invalidRequest(c, err)
+	}
+	owner.ItemID = itemId
+
+	res, err := model.CreateOwnership(owner)
+	if err != nil {
+		return internalServerError(c, err)
+	}
+
+	return c.JSON(http.StatusOK, res)
 }
 
 // PatchOwners PUT /items/:id/owners/:ownershipid
 func PatchOwners(c echo.Context) error {
-	return echo.NewHTTPError(http.StatusNotImplemented, "Not Implemented")
+	itemId, err := strconv.Atoi(c.Param("id"))
+	if err != nil {
+		return invalidRequest(c, err)
+	}
+
+	ownershipId, err := strconv.Atoi(c.Param("ownershipid"))
+	if err != nil {
+		return invalidRequest(c, err)
+	}
+
+	owner := model.OwnershipPayload{}
+	if err := c.Bind(&owner); err != nil {
+		return invalidRequest(c, err)
+	}
+	owner.ItemID = itemId
+
+	res, err := model.UpdateOwnership(ownershipId, owner)
+	if err != nil {
+		return internalServerError(c, err)
+	}
+
+	return c.JSON(http.StatusOK, res)
 }
 
 // DeleteOwners PUT /items/:id/owners/:ownershipid
 func DeleteOwners(c echo.Context) error {
-	return echo.NewHTTPError(http.StatusNotImplemented, "Not Implemented")
+	ownershipId, err := strconv.Atoi(c.Param("ownershipid"))
+	if err != nil {
+		return invalidRequest(c, err)
+	}
+
+	me, err := getAuthorizedUser(c)
+	if err != nil {
+		return unauthorizedRequest(c, err)
+	}
+
+	err = model.DeleteOwnership(ownershipId, me)
+	if err != nil {
+		return internalServerError(c, err)
+	}
+
+	return c.NoContent(http.StatusNoContent)
 }