git-bug/bug/op_create.go

193 lines
4.6 KiB
Go
Raw Normal View History

package bug
2018-07-12 22:31:41 +03:00
import (
"crypto/rand"
2019-01-19 21:23:31 +03:00
"encoding/json"
"fmt"
"strings"
"github.com/MichaelMure/git-bug/entity"
2018-11-21 20:56:12 +03:00
"github.com/MichaelMure/git-bug/identity"
"github.com/MichaelMure/git-bug/repository"
"github.com/MichaelMure/git-bug/util/text"
"github.com/MichaelMure/git-bug/util/timestamp"
2018-07-12 22:31:41 +03:00
)
var _ Operation = &CreateOperation{}
2018-07-12 22:31:41 +03:00
// CreateOperation define the initial creation of a bug
2018-07-12 22:31:41 +03:00
type CreateOperation struct {
2018-10-01 12:37:17 +03:00
OpBase
// mandatory random bytes to ensure a better randomness of the data of the first
// operation of a bug, used to later generate the ID
// len(Nonce) should be > 20 and < 64 bytes
Nonce []byte `json:"nonce"`
Title string `json:"title"`
Message string `json:"message"`
Files []repository.Hash `json:"files"`
2018-07-12 22:31:41 +03:00
}
// Sign-post method for gqlgen
func (op *CreateOperation) IsOperation() {}
func (op *CreateOperation) base() *OpBase {
2018-10-01 12:37:17 +03:00
return &op.OpBase
}
func (op *CreateOperation) Id() entity.Id {
return idOperation(op)
}
// OVERRIDE
func (op *CreateOperation) SetMetadata(key string, value string) {
// sanity check: we make sure we are not in the following scenario:
// - the bug is created with a first operation
// - Id() is used
// - metadata are added, which will change the Id
// - Id() is used again
if op.id != entity.UnsetId {
panic("usage of Id() after changing the first operation")
}
op.OpBase.SetMetadata(key, value)
}
func (op *CreateOperation) Apply(snapshot *Snapshot) {
snapshot.addActor(op.Author)
snapshot.addParticipant(op.Author)
2018-07-12 22:31:41 +03:00
snapshot.Title = op.Title
comment := Comment{
id: op.Id(),
Message: op.Message,
Author: op.Author,
UnixTime: timestamp.Timestamp(op.UnixTime),
2018-07-12 22:31:41 +03:00
}
snapshot.Comments = []Comment{comment}
2018-08-01 03:15:40 +03:00
snapshot.Author = op.Author
snapshot.CreateTime = op.Time()
snapshot.Timeline = []TimelineItem{
&CreateTimelineItem{
CommentTimelineItem: NewCommentTimelineItem(op.Id(), comment),
},
}
2018-07-12 22:31:41 +03:00
}
func (op *CreateOperation) GetFiles() []repository.Hash {
return op.Files
}
func (op *CreateOperation) Validate() error {
if err := opBaseValidate(op, CreateOp); err != nil {
return err
}
if len(op.Nonce) > 64 {
return fmt.Errorf("create nonce is too big")
}
if len(op.Nonce) < 20 {
return fmt.Errorf("create nonce is too small")
}
if text.Empty(op.Title) {
return fmt.Errorf("title is empty")
}
if strings.Contains(op.Title, "\n") {
return fmt.Errorf("title should be a single line")
}
if !text.Safe(op.Title) {
return fmt.Errorf("title is not fully printable")
}
if !text.Safe(op.Message) {
return fmt.Errorf("message is not fully printable")
}
return nil
}
// UnmarshalJSON is a two step JSON unmarshalling
// This workaround is necessary to avoid the inner OpBase.MarshalJSON
// overriding the outer op's MarshalJSON
2019-01-19 21:23:31 +03:00
func (op *CreateOperation) UnmarshalJSON(data []byte) error {
// Unmarshal OpBase and the op separately
base := OpBase{}
err := json.Unmarshal(data, &base)
if err != nil {
return err
}
aux := struct {
Nonce []byte `json:"nonce"`
Title string `json:"title"`
Message string `json:"message"`
Files []repository.Hash `json:"files"`
2019-01-19 21:23:31 +03:00
}{}
err = json.Unmarshal(data, &aux)
if err != nil {
return err
}
op.OpBase = base
op.Nonce = aux.Nonce
2019-01-19 21:23:31 +03:00
op.Title = aux.Title
op.Message = aux.Message
op.Files = aux.Files
return nil
}
2018-12-23 19:11:37 +03:00
// Sign post method for gqlgen
func (op *CreateOperation) IsAuthored() {}
func makeNonce(len int) []byte {
result := make([]byte, len)
_, err := rand.Read(result)
if err != nil {
panic(err)
}
return result
}
func NewCreateOp(author identity.Interface, unixTime int64, title, message string, files []repository.Hash) *CreateOperation {
return &CreateOperation{
OpBase: newOpBase(CreateOp, author, unixTime),
Nonce: makeNonce(20),
2018-07-25 22:25:26 +03:00
Title: title,
Message: message,
Files: files,
2018-07-25 22:25:26 +03:00
}
}
// CreateTimelineItem replace a Create operation in the Timeline and hold its edition history
type CreateTimelineItem struct {
CommentTimelineItem
}
2019-06-23 19:32:22 +03:00
// Sign post method for gqlgen
func (c *CreateTimelineItem) IsAuthored() {}
2018-07-25 22:25:26 +03:00
// Convenience function to apply the operation
2018-11-21 20:56:12 +03:00
func Create(author identity.Interface, unixTime int64, title, message string) (*Bug, *CreateOperation, error) {
return CreateWithFiles(author, unixTime, title, message, nil)
}
func CreateWithFiles(author identity.Interface, unixTime int64, title, message string, files []repository.Hash) (*Bug, *CreateOperation, error) {
newBug := NewBug()
createOp := NewCreateOp(author, unixTime, title, message, files)
if err := createOp.Validate(); err != nil {
return nil, createOp, err
}
newBug.Append(createOp)
return newBug, createOp, nil
}