Beispiel #1
0
        public void Delete(IUserCategory category, TaskContext context)
        {
            category.Dispatcher.Invoke(() =>
            {
                if (category.Parent == null)
                {
                    return;
                }
                if (Verify() == false)
                {
                    return;
                }
                category.Delete(context.Authentication);
                context.Complete(category);
            });

            bool Verify()
            {
                if (context.AllowException == true)
                {
                    return(true);
                }
                if (category.Parent == null)
                {
                    return(false);
                }
                if (EnumerableUtility.Descendants <IUserItem, IUser>(category as IUserItem, item => item.Childs).Any() == true)
                {
                    return(false);
                }
                return(true);
            }
        }
        public async Task MoveAsync(IUserCategory category, TaskContext context)
        {
            var authentication = context.Authentication;
            var categories     = category.GetService(typeof(IUserCategoryCollection)) as IUserCategoryCollection;
            var categoryPath   = await categories.Dispatcher.InvokeAsync(() => categories.Random().Path);

            if (context.AllowException == false)
            {
                if (await category.Dispatcher.InvokeAsync(() => category.Parent) == null)
                {
                    return;
                }
                if (await category.Dispatcher.InvokeAsync(() => categoryPath.StartsWith(category.Path)) == true)
                {
                    return;
                }
                if (await category.Dispatcher.InvokeAsync(() => category.Path == categoryPath))
                {
                    return;
                }
                if (await category.Dispatcher.InvokeAsync(() => category.Parent.Path == categoryPath))
                {
                    return;
                }
            }
            await category.MoveAsync(authentication, categoryPath);
        }
Beispiel #3
0
        public void Move(IUserCategory category, TaskContext context)
        {
            category.Dispatcher.Invoke(() =>
            {
                if (category.Parent == null)
                {
                    return;
                }
                var categories   = category.GetService(typeof(IUserCategoryCollection)) as IUserCategoryCollection;
                var categoryPath = categories.Random().Path;
                if (Verify(categoryPath) == false)
                {
                    return;
                }
                category.Move(context.Authentication, categoryPath);
            });

            bool Verify(string categoryPath)
            {
                if (context.AllowException == true)
                {
                    return(true);
                }
                if (categoryPath.StartsWith(category.Path) == true)
                {
                    return(false);
                }
                if (category.Path == categoryPath)
                {
                    return(false);
                }
                return(true);
            }
        }
Beispiel #4
0
        public static Task <IUser> GenerateUserAsync(this IUserCategory userCategory, Authentication authentication)
        {
            var authorities = new Authority[] { Authority.Admin, Authority.Member, Authority.Guest };
            var authority   = authorities.Random();

            return(GenerateUserAsync(userCategory, authentication, authority));
        }
Beispiel #5
0
 public void AddNewCategory(IUserCategory category, TaskContext context)
 {
     category.Dispatcher.Invoke(() =>
     {
         var categoryName = RandomUtility.NextIdentifier();
         category.AddNewCategory(context.Authentication, categoryName);
     });
 }
 public UserCategoryDescriptor(Authentication authentication, IUserCategoryDescriptor descriptor, bool isSubscriptable, object owner)
     : base(authentication, descriptor.Target, descriptor, isSubscriptable)
 {
     this.category           = descriptor.Target;
     this.owner              = owner ?? this;
     this.usersReadonly      = new ReadOnlyObservableCollection <UserDescriptor>(this.users);
     this.categoriesReadonly = new ReadOnlyObservableCollection <UserCategoryDescriptor>(this.categories);
 }
 private void Category_Deleted(object sender, EventArgs e)
 {
     this.category = null;
     this.Dispatcher.InvokeAsync(() =>
     {
         this.OnDisposed(EventArgs.Empty);
     });
 }
Beispiel #8
0
 public static Task <string> GenerateNewCategoryNameAsync(this IUserCategory userCategory, string name)
 {
     return(userCategory.Dispatcher.InvokeAsync(() =>
     {
         var names = userCategory.Categories.Select(item => item.Name);
         return NameUtility.GenerateNewName(name, names);
     }));
 }
Beispiel #9
0
 private NewUserViewModel(Authentication authentication, IUserCategory category)
 {
     this.authentication          = authentication;
     this.authentication.Expired += Authentication_Expired;
     this.category = category;
     this.category.Dispatcher.VerifyAccess();
     this.DisplayName = Resources.Title_NewUser;
 }
 private MoveUserCategoryViewModel(Authentication authentication, IUserCategory category, string[] targetPaths)
     : base(category.Path, targetPaths)
 {
     this.authentication          = authentication;
     this.authentication.Expired += Authentication_Expired;
     this.category = category;
     this.category.Dispatcher.VerifyAccess();
     this.DisplayName = Resources.Title_MoveUserFolder;
 }
 public async Task AddNewUserAsync(IUserCategory category, TaskContext context)
 {
     var authentication = context.Authentication;
     var index          = RandomUtility.Next(int.MaxValue);
     var authority      = RandomUtility.NextEnum <Authority>();
     var userID         = $"{authority.ToString().ToLower()}_bot_{index}";
     var userName       = "******" + index;
     await category.AddNewUserAsync(authentication, userID, ToSecureString("1111"), userName, authority);
 }
 private DeleteUserCategoryViewModel(Authentication authentication, IUserCategory category)
 {
     this.authentication          = authentication;
     this.authentication.Expired += Authentication_Expired;
     this.category = category;
     this.category.Dispatcher.VerifyAccess();
     this.Target      = category.Path;
     this.DisplayName = Resources.Title_DeleteUserFolder;
 }
Beispiel #13
0
 private RenameCategoryViewModel(Authentication authentication, IUserCategory category)
     : base(category.Name)
 {
     this.authentication          = authentication;
     this.authentication.Expired += Authentication_Expired;
     this.category = category;
     this.category.Dispatcher.VerifyAccess();
     this.userContext = category.GetService(typeof(IUserContext)) as IUserContext;
     this.DisplayName = Resources.Title_RenameUserFolder;
 }
Beispiel #14
0
        public static async Task <IUser> GenerateUserAsync(this IUserCategory userCategory, Authentication authentication, Authority authority)
        {
            var userCollection = userCategory.GetService(typeof(IUserCollection)) as IUserCollection;
            var newID          = await userCollection.GenerateNewUserIDAsync("user");

            var newName  = newID.Replace("user", $"{authority}User");
            var password = authority.ToString().ToLower().ToSecureString();

            return(await userCategory.AddNewUserAsync(authentication, newID, password, newName, authority));
        }
Beispiel #15
0
 public void AddNewUser(IUserCategory category, TaskContext context)
 {
     category.Dispatcher.Invoke(() =>
     {
         var index     = RandomUtility.Next(int.MaxValue);
         var authority = RandomUtility.NextEnum <Authority>();
         var userID    = $"{authority.ToString().ToLower()}_bot_{index}";
         var userName  = "******" + index;
         category.AddNewUser(context.Authentication, userID, ToSecureString("1111"), userName, authority);
     });
 }
Beispiel #16
0
        private void MoveUserCategory(Authentication authentication, IUserCategory sourceCategory, string destPath)
        {
            var destObject = this.GetObject(destPath);

            this.UserContext.Dispatcher.Invoke(MoveUserCategory);

            void MoveUserCategory()
            {
                //var dataBase = sourceCategory.GetService(typeof(IDataBase)) as IDataBase;
                var users = sourceCategory.GetService(typeof(IUserCollection)) as IUserCollection;

                //if (destPath.DataBaseName != dataBase.Name)
                //    throw new InvalidOperationException($"cannot move to : {destPath}");
                //if (destPath.Context != CremaSchema.UserDirectory)
                //    throw new InvalidOperationException($"cannot move to : {destPath}");
                if (destObject is IUser)
                {
                    throw new InvalidOperationException($"cannot move to : {destPath}");
                }

                if (destObject is IUserCategory destCategory)
                {
                    if (sourceCategory.Parent != destCategory)
                    {
                        sourceCategory.Move(authentication, destCategory.Path);
                    }
                }
                else
                {
                    if (NameValidator.VerifyCategoryPath(destPath) == true)
                    {
                        throw new InvalidOperationException($"cannot move to : {destPath}");
                    }
                    var itemName   = new ItemName(destPath);
                    var categories = sourceCategory.GetService(typeof(IUserCategoryCollection)) as IUserCategoryCollection;
                    if (categories.Contains(itemName.CategoryPath) == false)
                    {
                        throw new InvalidOperationException($"cannot move to : {destPath}");
                    }
                    if (sourceCategory.Name != itemName.Name && users.Contains(itemName.Name) == true)
                    {
                        throw new InvalidOperationException($"cannot move to : {destPath}");
                    }
                    if (sourceCategory.Parent.Path != itemName.CategoryPath)
                    {
                        sourceCategory.Move(authentication, itemName.CategoryPath);
                    }
                    if (sourceCategory.Name != itemName.Name)
                    {
                        sourceCategory.Rename(authentication, itemName.Name);
                    }
                }
            }
        }
Beispiel #17
0
 public void Rename(IUserCategory category, TaskContext context)
 {
     category.Dispatcher.Invoke(() =>
     {
         if (category.Parent == null)
         {
             return;
         }
         var categoryName = RandomUtility.NextIdentifier();
         category.Rename(context.Authentication, categoryName);
     });
 }
Beispiel #18
0
 public static void ClassInit(TestContext context)
 {
     app = new CremaBootstrapper();
     app.Initialize(context, nameof(IUserCategory_DispatcherTest));
     cremaHost = app.GetService(typeof(ICremaHost)) as ICremaHost;
     cremaHost.Dispatcher.Invoke(() =>
     {
         authentication = cremaHost.Start();
         userContext    = cremaHost.GetService(typeof(IUserContext)) as IUserContext;
     });
     category = userContext.Dispatcher.Invoke(() => userContext.Categories.Random());
 }
        public async Task RenameAsync(IUserCategory category, TaskContext context)
        {
            var authentication = context.Authentication;
            var categoryName   = RandomUtility.NextIdentifier();

            if (context.AllowException == false)
            {
                if (await category.Dispatcher.InvokeAsync(() => category.Parent) == null)
                {
                    return;
                }
            }
            await category.RenameAsync(authentication, categoryName);
        }
Beispiel #20
0
        private async Task MoveUserCategoryAsync(Authentication authentication, IUserCategory sourceCategory, string destPath)
        {
            var destObject = await this.GetObjectAsync(destPath);

            //var dataBase = sourceCategory.GetService(typeof(IDataBase)) as IDataBase;
            var users = sourceCategory.GetService(typeof(IUserCollection)) as IUserCollection;

            //if (destPath.DataBaseName != dataBase.Name)
            //    throw new InvalidOperationException($"cannot move to : {destPath}");
            //if (destPath.Context != CremaSchema.UserDirectory)
            //    throw new InvalidOperationException($"cannot move to : {destPath}");
            if (destObject is IUser)
            {
                throw new InvalidOperationException($"cannot move to : {destPath}");
            }

            if (destObject is IUserCategory destCategory)
            {
                if (sourceCategory.Parent != destCategory)
                {
                    await sourceCategory.MoveAsync(authentication, destCategory.Path);
                }
            }
            else
            {
                if (NameValidator.VerifyCategoryPath(destPath) == true)
                {
                    throw new InvalidOperationException($"cannot move to : {destPath}");
                }
                var itemName   = new ItemName(destPath);
                var categories = sourceCategory.GetService(typeof(IUserCategoryCollection)) as IUserCategoryCollection;
                if (await categories.ContainsAsync(itemName.CategoryPath) == false)
                {
                    throw new InvalidOperationException($"cannot move to : {destPath}");
                }
                if (sourceCategory.Name != itemName.Name && await users.ContainsAsync(itemName.Name) == true)
                {
                    throw new InvalidOperationException($"cannot move to : {destPath}");
                }
                if (sourceCategory.Parent.Path != itemName.CategoryPath)
                {
                    await sourceCategory.MoveAsync(authentication, itemName.CategoryPath);
                }
                if (sourceCategory.Name != itemName.Name)
                {
                    await sourceCategory.RenameAsync(authentication, itemName.Name);
                }
            }
        }
 private static bool CanMove(IUserCategory userCategory, IUserCategory parentCategory)
 {
     if (userCategory.Parent == null)
     {
         return(false);
     }
     if (userCategory.Parent.Path == parentCategory.Path)
     {
         return(false);
     }
     if (parentCategory.Categories.ContainsKey(userCategory.Name) == true)
     {
         return(false);
     }
     return(parentCategory.Path.StartsWith(userCategory.Path) == false);
 }
        public async Task DeleteAsync(IUserCategory category, TaskContext context)
        {
            var authentication = context.Authentication;

            if (context.AllowException == false)
            {
                if (await category.Dispatcher.InvokeAsync(() => category.Parent) == null)
                {
                    return;
                }
                if (await category.Dispatcher.InvokeAsync(() => EnumerableUtility.Descendants <IUserItem, IUser>(category as IUserItem, item => item.Childs).Any()) == true)
                {
                    return;
                }
            }
            await category.DeleteAsync(authentication);

            context.Complete(category);
        }
        public UserCategoryDescriptor(Authentication authentication, IUserCategory category, DescriptorTypes descriptorTypes, object owner)
            : base(authentication, category, descriptorTypes)
        {
            this.category = category;
            this.owner    = owner ?? this;
            this.category.Dispatcher.VerifyAccess();
            this.categoryName = category.Name;
            this.categoryPath = category.Path;

            this.usersReadonly      = new ReadOnlyObservableCollection <UserDescriptor>(this.users);
            this.categoriesReadonly = new ReadOnlyObservableCollection <UserCategoryDescriptor>(this.categories);

            if (this.descriptorTypes.HasFlag(DescriptorTypes.IsSubscriptable) == true)
            {
                this.category.Renamed += Category_Renamed;
                this.category.Moved   += Category_Moved;
                this.category.Deleted += Category_Deleted;
            }

            if (this.descriptorTypes.HasFlag(DescriptorTypes.IsRecursive) == true)
            {
                if (this.descriptorTypes.HasFlag(DescriptorTypes.IsSubscriptable) == true)
                {
                    this.category.Users.CollectionChanged      += Users_CollectionChanged;
                    this.category.Categories.CollectionChanged += Categories_CollectionChanged;
                }

                foreach (var item in this.category.Categories)
                {
                    var descriptor = new UserCategoryDescriptor(this.authentication, item, this.descriptorTypes, this.owner);
                    item.ExtendedProperties[this.owner] = descriptor;
                    this.categories.Add(descriptor);
                }

                foreach (var item in this.category.Users)
                {
                    var descriptor = new UserDescriptor(this.authentication, item, this.descriptorTypes, this.owner);
                    item.ExtendedProperties[this.owner] = descriptor;
                    this.users.Add(descriptor);
                }
            }
        }
        private bool PredicateFunc(IUserCategory userCategory)
        {
            if (this.HasParent == true && userCategory.Parent == null)
            {
                return(false);
            }
            if (this.HasCategories == true && userCategory.Categories.Any() == false)
            {
                return(false);
            }
            if (this.HasUsers == true && userCategory.Users.Any() == false)
            {
                return(false);
            }
            if (this.IsLeaf == true && (userCategory.Categories.Any() == true || userCategory.Users.Any() == true))
            {
                return(false);
            }
            if (this.ExcludedCategories != null && this.ExcludedCategories.Contains(userCategory) == true)
            {
                return(false);
            }
            if (this.ExcludedItems != null && this.ExcludedItems.Contains(userCategory as IUserItem) == true)
            {
                return(false);
            }
            if (this.CategoryToMove != null && CanMove(this.CategoryToMove, userCategory) == false)
            {
                return(false);
            }
            if (this.UserToMove != null && CanMove(this.UserToMove, userCategory.Path) == false)
            {
                return(false);
            }
            if (this.Predicate != null && this.Predicate(userCategory) == false)
            {
                return(false);
            }

            return(true);
        }
 private static bool DefaultPredicate(IUserCategory _) => true;
Beispiel #26
0
 public UserCategoryTreeViewItemViewModel(Authentication authentication, IUserCategory category, object owner)
     : this(authentication, new UserCategoryDescriptor(authentication, category, DescriptorTypes.All, owner), owner)
 {
 }
 public BotVkApi(IFriendCategory friends, IUserCategory users)
 {
     Friends = friends ?? throw new ArgumentNullException(paramName: nameof(friends));
     Users   = users ?? throw new ArgumentNullException(paramName: nameof(users));
 }
Beispiel #28
0
        public static async Task <IUserCategory> GenerateUserCategoryAsync(this IUserCategory userCategory, Authentication authentication)
        {
            var name = await userCategory.GenerateNewCategoryNameAsync();

            return(await userCategory.AddNewCategoryAsync(authentication, name));
        }
 public UserCategoryTreeItemBase(Authentication authentication, IUserCategory category, bool isSubscriptable, object owner)
     : this(authentication, new UserCategoryDescriptor(authentication, category, isSubscriptable == true ? DescriptorTypes.All : DescriptorTypes.IsRecursive, owner), owner)
 {
 }
Beispiel #30
0
 public static Task <string> GenerateNewCategoryNameAsync(this IUserCategory userCategory)
 {
     return(GenerateNewCategoryNameAsync(userCategory, "NewCategory"));
 }