public string JudgeTaskType(TaskImportModel taskImportModel)
{
long employeeId = _employeeService.FindByNumber(taskImportModel.EmployeeNumber).Id;
List<task_employee> taskEmployees = _taskEmployeeService.FindByEmployeeId(employeeId);
if (taskEmployees.Count == 1)
{
long taskId = taskEmployees[0].TaskId;
return _taskService.Find(taskId).task_type.Name;
}
if (taskEmployees.Count >= 2)
{
//foreach (var u in taskEmployees)
//{
// if(_taskService.Find(u.TaskId).TaskStatusId==3)
// {
// taskEmployees.Remove(u);
// }
//}
//用来记录与各个任务的相符合度
var count = new int[taskEmployees.Count];
for (int i = 0; i < taskEmployees.Count; i++)
{
count[i] = 0;
}
int k = 0;
foreach (task_employee c in taskEmployees)
{
string taskTypeName = _taskTypeService.Find(_taskService.Find(c.TaskId).TaskTypeId).Name;
if (taskTypeName == "喂饲" || taskTypeName == "防疫")
{
List<task_pigsty> taskPigsties = _taskPigstyService.FindByTaskId(c.TaskId);
foreach (task_pigsty taskPigsty in taskPigsties)
{
foreach (RawDataDetail r in taskImportModel.RawDataDetails)
{
if (taskPigsty.PigstyId == r.PigstyId)
count[k]++;
}
}
k++;
}
if (taskTypeName == "转栏" || taskTypeName == "销售" || taskTypeName == "治疗"||taskTypeName=="死亡"||taskTypeName=="淘汰")
{
List<task_pig> taskPigs = _taskPigService.FindByTaskId(c.TaskId);
foreach (task_pig taskPig in taskPigs)
{
foreach (RawDataDetail r in taskImportModel.RawDataDetails)
{
if (taskPig.PigId == r.PigId)
count[k]++;
}
}
k++;
}
if (taskTypeName == "巡查")
{
List<task_pighouse> taskPighouses = _taskPigHouseService.FindByTaskId(c.TaskId);
foreach (task_pighouse taskPighouse in taskPighouses)
{
foreach (RawDataDetail r in taskImportModel.RawDataDetails)
{
if (taskPighouse.PigHouseId == r.PigHouseId)
count[k]++;
}
}
k++;
}
}
//找到相符度最高的任务名字并返回
int max = count[0];
int maxnum = 0;
for (int j = 1; j < taskEmployees.Count; j++)
{
if (max < count[j])
{
max = count[j];
maxnum = j;
}
}
return _taskTypeService.Find(_taskService.Find(taskEmployees[maxnum].TaskId).TaskTypeId).Name;
}
return "喂饲";
}
public void CutFileAndSaveData(TaskImportModel taskImportModel)
{
if (!Directory.Exists(@"c:\pigrecorder\Import"))
{
// 如果目录不在，则创建
Directory.CreateDirectory(@"c:\pigrecorder\Import");
}
//将已经导入的数据放到Import目录下以当天命名的文件中
var fs = new FileStream(@"c:\pigrecorder\Import\" + DateTime.Now.ToLongDateString() + ".txt",
FileMode.Append);
var sw = new StreamWriter(fs, Encoding.Default);
string b = _employeeService.FindByNumber(taskImportModel.EmployeeNumber).RFID + "," +
taskImportModel.StartTime;
sw.Write(b);
sw.WriteLine();
foreach (RawDataDetail detail in taskImportModel.RawDataDetails)
{
if (detail.Rfid != "")
{
string a = detail.Rfid + "," + detail.Time;
sw.Write(a);
sw.WriteLine();
}
}
sw.Close();
fs.Close();
string file = taskImportModel.File;
//找到已导入的数据，不放到lines栈中，最后将lines栈重新写回file文件
int readstartflag = 1;
int readendflag = 1;
int starttime = 0;
if (File.Exists(file))
{
var dReader = new StreamReader(file);
var lines = new List<string>();
while (!dReader.EndOfStream)
{
string dataread = dReader.ReadLine();
//若是已导入的数据，则不放到lines数组中
if (dataread != null)
{
//首先找到已导入的人员的RFID和时间，直到下次找到人员时停止
//这个阶段不把数据放入lines栈中
if (_employeeService.FindByNumber(taskImportModel.EmployeeNumber).RFID ==
dataread.Split(',')[0] &&
taskImportModel.StartTime.ToString(CultureInfo.InvariantCulture) ==
Convert.ToDateTime(dataread.Split(',')[1]).ToString(CultureInfo.InvariantCulture))
{
readstartflag = 0;
}
if (readstartflag == 0)
{
starttime++;
}
if (starttime >= 2)
{
if (_employeeService.FindByRfid(dataread.Split(',')[0]) != null)
{
readendflag = 0;
}
}
//还没找到已导入的人员 和找到已导入人员的下一个人员的2种情况
if (readstartflag == 1 || (readstartflag == 0 && readendflag == 0))
{
lines.Add(dataread);
}
}
}
dReader.Close();
var iStream = new FileStream(file, FileMode.Create);
var iWriter = new StreamWriter(iStream);
foreach (string t in lines)
{
iWriter.Write(t);
iWriter.WriteLine();
}
iWriter.Close();
iStream.Close();
}
}
public string TransferDataImport(TaskImportModel taskImportModel, string memo)
{
int taskflag = 0; //标志，判断当天是否有转栏任务
long employeeId = _employeeService.FindByNumber(taskImportModel.EmployeeNumber).Id;
List<task_employee> taskEmployee = _taskEmployeeService.FindByEmployeeId(employeeId);
if (taskEmployee != null)
{
long taskId = JudgeHaveTask(taskEmployee, taskImportModel.TaskType, taskImportModel);
if (taskId != 0)
{
taskImportModel.TaskNumber = _taskService.Find(taskId).TaskNumber;
taskflag = 1;
}
}
//当天有转栏任务
if (taskflag == 1)
{
long pigstyId = taskImportModel.RawDataDetails[0].PigstyId;
for (int i = 0; i <= taskImportModel.RawDataDetails.Count - 1; i++)
{
var transfer = new transfer();
//若有猪栏，先标记猪栏，后对猪进行赋值，并导入数据库
if (taskImportModel.RawDataDetails[i].PigstyId != 0 && taskImportModel.RawDataDetails[i].PigId == 0)
{
pigstyId = taskImportModel.RawDataDetails[i].PigstyId;
}
//若无猪栏，则代表猪栏已经标记
else if (taskImportModel.RawDataDetails[i].PigId != 0)
{
transfer.TaskId = _taskService.FindByTaskNumber(taskImportModel.TaskNumber).Id;
transfer.PigstyId = pigstyId;
transfer.PigId = taskImportModel.RawDataDetails[i].PigId;
transfer.Time = taskImportModel.RawDataDetails[i].Time;
transfer.Memo = memo;
//当该员工有当天的任务
_transferService.Insert(transfer);
}
}
//修改任务状态
task task = _taskService.FindByTaskNumber(taskImportModel.TaskNumber);
if (task.EndTime != null)
{
if (task.EndTime <= taskImportModel.EndTime)
{
task.TaskStatusId = 3;
}
else
{
task.TaskStatusId = 2;
}
}
else
{
task.TaskStatusId = 3;
}
_taskService.Update(task);
}
else
{
return "请确保" + taskImportModel.EmployeeName + "的任务是否选择正确,或者该员工没有" + taskImportModel.TaskType + "的任务";
}
return "";
}
public List<TaskImportModel> GetFilearray(string strFile)
{
var rTaskImportModel = new List<TaskImportModel>();
TaskImportModel taskImportModel = null;
List<RawDataDetail> rawDataDetails = null;
//读取指定文件夹下面的指定文件
string[] lineList = File.ReadAllLines(strFile, Encoding.Default);
//单个文件中原始的记录的2维字符串数组
var array = new string[lineList.Length,2];
int i = 0;
int length = lineList.Length;
foreach (string line in lineList)
{
string[] elementList = line.Split(',');
for (int j = 0; j < elementList.Length; j++)
{
if (elementList[0] != "")
array[i, j] = elementList[j];
}
if (elementList[0] != "")
i++;
else
length--;
}
//2维字符串数组中前后rfid相同的合并
for (i = 0; i < length - 1; i++)
{
if (array[i, 0] == array[i + 1, 0])
{
for (int j = i + 1; j < length - 1; j++)
{
array[j, 0] = array[j + 1, 0];
array[j, 1] = array[j + 1, 1];
}
length--;
i--;
}
}
//将不重复的2维字符串数组写回文件中
var iStream = new FileStream(strFile, FileMode.Create);
var iWriter = new StreamWriter(iStream);
for (i = 0; i < length; i++)
{
string t = array[i, 0] + "," + array[i, 1] + "\n";
iWriter.Write(t);
iWriter.WriteLine();
}
iWriter.Close();
iStream.Close();
//从array数组中寻找员工的rfid
for (i = 0; i < length; i++)
{
string findrfid = array[i, 0];
//若该rfid为员工rfid,则创建新的DataModel
if (_employeeService.FindByRfid(findrfid) != null)
{
employee employee = _employeeService.FindByRfid(findrfid);
rawDataDetails = new List<RawDataDetail>();
taskImportModel = new TaskImportModel
{
Checked = true,
File = strFile,
EmployeeName = employee.Name,
EmployeeNumber = employee.Number,
ImportStatus = false,
StartTime = Convert.ToDateTime(array[i, 1])
};
if (i + 1 < length && _employeeService.FindByRfid(array[i + 1, 0]) == null)
{
rTaskImportModel.Add(taskImportModel);
}
}
//否则则为记录的猪舍或猪栏的rfid，创建Detail，并添加到DataModel
else
{
var rawDataDetail = new RawDataDetail
{
Rfid = array[i, 0],
Time = Convert.ToDateTime(array[i, 1])
};
if (rawDataDetails != null)
{
int rfidFlag = 1; //判断rfid是否重复记录
foreach (RawDataDetail importModel in rawDataDetails)
{
if (importModel.Rfid == rawDataDetail.Rfid)
{
rfidFlag = 0;
}
}
if (rfidFlag == 1)
{
rawDataDetails.Add(rawDataDetail);
taskImportModel.RawDataDetails = rawDataDetails;
}
}
}
}
//从数据库中寻找rfid，并存入具体的类别信息，或猪舍，或猪栏，或猪，否则，则不记录到RawDataDetail
foreach (TaskImportModel dTaskImportModel in rTaskImportModel)
{
dTaskImportModel.EndTime =
dTaskImportModel.RawDataDetails[dTaskImportModel.RawDataDetails.Count - 1].Time;
foreach (RawDataDetail detail in dTaskImportModel.RawDataDetails)
{
string rfid = detail.Rfid;
pig_house pighouse = _pigHouseService.FindByRfid(rfid);
//猪舍
if (pighouse != null)
{
detail.PigHouseName = pighouse.pig_house_type.Name;
detail.PigHouseId = pighouse.Id;
detail.PigHouseNumber = pighouse.Number;
}
else
{
pigsty pigsty = _pigstyService.FindByRfid(rfid);
//猪栏
if (pigsty != null)
{
pig_house pigstyHouse = _pigHouseService.Find(pigsty.PigHouseId);
detail.PigHouseName = pigstyHouse.pig_house_type.Name;
detail.PigHouseNumber = pigstyHouse.Number;
detail.PigHouseId = pigstyHouse.Id;
detail.PigstyNumber = pigsty.Number;
detail.PigstyId = pigsty.Id;
}
else
{
pig pig = _pigService.FindByRfid(rfid);
//猪
if (pig != null)
{
List<transfer> transfers = _transferService.FindByPigId(pig.Id);
//若这头猪的rfid不在transfers这张表中
if (transfers.Count != 0)
{
DateTime possbileTime = transfers[0].Time;
int possiblePigstyNumber = transfers[0].pigsty.Number;
long possiblePigstyId = transfers[0].pigsty.Id;
foreach (transfer transfer in transfers)
{
if (possbileTime <= transfer.Time)
{
possbileTime = transfer.Time;
possiblePigstyNumber = transfer.pigsty.Number;
possiblePigstyId = transfer.pigsty.Id;
}
}
pig_house pigHouse = _pigHouseService.FindbyPigstyId(possiblePigstyId);
detail.PigHouseId = pigHouse.Id;
detail.PigHouseName = pigHouse.pig_house_type.Name;
detail.PigHouseNumber = pigHouse.Number;
detail.PigstyId = possiblePigstyId;
detail.PigstyNumber = possiblePigstyNumber;
detail.PigId = pig.Id;
detail.PigName = pig.pig_type.Name;
detail.PigNumber = pig.Number;
}
}
}
}
}
//得到最有可能的任务类型
dTaskImportModel.TaskType = JudgeTaskType(dTaskImportModel);
}
return rTaskImportModel;
}
public string PreventionDataImport(TaskImportModel taskImportModel, string memo)
{
int taskflag = 0; //标志，判断当天是否有防疫任务
long employeeId = _employeeService.FindByNumber(taskImportModel.EmployeeNumber).Id;
List<task_employee> taskEmployee = _taskEmployeeService.FindByEmployeeId(employeeId);
if (taskEmployee != null)
{
long taskId = JudgeHaveTask(taskEmployee, taskImportModel.TaskType, taskImportModel);
if (taskId != 0)
{
taskImportModel.TaskNumber = _taskService.Find(taskId).TaskNumber;
taskflag = 1;
}
}
//该员工当天有防疫任务
if (taskflag == 1)
{
foreach (RawDataDetail detail in taskImportModel.RawDataDetails)
{
//如果猪栏不为空
if (detail.PigstyId != 0 && detail.PigId == 0)
{
var prevention = new prevention
{
EmployeeId = employeeId,
PigstyId = detail.PigstyId,
Memo = memo,
Time = detail.Time,
TaskId = _taskService.FindByTaskNumber(taskImportModel.TaskNumber).Id
};
_preventionService.Insert(prevention);
}
}
//修改任务状态
task task = _taskService.FindByTaskNumber(taskImportModel.TaskNumber);
if (task.EndTime != null)
{
if (task.EndTime <= taskImportModel.EndTime)
{
task.TaskStatusId = 3;
}
else
{
task.TaskStatusId = 2;
}
}
else
{
task.TaskStatusId = 3;
}
_taskService.Update(task);
}
else
{
return "请确保" + taskImportModel.EmployeeName + "的任务是否选择正确,或者该员工没有" + taskImportModel.TaskType + "的任务";
}
return "";
}
public string SaleDataImport(TaskImportModel taskImportModel, string memo)
{
int taskflag = 0; //标志，判断当天是否有销售任务
long employeeId = _employeeService.FindByNumber(taskImportModel.EmployeeNumber).Id;
List<task_employee> taskEmployee = _taskEmployeeService.FindByEmployeeId(employeeId);
if (taskEmployee != null)
{
long taskId = JudgeHaveTask(taskEmployee, taskImportModel.TaskType, taskImportModel);
if (taskId != 0)
{
taskImportModel.TaskNumber = _taskService.Find(taskId).TaskNumber;
taskflag = 1;
}
}
//若有当天的销售的任务，才插入数据库
if (taskflag == 1)
{
int saleflag = 0; //用来判断销售单是否已存在于sale这张表中
List<sale> salelistflags = _saleService.FindAll();
foreach (sale salelistflag in salelistflags)
{
if (salelistflag.EmployeeId == _taskService.FindByTaskNumber(taskImportModel.TaskNumber).Id &&
salelistflag.EmployeeId == employeeId)
{
saleflag = 1;
}
}
//如果sale中还没有该员工的销售单，则将其插入
if (saleflag == 0)
{
var sale = new sale
{
EmployeeId = employeeId,
TaskId = _taskService.FindByTaskNumber(taskImportModel.TaskNumber).Id
};
_saleService.Insert(sale);
}
foreach (RawDataDetail detail in taskImportModel.RawDataDetails)
{
long saleId = 0;
List<sale> saleslist = _saleService.FindAll();
//首先从sale表中获得该人员的销售id
foreach (sale salelist in saleslist)
{
if (salelist.EmployeeId == employeeId &&
salelist.TaskId == _taskService.FindByTaskNumber(taskImportModel.TaskNumber).Id)
{
saleId = salelist.Id;
}
}
//将所有的猪的销售Id插入到salepig表中
if (detail.PigHouseId != 0 && detail.PigstyId != 0 && detail.PigId != 0)
{
var salepig = new sale_pig
{
SaleId = saleId,
PigId = detail.PigId,
Time = detail.Time,
Memo = memo
};
_salePigService.Insert(salepig);
pig pig = _pigService.Find(detail.PigId);
pig.State = true;
_pigService.Update(pig);
sale modifysale = new sale();
modifysale.TaskId = _taskService.FindByTaskNumber(taskImportModel.TaskNumber).Id;
modifysale.EmployeeId = employeeId;
modifysale.SaleType = "销售";
_saleService.Insert(modifysale);
}
}
//修改任务状态
task task = _taskService.FindByTaskNumber(taskImportModel.TaskNumber);
if (task.EndTime != null)
{
if (task.EndTime <= taskImportModel.EndTime)
{
task.TaskStatusId = 3;
}
else
{
task.TaskStatusId = 2;
}
}
else
{
task.TaskStatusId = 3;
}
_taskService.Update(task);
}
else
{
return "请确保" + taskImportModel.EmployeeName + "的任务是否选择正确,或者该员工没有" + taskImportModel.TaskType + "的任务";
}
return "";
}
public long JudgeHaveTaskCirculate(List<task_employee> taskEmployees, string taskType,
TaskImportModel taskImportModel)
{
//在所有的任务里判断在这一天是否有该类型的任务 注：一个人一天只有一个相同的任务
foreach (task_employee taskemployee in taskEmployees)
{
long taskTypeId = _taskService.Find(taskemployee.TaskId).TaskTypeId;
if (_taskTypeService.Find(taskTypeId).Name == taskType)
{
List<task_interval_cycle> taskInterval =
_taskIntervalCycleService.FindByTaskId(taskemployee.TaskId);
foreach (task_interval_cycle taskinterval in taskInterval)
{
for (int i = 0; i < 1000; i++)
{
//根据任务的循环时间匹配是否有当天的任务
if (
taskinterval.FirstExecuteDate.AddDays(Convert.ToDouble(taskinterval.CycleDays*i))
.
ToShortDateString() == taskImportModel.StartTime.ToShortDateString())
{
return taskemployee.TaskId;
}
}
}
}
}
return 0;
}
public long JudgeHaveTask(List<task_employee> taskEmployees, string taskType, TaskImportModel taskImportModel)
{
//在所有的任务里判断在这一天是否有该类型的任务 注：一个人一天只有一个相同的任务
foreach (task_employee taskemployee in taskEmployees)
{
long taskTypeId = _taskService.Find(taskemployee.TaskId).TaskTypeId;
if (_taskTypeService.Find(taskTypeId).Name == taskType)
{
foreach (cure_task_course c in _cureTaskCourseService.FindByTaskId(taskemployee.TaskId))
{
if (c.Time.ToShortDateString() == taskImportModel.StartTime.ToShortDateString())
{
return taskemployee.TaskId;
}
}
}
if (_taskTypeService.Find(taskTypeId).Name == taskType)
{
//判断当前记录的时间是否和任务的开始时间相同，若是，则代表当天有防疫任务
DateTime startTime = _taskService.Find(taskemployee.TaskId).StartTime;
if (startTime.ToShortDateString() == taskImportModel.StartTime.ToShortDateString())
{
return taskemployee.TaskId;
}
}
}
return 0;
}
public string FeedDataImport(TaskImportModel taskImportModel, string memo)
{
int taskflag = 0; //标志，判断当天是否有喂饲任务
//根据员工的工号找到找到所有的任务
long employeeId = _employeeService.FindByNumber(taskImportModel.EmployeeNumber).Id;
List<task_employee> taskEmployee = _taskEmployeeService.FindByEmployeeId(employeeId);
if (taskEmployee != null)
{
long taskId = JudgeHaveTaskCirculate(taskEmployee, "喂饲", taskImportModel);
if (taskId != 0)
{
taskImportModel.TaskNumber = _taskService.Find(taskId).TaskNumber;
taskflag = 1;
}
}
//当该员工有有喂饲任务
if (taskflag == 1)
{
//找到该任务的所有的猪栏.
List<task_pigsty> pigsties =
_taskPigstyService.FindByTaskId(_taskService.FindByTaskNumber(taskImportModel.TaskNumber).Id);
foreach (RawDataDetail detail in taskImportModel.RawDataDetails)
{
if (detail.PigstyId != 0)
{
//找到对应猪栏的feedtaskquality
feed_task_quality feedTaskQuality = null;
foreach (task_pigsty taskPigsty in pigsties)
{
if (taskPigsty.PigstyId == detail.PigstyId)
{
feedTaskQuality = _feedTaskQualityService.FindByFeedTaskPigstyId(taskPigsty.Id)[0];
}
}
if (feedTaskQuality != null && _pigstyService.GetPignumbers(detail.PigstyId) != 0)
{
var feed = new feed
{
TaskId = _taskService.FindByTaskNumber(taskImportModel.TaskNumber).Id,
EmployeeId = employeeId,
PigstyId = detail.PigstyId,
//Quality = feedTaskQuality.Quality*_pigstyService.GetPignumbers(detail.PigstyId),
//FodderTypeId = feedTaskQuality.FodderTypeId,
//UnitId = feedTaskQuality.UnitId,
Time = detail.Time,
Memo = memo
};
_feedService.Insert(feed);
}
}
}
//修改任务状态
task task = _taskService.FindByTaskNumber(taskImportModel.TaskNumber);
if (task.EndTime != null)
{
if (task.EndTime <= taskImportModel.EndTime)
{
task.TaskStatusId = 3;
}
else
{
task.TaskStatusId = 2;
}
}
else
{
task.TaskStatusId = 2;
}
_taskService.Update(task);
}
return "";
}
public string EliminateDataImport(TaskImportModel taskImportModel, string memo)
{
int taskflag = 0; //标志，判断当天是否有淘汰任务
long employeeId = _employeeService.FindByNumber(taskImportModel.EmployeeNumber).Id;
List<task_employee> taskEmployee = _taskEmployeeService.FindByEmployeeId(employeeId);
if (taskEmployee != null)
{
long taskId = JudgeHaveTask(taskEmployee, taskImportModel.TaskType, taskImportModel);
if (taskId != 0)
{
taskImportModel.TaskNumber = _taskService.Find(taskId).TaskNumber;
taskflag = 1;
}
}
//若有当天的淘汰的任务，才修改生猪的状态
if (taskflag == 1)
{
foreach (RawDataDetail detail in taskImportModel.RawDataDetails)
{
pig modifypig = _pigService.Find(detail.PigId);
modifypig.State = true;
_pigService.Update(modifypig);
sale modifysale = new sale();
modifysale.TaskId = _taskService.FindByTaskNumber(taskImportModel.TaskNumber).Id;
modifysale.EmployeeId = employeeId;
modifysale.SaleType = "淘汰";
_saleService.Insert(modifysale);
}
//修改任务状态
task task = _taskService.FindByTaskNumber(taskImportModel.TaskNumber);
if (task.EndTime != null)
{
if (task.EndTime <= taskImportModel.EndTime)
{
task.TaskStatusId = 3;
}
else
{
task.TaskStatusId = 2;
}
}
else
{
task.TaskStatusId = 3;
}
_taskService.Update(task);
}
else
{
return "请确保" + taskImportModel.EmployeeName + "的任务是否选择正确,或者该员工没有" + taskImportModel.TaskType + "的任务";
}
return "";
}
public string CureDataImport(TaskImportModel taskImportModel, string memo)
{
int taskflag = 0; //标志，判断当天是否有治疗任务
long employeeId = _employeeService.FindByNumber(taskImportModel.EmployeeNumber).Id;
List<task_employee> taskEmployee = _taskEmployeeService.FindByEmployeeId(employeeId);
if (taskEmployee != null)
{
long taskId = JudgeHaveTask(taskEmployee, taskImportModel.TaskType, taskImportModel);
if (taskId != 0)
{
taskImportModel.TaskNumber = _taskService.Find(taskId).TaskNumber;
taskflag = 1;
}
}
if (taskflag == 1)
{
foreach (RawDataDetail detail in taskImportModel.RawDataDetails)
{
//当猪不为空，导入数据库
if (detail.PigHouseId != 0 && detail.PigstyId != 0 && detail.PigId != 0)
{
var curepig = new cure_pig
{
EmployeeId = employeeId,
PigId = detail.PigId,
CureTime = detail.Time,
Memo = memo
};
//根据任务编号和当前的时间找出治疗任务的疗程号
long taskId = _taskService.FindByTaskNumber(taskImportModel.TaskNumber).Id;
//先找出该任务编号的所有的疗程
List<cure_task_course> cureTaskCourse = _cureTaskCourseService.FindByTaskId(taskId);
if (cureTaskCourse != null)
{
foreach (cure_task_course cureCourse in cureTaskCourse)
{
//在所有的疗程根据时间判断今天的疗程
if (cureCourse.Time.ToShortDateString() == taskImportModel.StartTime.ToShortDateString())
{
curepig.CureTaskCourseId = cureCourse.Id;
}
}
}
_curePigService.Insert(curepig);
}
}
//修改任务状态
task task = _taskService.FindByTaskNumber(taskImportModel.TaskNumber);
if (task.EndTime != null)
{
if (task.EndTime <= taskImportModel.EndTime)
{
task.TaskStatusId = 3;
}
else
{
task.TaskStatusId = 2;
}
}
else
{
task.TaskStatusId = 3;
}
_taskService.Update(task);
}
else
{
return "请确保" + taskImportModel.EmployeeName + "的任务是否选择正确,或者该员工没有" + taskImportModel.TaskType + "的任务";
}
return "";
}
