kopia lustrzana https://github.com/reiver/greatape
253 wiersze
7.6 KiB
Go
253 wiersze
7.6 KiB
Go
package core
|
|
|
|
import (
|
|
. "github.com/reiver/greatape/components/constants"
|
|
. "github.com/reiver/greatape/components/contracts"
|
|
. "github.com/reiver/greatape/components/contracts/model"
|
|
. "github.com/reiver/greatape/components/model/entity"
|
|
"github.com/reiver/greatape/components/model/repository"
|
|
. "github.com/xeronith/diamante/contracts/logging"
|
|
. "github.com/xeronith/diamante/contracts/security"
|
|
. "github.com/xeronith/diamante/contracts/settings"
|
|
. "github.com/xeronith/diamante/contracts/system"
|
|
. "github.com/xeronith/diamante/system"
|
|
)
|
|
|
|
// noinspection GoSnakeCaseUsage
|
|
const USER_MANAGER = "UserManager"
|
|
|
|
type userManager struct {
|
|
systemComponent
|
|
cache ICache
|
|
}
|
|
|
|
func newUserManager(configuration IConfiguration, logger ILogger, dependencies ...ISystemComponent) IUserManager {
|
|
manager := &userManager{
|
|
systemComponent: newSystemComponent(configuration, logger),
|
|
cache: NewCache(),
|
|
}
|
|
|
|
if err := manager.ResolveDependencies(dependencies...); err != nil {
|
|
return nil
|
|
}
|
|
|
|
return manager
|
|
}
|
|
|
|
func (manager *userManager) Name() string {
|
|
return USER_MANAGER
|
|
}
|
|
|
|
func (manager *userManager) ResolveDependencies(_ ...ISystemComponent) error {
|
|
return nil
|
|
}
|
|
|
|
func (manager *userManager) Load() error {
|
|
userEntities, err := repository.Users.FetchAll()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
users := make(SystemObjectCache)
|
|
for _, userEntity := range userEntities {
|
|
if user, err := NewUserFromEntity(userEntity); err == nil {
|
|
users[user.Id()] = user
|
|
} else {
|
|
return err
|
|
}
|
|
}
|
|
|
|
manager.cache.Load(users)
|
|
return nil
|
|
}
|
|
|
|
func (manager *userManager) Reload() error {
|
|
return manager.Load()
|
|
}
|
|
|
|
func (manager *userManager) OnCacheChanged(callback UserCacheCallback) {
|
|
manager.cache.OnChanged(callback)
|
|
}
|
|
|
|
func (manager *userManager) Count() int {
|
|
return manager.cache.Size()
|
|
}
|
|
|
|
func (manager *userManager) Exists(id int64) bool {
|
|
return manager.Find(id) != nil
|
|
}
|
|
|
|
func (manager *userManager) ExistsWhich(condition UserCondition) bool {
|
|
var users Users
|
|
manager.ForEach(func(user IUser) {
|
|
if condition(user) {
|
|
users = append(users, user)
|
|
}
|
|
})
|
|
|
|
return len(users) > 0
|
|
}
|
|
|
|
func (manager *userManager) ListUsers(_ /* pageIndex */ uint32, _ /* pageSize */ uint32, _ /* criteria */ string, _ Identity) IUserCollection {
|
|
return manager.Filter(UserPassThroughFilter)
|
|
}
|
|
|
|
func (manager *userManager) GetUser(id int64, _ Identity) (IUser, error) {
|
|
if user := manager.Find(id); user == nil {
|
|
return nil, ERROR_USER_NOT_FOUND
|
|
} else {
|
|
return user, nil
|
|
}
|
|
}
|
|
|
|
func (manager *userManager) AddUser(identityId int64, github string, editor Identity) (IUser, error) {
|
|
userEntity := NewUserEntity(identityId, github)
|
|
return manager.Apply(userEntity, repository.Users.Add, manager.cache.Put, editor)
|
|
}
|
|
|
|
func (manager *userManager) AddUserObject(identityId int64, user IUser, editor Identity) (IUser, error) {
|
|
userEntity := NewUserEntity(identityId, user.Github())
|
|
return manager.Apply(userEntity, repository.Users.Add, manager.cache.Put, editor)
|
|
}
|
|
|
|
func (manager *userManager) AddUserAtomic(transaction ITransaction, identityId int64, github string, editor Identity) (IUser, error) {
|
|
userEntity := NewUserEntity(identityId, github)
|
|
return manager.ApplyAtomic(transaction, userEntity, repository.Users.AddAtomic, manager.cache.Put, editor)
|
|
}
|
|
|
|
func (manager *userManager) AddUserObjectAtomic(transaction ITransaction, identityId int64, user IUser, editor Identity) (IUser, error) {
|
|
userEntity := NewUserEntity(identityId, user.Github())
|
|
return manager.ApplyAtomic(transaction, userEntity, repository.Users.AddAtomic, manager.cache.Put, editor)
|
|
}
|
|
|
|
func (manager *userManager) Log(identityId int64, github string, source string, editor Identity, payload string) {
|
|
userPipeEntity := NewUserPipeEntity(identityId, github, source, editor.Id(), payload)
|
|
repository.Pipe.Insert(userPipeEntity)
|
|
|
|
user, err := NewUserFromEntity(userPipeEntity)
|
|
if err != nil {
|
|
manager.Logger().Error(err)
|
|
} else {
|
|
manager.cache.Put(user.Id(), user)
|
|
}
|
|
}
|
|
|
|
func (manager *userManager) UpdateUser(id int64, github string, editor Identity) (IUser, error) {
|
|
userEntity := NewUserEntity(id, github)
|
|
return manager.Apply(userEntity, repository.Users.Update, manager.cache.Put, editor)
|
|
}
|
|
|
|
func (manager *userManager) UpdateUserObject(id int64, user IUser, editor Identity) (IUser, error) {
|
|
userEntity := NewUserEntity(id, user.Github())
|
|
return manager.Apply(userEntity, repository.Users.Update, manager.cache.Put, editor)
|
|
}
|
|
|
|
func (manager *userManager) UpdateUserAtomic(transaction ITransaction, id int64, github string, editor Identity) (IUser, error) {
|
|
userEntity := NewUserEntity(id, github)
|
|
return manager.ApplyAtomic(transaction, userEntity, repository.Users.UpdateAtomic, manager.cache.Put, editor)
|
|
}
|
|
|
|
func (manager *userManager) UpdateUserObjectAtomic(transaction ITransaction, id int64, user IUser, editor Identity) (IUser, error) {
|
|
userEntity := NewUserEntity(id, user.Github())
|
|
return manager.ApplyAtomic(transaction, userEntity, repository.Users.UpdateAtomic, manager.cache.Put, editor)
|
|
}
|
|
|
|
func (manager *userManager) AddOrUpdateUserObject(id int64, user IUser, editor Identity) (IUser, error) {
|
|
if manager.Exists(id) {
|
|
return manager.UpdateUserObject(id, user, editor)
|
|
} else {
|
|
return manager.AddUserObject(id, user, editor)
|
|
}
|
|
}
|
|
|
|
func (manager *userManager) AddOrUpdateUserObjectAtomic(transaction ITransaction, id int64, user IUser, editor Identity) (IUser, error) {
|
|
if manager.Exists(id) {
|
|
return manager.UpdateUserObjectAtomic(transaction, id, user, editor)
|
|
} else {
|
|
return manager.AddUserObjectAtomic(transaction, id, user, editor)
|
|
}
|
|
}
|
|
|
|
func (manager *userManager) RemoveUser(id int64, editor Identity) (IUser, error) {
|
|
userEntity := NewUserEntity(id, "")
|
|
return manager.Apply(userEntity, repository.Users.Remove, manager.cache.Remove, editor)
|
|
}
|
|
|
|
func (manager *userManager) RemoveUserAtomic(transaction ITransaction, id int64, editor Identity) (IUser, error) {
|
|
userEntity := NewUserEntity(id, "")
|
|
return manager.ApplyAtomic(transaction, userEntity, repository.Users.RemoveAtomic, manager.cache.Remove, editor)
|
|
}
|
|
|
|
func (manager *userManager) Apply(userEntity IUserEntity, repositoryHandler func(IUserEntity, int64) error, cacheHandler func(int64, ISystemObject), editor Identity) (IUser, error) {
|
|
result, err := NewUserFromEntity(userEntity)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := repositoryHandler(userEntity, editor.Id()); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
cacheHandler(result.Id(), result)
|
|
return result, nil
|
|
}
|
|
|
|
func (manager *userManager) ApplyAtomic(transaction ITransaction, userEntity IUserEntity, repositoryHandler func(IRepositoryTransaction, IUserEntity, int64) error, cacheHandler func(int64, ISystemObject), editor Identity) (IUser, error) {
|
|
result, err := NewUserFromEntity(userEntity)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
transaction.OnCommit(func() {
|
|
cacheHandler(result.Id(), result)
|
|
})
|
|
|
|
if err := repositoryHandler(transaction, userEntity, editor.Id()); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func (manager *userManager) Find(id int64) IUser {
|
|
if object, exists := manager.cache.Get(id); !exists {
|
|
return nil
|
|
} else {
|
|
return object.(IUser)
|
|
}
|
|
}
|
|
|
|
func (manager *userManager) ForEach(iterator UserIterator) {
|
|
manager.cache.ForEachValue(func(object ISystemObject) {
|
|
iterator(object.(IUser))
|
|
})
|
|
}
|
|
|
|
func (manager *userManager) Filter(predicate UserFilterPredicate) IUserCollection {
|
|
users := NewUsers()
|
|
if predicate == nil {
|
|
return users
|
|
}
|
|
|
|
manager.ForEach(func(user IUser) {
|
|
if predicate(user) {
|
|
users.Append(user)
|
|
}
|
|
})
|
|
|
|
return users
|
|
}
|
|
|
|
func (manager *userManager) Map(predicate UserMapPredicate) IUserCollection {
|
|
users := NewUsers()
|
|
if predicate == nil {
|
|
return users
|
|
}
|
|
|
|
manager.ForEach(func(user IUser) {
|
|
users.Append(predicate(user))
|
|
})
|
|
|
|
return users
|
|
}
|