Catalogue.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using Shared;
using Server.Data;
using System.Text.RegularExpressions;

namespace Server
{
    public class Catalogue
    {
        #region Constructor and class variables
        
        private IPersistentData database;
        private DataContainer data;
        private int UniqueTagCount = -1;

        public Catalogue(IPersistentData database)
        {
            this.database = database;
            data = database.LoadData();
        }

        public void SaveData()
        {
            database.SaveData(data);
        }

        #endregion

        #region Project methods

        public Project GetProject(int id)
        {
            if (data.ProjectTable.ContainsKey(id))
            {
                return data.ProjectTable[id];
            }
            return null;
        }
        public ProjectInfo GetProjectInfo(int id)
        {
            if (data.ProjectTable.ContainsKey(id))
            {
                return data.ProjectTable[id].Info;
            }
            return new ProjectInfo();
        }
        public Messages DeleteProject(int id)
        {
            if (!data.ProjectTable.ContainsKey(id)) return Messages.Fail;

            DataRow[] rows = data.Tags.Select("ID = '" + id.ToString() + "'");
            
            if (rows.Length > 0)
            {
                foreach (DataRow dr in rows)
                {
                    data.Tags.Rows.Remove(dr);    
                }
                                
                data.Tags.AcceptChanges();
                
            }

            List<Reference> references = new List<Reference>();
            references.AddRange(data.ProjectTable[id].References);

            foreach (Reference r in references)
            {
                DeleteReference(r.Project.ID, r.Literature.ID);
            }


            data.ProjectTable.Remove(id);
            database.SaveData(data);

            return Messages.OK;
        }
        public Messages CreateProject(ProjectInfo pi, string creator, out int id)
        {
            id = -1;
            Person person = GetUser(creator);
            if (person == null)
                return Messages.Fail;

            id = UniquelyIdentifiable.NextID;
            Project p = new Project(id, pi.startDate, pi.endDate, pi.subject, pi.title, pi.department, pi.synopsis, pi.submitted);
            p.AddPerson(person, RoleType.Creator);
            data.ProjectTable.Add(p.ID, p);

            database.SaveData(data);

            return Messages.OK;
        }
        public Messages UpdateProject(ProjectInfo info)
        {
            if (!data.ProjectTable.ContainsKey(info.id))
                return Messages.Fail;

            Project p = data.ProjectTable[info.id];
            p.IsSubmitted = info.submitted;
            p.StartDate = info.startDate;
            p.Subject = info.subject;
            p.Synopsis = info.synopsis;
            p.Title = info.title;
            p.EndDate = info.endDate;
            p.Department = info.department;
            return Messages.OK;
        }
        public ProjectInfo[] ListProjects()
        {
            ProjectInfo[] infos = new ProjectInfo[data.ProjectTable.Count];
            int i = 0;
            foreach (Project project in data.ProjectTable.Values)
            {
                infos[i++] = project.Info;
            }

            return infos;
        }
        public ProjectInfo[] GetUsersProjects(string username)
        {
            List<ProjectInfo> result = new List<ProjectInfo>();

            foreach (KeyValuePair<int, Project> p in data.ProjectTable)
            {
                foreach (Role r in p.Value.Roles)
                {
                    if (r.Person.UserName == username) result.Add(new ProjectInfo(p.Value.ID,
                        p.Value.StartDate, p.Value.EndDate, p.Value.Subject, p.Value.Title, p.Value.Department,
                        p.Value.Synopsis, p.Value.IsSubmitted));
                }
            }

            return result.ToArray();
        }
        
        #endregion

        #region Literature methods

        public Messages CreateLiterature(LiteratureInfo info, out int id)
        {
            id = -1;
            if (!data.PersonTable.ContainsKey(info.creator))
                return Messages.Fail;
            id = UniquelyIdentifiable.NextID;
            Literature l = new Literature(id, data.PersonTable[info.creator], info.title, info.author, info.summary, info.source, info.isbn, info.date, info.type);
            data.LiteratureTable.Add(l.ID, l);

            database.SaveData(data);

            return Messages.OK;
        }
        public LiteratureInfo[] ListLiterature()
        {
            LiteratureInfo[] infos = new LiteratureInfo[data.LiteratureTable.Count];
            int i = 0;
            foreach (Literature literature in data.LiteratureTable.Values)
            {
                infos[i++] = literature.Info;
            }

            return infos;
        }
        public Messages DeleteLiterature(int id)
        {
            if (!data.LiteratureTable.ContainsKey(id)) return Messages.Fail;

            DataRow[] rows = data.Tags.Select("ID = '" + id.ToString() + "'");

            if (rows.Length > 0)
            {
                foreach (DataRow dr in rows)
                {
                    data.Tags.Rows.Remove(dr);
                }

                data.Tags.AcceptChanges();

            }

            data.LiteratureTable.Remove(id);
            database.SaveData(data);

            return Messages.OK;
        }
        public LiteratureInfo GetLiteratureInfo(int id)
        {
            if (data.LiteratureTable.ContainsKey(id))
            {
                return data.LiteratureTable[id].Info;
            }
            return new LiteratureInfo();
        }
        public Messages UpdateLiterature(LiteratureInfo info)
        {
            if (!data.LiteratureTable.ContainsKey(info.id))
                return Messages.Fail;

            Literature l = data.LiteratureTable[info.id];
            l.Author = info.author;
            l.ISBN = info.isbn;
            l.Source = info.source;
            l.Summary = info.summary;
            l.Title = info.title;
            l.Type = info.type;
            return Messages.OK;
        }
        
        #endregion

        #region Comment methods

        public Messages CreateComment(CommentInfo ci, out int id)
        {
            id = -1;
            if (ci.type == CommentType.Literature)
            {
                id = ci.id = UniquelyIdentifiable.NextID;
                Comment c = new Comment(ci.id, data.PersonTable[ci.poster], ci.title, ci.text, ci.type, ci.date);
                data.LiteratureTable[ci.parent].Comments.Add(c);
                data.CommentTable.Add(ci.id, c);
            }

            if (ci.type == CommentType.Reference)
            {
                Reference r = GetReference(ci.project, ci.parent);

                if (r != null)
                {
                    id = ci.id = UniquelyIdentifiable.NextID;
                    Comment c = new Comment(ci.id, data.PersonTable[ci.poster], ci.title, ci.text, ci.type, ci.date);
                    r.Comments.Add(c);
                    data.CommentTable.Add(ci.id, c);

                    return Messages.OK;
                }

                return Messages.Fail;

            }

            if (ci.type == CommentType.Comment)
            {
                id = ci.id = UniquelyIdentifiable.NextID;
                Comment c = new Comment(ci.id, data.PersonTable[ci.poster], ci.title, ci.text, ci.type, ci.date);
                data.CommentTable[ci.parent].Comments.Add(c);
                data.CommentTable.Add(ci.id, c);
            }

            return Messages.OK;

        }
        public CommentInfo[] GetComments(int literatureID)
        {
            List<CommentInfo> result = new List<CommentInfo>();
            Literature temp;
            
            try
            {
                data.LiteratureTable.TryGetValue(literatureID, out temp);
            }
            catch (KeyNotFoundException) { return null; }

            GetAllComments(temp.Comments, result, temp.ID, -1);

            return result.ToArray();
        }
        public CommentInfo[] GetComments(int literatureID, int projectID)
        {
            List<CommentInfo> result = new List<CommentInfo>();

            Reference r = GetReference(projectID, literatureID);

            GetAllComments(r.Comments, result, literatureID, projectID);
                        
            return result.ToArray();
        }
        private void GetAllComments(List<Comment> root, List<CommentInfo> output, int parent, int project)
        {
            foreach (Comment c in root)
            {
                output.Add(new CommentInfo(c.ID, parent, project, c.Poster.UserName, c.Title, c.Text, c.Date, c.CommentType));
                GetAllComments(c.Comments, output, c.ID, project);
            }

        }

        #endregion

        #region Review methods

        public ReviewInfo GetReviewInfo(int project, int literature)
        {
            Reference r = GetReference(project, literature);
            if (r == null)
                return new ReviewInfo();

            if (r is Review)
            {
                return ((Review)r).Info;
            }

            return new ReviewInfo();
        }
        public ReviewInfo[] ListReviews(int project)
        {
            List<ReviewInfo> infos = new List<ReviewInfo>();

            if (!data.ProjectTable.ContainsKey(project) && !data.LiteratureTable.ContainsKey(project))
                return null;

            List<Reference> refs = data.ProjectTable.ContainsKey(project) ? data.ProjectTable[project].References : data.LiteratureTable[project].References;

            foreach (Reference r in refs)
            {
                if (r is Review)
                {
                    infos.Add(((Review)r).Info);
                }
            }
            return infos.ToArray();
        }
        public Messages CreateReview(ReviewInfo ri)
        {
            Reference r = GetReference(ri.project, ri.literature);
            if (r != null && (r is Review))
                return Messages.Fail;

            if (!data.PersonTable.ContainsKey(ri.person))
                return Messages.Fail;

            List<Comment> comments = null;
            if (r is Reference)
            {
                comments = r.Comments;
                DeleteReference(ri.project, ri.literature);
            }

            Review rv = new Review(data.ProjectTable[ri.project], data.PersonTable[ri.person], data.LiteratureTable[ri.literature], ri.date, ri.used, ri.status, ri.title, ri.text, ri.rating);
            if (comments != null)
                rv.Comments.AddRange(comments);


            data.ProjectTable[ri.project].References.Add(rv);
            data.LiteratureTable[ri.literature].References.Add(rv);
            return Messages.OK;
        }
        public Messages UpdateReview(ReviewInfo ri)
        {
            Reference r = GetReference(ri.project, ri.literature);
            if (r == null || !(r is Review))
                return Messages.Fail;

            Review rv = (Review)r;

            rv.Date = ri.date;
            rv.Status = ri.status;
            rv.Used = ri.used;
            rv.Title = ri.title;
            rv.Text = ri.text;
            rv.Rating = ri.rating;
            return Messages.OK;
        }

        #endregion

        #region Reference methods

        public Messages CreateReference(ReferenceInfo ri)
        {
            if (!data.ProjectTable.ContainsKey(ri.project) || !data.LiteratureTable.ContainsKey(ri.literature))
                return Messages.Fail;

            Reference r = GetReference(ri.project, ri.literature);
            if (r != null)
                return Messages.Fail;

            Reference re = new Reference(data.ProjectTable[ri.project], data.LiteratureTable[ri.literature], ri.date, ri.used, ri.status);
            data.ProjectTable[ri.project].References.Add(re);
            data.LiteratureTable[ri.literature].References.Add(re);
            return Messages.OK;
        }
        public Messages UpdateReference(ReferenceInfo ri)
        {
            Reference r = GetReference(ri.project, ri.literature);
            if (r == null)
                return Messages.Fail;

            r.Date = ri.date;
            r.Status = ri.status;
            r.Used = ri.used;
            return Messages.OK;
        }
        private Reference GetReference(int project, int literature)
        {
            if (!data.ProjectTable.ContainsKey(project))
                return null;

            foreach (Reference r in data.ProjectTable[project].References)
            {
                if (r.Literature.ID == literature)
                    return r;
            }
            return null;
        }
        public Messages DeleteReference(int project, int literature)
        {
            Reference reference = GetReference(project, literature);
            if (reference == null)
                return Messages.Fail;

            data.ProjectTable[project].References.Remove(reference);
            data.LiteratureTable[literature].References.Remove(reference);
            return Messages.OK;
        }
        public ReferenceInfo GetReferenceInfo(int project, int literature)
        {
            Reference r = GetReference(project, literature);
            if (r == null)
                return new ReferenceInfo();

            if (r is Reference)
            {
                return ((Reference)r).Info;
            }

            return new ReferenceInfo();
        }
        public ReferenceInfo[] ListReferences(int project)
        {
            List<ReferenceInfo> infos = new List<ReferenceInfo>();

            if (!data.ProjectTable.ContainsKey(project) && !data.LiteratureTable.ContainsKey(project))
                return null;

            List<Reference> refs = data.ProjectTable.ContainsKey(project) ? data.ProjectTable[project].References : data.LiteratureTable[project].References;

            foreach (Reference r in refs)
            {
                if (r is Reference && !(r is Review) && !(r is Suggestion))
                {
                    infos.Add(r.Info);
                }
            }
            return infos.ToArray();
        }

        #endregion

        #region Suggestion methods

        public Messages CreateSuggestion(SuggestionInfo si)
        {
            Reference r = GetReference(si.project, si.literature);
            if (r != null && !(r is Reference))
                return Messages.Fail;

            if (!data.PersonTable.ContainsKey(si.person))
                return Messages.Fail;

            List<Comment> comments = null;
            if (r is Reference)
            {
                comments = r.Comments;
                DeleteReference(si.project, si.literature);
            }

            Suggestion rv = new Suggestion(data.ProjectTable[si.project], data.PersonTable[si.person], data.LiteratureTable[si.literature], si.date, si.used, si.status, si.reason);
            if (comments != null)
                rv.Comments.AddRange(comments);
            
            data.ProjectTable[si.project].References.Add(rv);
            data.LiteratureTable[si.literature].References.Add(rv);
            return Messages.OK;
        }
        public Messages UpdateSuggestion(SuggestionInfo si)
        {
            Reference r = GetReference(si.project, si.literature);
            if (r == null || !(r is Suggestion))
                return Messages.Fail;

            Suggestion s = (Suggestion)r;

            s.Date = si.date;
            s.Status = si.status;
            s.Used = si.used;
            s.Reason = si.reason;
            return Messages.OK;
        }
        public SuggestionInfo GetSuggestionInfo(int project, int literature)
        {
            Reference r = GetReference(project, literature);
            if (r == null)
                return new SuggestionInfo();

            if (r is Suggestion)
            {
                return ((Suggestion)r).Info;
            }

            return new SuggestionInfo();
        }
        public SuggestionInfo[] ListSuggestions(int project)
        {
            List<SuggestionInfo> infos = new List<SuggestionInfo>();

            if (!data.ProjectTable.ContainsKey(project) && !data.LiteratureTable.ContainsKey(project))
                return null;

            List<Reference> refs = data.ProjectTable.ContainsKey(project) ? data.ProjectTable[project].References : data.LiteratureTable[project].References;

            foreach (Reference r in refs)
            {
                if (r is Suggestion)
                {
                    infos.Add(((Suggestion)r).Info);
                }
            }
            return infos.ToArray();
        }

        #endregion

        #region Search methods

        private float TermFrequency(string input, string query)
        {
            string[] result = input.ToLower().Split(new string[] { query.ToLower() }, StringSplitOptions.None);
            return result.Length - 1;
        }
        private float WordCount(string input)
        {
            string replaced = Regex.Replace(input, @"[^\w]+", " ");

            string[] words = replaced.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
            return words.Length;
        }
        private float TermFreq(string title, string text, string query)
        {
            float tf = 0, tmpTf;

            tmpTf = TermFrequency(title, query);
            if (tmpTf > 0)
            {
                tmpTf *= 2;
                tf += tmpTf;
            }

            tmpTf = TermFrequency(text, query);
            if (tmpTf > 0)
                tf += tmpTf / WordCount(text);
            return tf;
        }
        public List<SearchResult> Search(string query, ResultType searchTypes)
        {
            query = query.ToLower().Trim();
            List<SearchResult> results = new List<SearchResult>();

            if (query.Length < 3)
                return results;

            int totalDocuments = 0;

            if ((searchTypes & ResultType.Literature) == ResultType.Literature)
                foreach (Literature lit in data.LiteratureTable.Values)
                {
                    StringBuilder people = new StringBuilder();
                    foreach (Reference re in lit.References)
                    {
                        foreach (Role role in re.Project.Roles)
                        {
                            people.AppendLine(role.Person.Name + " " + role.Person.UserName);
                        }
                    }

                    float tf = TermFreq(String.Join(" ", new string[] { lit.Author, lit.ISBN, lit.Title, lit.Creator.UserName, lit.Creator.Name, people.ToString() }), lit.Summary, query);
                    
                    
                    if (tf > 0)
                        results.Add(new SearchResult(tf, lit.Info));

                    totalDocuments++;
                    // AddComments
                }

            if ((searchTypes & ResultType.Person) == ResultType.Person)
                foreach (Person person in data.PersonTable.Values)
                {
                    float tf = TermFreq(String.Join(" ", new string[] { person.Name, person.UserName }), person.Department, query);

                    if (tf > 0)
                        results.Add(new SearchResult(tf, person.Info));

                    totalDocuments++;
                }

            if ((searchTypes & ResultType.Project) == ResultType.Project || (searchTypes & ResultType.Review) == ResultType.Review)
                foreach (Project project in data.ProjectTable.Values)
                {
                    if ((searchTypes & ResultType.Project) == ResultType.Project)
                    {
                        StringBuilder sb = new StringBuilder();
                        foreach (Role r in project.Roles)
                        {
                            sb.Append(r.Person.UserName + " " + r.Person.Name + " ");
                            // Addcomments
                        }


                        float tf = TermFreq(String.Join(" ", new string[] { project.Title, project.Subject }), project.Department + " " + project.Synopsis + " " + sb.ToString(), query);



                        if (tf > 0)
                        {
                            results.Add(new SearchResult(tf, project.Info));
                        }
                        totalDocuments++;
                    }

                    if ((searchTypes & ResultType.Review) == ResultType.Review)
                    {
                        foreach (Reference r in project.References)
                        {
                            if (!(r is Review))
                                continue;

                            Review review = (Review)r;

                            float tf2 = TermFreq(review.Title, review.Text, query);

                            if (tf2 > 0)
                                results.Add(new SearchResult(tf2, review.Info));

                            totalDocuments++;
                            // Addcomments
                        }
                    }


                }
            for (int i = 0; i < results.Count; i++)
            {
                results[i].Relevance /= ((float)results.Count / (float)totalDocuments);
            }


            return results;
        }
        public ISearchable[] ListItems(ResultType type)
        {
            List<ISearchable> searchables = new List<ISearchable>();

            if ((type & ResultType.Project) == ResultType.Project)
            {
                foreach (Project p in data.ProjectTable.Values)
                    searchables.Add(p.Info);
            }

            if ((type & ResultType.Literature) == ResultType.Literature)
            {
                foreach (Literature p in data.LiteratureTable.Values)
                    searchables.Add(p.Info);
            }

            if ((type & ResultType.Person) == ResultType.Person)
            {
                foreach (Person p in data.PersonTable.Values)
                    searchables.Add(p.Info);
            }

            return searchables.ToArray();
        }
        public ISearchable[] ListItems(ResultType type, string creator)
        {
            List<ISearchable> searchables = new List<ISearchable>();

            if ((type & ResultType.Project) == ResultType.Project)
            {
                foreach (Project p in data.ProjectTable.Values)
                {
                    if(GetRole(p.ID, creator) != null)
                        searchables.Add(p.Info);
                }
            }

            if ((type & ResultType.Literature) == ResultType.Literature)
            {
                foreach (Literature p in data.LiteratureTable.Values)
                    if (p.Creator.UserName == creator)
                        searchables.Add(p.Info);
            }

            return searchables.ToArray();
        }


        public List<SearchResult> SearchByTag(string tag)
        {
            TagInfo[] tags = TagInfo.Group(GetTags(tag, -1, null));
            List<SearchResult> list = new List<SearchResult>();
            Array.Sort<TagInfo>(tags, new TagComparer());
            foreach (TagInfo t in tags)
            {
                ISearchable i = data.ProjectTable.ContainsKey(t.ID) ? (ISearchable)data.ProjectTable[t.ID].Info : (ISearchable)data.LiteratureTable[t.ID].Info;
                SearchResult sr = new SearchResult(t.Count, i);
                list.Add(sr);
            }

            return list;
        }
        private class TagComparer : IComparer<TagInfo>
        {
            #region IComparer<TagInfo> Members

            public int Compare(TagInfo x, TagInfo y)
            {
                if (x.Count < y.Count)
                    return 1;
                if (x.Count > y.Count)
                    return -1;
                return 0;
            }

            #endregion
        }

        private class SearchResultComparer : IComparer<SearchResult>
        {
            #region IComparer<SearchResult> Members

            public int Compare(SearchResult x, SearchResult y)
            {
                if (x.Relevance < y.Relevance)
                    return 1;
                if (x.Relevance > y.Relevance)
                    return -1;
                return 0;
            }

            #endregion
        }

        public List<SearchResult> ShowRelated(int id)
        {
            List<SearchResult> sr = new List<SearchResult>();
            Dictionary<int, SearchResult> results = new Dictionary<int, SearchResult>();

            TagInfo[] tags = GetTags(null, id, null);
            tags = TagInfo.Group(tags);

            foreach (TagInfo ti in tags)
            {
                TagInfo[] tags2 = GetTags(ti.Name, -1, null);
                tags2 = TagInfo.Group(tags2);

                foreach (TagInfo ti2 in tags2)
                {
                    ISearchable i = null;
                    if(ti2.ID == id)
                        continue;
                    
                    if(data.ProjectTable.ContainsKey(ti2.ID))
                        i = data.ProjectTable[ti2.ID].Info;
                    
                    if(data.LiteratureTable.ContainsKey(ti2.ID))
                        i = data.LiteratureTable[ti2.ID].Info;

                    if(i == null)
                        continue;

                    if (results.ContainsKey(ti2.ID))
                    {
                        results[ti2.ID].Relevance += ti2.Count * ti.Count;
                    }
                    else
                        results.Add(ti2.ID, new SearchResult(ti2.Count * ti.Count, i));

                }
            }
            sr.AddRange(results.Values);
            sr.Sort(new SearchResultComparer());
            return sr;
        }

        
        #endregion

        #region Tag methods

        public TagInfo[] GetTags(string tag, int id, string username)
        {
            List<string> query = new List<string>();

            if (!string.IsNullOrEmpty(tag))
                query.Add("Tag = '" + tag.Replace("'", "''") + "'");

            if (id >= 0)
                query.Add("ID = '" + id.ToString() + "'");

            if (!string.IsNullOrEmpty(username))
                query.Add("UserName = '" + username.Replace("'", "''") + "'");

            // Get the tag
            DataRow[] rows = data.Tags.Select(String.Join(" AND ", query.ToArray()));
            TagInfo[] tags = new TagInfo[rows.Length];
            for (int i = 0; i < rows.Length; i++)
            {
                tags[i] = new TagInfo(rows[i]["Tag"].ToString(), (int)rows[i]["ID"], rows[i]["UserName"].ToString());
            }
            return tags;
        }
        public Messages AddTag(string tag, int id, string username)
        {
            if (!data.LiteratureTable.ContainsKey(id) && !data.ProjectTable.ContainsKey(id))
                return Messages.Fail;

            // Get the tag
            DataRow[] rows = data.Tags.Select("Tag = '" + tag.Replace("'", "''") + "' AND UserName = '" + username.Replace("'", "''") + "' AND ID = '" + id.ToString() + "'");
            // if the tag was not found
            if (rows.Length == 0)
            {
                data.Tags.Rows.Add(tag, id.ToString(), username);
                data.Tags.AcceptChanges();
                SaveData();
                UniqueTagCount = -1;
                return Messages.OK;
            }
            return Messages.Fail;
        }
        public Messages RemoveTag(string tag, int id, string username)
        {
            if (!data.LiteratureTable.ContainsKey(id) && !data.ProjectTable.ContainsKey(id))
                return Messages.Fail;

            // Get the tag
            DataRow[] rows = data.Tags.Select("Tag = '" + tag.Replace("'", "''") + "' AND UserName = '" + username.Replace("'", "''") + "' AND ID = '" + id.ToString() + "'");
            // if the tag was found
            if (rows.Length == 1)
            {
                data.Tags.Rows.Remove(rows[0]);
                data.Tags.AcceptChanges();
                SaveData();
                UniqueTagCount = -1;
                return Messages.OK;
            }
            return Messages.Fail;
        }

        private int CalcUniqueTags()
        {
            if (UniqueTagCount > -1)
                return UniqueTagCount;

            Dictionary<string, int> tags = new Dictionary<string, int>();
            foreach (DataRow row in data.Tags.Rows)
            {
                if (!tags.ContainsKey(row["Tag"].ToString()))
                    tags.Add(row["Tag"].ToString(), 1);
                else
                    tags[row["Tag"].ToString()]++;
            }
            UniqueTagCount = tags.Count;
            return tags.Count;
        }

        #endregion

        #region Person methods

        public Messages RegisterUser(string user, string password, string name, string department, string email)
        {
            Person p = GetUser(user);
            if (p != null)
                return Messages.UserExists;

            p = new Person(user, password, name, department, email);
            data.PersonTable.Add(p.UserName, p);

            database.SaveData(data);

            return Messages.OK;
        }
        public Person GetUser(string user)
        {
            if (data.PersonTable.ContainsKey(user))
                return data.PersonTable[user];

            return null;
        }
        public PersonInfo GetPersonInfo(string username)
        {
            if (data.PersonTable.ContainsKey(username))
            {
                return data.PersonTable[username].Info;

            }
            return new PersonInfo();
        }
        public Messages UpdatePerson(PersonInfo pi)
        {
            if (!data.PersonTable.ContainsKey(pi.username))
                return Messages.Fail;

            Person p = data.PersonTable[pi.username];
            p.Department = pi.department;
            p.Email = pi.email;
            if (pi.password.Trim().Length > 0)
                p.Password = pi.password;
            p.Name = pi.name;
            return Messages.OK;
        }
        

        #endregion

        #region Role methods
        
        public RoleInfo[] GetRoles(int id)
        {
            if (!data.ProjectTable.ContainsKey(id))
                return new RoleInfo[0];

            RoleInfo[] infos = new RoleInfo[data.ProjectTable[id].Roles.Count];
            for (int i = 0; i < infos.Length; i++)
                infos[i] = data.ProjectTable[id].Roles[i].Info;

            return infos;
        }
        public Messages AssignUser(string username, int project, RoleType role)
        {
            if (!data.PersonTable.ContainsKey(username) || !data.ProjectTable.ContainsKey(project))
                return Messages.Fail;

            data.ProjectTable[project].AddPerson(data.PersonTable[username], role);
            return Messages.OK;
        }
        public Messages UnassignUser(string username, int project)
        {
            if (!data.PersonTable.ContainsKey(username) || !data.ProjectTable.ContainsKey(project))
                return Messages.Fail;

            Role r = data.ProjectTable[project].GetPerson(username);
            if (r != null && r.Type != RoleType.Creator)
                data.ProjectTable[project].Roles.Remove(r);
            return Messages.OK;
        }
        public Role GetRole(int project, string username)
        {
            if (!data.ProjectTable.ContainsKey(project))
                return null;

            return data.ProjectTable[project].GetPerson(username);
        }

        #endregion

        #region Statistics method
        public StatisticsInfo GetStatistics()
        {
            return new StatisticsInfo(data.ProjectTable.Count, CalcUniqueTags(), data.Tags.Rows.Count, data.LiteratureTable.Count, data.PersonTable.Count);
        }

        #endregion
    }
}

---