public interface ITaskService
    {
        void SaveChanges();
        bool DeleteTask(Task task);
        bool CreateTask(Task task);
        bool UpdateTask(Task task);
        Task GetTask(int id);
        IEnumerable<Task> GetTasksByDepartment(Department department);

        IEnumerable<Task> GetTasksInProgressWhereIamExecutor(Account account);
        IEnumerable<Task> GetTasksInProgressWhereIamParticipant(Account account);
        IEnumerable<Task> GetTasksInProgressWhereIamOwner(Account account);

        IEnumerable<Task> GetTasksByDepartment(string webpath);
        IEnumerable<Task> GetTasksByDepartmentForOtherRole(Account account, Department department);

        IEnumerable<Task> GetArchiveTasksInOwnDepartment(Account account, Department department);
        IEnumerable<Task> GetArchiveTasksInDepartmentForOther(Account account, Department department);

    }

    public class TaskService :  ITaskService
    {
        private readonly IUnitOfWork _uow;
        private readonly IRepository<Task> _repository;
     //   private ISpecification<Task> specification;

        public TaskService(IUnitOfWork uow)
        {
            _uow = uow;
            _repository = _uow.Repository<Task>();
        }

        #region ITaskService Members

        public virtual void SaveChanges()
        {
            _uow.Commit();
        }

        public virtual bool CreateTask(Task task)
        {
            return _repository.Add(task);
        }
        public virtual bool DeleteTask(Task task)
        {
            return _repository.Delete(task);
        }

        public virtual IEnumerable<Task> GetTasksByDepartment(string webpath)
        {
            return _repository.FilterBy(x => x.Department.WebPath == webpath);
        }

        public virtual Task GetTask(int id)
        {
            return _repository.FindBy(x => x.UID == id);
        }

        public virtual IEnumerable<Task> GetArchiveTasksInOwnDepartment(Account account, Department department)
        {
           //var closedTask = new Specification<Task>(x => x.Status == TaskStatus.Closed);
           // var myDepartment = new Specification<Task>(x => x.Department.UID == department.UID);
           // return _repository.FilterBy(closedTask.SatisfyingEntitiesFrom(myDepartment));
            return _repository.FilterBy(x => x.Status == TaskStatus.Closed).
                Where(x => x.Department.UID == department.UID);
        }
        public virtual IEnumerable<Task> GetArchiveTasksInDepartmentForOther(Account account, Department department)
        {
            return _repository.FilterBy(x => x.Status == TaskStatus.Closed)
                .Where(x => x.Department.UID == department.UID)
            .Where(x => x.Owner == account || x.ParticipantEntityList.Any(p => p.Login == account));
        }
        public virtual IEnumerable<Task> GetTasksByDepartmentForOtherRole(Account account,
                                                                  Department department)
        {
            return _repository.FilterBy(x => x.Status == TaskStatus.InProgress)
                .Where(x => x.Department.WebPath == department.WebPath)
            .Where(x => x.Owner == account || x.ParticipantEntityList.Any(p => p.Login == account));
        }

        public virtual IEnumerable<Task> GetTasksByDepartment(Department department)
        {
            return _repository.FilterBy(x => x.Department.UID == department.UID);
        }

        public virtual IEnumerable<Task> GetTasksInProgressWhereIamExecutor(Account account)
        {
            return _repository.FilterBy(x => x.Status == TaskStatus.InProgress)
                .Where(x => x.Executor == account).OrderBy(x => x.Department);
        }

        public virtual IEnumerable<Task> GetTasksInProgressWhereIamParticipant(Account account)
        {
            return _repository.FilterBy(x => x.ParticipantEntityList.Any(z=>z.Login == account))
               .Where(x => x.Status == TaskStatus.InProgress).OrderBy(x => x.Department);
        }

        public virtual IEnumerable<Task> GetTasksInProgressWhereIamOwner(Account account)
        {
            return _repository.FilterBy(x => x.Status == TaskStatus.InProgress)
                .Where(x => x.Owner == account).OrderBy(x => x.Department);
        }


        public bool UpdateTask(Task task)
        {
            return _repository.Update(task);
        }

        #endregion
    }