Beispiel #1
0
        public virtual IEnumerable <TrainingAndRelatedEmployees> GetTrainingAndRelatedEmployees(int trainingId)
        {
            IEnumerable <Training>         trainingList         = new RepositoryFactory().Create <Training>().GetAll();
            IEnumerable <Employee>         employeeList         = new RepositoryFactory().Create <Employee>().GetAll();
            IEnumerable <TrainingEmployee> trainingEmployeeList = new TrainingEmployeeRepository().GetAll();

            try
            {
                var result = from training in trainingList
                             join combo in trainingEmployeeList on training.TrainingId equals combo.TrainingId
                             join employee in employeeList on combo.EmployeeId equals employee.EmployeeId
                             select new TrainingAndRelatedEmployees
                {
                    TrainingId   = training.TrainingId,
                    TrainingName = training.TrainingName,
                    EmployeeName = employee.EmployeeName
                };
                return(result.Where(item =>
                                    item.TrainingId == trainingId));
            }
            catch (Exception e)
            {
                Console.WriteLine("Error in combining training and employee : " + e);
                return(new List <TrainingAndRelatedEmployees>());
            }
        }
Beispiel #2
0
        public virtual dynamic GetEmployeeAndRelatedTraining(int employeeId)
        {
            IEnumerable <Training>         trainingList         = new TrainingRepository().GetAll().Result;
            IEnumerable <Employee>         employeeList         = new EmployeeRepository().GetAll().Result;
            IEnumerable <TrainingEmployee> trainingEmployeeList = new TrainingEmployeeRepository().GetAll().Result;

            try
            {
                var result = from emp in  employeeList
                             join combo in trainingEmployeeList on emp.EmployeeId equals combo.EmployeeId
                             join train in trainingList on combo.TrainingId equals train.TrainingId
                             select new
                {
                    EmployeeId   = emp.EmployeeId,
                    EmployeeName = emp.EmployeeName,
                    TrainingName = train.TrainingName
                };
                return(result.Where(item =>
                                    item.EmployeeId == employeeId));
            }
            catch (Exception e)
            {
                Console.WriteLine("Error in combining training and employee : " + e);
                return(new List <dynamic>());
            }
        }
Beispiel #3
0
        public virtual async Task <bool> AddEmployeesToTrainingProgram(int trainingId, List <int> employeeIdList)
        {
            try
            {
                TrainingEmployeeRepository comboRepo = new TrainingEmployeeRepository();
                foreach (int id in employeeIdList)
                {
                    TrainingEmployee item = new TrainingEmployee();
                    item.TrainingId = trainingId;
                    item.EmployeeId = id;

                    await comboRepo.Insert(item);
                }

                return(true);
            }
            catch (Exception e)
            {
                Console.WriteLine("Encountered error while adding employees to training: " + e);
                return(false);
            }
        }