Пример #1
0
        public bool Load()
        {
            try
            {
                if (!File.Exists(_fileLocation))
                {
                    return(false);                                             // File.Create(_fileLocation).Close();
                }
                Groups.Clear();
                Users.Clear();

                using (var reader = new XmlTextReader(_fileLocation))
                {
                    var doc = new XmlDocument();
                    doc.Load(reader);
                    var list = doc.SelectNodes("XPermissions");
                    if (list.Count > 0)
                    {
                        //while (reader.Read())
                        foreach (XmlNode node in list.Item(0))
                        {
                            switch (node.NodeType)
                            {
                            case XmlNodeType.Element:
                                var elementName = node.Name;

                                switch (elementName)
                                {
                                case "Groups":
                                    ParseKnownElement(node, false);
                                    break;

                                case "Users":
                                    ParseKnownElement(node);
                                    break;
                                }
                                break;
                            }
                        }
                    }
                }
                return(true);
            }
            catch (Exception e)
            {
                PermissionsX.XLog("Exception loading in {0}\n{1}", GetType().FullName, e);
            }

            return(false);
        }
        public void LoadLanguages(PermissionsX permissions)
        {
            DisabledMessaged	= permissions.SetLanguageVariable("Disabled", "has been disabled.");
            Initializing		= permissions.SetLanguageVariable("Initializing", "Initializing...");
            Enabled				= permissions.SetLanguageVariable("Enabled", "Enabled");
            Protected			= permissions.SetLanguageVariable("Protected", "Your Server is now protected!");
            GetAuth				= permissions.SetLanguageVariable("GetAuth", "Your Server is vulnerable, Get an Authentication system!");
            NoAuth				= permissions.SetLanguageVariable("NoAuth", "No login system found! Restrict will be downloaded.");
            RestrictLoadFail	= permissions.SetLanguageVariable("RestrictLoadFail", "Restrict failed to install!");
            RestrictLoadResult	= permissions.SetLanguageVariable("RestrictLoadResult", "Load result:");
            RestrictDlFailed	= permissions.SetLanguageVariable("RestrictDlFailed", "Restrict failed to download!");

            Success				= permissions.SetLanguageVariable("Success", "success");
            Failure				= permissions.SetLanguageVariable("Failure", "failure");
            Failed				= permissions.SetLanguageVariable("Failed", "failed");
            Saving				= permissions.SetLanguageVariable("Saving", "saving");
            Loading				= permissions.SetLanguageVariable("Loading", "loading");

            Added				= permissions.SetLanguageVariable("Added", "Added");
            Removed				= permissions.SetLanguageVariable("Removed", "Removed");

            NoPlayersAndForce	= permissions.SetLanguageVariable("NoPlayersAndForce", "No online player found, Use -f if you know for certain that the name is correct.");
            DefinitionsExist	= permissions.SetLanguageVariable("DefinitionsExist", "Definitions already exist for that ");

            User				= permissions.SetLanguageVariable("User", "user");
            Group				= permissions.SetLanguageVariable("Group", "group");
            Definitions			= permissions.SetLanguageVariable("Definitions", "Definitions");
            HasBeenCreated		= permissions.SetLanguageVariable("HasBeenCreated", "has been created");
            ArgumentsExpected	= permissions.SetLanguageVariable("ArgumentsExpected", "Arguments expected");
            UserAndNodeExpected = permissions.SetLanguageVariable("UserAndNodeExpected", "User & permission node(s) expected");
            GrpAndNodeExpected	= permissions.SetLanguageVariable("GrpAndNodeExpected", "Group & permission node(s) expected");
            UserAndGrpExpected	= permissions.SetLanguageVariable("UserAndGrpExpected", "User & group(s) expected");
            NoUser				= permissions.SetLanguageVariable("NoUser", "No user");
            NoGroup				= permissions.SetLanguageVariable("NoGroup", "No group");
            NodesWhere			= permissions.SetLanguageVariable("NodesWhere", "node(s) where");

            UpdatingAttribute	= permissions.SetLanguageVariable("UpdatingAttribute", "updating attribute");
            InvalidColorMsg		= permissions.SetLanguageVariable("InvalidColorMsg", "Invalid color value, try");
            InvalidBooleanValue = permissions.SetLanguageVariable("InvalidBooleanValue", "Invalid boolean value");
            AttributeExpected	= permissions.SetLanguageVariable("AttributeExpected", "Attribute expected");
        }
Пример #3
0
        public bool Save()
        {
            try
            {
                if (File.Exists(_fileLocation))
                {
                    File.Delete(_fileLocation);
                }

                using (var writer = new XmlTextWriter(_fileLocation, Encoding.ASCII))
                {
                    writer.WriteStartDocument();
                    writer.WriteStartElement("XPermissions");

                    writer.WriteStartElement("Groups");
                    foreach (var group in Groups)
                    {
                        group.WriteElement(writer);
                    }
                    writer.WriteEndElement();

                    writer.WriteStartElement("Users");
                    foreach (var user in Users)
                    {
                        user.WriteElement(writer);
                    }
                    writer.WriteEndElement();

                    writer.WriteEndElement();
                    writer.WriteEndDocument();

                    return(true);
                }
            }
            catch (Exception e)
            {
                PermissionsX.XLog("Exception saving in {0}\n{1}", GetType().FullName, e);
            }

            return(false);
        }
        public void LoadLanguages(PermissionsX permissions)
        {
            DisabledMessaged   = permissions.SetLanguageVariable("Disabled", "has been disabled.");
            Initializing       = permissions.SetLanguageVariable("Initializing", "Initializing...");
            Enabled            = permissions.SetLanguageVariable("Enabled", "Enabled");
            Protected          = permissions.SetLanguageVariable("Protected", "Your Server is now protected!");
            GetAuth            = permissions.SetLanguageVariable("GetAuth", "Your Server is vulnerable, Get an Authentication system!");
            NoAuth             = permissions.SetLanguageVariable("NoAuth", "No login system found! Restrict will be downloaded.");
            RestrictLoadFail   = permissions.SetLanguageVariable("RestrictLoadFail", "Restrict failed to install!");
            RestrictLoadResult = permissions.SetLanguageVariable("RestrictLoadResult", "Load result:");
            RestrictDlFailed   = permissions.SetLanguageVariable("RestrictDlFailed", "Restrict failed to download!");

            Success = permissions.SetLanguageVariable("Success", "success");
            Failure = permissions.SetLanguageVariable("Failure", "failure");
            Failed  = permissions.SetLanguageVariable("Failed", "failed");
            Saving  = permissions.SetLanguageVariable("Saving", "saving");
            Loading = permissions.SetLanguageVariable("Loading", "loading");

            Added   = permissions.SetLanguageVariable("Added", "Added");
            Removed = permissions.SetLanguageVariable("Removed", "Removed");

            NoPlayersAndForce = permissions.SetLanguageVariable("NoPlayersAndForce", "No online player found, Use -f if you know for certain that the name is correct.");
            DefinitionsExist  = permissions.SetLanguageVariable("DefinitionsExist", "Definitions already exist for that ");

            User                = permissions.SetLanguageVariable("User", "user");
            Group               = permissions.SetLanguageVariable("Group", "group");
            Definitions         = permissions.SetLanguageVariable("Definitions", "Definitions");
            HasBeenCreated      = permissions.SetLanguageVariable("HasBeenCreated", "has been created");
            ArgumentsExpected   = permissions.SetLanguageVariable("ArgumentsExpected", "Arguments expected");
            UserAndNodeExpected = permissions.SetLanguageVariable("UserAndNodeExpected", "User & permission node(s) expected");
            GrpAndNodeExpected  = permissions.SetLanguageVariable("GrpAndNodeExpected", "Group & permission node(s) expected");
            UserAndGrpExpected  = permissions.SetLanguageVariable("UserAndGrpExpected", "User & group(s) expected");
            NoUser              = permissions.SetLanguageVariable("NoUser", "No user");
            NoGroup             = permissions.SetLanguageVariable("NoGroup", "No group");
            NodesWhere          = permissions.SetLanguageVariable("NodesWhere", "node(s) where");

            UpdatingAttribute   = permissions.SetLanguageVariable("UpdatingAttribute", "updating attribute");
            InvalidColorMsg     = permissions.SetLanguageVariable("InvalidColorMsg", "Invalid color value, try");
            InvalidBooleanValue = permissions.SetLanguageVariable("InvalidBooleanValue", "Invalid boolean value");
            AttributeExpected   = permissions.SetLanguageVariable("AttributeExpected", "Attribute expected");
        }
Пример #5
0
        public void ParseUser(XmlNode node)
        {
            if (node.Attributes.Count > 0)
            {
                var user = new User();
                user.Initialize();

                foreach (XmlAttribute attribute in node.Attributes)
                {
                    switch (attribute.Name)
                    {
                    case "Name":
                        user.Name = attribute.Value;
                        break;

                    case "Color":
                        Color colour;
                        if (Color.TryParseRGB(attribute.Value, out colour))
                        {
                            user.Color = colour;
                        }
                        break;

                    case "CanBuild":
                        bool canBuild;
                        if (Boolean.TryParse(attribute.Value, out canBuild))
                        {
                            user.CanBuild = canBuild;
                        }
                        break;

                    case "Prefix":
                        user.Prefix = attribute.Value;
                        break;

                    case "Suffix":
                        user.Suffix = attribute.Value;
                        break;

                    case "ChatSeperator":
                        user.ChatSeperator = attribute.Value;
                        break;
                    }
                }

                if (node.HasChildNodes)
                {
                    foreach (XmlNode cNode in node.ChildNodes)
                    {
                        switch (cNode.Name)
                        {
                        case "UserGroups":
                            if (cNode.HasChildNodes)
                            {
                                foreach (XmlNode gNode in cNode.ChildNodes)
                                {
                                    var groupName = gNode.InnerText.Trim();
                                    if (HasGroup(groupName))
                                    {
                                        var group = GetGroup(groupName);
                                        user.Groups.Add(group);
                                    }
                                }
                            }
                            break;

                        case "Permissions":
                            if (cNode.HasChildNodes)
                            {
                                foreach (XmlNode gNode in cNode.ChildNodes)
                                {
                                    var permission = gNode.InnerText.Trim();
                                    if (permission != null && permission.Length > 0)
                                    {
                                        user.Permissions.Add(permission);
                                    }
                                }
                            }
                            break;

                        case "DenyPermissions":
                            if (cNode.HasChildNodes)
                            {
                                foreach (XmlNode gNode in cNode.ChildNodes)
                                {
                                    var permission = gNode.InnerText.Trim();
                                    if (permission != null && permission.Length > 0)
                                    {
                                        user.DenyPermissions.Add(permission);
                                    }
                                }
                            }
                            break;

                        default:
                            PermissionsX.XLog("Uknown element `{0}`", cNode.Name);
                            break;
                        }
                    }
                }

                Users.Add(user);
            }
        }
Пример #6
0
        public void ParseGroup(XmlNode node)
        {
            if (node.Attributes.Count > 0)
            {
                var group = new Group();
                group.Initialize();

                foreach (XmlAttribute attribute in node.Attributes)
                {
                    switch (attribute.Name)
                    {
                    case "Name":
                        group.Name = attribute.Value;
                        break;

                    case "Color":
                        Color colour;
                        if (Color.TryParseRGB(attribute.Value, out colour))
                        {
                            group.Color = colour;
                        }
                        break;

                    case "CanBuild":
                        bool canBuild;
                        if (Boolean.TryParse(attribute.Value, out canBuild))
                        {
                            group.CanBuild = canBuild;
                        }
                        break;

                    case "Default":
                        if (HasDefaultGroup())
                        {
                            ProgramLog.Admin.Log("[Warning] Multiple default groups");
                            continue;
                        }

                        bool _default;
                        if (Boolean.TryParse(attribute.Value, out _default))
                        {
                            group.Default = _default;
                        }
                        break;

                    case "Prefix":
                        group.Prefix = attribute.Value;
                        break;

                    case "Suffix":
                        group.Suffix = attribute.Value;
                        break;

                    case "ChatSeperator":
                        group.ChatSeperator = attribute.Value;
                        break;

                    case "Rank":
                        int rank;
                        if (Int32.TryParse(attribute.Value, out rank))
                        {
                            group.Rank = rank;
                        }
                        break;
                    }
                }

                if (node.HasChildNodes)
                {
                    foreach (XmlNode cNode in node.ChildNodes)
                    {
                        switch (cNode.Name)
                        {
                        case "Permissions":
                            if (cNode.HasChildNodes)
                            {
                                foreach (XmlNode gNode in cNode.ChildNodes)
                                {
                                    var permission = gNode.InnerText.Trim();
                                    if (permission != null && permission.Length > 0)
                                    {
                                        group.Permissions.Add(permission);
                                    }
                                }
                            }
                            break;

                        case "DenyPermissions":
                            if (cNode.HasChildNodes)
                            {
                                foreach (XmlNode gNode in cNode.ChildNodes)
                                {
                                    var permission = gNode.InnerText.Trim();
                                    if (permission != null && permission.Length > 0)
                                    {
                                        group.DenyPermissions.Add(permission);
                                    }
                                }
                            }
                            break;

                        default:
                            PermissionsX.XLog("Uknown element `{0}`", cNode.Name);
                            break;
                        }
                    }
                }

                Groups.Add(group);
            }
        }