private void UpdateByIdStr(task task, string[] ids)
        {
            int oldLen = task.task_pighouse.Count;
            int newLen = ids.Length;
            int leastLength = oldLen < newLen ? oldLen : newLen;

            var taskPigHouseService = new TaskPigHouseService();
            List<task_pighouse> taskPigHouseList = FindByTaskId(task.Id);

            for (int i = 0; i < leastLength; i++)
            {
                task_pighouse updateitem = taskPigHouseList[i];
                updateitem.PigHouseId = long.Parse(ids[i]);
                Update(updateitem);
            }

            for (int i = leastLength; i < oldLen; i++)
            {
                taskPigHouseService.Delete(taskPigHouseService.Find(taskPigHouseList[i].Id));
            }

            for (int i = leastLength; i < newLen; i++)
            {
                taskPigHouseService.Insert(new task_pighouse
                                               {
                                                   TaskId = task.Id,
                                                   PigHouseId = long.Parse(ids[i])
                                               });
            }
        }
Example #2
0
        public InspectTask GetInspectTask(string taskNumber)
        {
            var taskService = new TaskService();
            task task = taskService.FindByTaskNumber(taskNumber);

            if (task == null)
            {
                return null;
            }
            var taskEmployeeService = new TaskEmployeeService();
            var taskPigHouseService = new TaskPigHouseService();
            var checkTask = new InspectTask
                                {
                                    TaskNumber = task.TaskNumber,
                                    StartTime = task.StartTime,
                                    EndTime = task.EndTime,
                                    EmployeeName = taskEmployeeService.GetEmployeeNames(task.Id),
                                    EmployeeNumber = taskEmployeeService.GetEmployeeNumbers(task.Id),
                                    PigHouse = taskPigHouseService.GetPigHouseTypeAndNumsByTaskId(task.Id),
                                    PigHouseId = taskPigHouseService.GetPigHouseIds(task.Id),
                                    Status = task.task_status_type.Name,
                                    Memo = task.Memo
                                };

            List<TaskCycle> taskCycle = task.task_interval_cycle.Select(taskCycleitem => new TaskCycle
                                                                                             {
                                                                                                 FirstExecuteDate
                                                                                                     =
                                                                                                     taskCycleitem
                                                                                                     .
                                                                                                     FirstExecuteDate,
                                                                                                 CycleDays
                                                                                                     =
                                                                                                     taskCycleitem
                                                                                                     .
                                                                                                     CycleDays
                                                                                             }).ToList();
            if (taskCycle.Count != 0)
            {
                checkTask.InspectTaskCycle = taskCycle;
            }
            return checkTask;
        }
Example #3
0
        /// <summary>
        ///     删除指定任务编号的任务
        /// </summary>
        /// <param name="taskNumber">任务编号</param>
        /// <returns>返回删除是否成功</returns>
        public bool DeleteTask(string taskNumber)
        {
            task task = FindByTaskNumber(taskNumber);

            if (task == null || new FeedService().FindByTaskId(task.Id).Count > 0 ||
                new FodderTakeService().FindByTaskId(task.Id).Count > 0 ||
                new TransferService().FindByTaskId(task.Id).Count > 0 ||
                new PreventionService().FindByTaskId(task.Id).Count > 0 ||
                new InspectionService().FindByTaskId(task.Id).Count > 0 ||
                new SaleService().FindByTaskId(task.Id).Count > 0)
            {
                return false;
            }

            var cureMethodService = new CureMethodService();
            cure_task_course cureCourse = task.cure_task_course.FirstOrDefault();
            if (cureCourse != null && cureMethodService.FindByCureTaskCourseId(cureCourse.Id).Count > 0)
            {
                return false;
            }

            var saleTaskQualityService = new SaleTaskQualityService();
            foreach (sale_task_quality delItem in task.sale_task_quality)
            {
                saleTaskQualityService.Delete(saleTaskQualityService.Find(delItem.Id));
            }

            var transferTaskPigService = new TaskPigService();
            foreach (task_pig transferTaskPig in task.task_pig)
            {
                transferTaskPigService.Delete(transferTaskPigService.Find(transferTaskPig.Id));
            }

            var taskIntervalCycleService = new TaskIntervalCycleService();
            foreach (task_interval_cycle item in task.task_interval_cycle)
            {
                taskIntervalCycleService.Delete(taskIntervalCycleService.Find(item.Id));
            }

            var taskPigstyService = new TaskPigstyService();
            var feedTaskQualityService = new FeedTaskQualityService();
            foreach (task_pigsty item in task.task_pigsty)
            {
                foreach (feed_task_quality delItem in item.feed_task_quality)
                {
                    feedTaskQualityService.Delete(feedTaskQualityService.Find(delItem.Id));
                }
                taskPigstyService.Delete(taskPigstyService.Find(item.Id));
            }

            var taskEmployeeService = new TaskEmployeeService();
            foreach (task_employee item in task.task_employee)
            {
                taskEmployeeService.Delete(taskEmployeeService.Find(item.Id));
            }

            var cureTaskCourseService = new CureTaskCourseService();
            var cureTaskMethodService = new CureTaskMethodService();
            var cureTaskMedicineService = new CureTaskMedicineService();
            foreach (cure_task_course cureTaskCourse in task.cure_task_course)
            {
                foreach (cure_task_method cureTaskMethod in cureTaskCourse.cure_task_method)
                {
                    foreach (cure_task_medicine cureTaskMedicine in cureTaskMethod.cure_task_medicine)
                    {
                        cureTaskMedicineService.Delete(cureTaskMedicineService.Find(cureTaskMedicine.Id));
                    }
                    cureTaskMethodService.Delete(cureTaskMethodService.Find(cureTaskMethod.Id));
                }
                cureTaskCourseService.Delete(cureTaskCourseService.Find(cureTaskCourse.Id));
            }

            var taskPreventionService = new TaskPreventionService();
            foreach (task_prevention taskPrevention in task.task_prevention)
            {
                taskPreventionService.Delete(taskPreventionService.Find(taskPrevention.Id));
            }

            var taskPigHouseService = new TaskPigHouseService();
            foreach (task_pighouse taskPighouse in task.task_pighouse)
            {
                taskPigHouseService.Delete(taskPigHouseService.Find(taskPighouse.Id));
            }

            var taskRepository = new TaskRepository();
            taskRepository.Delete(taskRepository.Find(task.Id));

            return true;
        }