Esempio n. 1
0
 internal WorkspaceObject(ResponseContext ctx, SyncResponseObject syncResponseObject)
 {
     this.Workspace = ctx.Workspace;
     this.Id        = long.Parse(syncResponseObject.i);
     this.Class     = (IClass)this.Workspace.ObjectFactory.MetaPopulation.Find(Guid.Parse(syncResponseObject.t));
     this.Version   = !string.IsNullOrEmpty(syncResponseObject.v) ? long.Parse(syncResponseObject.v) : 0;
     this.Roles     = syncResponseObject.r?.Select(v => new WorkspaceRole(this.Workspace.ObjectFactory.MetaPopulation, v)).Cast <IWorkspaceRole>().ToArray();
     this.SortedAccessControlIds    = ctx.ReadSortedAccessControlIds(syncResponseObject.a);
     this.SortedDeniedPermissionIds = ctx.ReadSortedDeniedPermissionIds(syncResponseObject.d);
 }
Esempio n. 2
0
        public WorkspaceObject(Workspace workspace, SyncResponse loadResponse, SyncResponseObject loadObject)
        {
            this.Workspace        = workspace;
            this.Id               = long.Parse(loadObject.I);
            this.Version          = !string.IsNullOrEmpty(loadObject.V) ? long.Parse(loadObject.V) : 0;
            this.UserSecurityHash = loadResponse.UserSecurityHash;
            this.ObjectType       = (Class)this.Workspace.ObjectFactory.GetObjectTypeForTypeName(loadObject.T);

            this.Roles   = new Dictionary <string, object>();
            this.Methods = new Dictionary <string, object>();

            if (loadObject.Roles != null)
            {
                foreach (var role in loadObject.Roles)
                {
                    var name     = (string)role[0];
                    var access   = (string)role[1];
                    var canRead  = access.Contains("r");
                    var canWrite = access.Contains("w");

                    this.Roles[$"CanRead{name}"]  = canRead;
                    this.Roles[$"CanWrite{name}"] = canWrite;

                    if (canRead)
                    {
                        var value = role.Length > 2 ? role[2] : null;
                        this.Roles[name] = value;
                    }
                }
            }

            if (loadObject.Methods != null)
            {
                foreach (var method in loadObject.Methods)
                {
                    var name       = method[0];
                    var access     = method[1];
                    var canExecute = access.Contains("x");

                    this.Methods[$"CanExecute{name}"] = canExecute;
                }
            }
        }