kopia lustrzana https://github.com/reiver/greatape
289 wiersze
7.1 KiB
Go
289 wiersze
7.1 KiB
Go
package core
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
. "github.com/reiver/greatape/components/contracts"
|
|
. "github.com/reiver/greatape/components/contracts/model"
|
|
"github.com/reiver/greatape/components/model/repository"
|
|
. "github.com/xeronith/diamante/contracts/security"
|
|
)
|
|
|
|
type user struct {
|
|
object
|
|
github string
|
|
}
|
|
|
|
func NewUser(id int64, github string) (IUser, error) {
|
|
instance := &user{
|
|
object: object{
|
|
id: id,
|
|
},
|
|
github: github,
|
|
}
|
|
|
|
if err := instance.Validate(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return instance, nil
|
|
}
|
|
|
|
func NewUserFromEntity(entity IUserEntity) (IUser, error) {
|
|
instance := &user{
|
|
object: object{
|
|
id: entity.Id(),
|
|
},
|
|
github: entity.Github(),
|
|
}
|
|
|
|
if err := instance.Validate(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return instance, nil
|
|
}
|
|
|
|
func (user *user) Github() string {
|
|
return user.github
|
|
}
|
|
|
|
func (user *user) UpdateGithub(github string, editor Identity) {
|
|
if err := repository.Users.UpdateGithub(user.id, github, editor.Id()); err != nil {
|
|
panic(err.Error())
|
|
}
|
|
|
|
user.github = github
|
|
}
|
|
|
|
func (user *user) UpdateGithubAtomic(transaction ITransaction, github string, editor Identity) {
|
|
transaction.OnCommit(func() {
|
|
user.github = github
|
|
})
|
|
|
|
if err := repository.Users.UpdateGithubAtomic(transaction, user.id, github, editor.Id()); err != nil {
|
|
panic(err.Error())
|
|
}
|
|
}
|
|
|
|
func (user *user) Validate() error {
|
|
return nil
|
|
}
|
|
|
|
func (user *user) String() string {
|
|
return fmt.Sprintf("User (Id: %d, Github: %v)", user.Id(), user.Github())
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
type users struct {
|
|
collection Users
|
|
}
|
|
|
|
// NewUsers creates an empty collection of 'User' which is not thread-safe.
|
|
func NewUsers() IUserCollection {
|
|
return &users{
|
|
collection: make(Users, 0),
|
|
}
|
|
}
|
|
|
|
func (users *users) Count() int {
|
|
return len(users.collection)
|
|
}
|
|
|
|
func (users *users) IsEmpty() bool {
|
|
return len(users.collection) == 0
|
|
}
|
|
|
|
func (users *users) IsNotEmpty() bool {
|
|
return len(users.collection) > 0
|
|
}
|
|
|
|
func (users *users) HasExactlyOneItem() bool {
|
|
return len(users.collection) == 1
|
|
}
|
|
|
|
func (users *users) HasAtLeastOneItem() bool {
|
|
return len(users.collection) >= 1
|
|
}
|
|
|
|
func (users *users) First() IUser {
|
|
return users.collection[0]
|
|
}
|
|
|
|
func (users *users) Append(user IUser) {
|
|
users.collection = append(users.collection, user)
|
|
}
|
|
|
|
func (users *users) Reverse() IUserCollection {
|
|
slice := users.collection
|
|
|
|
start := 0
|
|
end := len(slice) - 1
|
|
|
|
for start < end {
|
|
slice[start], slice[end] = slice[end], slice[start]
|
|
start++
|
|
end--
|
|
}
|
|
|
|
users.collection = slice
|
|
|
|
return users
|
|
}
|
|
|
|
func (users *users) ForEach(iterator UserIterator) {
|
|
if iterator == nil {
|
|
return
|
|
}
|
|
|
|
for _, value := range users.collection {
|
|
iterator(value)
|
|
}
|
|
}
|
|
|
|
func (users *users) Array() Users {
|
|
return users.collection
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
func (dispatcher *dispatcher) UserExists(id int64) bool {
|
|
return dispatcher.conductor.UserManager().Exists(id)
|
|
}
|
|
|
|
func (dispatcher *dispatcher) UserExistsWhich(condition UserCondition) bool {
|
|
return dispatcher.conductor.UserManager().ExistsWhich(condition)
|
|
}
|
|
|
|
func (dispatcher *dispatcher) ListUsers() IUserCollection {
|
|
return dispatcher.conductor.UserManager().ListUsers(0, 0, "", dispatcher.identity)
|
|
}
|
|
|
|
func (dispatcher *dispatcher) ForEachUser(iterator UserIterator) {
|
|
dispatcher.conductor.UserManager().ForEach(iterator)
|
|
}
|
|
|
|
func (dispatcher *dispatcher) FilterUsers(predicate UserFilterPredicate) IUserCollection {
|
|
return dispatcher.conductor.UserManager().Filter(predicate)
|
|
}
|
|
|
|
func (dispatcher *dispatcher) MapUsers(predicate UserMapPredicate) IUserCollection {
|
|
return dispatcher.conductor.UserManager().Map(predicate)
|
|
}
|
|
|
|
func (dispatcher *dispatcher) GetUser(id int64) IUser {
|
|
if user, err := dispatcher.conductor.UserManager().GetUser(id, dispatcher.identity); err != nil {
|
|
panic(err.Error())
|
|
} else {
|
|
return user
|
|
}
|
|
}
|
|
|
|
func (dispatcher *dispatcher) AddUser(identityId int64, github string) IUser {
|
|
transaction := dispatcher.transaction
|
|
if transaction != nil {
|
|
if user, err := dispatcher.conductor.UserManager().AddUserAtomic(transaction, identityId, github, dispatcher.identity); err != nil {
|
|
panic(err.Error())
|
|
} else {
|
|
return user
|
|
}
|
|
} else {
|
|
if user, err := dispatcher.conductor.UserManager().AddUser(identityId, github, dispatcher.identity); err != nil {
|
|
panic(err.Error())
|
|
} else {
|
|
return user
|
|
}
|
|
}
|
|
}
|
|
|
|
func (dispatcher *dispatcher) AddUserObject(identity IIdentity, user IUser) IUser {
|
|
transaction := dispatcher.transaction
|
|
if transaction != nil {
|
|
if user, err := dispatcher.conductor.UserManager().AddUserObjectAtomic(transaction, identity.Id(), user, dispatcher.identity); err != nil {
|
|
panic(err.Error())
|
|
} else {
|
|
return user
|
|
}
|
|
} else {
|
|
if user, err := dispatcher.conductor.UserManager().AddUserObject(identity.Id(), user, dispatcher.identity); err != nil {
|
|
panic(err.Error())
|
|
} else {
|
|
return user
|
|
}
|
|
}
|
|
}
|
|
|
|
func (dispatcher *dispatcher) LogUser(identityId int64, github string, source string, payload string) {
|
|
dispatcher.conductor.UserManager().Log(identityId, github, source, dispatcher.identity, payload)
|
|
}
|
|
|
|
func (dispatcher *dispatcher) UpdateUser(id int64, github string) IUser {
|
|
transaction := dispatcher.transaction
|
|
if transaction != nil {
|
|
if user, err := dispatcher.conductor.UserManager().UpdateUserAtomic(transaction, id, github, dispatcher.identity); err != nil {
|
|
panic(err.Error())
|
|
} else {
|
|
return user
|
|
}
|
|
} else {
|
|
if user, err := dispatcher.conductor.UserManager().UpdateUser(id, github, dispatcher.identity); err != nil {
|
|
panic(err.Error())
|
|
} else {
|
|
return user
|
|
}
|
|
}
|
|
}
|
|
|
|
// noinspection GoUnusedParameter
|
|
func (dispatcher *dispatcher) UpdateUserObject(object IObject, user IUser) IUser {
|
|
transaction := dispatcher.transaction
|
|
if transaction != nil {
|
|
if user, err := dispatcher.conductor.UserManager().UpdateUserAtomic(transaction, object.Id(), user.Github(), dispatcher.identity); err != nil {
|
|
panic(err.Error())
|
|
} else {
|
|
return user
|
|
}
|
|
} else {
|
|
if user, err := dispatcher.conductor.UserManager().UpdateUser(object.Id(), user.Github(), dispatcher.identity); err != nil {
|
|
panic(err.Error())
|
|
} else {
|
|
return user
|
|
}
|
|
}
|
|
}
|
|
|
|
func (dispatcher *dispatcher) AddOrUpdateUserObject(object IObject, user IUser) IUser {
|
|
transaction := dispatcher.transaction
|
|
if transaction != nil {
|
|
if user, err := dispatcher.conductor.UserManager().AddOrUpdateUserObjectAtomic(transaction, object.Id(), user, dispatcher.identity); err != nil {
|
|
panic(err.Error())
|
|
} else {
|
|
return user
|
|
}
|
|
} else {
|
|
if user, err := dispatcher.conductor.UserManager().AddOrUpdateUserObject(object.Id(), user, dispatcher.identity); err != nil {
|
|
panic(err.Error())
|
|
} else {
|
|
return user
|
|
}
|
|
}
|
|
}
|
|
|
|
func (dispatcher *dispatcher) RemoveUser(id int64) IUser {
|
|
transaction := dispatcher.transaction
|
|
if transaction != nil {
|
|
if user, err := dispatcher.conductor.UserManager().RemoveUserAtomic(transaction, id, dispatcher.identity); err != nil {
|
|
panic(err.Error())
|
|
} else {
|
|
return user
|
|
}
|
|
} else {
|
|
if user, err := dispatcher.conductor.UserManager().RemoveUser(id, dispatcher.identity); err != nil {
|
|
panic(err.Error())
|
|
} else {
|
|
return user
|
|
}
|
|
}
|
|
}
|