source: branches/ClientUserManagement/HeuristicLab.Services.Access/3.3/AccessService.cs @ 7357

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Web.Security;
using HeuristicLab.GeoIP;
using DA = HeuristicLab.Services.Access.DataAccess;
using DT = HeuristicLab.Services.Access.DataTransfer;

namespace HeuristicLab.Services.Access {
  [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
  public class AccessService : IAccessService {
    private IUserManager userManager;
    private IUserManager UserManager {
      get {
        if (userManager == null) userManager = new UserManager();
        return userManager;
      }
    }

    private IRoleVerifier roleVerifier;
    private IRoleVerifier RoleVerifier {
      get {
        if (roleVerifier == null) roleVerifier = new RoleVerifier();
        return roleVerifier;
      }
    }

    #region Client Members
    public bool ClientExists(Guid id) {
      if (id != Guid.Empty) {
        using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
          return (context.Resources.Where(x => x.Id == id).Count() != 0);
        }
      }
      return false;
    }

    public DT.Client GetClient(Guid id) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from c in context.GetTable<DA.Resource>().OfType<DA.Client>()
                    where c.Id == id
                    select c;

        return Convert.ToDto(query.FirstOrDefault());
      }
    }

    public IEnumerable<DT.Client> GetClients(IEnumerable<Guid> ids) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from c in context.GetTable<DA.Resource>().OfType<DA.Client>()
                    where ids.Contains(c.Id)
                    select Convert.ToDto(c);
        return query.ToList();
      }
    }

    public IEnumerable<DT.Client> GetAllClients() {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from c in context.GetTable<DA.Resource>().OfType<DA.Client>()
                    select Convert.ToDto(c);
        return query.ToList();
      }
    }

    public Guid AddClient(DT.Client client) {
      string country = string.Empty;

      OperationContext opContext = OperationContext.Current;

      if (opContext != null) {
        MessageProperties properties = opContext.IncomingMessageProperties;
        RemoteEndpointMessageProperty endpoint = properties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty;
        string ipAdr = endpoint.Address;
        country = GeoIPLookupService.Instance.GetCountryName(ipAdr);
      }

      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        DA.Client entity = Convert.ToEntity(client);

        if (country != string.Empty) {
          var query = from c in context.GetTable<DA.Country>()
                      where c.Name == country
                      select c;

          if (query.Count() > 0) {
            entity.CountryId = query.First().Id;
          }
        }

        context.Resources.InsertOnSubmit(entity);
        context.SubmitChanges();
        return entity.Id;
      }
    }

    public void UpdateClient(DT.Client client) {
      AddClient(client);
    }

    public void DeleteClient(DT.Client client) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        //load client because we could get a detached object
        var query = from c in context.GetTable<DA.Resource>().OfType<DA.Client>()
                    where c.Id == client.Id
                    select c;
        if (query.Count() > 0) {

          //delete affiliation first
          var queryMapping = context.ResourceResourceGroups.Where(x => x.ResourceId == client.Id);
          if (queryMapping.Count() > 0) {
            context.ResourceResourceGroups.DeleteAllOnSubmit(queryMapping);
          }

          context.Resources.DeleteOnSubmit(query.First());
          context.SubmitChanges();
        }
      }
    }
    #endregion

    #region ClientGroup
    public IEnumerable<DT.ClientGroup> GetAllClientGroups() {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from c in context.GetTable<DA.Resource>().OfType<DA.ClientGroup>()
                    select Convert.ToDto(c);
        return query.ToList();
      }
    }

    public IEnumerable<DT.ClientGroup> GetClientGroups(IEnumerable<Guid> ids) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from c in context.GetTable<DA.Resource>().OfType<DA.ClientGroup>()
                    where ids.Contains(c.Id)
                    select Convert.ToDto(c);
        return query.ToList();
      }
    }

    public Guid AddClientGroup(DT.ClientGroup group) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var entity = Convert.ToEntity(group);
        context.Resources.InsertOnSubmit(entity);
        context.SubmitChanges();
        return entity.Id;
      }
    }

    public void UpdateClientGroup(DT.ClientGroup group) {
      AddClientGroup(group);
    }

    public void DeleteClientGroup(DT.ClientGroup clientGroup) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        //load clientGroup because we could get a detached object
        var query = from c in context.GetTable<DA.Resource>().OfType<DA.ClientGroup>()
                    where c.Id == clientGroup.Id
                    select c;
        if (query.Count() > 0) {
          context.Resources.DeleteOnSubmit(query.First());
          context.SubmitChanges();
        }
      }
    }

    public void AddResourceToGroup(DT.Resource resource, DT.ClientGroup group) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        DA.ResourceResourceGroup rrg = new DA.ResourceResourceGroup() {
          ResourceId = resource.Id,
          ResourceGroupId = group.Id
        };

        context.ResourceResourceGroups.InsertOnSubmit(rrg);
        context.SubmitChanges();
      }
    }

    public void RemoveResourceFromGroup(DT.Resource resource, DT.ClientGroup group) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = context.ResourceResourceGroups.Where(x => x.ResourceId == resource.Id && x.ResourceGroupId == group.Id);
        if (query.Count() > 0) {
          context.ResourceResourceGroups.DeleteOnSubmit(query.First());
          context.SubmitChanges();
        }
      }
    }
    #endregion

    #region ClientGroupMapping
    public IEnumerable<DT.ClientGroupMapping> GetClientGroupMapping() {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from c in context.GetTable<DA.ResourceResourceGroup>()
                    select Convert.ToDto(c);
        return query.ToList();
      }
    }
    #endregion

    #region Resource
    public IEnumerable<DT.Resource> GetResources() {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from r in context.Resources
                    select Convert.ToDto(r);
        return query.ToList();
      }
    }
    #endregion

    #region ClientLog
    public DT.ClientLog GetLastClientLog(Guid clientId) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from r in context.ClientLogs
                    where r.ResourceId == clientId
                    select r;
        return Convert.ToDto(query.OrderBy(x => x.Timestamp).LastOrDefault());
      }
    }

    public IEnumerable<DT.ClientLog> GetClientLogs(Guid clientId) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from r in context.ClientLogs
                    where r.ResourceId == clientId
                    select Convert.ToDto(r);
        return query.ToList();
      }
    }

    public IEnumerable<DT.ClientLog> GetClientLogsSince(DateTime startDate) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from r in context.ClientLogs
                    where r.Timestamp >= startDate
                    select Convert.ToDto(r);
        return query.ToList();
      }
    }

    public void AddClientLog(DT.ClientLog log) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        context.ClientLogs.InsertOnSubmit(Convert.ToEntity(log));
        context.SubmitChanges();
      }
    }

    public void DeleteClientLog(DT.ClientLog log) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        context.ClientLogs.DeleteOnSubmit(Convert.ToEntity(log));
        context.SubmitChanges();
      }
    }
    #endregion

    #region User
    private DT.User BuildUserDto(Guid userId) {
      DA.aspnet_User aspUser = null;
      DA.aspnet_Membership aspMembership = null;
      DA.User accessUser = null;

      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from u in context.UserGroupBases.OfType<DA.User>()
                    where u.Id == userId
                    select u;
        if (query.Count() == 1) {
          accessUser = query.First();
        }
      }

      using (DA.ASPNETAuthenticationDataContext context = new DA.ASPNETAuthenticationDataContext()) {
        var userQuery = from u in context.aspnet_Users
                        where u.UserId == userId
                        select u;
        if (userQuery.Count() == 1) {
          aspUser = userQuery.First();
        }

        var memQuery = from u in context.aspnet_Memberships
                       where u.UserId == userId
                       select u;
        if (memQuery.Count() == 1) {
          aspMembership = memQuery.First();
        }
      }

      if (aspUser == null || aspMembership == null || accessUser == null) {
        //TODO: error handling
        return null;
      } else {
        return Convert.ToDto(accessUser, aspUser, aspMembership);
      }
    }

    public DT.User Login() {
      Guid userId = UserManager.CurrentUserId;
      return BuildUserDto(userId);
    }

    public IEnumerable<DT.User> GetAllUsers() {
      List<Guid> accessUserGuids = null;

      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from u in context.UserGroupBases.OfType<DA.User>()
                    select u.Id;
        accessUserGuids = query.ToList();
      }

      return accessUserGuids.Select(x => BuildUserDto(x));
    }

    public IEnumerable<DT.User> GetUsers(IEnumerable<Guid> ids) {
      List<Guid> accessUserGuids = null;

      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from u in context.UserGroupBases.OfType<DA.User>()
                    where ids.Contains(u.Id)
                    select u.Id;
        accessUserGuids = query.ToList();
      }

      return accessUserGuids.Select(x => BuildUserDto(x));
    }

    public DT.User AddUser(DT.User user) {
      DA.User accessUser;
      DA.aspnet_User aspUser;
      DA.aspnet_Membership aspMembership;
      bool userExistsInASP;

      Convert.ToEntity(user, out accessUser, out aspUser, out aspMembership, out userExistsInASP);

      if (userExistsInASP) {
        if (accessUser.Id == null || accessUser.Id == Guid.Empty) {
          accessUser.Id = aspMembership.UserId;
        }
        using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
          context.UserGroupBases.InsertOnSubmit(accessUser);
          context.SubmitChanges();
        }
        MembershipUser membershipUser = Membership.GetUser((object)accessUser.Id);
        if (membershipUser != null) {
          membershipUser.Email = aspMembership.Email;
          membershipUser.IsApproved = aspMembership.IsApproved;
          membershipUser.Comment = aspMembership.Comment;
          Membership.UpdateUser(membershipUser);
        }
      } else {
        MembershipUser membershipUser = Membership.CreateUser(aspUser.UserName, aspUser.UserName, aspMembership.Email);
        membershipUser.IsApproved = aspMembership.IsApproved;
        membershipUser.Comment = aspMembership.Comment;
        Membership.UpdateUser(membershipUser);

        Guid userId = (Guid)membershipUser.ProviderUserKey;
        accessUser.Id = userId;

        using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
          context.UserGroupBases.InsertOnSubmit(accessUser);
          context.SubmitChanges();
        }
      }

      using (DA.ASPNETAuthenticationDataContext context = new DA.ASPNETAuthenticationDataContext()) {
        var newAspUser = context.aspnet_Users.Where(x => x.UserId == accessUser.Id).FirstOrDefault();
        var newAspMembership = context.aspnet_Memberships.Where(x => x.UserId == accessUser.Id).FirstOrDefault();
        return Convert.ToDto(accessUser, newAspUser, newAspMembership);
      }
    }

    public void DeleteUser(DT.User user) {
      if (user.Id != null && user.Id != Guid.Empty) {
        //delete asp.net user
        Membership.DeleteUser(user.UserName);
        using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
          var query = context.UserGroupBases.OfType<DA.User>().Where(x => x.Id == user.Id);
          if (query.Count() > 0) {

            //delete affiliation first
            var queryMapping = context.UserGroupUserGroups.Where(x => x.UserGroupId == user.Id);
            if (queryMapping.Count() > 0) {
              context.UserGroupUserGroups.DeleteAllOnSubmit(queryMapping);
            }

            //delete user from access db
            context.UserGroupBases.DeleteOnSubmit(query.First());
            context.SubmitChanges();
          }
        }
      }
    }

    public void UpdateUser(DT.User user) {
      AddUser(user);
    }

    public void AddUserToRole(DT.Role role, DT.User user) {
      //TODO: usernames and rolenames have to be unique!
      MembershipUser msUser = Membership.GetUser((object)user.Id);
      if (msUser != null) {
        Roles.AddUserToRole(msUser.UserName, role.Name);
      }
    }

    public void RemoveUserFromRole(DT.Role role, DT.User user) {
      MembershipUser msUser = Membership.GetUser((object)user.Id);
      if (msUser != null) {
        Roles.RemoveUserFromRole(msUser.UserName, role.Name);
      }
    }

    public bool ResetPassword(DT.User user, string oldPassword, string newPassword) {
      MembershipUser msUser = Membership.GetUser((object)user.Id);
      if (msUser != null) {
        return msUser.ChangePassword(oldPassword, newPassword);
      }
      return false;
    }
    #endregion

    #region UserGroup
    public IEnumerable<DT.UserGroup> GetAllUserGroups() {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from u in context.UserGroupBases.OfType<DA.UserGroup>()
                    select Convert.ToDto(u);
        return query.ToList();
      }
    }

    public IEnumerable<DT.UserGroup> GetUserGroups(IEnumerable<Guid> ids) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from u in context.UserGroupBases.OfType<DA.UserGroup>()
                    where ids.Contains(u.Id)
                    select Convert.ToDto(u);
        return query.ToList();
      }
    }

    public Guid AddUserGroup(DT.UserGroup group) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        //because id is not automatically set because of user, we have to do it here manually for group
        group.Id = Guid.NewGuid();
        context.UserGroupBases.InsertOnSubmit(Convert.ToEntity(group));
        context.SubmitChanges();
        return group.Id;
      }
    }

    public void UpdateUserGroup(DT.UserGroup group) {
      AddUserGroup(group);
    }

    public void DeleteUserGroup(DT.UserGroup group) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        context.UserGroupBases.DeleteOnSubmit(Convert.ToEntity(group));
        context.SubmitChanges();
      }
    }

    public void AddUserGroupBaseToGroup(DT.UserGroupBase resource, DT.UserGroup group) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        DA.UserGroupUserGroup ugug = new DA.UserGroupUserGroup();
        ugug.UserGroupId = resource.Id;
        ugug.UserGroupUserGroupId = group.Id;
        context.UserGroupUserGroups.InsertOnSubmit(ugug);
        context.SubmitChanges();
      }
    }

    public void RemoveUserGroupBaseFromGroup(DT.UserGroupBase resource, DT.UserGroup userGroup) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from u in context.UserGroupUserGroups
                    where u.UserGroupId == resource.Id && u.UserGroupUserGroupId == userGroup.Id
                    select u;

        if (query.Count() == 1) {
          context.UserGroupUserGroups.DeleteOnSubmit(query.First());
          context.SubmitChanges();
        }
      }
    }

    public IEnumerable<DT.UserGroupBase> GetUsersAndGroups() {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from u in context.UserGroupBases
                    select Convert.ToDto(u);
        return query.ToList();
      }
    }

    public IEnumerable<DT.UserGroupMapping> GetUserGroupMapping() {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from u in context.UserGroupUserGroups
                    select Convert.ToDto(u);
        return query.ToList();
      }
    }
    #endregion

    #region Roles
    public IEnumerable<DT.Role> GetRoles() {
      using (DA.ASPNETAuthenticationDataContext context = new DA.ASPNETAuthenticationDataContext()) {
        var query = from u in context.aspnet_Roles
                    select Convert.ToDto(u);
        return query.ToList();
      }
    }

    public DT.Role AddRole(DT.Role role) {
      Roles.CreateRole(role.Name);
      return role;
    }

    public void DeleteRole(DT.Role role) {
      Roles.DeleteRole(role.Name);
    }

    public IEnumerable<DT.Role> GetUserRoles(DT.User user) {
      var roles = Roles.GetRolesForUser(user.UserName);
      return roles.Select(x => new DT.Role() { Name = x });
    }

    public void AddRoleToGroup(DT.UserGroup userGroup, DT.Role role) {
      Guid[] userIds;
      string[] aspUsers;

      using (DA.ClientManagementDataContext accessContext = new DA.ClientManagementDataContext()) {
        userIds = (from u in accessContext.UserGroupUserGroups
                   where u.UserGroupUserGroupId == userGroup.Id
                   select u.UserGroupId).ToArray();
      }

      using (DA.ASPNETAuthenticationDataContext aspContext = new DA.ASPNETAuthenticationDataContext()) {
        aspUsers = (from u in aspContext.aspnet_Users
                    where userIds.Contains(u.UserId)
                    select u.UserName).ToArray();
      }

      Roles.AddUsersToRole(aspUsers, role.Name);

    }

    public void RemoveRoleFromGroup(DT.UserGroup userGroup, DT.Role role) {
      Guid[] userIds;
      string[] aspUsers;

      using (DA.ClientManagementDataContext accessContext = new DA.ClientManagementDataContext()) {
        userIds = (from u in accessContext.UserGroupUserGroups
                   where u.UserGroupUserGroupId == userGroup.Id
                   select u.UserGroupId).ToArray();
      }

      using (DA.ASPNETAuthenticationDataContext aspContext = new DA.ASPNETAuthenticationDataContext()) {
        aspUsers = (from u in aspContext.aspnet_Users
                    where userIds.Contains(u.UserId)
                    select u.UserName).ToArray();
      }

      Roles.RemoveUsersFromRole(aspUsers.ToArray(), role.Name);
    }
    #endregion

    #region Error Reporting
    public void ReportError(DT.ClientError error) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        context.ClientErrors.InsertOnSubmit(Convert.ToEntity(error));
        context.SubmitChanges();
      }
    }

    public IEnumerable<DT.ClientError> GetClientErrors() {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from c in context.ClientErrors
                    select Convert.ToDto(c);
        return query.ToList();
      }
    }

    public IEnumerable<DT.ClientError> GetLastClientErrors(DateTime startDate) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = from c in context.ClientErrors
                    where c.Timestamp >= startDate
                    select Convert.ToDto(c);
        return query.ToList();
      }
    }

    public void DeleteError(DT.ClientError error) {
      using (DA.ClientManagementDataContext context = new DA.ClientManagementDataContext()) {
        var query = context.ClientErrors.Where(x => x.Id == error.Id);
        if (query.Count() > 0) {
          context.ClientErrors.DeleteOnSubmit(query.First());
          context.SubmitChanges();
        }
      }
    }
    #endregion
  }
}