The mår bestest UI ever

11 |

12 | 13 |

14 | 15 |

16 | 19 |

20 |

21 | 22 |

23 | {{template "mainContent" .}} 24 | 26 |

27 | 28 | {{end}} 29 | -------------------------------------------------------------------------------- /CQRSGui/pages/changename.html: -------------------------------------------------------------------------------- 1 | {{define "title"}}Change Name{{end}} 2 | 3 | {{define "mainContent"}} 4 |

Change Name

5 | 14 | {{end}} 15 | -------------------------------------------------------------------------------- /CQRSGui/pages/checkin.html: -------------------------------------------------------------------------------- 1 | {{define "title"}}Check in{{end}} 2 | 3 | {{define "mainContent"}} 4 |

Check in

5 | 12 | {{end}} 13 | -------------------------------------------------------------------------------- /CQRSGui/pages/deactivate.html: -------------------------------------------------------------------------------- 1 | <%@ Page Title="" Language="C#" Inherits="System.Web.Mvc.ViewPage" MasterPageFile="~/Views/Shared/Site.Master" %> 2 | 3 | 4 | <% using (Html.BeginForm()) 5 | {%> 6 | <%: Html.Hidden("Id",Model.Id) %> 7 | <%: Html.Hidden("Version",Model.Version) %> 8 | Deactivate "<%: Model.Name %>" (Version: <%: Model.Version %>)? 9 | 10 | 11 | <% 12 | }%> 13 | 14 | 15 | 16 | {{define "title"}}Deactivate{{end}} 17 | 18 | {{define "mainContent"}} 19 |

Deactivate

20 | 26 | {{end}} 27 | -------------------------------------------------------------------------------- /CQRSGui/pages/details.html: -------------------------------------------------------------------------------- 1 | {{define "title"}}Details{{end}} 2 | 3 | {{define "mainContent"}} 4 |

Details:

5 | Id: {{.Model.Id}}
6 | Name: {{.Model.Name}}
7 | Count: {{.Model.CurrentCount }}

8 | 9 | Rename
10 | Deactivate
11 | Check in
12 | Remove
13 | 14 | {{end}} 15 | -------------------------------------------------------------------------------- /CQRSGui/pages/index.html: -------------------------------------------------------------------------------- 1 | {{define "title"}}Home Page{{end}} 2 | {{define "mainContent"}} 3 |

All items:

4 | 5 | 6 |

Name: {{.Name}}

11 | 12 | Add 13 | 14 | {{end}} 15 | -------------------------------------------------------------------------------- /CQRSGui/pages/remove.html: -------------------------------------------------------------------------------- 1 | {{define "title"}}Remove{{end}} 2 | 3 | {{define "mainContent"}} 4 |

Remove

5 | 12 | {{end}} 13 | -------------------------------------------------------------------------------- /CQRSGui/pages/view.html: -------------------------------------------------------------------------------- 1 |

2 | 3 |

[edit]

4 | 5 |

6 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 Andrew Dodd 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Golang m-r 2 | 3 | A golang port of Greg Young's [Simple CQRS example](https://github.com/gregoryyoung/m-r) 4 | 5 | Run: 6 | 7 | > go run CQRSGui/main.go 8 | 9 | Edit [here](https://github.com/andrewdodd/m-r/blob/028152c4c04fe2d04ea242443f92608de6f482cb/CQRSGui/main.go#L332) to induce some eventual consistency. 10 | 11 | I have explained some of the choices in these blog posts: 12 | 13 | * [SimpleCQRS Golang Port](http://adodd.net/post/simple-cqrs-golang-port/) 14 | * [Updating the SimpleCQRS Golang port](http://adodd.net/post/updating-simple-cqrs-golang-port/) 15 | -------------------------------------------------------------------------------- /SimpleCQRS/CommandHandlers.go: -------------------------------------------------------------------------------- 1 | package SimpleCQRS 2 | 3 | import ( 4 | "time" 5 | ) 6 | 7 | type InventoryCommandHandlers struct { 8 | repo InventoryItemRepository 9 | } 10 | 11 | func NewInventoryCommandHandlers(repo InventoryItemRepository) InventoryCommandHandlers { 12 | return InventoryCommandHandlers{repo} 13 | } 14 | 15 | func (r *InventoryCommandHandlers) HandleCreateInventoryItem(m Command) error { 16 | message := m.(CreateInventoryItem) 17 | item := NewInventoryItem(message.InventoryItemId, message.Name) 18 | return r.repo.Save(item, -1) 19 | } 20 | 21 | func (r *InventoryCommandHandlers) HandleDeactivateInventoryItem(m Command) error { 22 | message := m.(DeactivateInventoryItem) 23 | ar, _ := r.repo.GetById(message.InventoryItemId) 24 | item := ar.(*InventoryItem) 25 | err := item.Deactivate() 26 | if err != nil { 27 | return err 28 | } 29 | return r.repo.Save(item, message.OriginalVersion) 30 | } 31 | 32 | func (r *InventoryCommandHandlers) HandleRemoveItemsFromInventory(m Command) error { 33 | message := m.(RemoveItemsFromInventory) 34 | ar, _ := r.repo.GetById(message.InventoryItemId) 35 | item := ar.(*InventoryItem) 36 | err := item.Remove(message.Count) 37 | if err != nil { 38 | return err 39 | } 40 | return r.repo.Save(item, message.OriginalVersion) 41 | } 42 | 43 | func (r *InventoryCommandHandlers) HandleCheckInItemsToInventory(m Command) error { 44 | message := m.(CheckInItemsToInventory) 45 | ar, _ := r.repo.GetById(message.InventoryItemId) 46 | item := ar.(*InventoryItem) 47 | err := item.CheckIn(message.Count) 48 | if err != nil { 49 | return err 50 | } 51 | return r.repo.Save(item, message.OriginalVersion) 52 | } 53 | 54 | func (r *InventoryCommandHandlers) HandleRenameInventoryItem(m Command) error { 55 | message := m.(RenameInventoryItem) 56 | ar, _ := r.repo.GetById(message.InventoryItemId) 57 | item := ar.(*InventoryItem) 58 | //time.Sleep(10 * time.Second) // Name changes take ages, not sure why 59 | time.Sleep(2 * time.Millisecond) // This is short enough to be handled before my next HTTP request (i.e. it "looks" synchronous) 60 | err := item.ChangeName(message.NewName) 61 | if err != nil { 62 | return err 63 | } 64 | return r.repo.Save(item, message.OriginalVersion) 65 | } 66 | -------------------------------------------------------------------------------- /SimpleCQRS/Domain.go: -------------------------------------------------------------------------------- 1 | package SimpleCQRS 2 | 3 | import ( 4 | "errors" 5 | ) 6 | 7 | type Guid string 8 | 9 | type AggregateRoot interface { 10 | Id() Guid 11 | GetUncommittedChanges() []Event 12 | MarkChangesAsCommitted() 13 | LoadsFromHistory(history []Event) error 14 | ApplyChange(e Event) error 15 | } 16 | 17 | type AggRoot struct { 18 | changes []Event 19 | _version int 20 | id Guid 21 | InnerApply func(e Event) error // Needs public scope 22 | } 23 | 24 | func NewEmptyAggRoot() AggRoot { 25 | ag := AggRoot{ 26 | changes: make([]Event, 0), 27 | } 28 | return ag 29 | } 30 | 31 | func (ag *AggRoot) Id() Guid { 32 | return ag.id 33 | } 34 | 35 | func (ag *AggRoot) Version() int { 36 | return ag._version 37 | } 38 | 39 | func (ag *AggRoot) version(v int) { 40 | ag._version = v 41 | } 42 | 43 | func (ag *AggRoot) GetUncommittedChanges() []Event { 44 | return ag.changes 45 | } 46 | func (ag *AggRoot) MarkChangesAsCommitted() { 47 | ag.changes = make([]Event, 0) 48 | } 49 | 50 | func (ag *AggRoot) LoadsFromHistory(history []Event) error { 51 | for _, e := range history { 52 | err := ag.applyChangeInternal(e, false) 53 | if err != nil { 54 | return err 55 | } 56 | } 57 | return nil 58 | } 59 | 60 | func (ag *AggRoot) ApplyChange(e Event) error { 61 | return ag.applyChangeInternal(e, true) 62 | } 63 | 64 | // push atomic aggregate changes to local history for further processing (EventStore.SaveEvents) 65 | func (ag *AggRoot) applyChangeInternal(e Event, isNew bool) error { 66 | err := ag.InnerApply(e) 67 | if err != nil { 68 | return err 69 | } 70 | if isNew { 71 | ag.changes = append(ag.changes, e) 72 | } 73 | return nil 74 | } 75 | 76 | type InventoryItem struct { 77 | AggRoot 78 | activated bool 79 | } 80 | 81 | // used to create in repository ... many ways to avoid this, eg making private constructor 82 | func NewEmptyInventoryItem() *InventoryItem { 83 | i := &(InventoryItem{ 84 | AggRoot: NewEmptyAggRoot(), 85 | }) 86 | i.AggRoot.InnerApply = i.handleEvent 87 | return i 88 | } 89 | 90 | func NewInventoryItem(id Guid, name string) *InventoryItem { 91 | i := NewEmptyInventoryItem() 92 | i.ApplyChange(NewInventoryItemCreated(id, name)) 93 | return i 94 | } 95 | 96 | func (ii *InventoryItem) ChangeName(newName string) error { 97 | if newName == "" { 98 | return errors.New("newName cannot be empty") 99 | } 100 | ii.ApplyChange(NewInventoryItemRenamed(ii.id, newName)) 101 | return nil 102 | } 103 | 104 | func (ii *InventoryItem) Remove(count int) error { 105 | if count <= 0 { 106 | return errors.New("cannot remove negative count from inventory") 107 | } 108 | ii.ApplyChange(NewItemsRemovedFromInventory(ii.id, count)) 109 | return nil 110 | } 111 | 112 | func (ii *InventoryItem) CheckIn(count int) error { 113 | if count <= 0 { 114 | return errors.New("must have a count greater than 0 to add to inventory") 115 | } 116 | ii.ApplyChange(NewItemsCheckedInToInventory(ii.id, count)) 117 | return nil 118 | } 119 | 120 | func (ii *InventoryItem) Deactivate() error { 121 | if !ii.activated { 122 | return errors.New("already deactivated") 123 | } 124 | ii.ApplyChange(NewInventoryItemDeactivated(ii.id)) 125 | return nil 126 | } 127 | 128 | func (ii *InventoryItem) handleEvent(event Event) error { 129 | switch e := event.(type) { 130 | case InventoryItemCreated: 131 | ii.id = e.Id() 132 | ii.activated = true 133 | case InventoryItemDeactivated: 134 | ii.activated = false 135 | } 136 | return nil 137 | } 138 | 139 | type Repository interface { 140 | Save(ar AggregateRoot, expectedVersion int) error 141 | GetById(id Guid) (AggregateRoot, error) 142 | } 143 | 144 | type InventoryItemRepository struct { 145 | Storage EventStore 146 | } 147 | 148 | func (repo *InventoryItemRepository) Save(ar AggregateRoot, expectedVersion int) error { 149 | return repo.Storage.SaveEvents(ar.Id(), 150 | ar.GetUncommittedChanges(), 151 | expectedVersion) 152 | } 153 | 154 | func (repo *InventoryItemRepository) GetById(id Guid) (AggregateRoot, error) { 155 | obj := NewEmptyInventoryItem() 156 | events, err := repo.Storage.GetEventsForAggregate(id) 157 | if err != nil { 158 | return obj, err 159 | } 160 | obj.LoadsFromHistory(events) 161 | return obj, err 162 | } 163 | -------------------------------------------------------------------------------- /SimpleCQRS/EventStore.go: -------------------------------------------------------------------------------- 1 | package SimpleCQRS 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | type EventStore interface { 8 | SaveEvents(aggregateId Guid, events []Event, expectedVersion int) error 9 | GetEventsForAggregate(aggregateId Guid) ([]Event, error) 10 | } 11 | 12 | type es struct { 13 | publisher EventPublisher 14 | current map[Guid][]EventDescriptor 15 | } 16 | 17 | func NewEventStore(p EventPublisher) EventStore { 18 | return &es{p, make(map[Guid][]EventDescriptor)} 19 | } 20 | 21 | type EventDescriptor struct { 22 | data Event 23 | id Guid 24 | version int 25 | } 26 | 27 | func (e *es) SaveEvents(aggregateId Guid, events []Event, expectedVersion int) error { 28 | eventDescriptors, ok := e.current[aggregateId] 29 | 30 | if !ok { 31 | eventDescriptors = make([]EventDescriptor, 0) 32 | e.current[aggregateId] = eventDescriptors 33 | } else if expectedVersion != -1 { 34 | lastEvent := eventDescriptors[len(eventDescriptors)-1] 35 | if lastEvent.data.Version() != expectedVersion { 36 | return fmt.Errorf("concurrency error, expected version %v, but found %v", expectedVersion, lastEvent.data.Version()) 37 | } 38 | } 39 | 40 | i := expectedVersion 41 | 42 | // iterate through current aggregate events increasing version with each processed even 43 | for _, event := range events { 44 | i++ 45 | event.SaveVersion(i) 46 | 47 | ed := EventDescriptor{data: event, id: aggregateId, version: i} 48 | // push event to the event descriptors list for current aggregate 49 | eventDescriptors = append(eventDescriptors, ed) 50 | 51 | // publish current event to the bus for further processing by subscribers 52 | e.publisher.Publish(event) 53 | } 54 | e.current[aggregateId] = eventDescriptors 55 | 56 | return nil 57 | } 58 | 59 | // collect all processed events for given aggregate and return them as a list 60 | // used to build up an aggregate from its history (Domain.LoadsFromHistory) 61 | func (e *es) GetEventsForAggregate(aggregateId Guid) ([]Event, error) { 62 | eventDescriptors, ok := e.current[aggregateId] 63 | 64 | if !ok { 65 | return nil, fmt.Errorf("aggregate not found for id: %v", aggregateId) 66 | } 67 | events := make([]Event, len(eventDescriptors)) 68 | 69 | for i, ed := range eventDescriptors { 70 | events[i] = ed.data 71 | } 72 | 73 | return events, nil 74 | } 75 | -------------------------------------------------------------------------------- /SimpleCQRS/Events.go: -------------------------------------------------------------------------------- 1 | package SimpleCQRS 2 | 3 | type Event interface { 4 | Version() int 5 | SaveVersion(v int) 6 | } 7 | 8 | type BaseEvent struct { 9 | version int 10 | } 11 | 12 | func (e *BaseEvent) Version() int { 13 | return e.version 14 | } 15 | 16 | func (e *BaseEvent) SaveVersion(v int) { 17 | e.version = v 18 | } 19 | 20 | type InventoryItemCreated struct { 21 | *BaseEvent 22 | id Guid 23 | name string 24 | } 25 | 26 | func NewInventoryItemCreated(id Guid, name string) InventoryItemCreated { 27 | be := BaseEvent{} 28 | return InventoryItemCreated{id: id, name: name, BaseEvent: &be} 29 | } 30 | func (o InventoryItemCreated) Id() Guid { 31 | return o.id 32 | } 33 | func (o InventoryItemCreated) Name() string { 34 | return o.name 35 | } 36 | 37 | type InventoryItemDeactivated struct { 38 | *BaseEvent 39 | id Guid 40 | } 41 | 42 | func NewInventoryItemDeactivated(id Guid) InventoryItemDeactivated { 43 | be := BaseEvent{} 44 | return InventoryItemDeactivated{id: id, BaseEvent: &be} 45 | } 46 | func (o InventoryItemDeactivated) Id() Guid { 47 | return o.id 48 | } 49 | 50 | type InventoryItemRenamed struct { 51 | *BaseEvent 52 | id Guid 53 | newName string 54 | } 55 | 56 | func NewInventoryItemRenamed(id Guid, newName string) InventoryItemRenamed { 57 | be := BaseEvent{} 58 | return InventoryItemRenamed{id: id, newName: newName, BaseEvent: &be} 59 | } 60 | func (o InventoryItemRenamed) Id() Guid { 61 | return o.id 62 | } 63 | func (o InventoryItemRenamed) NewName() string { 64 | return o.newName 65 | } 66 | 67 | type ItemsCheckedInToInventory struct { 68 | *BaseEvent 69 | id Guid 70 | count int 71 | } 72 | 73 | func NewItemsCheckedInToInventory(id Guid, count int) ItemsCheckedInToInventory { 74 | be := BaseEvent{} 75 | return ItemsCheckedInToInventory{id: id, count: count, BaseEvent: &be} 76 | } 77 | func (o ItemsCheckedInToInventory) Id() Guid { 78 | return o.id 79 | } 80 | func (o ItemsCheckedInToInventory) Count() int { 81 | return o.count 82 | } 83 | 84 | type ItemsRemovedFromInventory struct { 85 | *BaseEvent 86 | id Guid 87 | count int 88 | } 89 | 90 | func NewItemsRemovedFromInventory(id Guid, count int) ItemsRemovedFromInventory { 91 | be := BaseEvent{} 92 | return ItemsRemovedFromInventory{id: id, count: count, BaseEvent: &be} 93 | } 94 | func (o ItemsRemovedFromInventory) Id() Guid { 95 | return o.id 96 | } 97 | func (o ItemsRemovedFromInventory) Count() int { 98 | return o.count 99 | } 100 | -------------------------------------------------------------------------------- /SimpleCQRS/FakeBus.go: -------------------------------------------------------------------------------- 1 | package SimpleCQRS 2 | 3 | import ( 4 | "errors" 5 | "fmt" 6 | "math/rand" 7 | "reflect" 8 | "time" 9 | ) 10 | 11 | type CommandHandler func(cmd Command) error 12 | type EventProcessor func(cmd Event) error 13 | 14 | type FakeBus struct { 15 | commandQueue chan queuedCommand 16 | commandHandlers map[reflect.Type]CommandHandler 17 | eventProcessors map[reflect.Type][]EventProcessor 18 | induceDelay bool 19 | } 20 | 21 | type queuedCommand struct { 22 | cmd Command 23 | synchronousResponse chan CommandProcessingError 24 | } 25 | 26 | func NewFakeBus(induceDelay bool) *FakeBus { 27 | fb := &FakeBus{ 28 | commandQueue: make(chan queuedCommand), 29 | commandHandlers: make(map[reflect.Type]CommandHandler), 30 | eventProcessors: make(map[reflect.Type][]EventProcessor), 31 | induceDelay: induceDelay, 32 | } 33 | 34 | go fb.processCommands() 35 | return fb 36 | } 37 | 38 | func (fb *FakeBus) processCommands() { 39 | for { 40 | select { 41 | case cmdReq := <-fb.commandQueue: 42 | cmd := cmdReq.cmd 43 | fmt.Println("Processing command:", cmd) 44 | resp := cmdReq.synchronousResponse 45 | handler, _ := fb.commandHandlers[reflect.TypeOf(cmd)] 46 | 47 | if fb.induceDelay { 48 | time.Sleep(time.Duration(1+rand.Intn(3)) * time.Second) // Have possible command race conditions too 49 | } 50 | 51 | result := handler(cmd) 52 | fmt.Println("Processed command, result:", result) 53 | select { 54 | case resp <- result: 55 | default: 56 | } 57 | } 58 | } 59 | } 60 | 61 | func (fb *FakeBus) SetCommandHandler(cmdType reflect.Type, handler CommandHandler) error { 62 | if _, ok := fb.commandHandlers[cmdType]; ok { 63 | return errors.New("command handler already registered") 64 | } 65 | fb.commandHandlers[cmdType] = handler 66 | return nil 67 | } 68 | 69 | func (fb *FakeBus) AddEventProcessor(eventType reflect.Type, processor EventProcessor) error { 70 | processors, ok := fb.eventProcessors[eventType] 71 | if !ok { 72 | processors = make([]EventProcessor, 0) 73 | } 74 | for _, p := range processors { 75 | if reflect.DeepEqual(p, processor) { 76 | return errors.New("processor already registered") 77 | } 78 | } 79 | processors = append(processors, processor) 80 | fb.eventProcessors[eventType] = processors 81 | return nil 82 | } 83 | 84 | func (fb *FakeBus) Dispatch(cmd Command, syncResp chan CommandProcessingError) CommandSubmissionError { 85 | if _, ok := fb.commandHandlers[reflect.TypeOf(cmd)]; ok { 86 | fmt.Println("Queuing command:", cmd) 87 | fb.commandQueue <- queuedCommand{cmd, syncResp} 88 | return nil 89 | } 90 | return errors.New("no handler registered") 91 | } 92 | 93 | func (fb *FakeBus) Publish(evt Event) error { 94 | if processors, ok := fb.eventProcessors[reflect.TypeOf(evt)]; ok { 95 | for _, processor := range processors { 96 | go func(p EventProcessor) { 97 | if fb.induceDelay { 98 | time.Sleep(time.Duration(rand.Intn(10)) * time.Second) // Have a variable degree of eventual consistency 99 | } 100 | p(evt) 101 | }(processor) 102 | } 103 | return nil 104 | } 105 | return errors.New("no processor registered") 106 | } 107 | 108 | type CommandProcessingError error 109 | type CommandSubmissionError error 110 | 111 | type CommandDispatcher interface { 112 | Dispatch(e Command, 113 | synchronousResponse chan CommandProcessingError) CommandSubmissionError 114 | } 115 | 116 | type EventPublisher interface { 117 | Publish(e Event) error 118 | } 119 | -------------------------------------------------------------------------------- /SimpleCQRS/ReadModel.go: -------------------------------------------------------------------------------- 1 | package SimpleCQRS 2 | 3 | import ( 4 | "errors" 5 | "sync" 6 | ) 7 | 8 | type InventoryItemDetailsDto struct { 9 | Id Guid 10 | Name string 11 | CurrentCount int 12 | Version int 13 | } 14 | 15 | type InventoryItemListDto struct { 16 | Id Guid 17 | Name string 18 | } 19 | 20 | type BSDB struct { 21 | list []InventoryItemListDto 22 | details map[Guid]InventoryItemDetailsDto 23 | s sync.RWMutex 24 | } 25 | 26 | func NewBSDB() BSDB { 27 | return BSDB{list: make([]InventoryItemListDto, 0), details: make(map[Guid]InventoryItemDetailsDto)} 28 | } 29 | 30 | type ReadModel interface { 31 | GetInventoryItems() []InventoryItemListDto 32 | GetInventoryItemDetails(id Guid) (InventoryItemDetailsDto, error) 33 | } 34 | 35 | type InventoryItemDetailView struct { 36 | db *BSDB 37 | } 38 | 39 | func NewInventoryItemDetailView(bsdb *BSDB) InventoryItemDetailView { 40 | return InventoryItemDetailView{bsdb} 41 | } 42 | 43 | func (detail *InventoryItemDetailView) ProcessInventoryItemCreated(e Event) error { 44 | evt, ok := e.(InventoryItemCreated) 45 | if !ok { 46 | return errors.New("passed incorrect event") 47 | } 48 | detail.db.s.Lock() 49 | defer detail.db.s.Unlock() 50 | 51 | detail.db.details[evt.Id()] = InventoryItemDetailsDto{evt.Id(), evt.Name(), 0, 0} 52 | return nil 53 | } 54 | func (detail *InventoryItemDetailView) ProcessInventoryItemDeactivated(e Event) error { 55 | evt, ok := e.(InventoryItemDeactivated) 56 | if !ok { 57 | return errors.New("passed incorrect event") 58 | } 59 | detail.db.s.Lock() 60 | defer detail.db.s.Unlock() 61 | 62 | delete(detail.db.details, evt.Id()) 63 | return nil 64 | } 65 | func (detail *InventoryItemDetailView) ProcessInventoryItemRenamed(e Event) error { 66 | evt, ok := e.(InventoryItemRenamed) 67 | if !ok { 68 | return errors.New("passed incorrect event") 69 | } 70 | detail.db.s.Lock() 71 | defer detail.db.s.Unlock() 72 | 73 | original, ok := detail.db.details[evt.Id()] 74 | if !ok { 75 | return errors.New("this should never happen") 76 | } 77 | original.Name = evt.NewName() 78 | original.Version = evt.Version() 79 | detail.db.details[evt.Id()] = original 80 | return nil 81 | } 82 | func (detail *InventoryItemDetailView) ProcessItemsCheckedInToInventory(e Event) error { 83 | evt, ok := e.(ItemsCheckedInToInventory) 84 | if !ok { 85 | return errors.New("passed incorrect event") 86 | } 87 | detail.db.s.Lock() 88 | defer detail.db.s.Unlock() 89 | 90 | original, ok := detail.db.details[evt.Id()] 91 | if !ok { 92 | return errors.New("this should never happen") 93 | } 94 | original.CurrentCount += evt.Count() 95 | original.Version = evt.Version() 96 | detail.db.details[evt.Id()] = original 97 | return nil 98 | } 99 | func (detail *InventoryItemDetailView) ProcessItemsRemovedFromInventory(e Event) error { 100 | evt, ok := e.(ItemsRemovedFromInventory) 101 | if !ok { 102 | return errors.New("passed incorrect event") 103 | } 104 | detail.db.s.Lock() 105 | defer detail.db.s.Unlock() 106 | 107 | original, ok := detail.db.details[evt.Id()] 108 | if !ok { 109 | return errors.New("this should never happen") 110 | } 111 | original.CurrentCount -= evt.Count() 112 | original.Version = evt.Version() 113 | detail.db.details[evt.Id()] = original 114 | return nil 115 | } 116 | 117 | type InventoryItemListView struct { 118 | db *BSDB 119 | } 120 | 121 | func NewInventoryListView(bsdb *BSDB) InventoryItemListView { 122 | return InventoryItemListView{bsdb} 123 | } 124 | func (list *InventoryItemListView) ProcessInventoryItemCreated(e Event) error { 125 | evt, ok := e.(InventoryItemCreated) 126 | if !ok { 127 | return errors.New("passed incorrect event") 128 | } 129 | list.db.s.Lock() 130 | defer list.db.s.Unlock() 131 | 132 | list.db.list = append(list.db.list, InventoryItemListDto{evt.Id(), evt.Name()}) 133 | return nil 134 | } 135 | 136 | func (list *InventoryItemListView) ProcessInventoryItemRenamed(e Event) error { 137 | evt, ok := e.(InventoryItemRenamed) 138 | if !ok { 139 | return errors.New("passed incorrect event") 140 | } 141 | list.db.s.Lock() 142 | defer list.db.s.Unlock() 143 | 144 | for i, item := range list.db.list { 145 | if evt.Id() == item.Id { 146 | list.db.list[i] = InventoryItemListDto{evt.Id(), evt.NewName()} 147 | } 148 | } 149 | return nil 150 | } 151 | 152 | func (list *InventoryItemListView) ProcessInventoryItemDeactivated(e Event) error { 153 | evt, ok := e.(InventoryItemDeactivated) 154 | if !ok { 155 | return errors.New("passed incorrect event") 156 | } 157 | list.db.s.Lock() 158 | defer list.db.s.Unlock() 159 | 160 | newList := make([]InventoryItemListDto, 0) 161 | for _, item := range list.db.list { 162 | if evt.Id() != item.Id { 163 | newList = append(newList, item) 164 | } 165 | } 166 | list.db.list = newList 167 | return nil 168 | } 169 | 170 | type ReadModelFacade struct { 171 | db *BSDB 172 | } 173 | 174 | func NewReadModelFacade(db *BSDB) ReadModelFacade { 175 | return ReadModelFacade{db} 176 | } 177 | 178 | func (rmf *ReadModelFacade) GetInventoryItems() []InventoryItemListDto { 179 | rmf.db.s.RLock() 180 | defer rmf.db.s.RUnlock() 181 | 182 | tmp := make([]InventoryItemListDto, len(rmf.db.list)) 183 | copy(tmp, rmf.db.list) 184 | return tmp 185 | } 186 | 187 | func (rmf *ReadModelFacade) GetInventoryItemDetails(id Guid) (InventoryItemDetailsDto, error) { 188 | rmf.db.s.RLock() 189 | defer rmf.db.s.RUnlock() 190 | 191 | item, ok := rmf.db.details[id] 192 | if !ok { 193 | return item, errors.New("No item") 194 | } 195 | return item, nil 196 | } 197 | -------------------------------------------------------------------------------- /SimpleCQRS/commands.go: -------------------------------------------------------------------------------- 1 | package SimpleCQRS 2 | 3 | type Command interface{} 4 | 5 | type DeactivateInventoryItem struct { 6 | InventoryItemId Guid 7 | OriginalVersion int 8 | } 9 | 10 | type CreateInventoryItem struct { 11 | InventoryItemId Guid 12 | Name string 13 | } 14 | 15 | type RenameInventoryItem struct { 16 | InventoryItemId Guid 17 | OriginalVersion int 18 | NewName string 19 | } 20 | type CheckInItemsToInventory struct { 21 | InventoryItemId Guid 22 | OriginalVersion int 23 | Count int 24 | } 25 | 26 | type RemoveItemsFromInventory struct { 27 | InventoryItemId Guid 28 | OriginalVersion int 29 | Count int 30 | } 31 | -------------------------------------------------------------------------------- /SimpleCQRS/guid.go: -------------------------------------------------------------------------------- 1 | package SimpleCQRS 2 | 3 | import ( 4 | "fmt" 5 | "os" 6 | ) 7 | 8 | func NewGuid() Guid { 9 | f, _ := os.Open("/dev/urandom") 10 | b := make([]byte, 16) 11 | f.Read(b) 12 | f.Close() 13 | uuid := fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:]) 14 | return Guid(uuid) 15 | } 16 | -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | module SimpleCQRS 2 | 3 | require ( 4 | github.com/gorilla/mux v1.6.2 // indirect 5 | github.com/julienschmidt/httprouter v1.2.0 // indirect 6 | ) 7 | -------------------------------------------------------------------------------- /go.sum: -------------------------------------------------------------------------------- 1 | github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= 2 | github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= 3 | --------------------------------------------------------------------------------

Add