Index: branches/HivePerformance/sources/HeuristicLab.Services.Hive/3.3/Manager/AuthorizationManager.cs
===================================================================
--- branches/HivePerformance/sources/HeuristicLab.Services.Hive/3.3/Manager/AuthorizationManager.cs	(revision 9385)
+++ branches/HivePerformance/sources/HeuristicLab.Services.Hive/3.3/Manager/AuthorizationManager.cs	(revision 9391)
@@ -36,5 +36,5 @@
       if (ServiceLocator.Instance.RoleVerifier.IsInRole(HiveRoles.Slave)) return; // slave-users can access all tasks
 
-      Permission permission = ServiceLocator.Instance.HiveDao.GetPermissionForTask(taskId, ServiceLocator.Instance.UserManager.CurrentUserId);
+      Permission permission = ServiceLocator.Instance.HiveDtoDao.GetPermissionForTask(taskId, ServiceLocator.Instance.UserManager.CurrentUserId);
       if (permission == Permission.NotAllowed || (permission != DT.Convert.ToEntity(requiredPermission) && DT.Convert.ToEntity(requiredPermission) == Permission.Full))
         throw new SecurityException("Current user is not authorized to access task");
@@ -42,5 +42,5 @@
 
     public void AuthorizeForJob(Guid jobId, DT.Permission requiredPermission) {
-      Permission permission = ServiceLocator.Instance.HiveDao.GetPermissionForJob(jobId, ServiceLocator.Instance.UserManager.CurrentUserId);
+      Permission permission = ServiceLocator.Instance.HiveDtoDao.GetPermissionForJob(jobId, ServiceLocator.Instance.UserManager.CurrentUserId);
       if (permission == Permission.NotAllowed || (permission != DT.Convert.ToEntity(requiredPermission) && DT.Convert.ToEntity(requiredPermission) == Permission.Full))
         throw new SecurityException("Current user is not authorized to access task");
@@ -48,5 +48,5 @@
 
     public void AuthorizeForResourceAdministration(Guid resourceId) {
-      Resource resource = DT.Convert.ToEntity(ServiceLocator.Instance.HiveDao.GetResource(resourceId));
+      Resource resource = DT.Convert.ToEntity(ServiceLocator.Instance.HiveDtoDao.GetResource(resourceId));
       if (resource.OwnerUserId != ServiceLocator.Instance.UserManager.CurrentUserId && !ServiceLocator.Instance.RoleVerifier.IsInRole(HiveRoles.Administrator))
         throw new SecurityException("Current user is not authorized to access resource");
Index: branches/HivePerformance/sources/HeuristicLab.Services.Hive/3.3/Manager/EventManager.cs
===================================================================
--- branches/HivePerformance/sources/HeuristicLab.Services.Hive/3.3/Manager/EventManager.cs	(revision 9385)
+++ branches/HivePerformance/sources/HeuristicLab.Services.Hive/3.3/Manager/EventManager.cs	(revision 9391)
@@ -32,6 +32,6 @@
   /// </summary>
   public class EventManager : IEventManager {
-    private IHiveDao dao {
-      get { return ServiceLocator.Instance.HiveDao; }
+    private IHiveDtoDao dao {
+      get { return ServiceLocator.Instance.HiveDtoDao; }
     }
     private IAuthorizationManager auth {
@@ -78,5 +78,5 @@
       //we have to find another way to deal with this.  
       //until then the next line is commented out...
-      //stats.UserStatistics = dao.GetUserStatistics();
+      //stats.UserStatistics = dtoDao.GetUserStatistics();
       dao.AddStatistics(stats);
     }
Index: branches/HivePerformance/sources/HeuristicLab.Services.Hive/3.3/Manager/HeartbeatManager.cs
===================================================================
--- branches/HivePerformance/sources/HeuristicLab.Services.Hive/3.3/Manager/HeartbeatManager.cs	(revision 9385)
+++ branches/HivePerformance/sources/HeuristicLab.Services.Hive/3.3/Manager/HeartbeatManager.cs	(revision 9391)
@@ -24,6 +24,6 @@
 using System.Linq;
 using System.Threading;
-using HeuristicLab.Services.Hive.DataTransfer;
-using DA = HeuristicLab.Services.Hive.DataAccess;
+using HeuristicLab.Services.Hive.DataAccess;
+using Heartbeat = HeuristicLab.Services.Hive.DataTransfer.Heartbeat;
 
 namespace HeuristicLab.Services.Hive {
@@ -48,7 +48,7 @@
       List<MessageContainer> actions = new List<MessageContainer>();
 
-      DA.Slave slave = null;
+      Slave slave = null;
       trans.UseTransaction(() => {
-        slave = dao.GetSlaveDA(heartbeat.SlaveId);
+        slave = dao.GetSlaveById(heartbeat.SlaveId);
 
         if (slave == null) {
@@ -67,8 +67,8 @@
           slave.CpuUtilization = heartbeat.CpuUtilization;
           slave.IsAllowedToCalculate = SlaveIsAllowedToCalculate(slave.ResourceId);
-          slave.SlaveState = (heartbeat.JobProgress != null && heartbeat.JobProgress.Count > 0) ? DA.SlaveState.Calculating : DA.SlaveState.Idle;
+          slave.SlaveState = (heartbeat.JobProgress != null && heartbeat.JobProgress.Count > 0) ? SlaveState.Calculating : SlaveState.Idle;
           slave.LastHeartbeat = DateTime.Now;
 
-          dao.UpdateSlaveDA(slave);
+          dao.UpdateSlave(slave);
         }
       });
@@ -86,9 +86,9 @@
             mutexAquired = mutex.WaitOne(Properties.Settings.Default.SchedulingPatience);
             if (!mutexAquired)
-              DA.LogFactory.GetLogger(this.GetType().Namespace).Log("HeartbeatManager: The mutex used for scheduling could not be aquired.");
+              LogFactory.GetLogger(this.GetType().Namespace).Log("HeartbeatManager: The mutex used for scheduling could not be aquired.");
             else {
               trans.UseTransaction(() => {
                 IEnumerable<TaskInfoForScheduler> availableTasks = null;
-                availableTasks = taskScheduler.Schedule(dao.GetWaitingTasksDA(slave).ToArray());
+                availableTasks = taskScheduler.Schedule(dao.GetWaitingTasks(slave).ToArray());
                 if (availableTasks.Any()) {
                   var task = availableTasks.First();
@@ -100,8 +100,8 @@
           }
           catch (AbandonedMutexException) {
-            DA.LogFactory.GetLogger(this.GetType().Namespace).Log("HeartbeatManager: The mutex used for scheduling has been abandoned.");
+            LogFactory.GetLogger(this.GetType().Namespace).Log("HeartbeatManager: The mutex used for scheduling has been abandoned.");
           }
           catch (Exception ex) {
-            DA.LogFactory.GetLogger(this.GetType().Namespace).Log("HeartbeatManager threw an exception in ProcessHeartbeat: " + ex.ToString());
+            LogFactory.GetLogger(this.GetType().Namespace).Log("HeartbeatManager threw an exception in ProcessHeartbeat: " + ex.ToString());
           }
           finally {
@@ -113,10 +113,10 @@
     }
 
-    private void AssignJob(DA.Slave slave, Guid taskId) {
-      var task = dao.UpdateTaskStateDA(taskId, DataAccess.TaskState.Transferring, slave.ResourceId, null, null);
+    private void AssignJob(Slave slave, Guid taskId) {
+      var task = dao.UpdateTaskState(taskId, DataAccess.TaskState.Transferring, slave.ResourceId, null, null);
 
       // from now on the task has some time to send the next heartbeat (ApplicationConstants.TransferringJobHeartbeatTimeout)
       task.LastHeartbeat = DateTime.Now;
-      dao.UpdateTaskDA(task);
+      dao.UpdateTask(task);
     }
 
@@ -137,9 +137,9 @@
         foreach (var jobProgress in heartbeat.JobProgress) {
           trans.UseTransaction(() => {
-            var curTask = dao.GetTaskDA(jobProgress.Key);
+            var curTask = dao.GetTaskById(jobProgress.Key);
             if (curTask == null) {
               // task does not exist in db
               actions.Add(new MessageContainer(MessageContainer.MessageType.AbortTask, jobProgress.Key));
-              DA.LogFactory.GetLogger(this.GetType().Namespace).Log("Task on slave " + heartbeat.SlaveId + " does not exist in DB: " + jobProgress.Key);
+              LogFactory.GetLogger(this.GetType().Namespace).Log("Task on slave " + heartbeat.SlaveId + " does not exist in DB: " + jobProgress.Key);
             } else {
               var currentStateLog = curTask.StateLogs.Last();
@@ -147,5 +147,5 @@
                 // assigned slave does not match heartbeat
                 actions.Add(new MessageContainer(MessageContainer.MessageType.AbortTask, curTask.TaskId));
-                DA.LogFactory.GetLogger(this.GetType().Namespace).Log("The slave " + heartbeat.SlaveId + " is not supposed to calculate task: " + curTask);
+                LogFactory.GetLogger(this.GetType().Namespace).Log("The slave " + heartbeat.SlaveId + " is not supposed to calculate task: " + curTask);
               } else if (!TaskIsAllowedToBeCalculatedBySlave(heartbeat.SlaveId, curTask)) {
                 // assigned resources ids of task do not match with slaveId (and parent resourceGroupIds); this might happen when slave is moved to different group
@@ -157,15 +157,15 @@
 
                 switch (curTask.Command) {
-                  case DA.Command.Stop:
+                  case Command.Stop:
                     actions.Add(new MessageContainer(MessageContainer.MessageType.StopTask, curTask.TaskId));
                     break;
-                  case DA.Command.Pause:
+                  case Command.Pause:
                     actions.Add(new MessageContainer(MessageContainer.MessageType.PauseTask, curTask.TaskId));
                     break;
-                  case DA.Command.Abort:
+                  case Command.Abort:
                     actions.Add(new MessageContainer(MessageContainer.MessageType.AbortTask, curTask.TaskId));
                     break;
                 }
-                dao.UpdateTaskDA(curTask);
+                dao.UpdateTask(curTask);
               }
             }
@@ -176,12 +176,12 @@
     }
 
-    private bool TaskIsAllowedToBeCalculatedBySlave(Guid slaveId, DA.Task curTask) {
-      var assignedResourceIds = dao.GetAssignedResourcesIdsDA(curTask.TaskId);
-      var slaveResourceIds = dao.GetParentResourcesIDsDA(slaveId).ToArray();
+    private bool TaskIsAllowedToBeCalculatedBySlave(Guid slaveId, Task curTask) {
+      var assignedResourceIds = dao.GetAssignedResourcesIds(curTask.TaskId);
+      var slaveResourceIds = dao.GetParentResourcesIDs(slaveId).ToArray();
       return assignedResourceIds.Any(r => slaveResourceIds.Contains(r));
     }
 
     private bool SlaveIsAllowedToCalculate(Guid slaveId) {
-      var downtimes = dao.GetNumberOfDowntimesFromParentResourcesAtCurrentTimeDA(slaveId, DA.DowntimeType.Offline);
+      var downtimes = dao.GetNumberOfDowntimesFromParentResourcesAtCurrentTime(slaveId, DowntimeType.Offline);
       // the slave may only calculate if there is no downtime right now. this needs to be checked for every parent resource also
       return downtimes.All(x => x == 0);
@@ -189,5 +189,5 @@
 
     private bool ShutdownSlaveComputer(Guid slaveId) {
-      var downtimes = dao.GetNumberOfDowntimesFromParentResourcesAtCurrentTimeDA(slaveId, DA.DowntimeType.Shutdown);
+      var downtimes = dao.GetNumberOfDowntimesFromParentResourcesAtCurrentTime(slaveId, DowntimeType.Shutdown);
       return downtimes.Any(x => x != 0);
     }
