Versioning must be set up on the document library

Steps to set up versioning are as follows:

1. Navigate to the document library you wan’t to do the sharepoint web service call on
2. Navigate to the document library settings, do this by hovering over “Settings” and then clicking “Document Library Settings”
3. Once on the library settings page, find and click the link called “Versioning settings”
4. Once you are the versioning settings for the library make sure the following values are set in the settings page.
   
   Content Approval: Yes/No
   Document Version History: Create major and minor(draft) versions
   Draft Item Security: Only users who can edit items
   Require Chekc Out: Yes/No
5. Once that is done click the “Ok” button

Ad user used by the sharepoint web service must have “Read access” only.

Steps to set up permissions are as follows

1. Navigate to the document library you wan’t to do the sharepoint web service call on
2. Navigate to the document library settings, do this by hovering over “Settings” and then clicking “Document Library Settings”
3. Once on the library settings page, find and click the link called “Permissions for thsi document library”
4. From this page, find the user and then make sure said user only has “Read” or “Restricted Read” permissions only, the main point is that ad user must not be able to edit documents.
   
   A side note is that if the user is part of a group that has enhanced permissions, this wont work, or if it is inheriting permissions, this wont work.
   It may be simpler to create a new user just for your sharepoint web service consumer.

That’s it, now your sharepoint web service consumer should only get back the latest major versions of documents.

Let’s say I wanted to store the following words in a trie: to, tea, ted, ten, team, a, i, in, inn.

Note that the parent node is always null or empty.

To find the word /team/, we would traverse the trie starting at t > e > a > m*

To find the word /in/, we would go i > n*

If we were to search for the word /te/, it would return false because it doesn’t end on a node with a marker.

* indicates a marker for a complete word.

A complete word is indicated by a red star in the diagram. It is also marked by a boolean property in our implementation.

Our first class is the node which represents each node on the trie.

    public class Node
    {
        char _letter;
        bool _last;
        Dictionary<char, Node> _children;

        protected Node() { }

        public Node(char c)
        {
            _children = new Dictionary<char, Node>();
            _last = false;
            _letter = c;
        }

        public char Letter
        {
            get { return this._letter; }
            set { this._letter = value; }
        }

        public bool Last
        {
            get { return this._last; }
            set { this._last = value; }
        }

        public Dictionary<char, Node> Children
        {
            get { return this._children; }
            set { this._children = value; }
        }

        public Node ChildNode(char c)
        {
            if (Children != null)
            {
                if (Children.ContainsKey(c))
                {
                    return Children1;
                }
            }
            return null;
        }

        public override bool Equals(object obj)
        {
            if (obj == null || this.GetType() != obj.GetType())
                return false;
            
            return Equals(obj);
        }
        
        public bool Equals(Node obj)
        {
            if (obj != null
                && obj.Letter == this.Letter)
            {
                return true;
            }               

            return false;
        }

        public override int GetHashCode()
        {
            int hash = 13;
            hash = (hash * 7) + this.Letter.GetHashCode();
            return hash;
        }
    }

*Edit: updated node class to use a dictionary for faster searches.

Our next class is our actual Trie, it contains each node and only has two operations – inserting and searching.

    public class Trie
    {
        private Node _root;

        public Trie()
        {
            _root = new Node(' ');
        }

        public void Insert(string s)
        {
            char[] word = s.ToLower().ToCharArray();

            Node current = _root;

            if (word.Length == 0)
            {
                current.Last = true;
            }

            for (int i = 0; i < s.Length; i++)
            {
                Node child = current.ChildNode(word[i]);
                if (child != null)
                {
                    current = child;
                }
                else
                {
                    current.Children.Add(word[i], new Node(word[i]));
                    current = current.ChildNode(word[i]);
                }

                if (i == word.Length - 1)
                {
                    current.Last = true;
                }
            }
        }

        public bool Search(string s)
        {
            char[] word = s.ToLower().ToCharArray();
            Node current = _root;
            while (current != null)
            {
                for (int i = 0; i < word.Length; i++)
                {
                    if (current.ChildNode(word[i]) == null)
                        return false;
                    else
                        current = current.ChildNode(word[i]);
                }

                if (current.Last == true)
                    return true;
                else
                    return false;
            }
            return false;
        }
    }

Implementation in a windows form application.

    public partial class MainForm : Form
    {
        Trie trie;

        public MainForm()
        {
            InitializeComponent();
        }

        private void MainForm_Load(object sender, EventArgs e)
        {
            trie = new Trie();
        }

        private void findButton_Click(object sender, EventArgs e)
        {
            if (trie.Search(findTextBox.Text.Trim()))
            {
                results.Text = String.Format("\"{0}\" was found in the trie.", findTextBox.Text);
            }
            else
            {
                results.Text = String.Format("\"{0}\" was not found in the trie.", findTextBox.Text);
            }

            findTextBox.Text = "";
        }

        private void insertButton_Click(object sender, EventArgs e)
        {
            string phrase = insertTextBox.Text.Trim();

            string[] words = phrase.Trim().Split(' ', ',', ';', '.');

            foreach (string word in words)
            {
                trie.Insert(word);
            }

            trie.Insert(phrase);

            results.Text = String.Format("\"{0}\" was successfully inserted into trie.", insertTextBox.Text);

            insertTextBox.Text = "";
        }

    }

Here’s the implementation in action.

Inserting words into trie.

Searching the trie for a word.

If a word isn’t in the trie then we would get a “false”.

rm -rf DirectoryToDelete

rm : remove
-rf : recursively delete a specified directory, including all files and all sub directories. (note the f makes it delete without asking confirmation)

For this example I’m going to show you how I installed

1. change directories to where your wp-content/plugins folder is located.
2. use the wget command to download the zip folder.
3. unzip your newly downloaded plugin
4. remove that zip folder from your wp-content/plugins folder.

Code:

cd /wp-content/plugins
wget http://downloads.wordpress.org/plugin/syntaxhighlighter.zip
unzip syntaxhighlighter.zip
rm syntaxhighlighter.zip

So you can use this method to securely manage your wordpress plugins.