RMIAccessHandler.cs

using System;
using System.Collections.Generic;
using System.Text;
using Shared;

namespace Server.Net
{
    public class RMIAccessHandler : MarshalByRefObject, IAccessHandler
    {
        #region Constructor, properties and private variables
        
        private Person user = null;
        private Catalogue catalogue;
        
        public RMIAccessHandler(Catalogue catalogue)
        {
            this.catalogue = catalogue;
        }
        public string WhoAmI
        {
            get
            {
                if (user == null)
                    return null;
                return user.UserName;
            }
        }

        #endregion
        
        #region Projects
        public ProjectInfo GetProjectInfo(int id)
        {
            if (user == null)
                return new ProjectInfo();

            return catalogue.GetProjectInfo(id);
        }
        public ProjectInfo[] ListProjects()
        {
            if (user == null)
                return null;

            return catalogue.ListProjects();
        }
        public Messages CreateProject(ProjectInfo pi, out int id)
        {
            id = -1;
            if (user == null)
                return Messages.OperationNotAllowed;

            return catalogue.CreateProject(pi, user.UserName, out id);
        }
        public Messages UpdateProject(ProjectInfo info)
        {
            if (user == null)
                return Messages.OperationNotAllowed;

            Project p = catalogue.GetProject(info.id);
            if (p == null)
                return Messages.Fail;

            Role person = p.GetPerson(user.UserName);
            if (person == null)
                return Messages.OperationNotAllowed;

            return catalogue.UpdateProject(info);
        }
        public Messages DeleteProject(int id)
        {
            if (user == null)
                return Messages.OperationNotAllowed;

            if (user.Moderator == true) return catalogue.DeleteProject(id);

            Project p = catalogue.GetProject(id);
            Role r = p.GetPerson(user.UserName);

            if (r != null && r.Person == user && r.Type == RoleType.Creator)
            {
                return catalogue.DeleteProject(id);
            }
            else
            {
                return Messages.OperationNotAllowed;
            }
        }
        public ProjectInfo[] GetUsersProjects(string username)
        {
            return catalogue.GetUsersProjects(username);
        }
        #endregion

        #region Literature

        public LiteratureInfo[] ListLiterature()
        {
            if (user == null)
                return new LiteratureInfo[0];

            return catalogue.ListLiterature();
        }
        public LiteratureInfo GetLiteratureInfo(int id)
        {
            if (user == null)
                return new LiteratureInfo();

            return catalogue.GetLiteratureInfo(id);

        }
        public Messages CreateLiterature(out int id, LiteratureInfo info)
        {
            id = -1;
            if (user == null)
                return Messages.OperationNotAllowed;

            info.creator = user.UserName;

            return catalogue.CreateLiterature(info, out id);
        }
        public Messages UpdateLiterature(LiteratureInfo info)
        {
            if (user == null)
                return Messages.OperationNotAllowed;

            LiteratureInfo l = GetLiteratureInfo(info.id);
            if (l.creator == user.UserName)
                return catalogue.UpdateLiterature(info);

            return Messages.OperationNotAllowed;
        }
        public Messages DeleteLiterature(int id)
        {
            if (user == null)
                return Messages.OperationNotAllowed;

            if (user.Moderator == true) return catalogue.DeleteLiterature(id);

            LiteratureInfo li = catalogue.GetLiteratureInfo(id);
            if (li.creator == user.UserName)
                return catalogue.DeleteLiterature(id);
            else
                return Messages.OperationNotAllowed;
        }

        #endregion

        #region References

        public ReferenceInfo[] ListReferences(int project)
        {
            if (user == null)
                return null;

            return catalogue.ListReferences(project);
        }
        public ReferenceInfo GetReferenceInfo(int project, int literature)
        {
            if (user == null)
                return new ReferenceInfo();

            return catalogue.GetReferenceInfo(project, literature);
        }
        public Messages CreateReference(ReferenceInfo ri)
        {
            if (user == null)
                return Messages.OperationNotAllowed;

            Role m = catalogue.GetRole(ri.project, user.UserName);
            if (m == null || m.Type == RoleType.Supervisor)
                return Messages.OperationNotAllowed;

            return catalogue.CreateReference(ri);
        }
        public Messages UpdateReference(ReferenceInfo ri)
        {
            if (user == null)
                return Messages.OperationNotAllowed;

            Role m = catalogue.GetRole(ri.project, user.UserName);
            if (m == null || m.Type == RoleType.Supervisor)
                return Messages.OperationNotAllowed;

            return catalogue.UpdateReference(ri);
        }
        public Messages DeleteReference(int project, int literature)
        {
            if (user == null)
                return Messages.OperationNotAllowed;

            Role m = catalogue.GetRole(project, user.UserName);
            if (m == null || m.Type == RoleType.Supervisor)
                return Messages.OperationNotAllowed;

            return catalogue.DeleteReference(project, literature);
        }

        #endregion

        #region Search

        public List<SearchResult> Search(string query)
        {
            if (user == null)
                return null;

            return catalogue.Search(query, ResultType.All);
        }
        public List<SearchResult> Search(string query, ResultType searchTypes)
        {
            if (user == null)
                return null;

            return catalogue.Search(query, searchTypes);
        }
        public List<SearchResult> SearchByTag(string tag)
        {
            if (user == null)
                return null;

            return catalogue.SearchByTag(tag);
        }
        public ISearchable[] ListItems(ResultType type)
        {
            if (user == null)
                return new ISearchable[0];

            return catalogue.ListItems(type);
        }
        public ISearchable[] ListItems(ResultType type, string creator)
        {
            if (user == null)
                return new ISearchable[0];

            return catalogue.ListItems(type,creator);
        }



        #endregion

        #region Suggestions

        public SuggestionInfo[] ListSuggestions(int project)
        {
            if (user == null)
                return null;

            return catalogue.ListSuggestions(project);
        }
        public SuggestionInfo GetSuggestionInfo(int project, int literature)
        {
            if (user == null)
                return new SuggestionInfo();

            return catalogue.GetSuggestionInfo(project, literature);
        }
        public Messages CreateSuggestion(SuggestionInfo si)
        {
            if (user == null)
                return Messages.OperationNotAllowed;

            Role m = catalogue.GetRole(si.project, user.UserName);
            if (m == null || m.Type != RoleType.Supervisor)
                return Messages.OperationNotAllowed;

            return catalogue.CreateSuggestion(si);
        }
        public Messages UpdateSuggestion(SuggestionInfo si)
        {
            if (user == null)
                return Messages.OperationNotAllowed;

            Role m = catalogue.GetRole(si.project, user.UserName);
            if (m == null)
                return Messages.OperationNotAllowed;

            return catalogue.UpdateSuggestion(si);
        }
        

        #endregion

        #region Reviews

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

            return catalogue.GetReviewInfo(project, literature);
        }
        public ReviewInfo[] ListReviews(int project)
        {
            if (user == null)
                return null;

            return catalogue.ListReviews(project);
        }
        public Messages CreateReview(ReviewInfo ri)
        {
            ri.person = this.user.UserName;
            if (user == null)
                return Messages.OperationNotAllowed;

            Role m = catalogue.GetRole(ri.project, user.UserName);
            if (m == null || m.Type == RoleType.Supervisor)
                return Messages.OperationNotAllowed;

            return catalogue.CreateReview(ri);
        }
        public Messages UpdateReview(ReviewInfo ri)
        {
            if (user == null)
                return Messages.OperationNotAllowed;

            Role m = catalogue.GetRole(ri.project, user.UserName);
            if (m == null || m.Type == RoleType.Supervisor)
                return Messages.OperationNotAllowed;

            return catalogue.UpdateReview(ri);
        }
        

        #endregion

        #region Tags

        public TagInfo[] GetAllTags()
        {
            return GetTags(null, -1, null);
        }
        public TagInfo[] GetTags(string tag, int id, string username)
        {
            if (user == null)
                return new TagInfo[0];

            return catalogue.GetTags(tag, id, username);
        }
        public Messages AddTag(string tag, int id)
        {
            if (user != null)
            {
                catalogue.AddTag(tag, id, user.UserName);
                return Messages.OK;
            }
            else return Messages.OperationNotAllowed;
        }
        public Messages RemoveTag(string tag, int id)
        {
            if (user != null)
            {
                catalogue.RemoveTag(tag, id, user.UserName);
                return Messages.OK;
            }
            else return Messages.OperationNotAllowed;
        }
        

        #endregion

        #region Persons & Roles  

        public PersonInfo GetPersonInfo(string username)
        {
            if (user == null)
                return new PersonInfo();
            return catalogue.GetPersonInfo(username);
        }
        public Messages Register(string user, string password, string name, string department, string email)
        {
            return catalogue.RegisterUser(user, password, name, department, email);
        }
        public Messages Login(string user, string password)
        {
            Person p = catalogue.GetUser(user);
            if (p == null)
                return Messages.LoginFailed;

            if (p.Password == password)
            {
                this.user = p;
                return Messages.OK;
            }

            return Messages.LoginFailed;
        }
        public Messages UpdatePerson(PersonInfo pi)
        {
            if (user == null)
                return Messages.OperationNotAllowed;

            if (pi.username != user.UserName)
                return Messages.OperationNotAllowed;

            return catalogue.UpdatePerson(pi);


        }
        public RoleInfo[] GetRoles(int id)
        {
            if (user == null)
                return null;

            return catalogue.GetRoles(id);
        }
        public Messages AssignUser(string username, int project, RoleType role)
        {
            if (username == null)
                return Messages.Fail;
            if (role == RoleType.Creator)
                return Messages.OperationNotAllowed;

            Project p = catalogue.GetProject(project);
            if (p == null)
                return Messages.Fail;

            Role r = p.GetPerson(user.UserName);
            if (r == null || r.Type != RoleType.Creator)
                return Messages.OperationNotAllowed;

            return catalogue.AssignUser(username, project, role);
        }
        public Messages UnassignUser(string username, int project)
        {
            if (username == null)
                return Messages.Fail;

            Project p = catalogue.GetProject(project);
            if (p == null)
                return Messages.Fail;

            Role r = p.GetPerson(user.UserName);
            if (r == null || r.Type != RoleType.Creator)
                return Messages.OperationNotAllowed;

            Role role = p.GetPerson(username);
            if (role == null)
                return Messages.Fail;

            p.Roles.Remove(role);

            return Messages.OK;
        }

        #endregion

        #region Comments

        public CommentInfo[] GetComments(int literatureID, int projectID)
        {
            return catalogue.GetComments(literatureID, projectID);
        }
        public CommentInfo[] GetComments(int literatureID)
        {
            return catalogue.GetComments(literatureID);
        }
        public Messages CreateComment(CommentInfo ci, out int id)
        {
            return catalogue.CreateComment(ci, out id);
        }

        #endregion 
    
        public StatisticsInfo GetStatistics()
        {
            if (user == null)
                return new StatisticsInfo();
            return catalogue.GetStatistics();
        }

        public List<SearchResult> ShowRelated(int id)
        {
            if (user == null)
                return null;

            return catalogue.ShowRelated(id);
        }
    }
}

---