//数据持久化
internal static void SaveToDb(OverTimeInfo pOverTimeInfo, OverTime pOverTime, bool pIsNew)
{
pOverTime.OverTimeId = pOverTimeInfo.overTimeId;
pOverTime.ApplyDate = pOverTimeInfo.applyDate;
pOverTime.TimeFrom = pOverTimeInfo.timeFrom;
pOverTime.TimeTo = pOverTimeInfo.timeTo;
pOverTime.ApplyEmName = pOverTimeInfo.applyEmName;
pOverTime.Reason = pOverTimeInfo.reason;
pOverTime.IsSubmit = pOverTimeInfo.isSubmit;
pOverTime.TimeSpan = pOverTimeInfo.timeSpan;
pOverTime.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pOverTime.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(OverTimeInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pOverTimeInfo.overTimeId = pOverTime.OverTimeId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(OverTimeInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(WeekSumInfo pWeekSumInfo, WeekSum pWeekSum, bool pIsNew)
{
pWeekSum.WeekSumId = pWeekSumInfo.weekSumId;
pWeekSum.WeekSumName = pWeekSumInfo.weekSumName;
pWeekSum.IsApprove = pWeekSumInfo.isApprove;
pWeekSum.IsApply = pWeekSumInfo.isApply;
pWeekSum.IsSend = pWeekSumInfo.isSend;
pWeekSum.ApplyTime = pWeekSumInfo.applyTime;
pWeekSum.RepplyTime = pWeekSumInfo.repplyTime;
pWeekSum.ApplyView = pWeekSumInfo.applyView;
pWeekSum.SendEmployeeId = pWeekSumInfo.sendEmployeeId;
pWeekSum.RecvEmployeeId = pWeekSumInfo.recvEmployeeId;
pWeekSum.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pWeekSum.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(WeekSumInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pWeekSumInfo.weekSumId = pWeekSum.WeekSumId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(WeekSumInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(ProjectStepInfo pProjectStepInfo, ProjectStep pProjectStep, bool pIsNew)
{
pProjectStep.ProjectStepId = pProjectStepInfo.projectStepId;
pProjectStep.ProjectStepName = pProjectStepInfo.projectStepName;
pProjectStep.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pProjectStep.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(ProjectStepInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pProjectStepInfo.projectStepId = pProjectStep.ProjectStepId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(ProjectStepInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(MainProjectCreateInfo pMainProjectCreateInfo, MainProjectCreate pMainProjectCreate, bool pIsNew)
{
pMainProjectCreate.MainProjectCreateId = pMainProjectCreateInfo.mainProjectCreateId;
pMainProjectCreate.ClientId = pMainProjectCreateInfo.clientId;
pMainProjectCreate.ProjectLevelId = pMainProjectCreateInfo.projectLevelId;
pMainProjectCreate.ProjectTypeId = pMainProjectCreateInfo.projectTypeId;
pMainProjectCreate.YeWuId = pMainProjectCreateInfo.yeWuId;
pMainProjectCreate.SheetNum = pMainProjectCreateInfo.sheetNum;
pMainProjectCreate.ProjectName = pMainProjectCreateInfo.projectName;
pMainProjectCreate.PreMoney = pMainProjectCreateInfo.preMoney;
pMainProjectCreate.PreProfit = pMainProjectCreateInfo.preProfit;
pMainProjectCreate.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pMainProjectCreate.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(MainProjectCreateInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pMainProjectCreateInfo.mainProjectCreateId = pMainProjectCreate.MainProjectCreateId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(MainProjectCreateInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(ClientInfo pClientInfo, Client pClient, bool pIsNew)
{
pClient.ClientId = pClientInfo.clientId;
pClient.ClientName = pClientInfo.clientName;
pClient.ClientLevelId = pClientInfo.clientLevelId;
pClient.Address = pClientInfo.address;
pClient.Telephone = pClientInfo.telephone;
pClient.MailNo = pClientInfo.mailNo;
pClient.Fax = pClientInfo.fax;
pClient.EmployeeId = pClientInfo.employeeId;
pClient.ClientTypeId = pClientInfo.clientTypeId;
pClient.SheetNum = pClientInfo.sheetNum;
pClient.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pClient.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(ClientInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pClientInfo.clientId = pClient.ClientId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(ClientInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(OutRegistInfo pOutRegistInfo, OutRegist pOutRegist, bool pIsNew)
{
pOutRegist.OutRegistId = pOutRegistInfo.outRegistId;
pOutRegist.OutDate = pOutRegistInfo.outDate;
pOutRegist.OutTime = pOutRegistInfo.outTime;
pOutRegist.OutContent = pOutRegistInfo.outContent;
pOutRegist.BackTime = pOutRegistInfo.backTime;
pOutRegist.OutTool = pOutRegistInfo.outTool;
pOutRegist.Memo = pOutRegistInfo.memo;
pOutRegist.ApplyName = pOutRegistInfo.applyName;
pOutRegist.DepartName = pOutRegistInfo.departName;
pOutRegist.State = pOutRegistInfo.state;
pOutRegist.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pOutRegist.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(OutRegistInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pOutRegistInfo.outRegistId = pOutRegist.OutRegistId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(OutRegistInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(CarApplyInfo pCarApplyInfo, CarApply pCarApply, bool pIsNew)
{
pCarApply.CarApplyId = pCarApplyInfo.carApplyId;
pCarApply.SheetNum = pCarApplyInfo.sheetNum;
pCarApply.ApplyTime = pCarApplyInfo.applyTime;
pCarApply.BeginSite = pCarApplyInfo.beginSite;
pCarApply.EndSite = pCarApplyInfo.endSite;
pCarApply.Reason = pCarApplyInfo.reason;
pCarApply.Memo = pCarApplyInfo.memo;
pCarApply.StateId = pCarApplyInfo.stateId;
pCarApply.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pCarApply.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(CarApplyInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pCarApplyInfo.carApplyId = pCarApply.CarApplyId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(CarApplyInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(ContactInfo pContactInfo, Contact pContact, bool pIsNew)
{
pContact.ContactId = pContactInfo.contactId;
pContact.Mobile = pContactInfo.mobile;
pContact.Officephone = pContactInfo.officephone;
pContact.PhoneExt = pContactInfo.phoneExt;
pContact.Homephone = pContactInfo.homephone;
pContact.Email = pContactInfo.email;
pContact.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pContact.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(ContactInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pContactInfo.contactId = pContact.ContactId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(ContactInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(WeekScoreInfo pWeekScoreInfo, WeekScore pWeekScore, bool pIsNew)
{
pWeekScore.WeekScoreId = pWeekScoreInfo.weekScoreId;
pWeekScore.WeekScoreNum = pWeekScoreInfo.weekScoreNum;
pWeekScore.IsSubmit = pWeekScoreInfo.isSubmit;
pWeekScore.EmployeeId = pWeekScoreInfo.employeeId;
pWeekScore.TotalScore = pWeekScoreInfo.totalScore;
pWeekScore.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pWeekScore.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(WeekScoreInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pWeekScoreInfo.weekScoreId = pWeekScore.WeekScoreId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(WeekScoreInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(AssetInfo pAssetInfo, Asset pAsset, bool pIsNew)
{
pAsset.AssetId = pAssetInfo.assetId;
pAsset.AssetName = pAssetInfo.assetName;
pAsset.Type = pAssetInfo.type;
pAsset.DepartName = pAssetInfo.departName;
pAsset.SiteName = pAssetInfo.siteName;
pAsset.UnitName = pAssetInfo.unitName;
pAsset.Amount = pAssetInfo.amount;
pAsset.Price = pAssetInfo.price;
pAsset.Memo = pAssetInfo.memo;
pAsset.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pAsset.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(AssetInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pAssetInfo.assetId = pAsset.AssetId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(AssetInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(StampInfo pStampInfo, Stamp pStamp, bool pIsNew)
{
pStamp.StampId = pStampInfo.stampId;
pStamp.UseDate = pStampInfo.useDate;
pStamp.StampFileTypeId = pStampInfo.stampFileTypeId;
pStamp.StampTypeId = pStampInfo.stampTypeId;
pStamp.Stampuse = pStampInfo.stampuse;
pStamp.Memo = pStampInfo.memo;
pStamp.ApplyName = pStampInfo.applyName;
pStamp.DepartName = pStampInfo.departName;
pStamp.State = pStampInfo.state;
pStamp.ApplyTime = pStampInfo.applyTime;
pStamp.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pStamp.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(StampInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pStampInfo.stampId = pStamp.StampId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(StampInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(ContractInfo pContractInfo, Contract pContract, bool pIsNew)
{
pContract.ContractId = pContractInfo.contractId;
pContract.ContractFileId = pContractInfo.contractFileId;
pContract.SignName = pContractInfo.signName;
pContract.ContractNum = pContractInfo.contractNum;
pContract.ContractName = pContractInfo.contractName;
pContract.BeginDate = pContractInfo.beginDate;
pContract.MoneySum = pContractInfo.moneySum;
pContract.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pContract.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(ContractInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pContractInfo.contractId = pContract.ContractId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(ContractInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(MasterInfo pMasterInfo, Master pMaster, bool pIsNew)
{
pMaster.MasterId = pMasterInfo.masterId;
pMaster.MasterName = pMasterInfo.masterName;
pMaster.MasterPsd = pMasterInfo.masterPsd;
pMaster.DepartId = pMasterInfo.departId;
pMaster.CreateDate = pMasterInfo.createDate;
pMaster.EmployeeId = pMasterInfo.employeeId;
pMaster.IsApply = pMasterInfo.isApply;
pMaster.State = pMasterInfo.state;
pMaster.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pMaster.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(MasterInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pMasterInfo.masterId = pMaster.MasterId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(MasterInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(DayScoreInfo pDayScoreInfo, DayScore pDayScore, bool pIsNew)
{
pDayScore.DayScoreId = pDayScoreInfo.dayScoreId;
pDayScore.Today = pDayScoreInfo.today;
pDayScore.Item = pDayScoreInfo.item;
pDayScore.FinishTime = pDayScoreInfo.finishTime;
pDayScore.Roles = pDayScoreInfo.roles;
pDayScore.TimeSpan = pDayScoreInfo.timeSpan;
pDayScore.Memo = pDayScoreInfo.memo;
pDayScore.Score = pDayScoreInfo.score;
pDayScore.WeekScoreId = pDayScoreInfo.weekScoreId;
pDayScore.DayRoleId = pDayScoreInfo.dayRoleId;
pDayScore.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pDayScore.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(DayScoreInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pDayScoreInfo.dayScoreId = pDayScore.DayScoreId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(DayScoreInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(FileEmployeeInfo pFileEmployeeInfo, FileEmployee pFileEmployee, bool pIsNew)
{
pFileEmployee.FileEmployeeId = pFileEmployeeInfo.fileEmployeeId;
pFileEmployee.FileId = pFileEmployeeInfo.fileId;
pFileEmployee.EmployeeId = pFileEmployeeInfo.employeeId;
pFileEmployee.IsMsg = pFileEmployeeInfo.isMsg;
pFileEmployee.IsDelete = pFileEmployeeInfo.isDelete;
pFileEmployee.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pFileEmployee.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(FileEmployeeInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pFileEmployeeInfo.fileEmployeeId = pFileEmployee.FileEmployeeId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(FileEmployeeInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(ProductTypeInfo pProductTypeInfo, ProductType pProductType, bool pIsNew)
{
pProductType.ProductTypeId = pProductTypeInfo.productTypeId;
pProductType.ProductName = pProductTypeInfo.productName;
pProductType.OfferPriceId = pProductTypeInfo.offerPriceId;
pProductType.Model = pProductTypeInfo.model;
pProductType.Unit = pProductTypeInfo.unit;
pProductType.Num = pProductTypeInfo.num;
pProductType.Price = pProductTypeInfo.price;
pProductType.Sums = pProductTypeInfo.sums;
pProductType.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pProductType.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(ProductTypeInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pProductTypeInfo.productTypeId = pProductType.ProductTypeId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(ProductTypeInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(NoticeInfo pNoticeInfo, Notice pNotice, bool pIsNew)
{
pNotice.NoticeId = pNoticeInfo.noticeId;
pNotice.NoticeContent = pNoticeInfo.noticeContent;
pNotice.SignName = pNoticeInfo.signName;
pNotice.NoticeTime = pNoticeInfo.noticeTime;
pNotice.NoticeTitle = pNoticeInfo.noticeTitle;
pNotice.EmployeeName = pNoticeInfo.employeeName;
pNotice.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pNotice.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(NoticeInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pNoticeInfo.noticeId = pNotice.NoticeId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(NoticeInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(RoleMasterInfo pRoleMasterInfo, RoleMaster pRoleMaster, bool pIsNew)
{
pRoleMaster.RoleMasterId = pRoleMasterInfo.roleMasterId;
pRoleMaster.RoleId = pRoleMasterInfo.roleId;
pRoleMaster.MasterId = pRoleMasterInfo.masterId;
pRoleMaster.IsPass = pRoleMasterInfo.isPass;
pRoleMaster.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pRoleMaster.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(RoleMasterInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pRoleMasterInfo.roleMasterId = pRoleMaster.RoleMasterId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(RoleMasterInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(DayInfo pDayInfo, Day pDay, bool pIsNew)
{
pDay.DayId = pDayInfo.dayId;
pDay.WeekId = pDayInfo.weekId;
pDay.WorkContent = pDayInfo.workContent;
pDay.WorkDate = pDayInfo.workDate;
pDay.Result = pDayInfo.result;
pDay.WeekSumId = pDayInfo.weekSumId;
pDay.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pDay.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(DayInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pDayInfo.dayId = pDay.DayId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(DayInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(MessageInfo pMessageInfo, Message pMessage, bool pIsNew)
{
pMessage.MessageId = pMessageInfo.messageId;
pMessage.Memo = pMessageInfo.memo;
pMessage.RecvEmployeeId = pMessageInfo.recvEmployeeId;
pMessage.Msg = pMessageInfo.msg;
pMessage.Url = pMessageInfo.url;
pMessage.EmployeeName = pMessageInfo.employeeName;
pMessage.MsgType = pMessageInfo.msgType;
pMessage.MsgTime = pMessageInfo.msgTime;
pMessage.MsgTitle = pMessageInfo.msgTitle;
pMessage.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pMessage.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(MessageInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pMessageInfo.messageId = pMessage.MessageId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(MessageInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(TaskInfo pTaskInfo, Task pTask, bool pIsNew)
{
pTask.TaskId = pTaskInfo.taskId;
pTask.TaskName = pTaskInfo.taskName;
pTask.EmployeeId = pTaskInfo.employeeId;
pTask.WorkSheetId = pTaskInfo.workSheetId;
pTask.RecvTime = pTaskInfo.recvTime;
pTask.IsFinish = pTaskInfo.isFinish;
pTask.FinishTime = pTaskInfo.finishTime;
pTask.BeginTime = pTaskInfo.beginTime;
pTask.IsMain = pTaskInfo.isMain;
pTask.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pTask.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(TaskInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pTaskInfo.taskId = pTask.TaskId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(TaskInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(RelateInfo pRelateInfo, Relate pRelate, bool pIsNew)
{
pRelate.RelateId = pRelateInfo.relateId;
pRelate.RelateName = pRelateInfo.relateName;
pRelate.Mobile = pRelateInfo.mobile;
pRelate.Email = pRelateInfo.email;
pRelate.Memo = pRelateInfo.memo;
pRelate.ClientId = pRelateInfo.clientId;
pRelate.Position = pRelateInfo.position;
pRelate.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pRelate.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(RelateInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pRelateInfo.relateId = pRelate.RelateId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(RelateInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(ProjectCreateInfo pProjectCreateInfo, ProjectCreate pProjectCreate, bool pIsNew)
{
pProjectCreate.ProjectCreateId = pProjectCreateInfo.projectCreateId;
pProjectCreate.ClientId = pProjectCreateInfo.clientId;
pProjectCreate.ProjectLevelId = pProjectCreateInfo.projectLevelId;
pProjectCreate.ProjectTypeId = pProjectCreateInfo.projectTypeId;
pProjectCreate.YeWuId = pProjectCreateInfo.yeWuId;
pProjectCreate.ProjectName = pProjectCreateInfo.projectName;
pProjectCreate.PreMoney = pProjectCreateInfo.preMoney;
pProjectCreate.PreProfit = pProjectCreateInfo.preProfit;
pProjectCreate.ApplyDate = pProjectCreateInfo.applyDate;
pProjectCreate.CreatePhaseExp = pProjectCreateInfo.createPhaseExp;
pProjectCreate.ProposePhaseExp = pProjectCreateInfo.proposePhaseExp;
pProjectCreate.CallbidPhaseExp = pProjectCreateInfo.callbidPhaseExp;
pProjectCreate.TalkPhaseExp = pProjectCreateInfo.talkPhaseExp;
pProjectCreate.CarryPhaseExp = pProjectCreateInfo.carryPhaseExp;
pProjectCreate.NeedDescribe = pProjectCreateInfo.needDescribe;
pProjectCreate.CompitDescribe = pProjectCreateInfo.compitDescribe;
pProjectCreate.ClientDescribe = pProjectCreateInfo.clientDescribe;
pProjectCreate.TechDescribe = pProjectCreateInfo.techDescribe;
pProjectCreate.BusinessDescribe = pProjectCreateInfo.businessDescribe;
pProjectCreate.RiskDescribe = pProjectCreateInfo.riskDescribe;
pProjectCreate.StrategyDesribe = pProjectCreateInfo.strategyDesribe;
pProjectCreate.Memo = pProjectCreateInfo.memo;
pProjectCreate.MarketView = pProjectCreateInfo.marketView;
pProjectCreate.TechView = pProjectCreateInfo.techView;
pProjectCreate.ManagerView = pProjectCreateInfo.managerView;
pProjectCreate.SheetNum = pProjectCreateInfo.sheetNum;
pProjectCreate.Today = pProjectCreateInfo.today;
pProjectCreate.ApplyName = pProjectCreateInfo.applyName;
pProjectCreate.DepartName = pProjectCreateInfo.departName;
pProjectCreate.State = pProjectCreateInfo.state;
pProjectCreate.ApplyTime = pProjectCreateInfo.applyTime;
pProjectCreate.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pProjectCreate.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(ProjectCreateInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pProjectCreateInfo.projectCreateId = pProjectCreate.ProjectCreateId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(ProjectCreateInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(EmployeeInfo pEmployeeInfo, Employee pEmployee, bool pIsNew)
{
pEmployee.EmployeeId = pEmployeeInfo.employeeId;
pEmployee.ContactId = pEmployeeInfo.contactId;
pEmployee.EmployeeName = pEmployeeInfo.employeeName;
pEmployee.PositionId = pEmployeeInfo.positionId;
pEmployee.Sex = pEmployeeInfo.sex;
pEmployee.Birthday = pEmployeeInfo.birthday;
pEmployee.Marrage = pEmployeeInfo.marrage;
pEmployee.Address = pEmployeeInfo.address;
pEmployee.NativePlace = pEmployeeInfo.nativePlace;
pEmployee.PoliticsId = pEmployeeInfo.politicsId;
pEmployee.IdentyNum = pEmployeeInfo.identyNum;
pEmployee.School = pEmployeeInfo.school;
pEmployee.Major = pEmployeeInfo.major;
pEmployee.EducationId = pEmployeeInfo.educationId;
pEmployee.LanguageId = pEmployeeInfo.languageId;
pEmployee.Certificate = pEmployeeInfo.certificate;
pEmployee.JobTime = pEmployeeInfo.jobTime;
pEmployee.JoinTime = pEmployeeInfo.joinTime;
pEmployee.DepartId = pEmployeeInfo.departId;
pEmployee.State = pEmployeeInfo.state;
pEmployee.OffJobTime = pEmployeeInfo.offJobTime;
pEmployee.Image = pEmployeeInfo.image;
pEmployee.Qq = pEmployeeInfo.qq;
pEmployee.TurnTime = pEmployeeInfo.turnTime;
pEmployee.EmLevelId = pEmployeeInfo.emLevelId;
pEmployee.EmDangId = pEmployeeInfo.emDangId;
pEmployee.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pEmployee.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(EmployeeInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pEmployeeInfo.employeeId = pEmployee.EmployeeId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(EmployeeInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(ContractApplyInfo pContractApplyInfo, ContractApply pContractApply, bool pIsNew)
{
pContractApply.ContractApplyId = pContractApplyInfo.contractApplyId;
pContractApply.ContractFileId = pContractApplyInfo.contractFileId;
pContractApply.SignName = pContractApplyInfo.signName;
pContractApply.ContractNum = pContractApplyInfo.contractNum;
pContractApply.SheetNum = pContractApplyInfo.sheetNum;
pContractApply.Today = pContractApplyInfo.today;
pContractApply.ContractName = pContractApplyInfo.contractName;
pContractApply.BeginDate = pContractApplyInfo.beginDate;
pContractApply.ApplyDate = pContractApplyInfo.applyDate;
pContractApply.ContractDes = pContractApplyInfo.contractDes;
pContractApply.BigMoney = pContractApplyInfo.bigMoney;
pContractApply.SmallMoney = pContractApplyInfo.smallMoney;
pContractApply.UseStampType = pContractApplyInfo.useStampType;
pContractApply.SectionView = pContractApplyInfo.sectionView;
pContractApply.ManagerView = pContractApplyInfo.managerView;
pContractApply.IsMoney = pContractApplyInfo.isMoney;
pContractApply.ApplyTime = pContractApplyInfo.applyTime;
pContractApply.ApplyName = pContractApplyInfo.applyName;
pContractApply.DepartName = pContractApplyInfo.departName;
pContractApply.State = pContractApplyInfo.state;
pContractApply.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pContractApply.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(ContractApplyInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pContractApplyInfo.contractApplyId = pContractApply.ContractApplyId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(ContractApplyInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(HolidayApplyInfo pHolidayApplyInfo, HolidayApply pHolidayApply, bool pIsNew)
{
pHolidayApply.HolidayApplyId = pHolidayApplyInfo.holidayApplyId;
pHolidayApply.Company1 = pHolidayApplyInfo.company1;
pHolidayApply.PositonName = pHolidayApplyInfo.positonName;
pHolidayApply.Company2 = pHolidayApplyInfo.company2;
pHolidayApply.Company2Name = pHolidayApplyInfo.company2Name;
pHolidayApply.HolidayTypeId = pHolidayApplyInfo.holidayTypeId;
pHolidayApply.BeginTime = pHolidayApplyInfo.beginTime;
pHolidayApply.EndTime = pHolidayApplyInfo.endTime;
pHolidayApply.TimeSum = pHolidayApplyInfo.timeSum;
pHolidayApply.Reason = pHolidayApplyInfo.reason;
pHolidayApply.SectionView = pHolidayApplyInfo.sectionView;
pHolidayApply.HrView = pHolidayApplyInfo.hrView;
pHolidayApply.ManagerView = pHolidayApplyInfo.managerView;
pHolidayApply.Memo = pHolidayApplyInfo.memo;
pHolidayApply.ApplyDate = pHolidayApplyInfo.applyDate;
pHolidayApply.ApplyTime = pHolidayApplyInfo.applyTime;
pHolidayApply.ApplyName = pHolidayApplyInfo.applyName;
pHolidayApply.DepartName = pHolidayApplyInfo.departName;
pHolidayApply.State = pHolidayApplyInfo.state;
pHolidayApply.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pHolidayApply.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(HolidayApplyInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pHolidayApplyInfo.holidayApplyId = pHolidayApply.HolidayApplyId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(HolidayApplyInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(WorkToolSumInfo pWorkToolSumInfo, WorkToolSum pWorkToolSum, bool pIsNew)
{
pWorkToolSum.WorkToolSumId = pWorkToolSumInfo.workToolSumId;
pWorkToolSum.DepartName = pWorkToolSumInfo.departName;
pWorkToolSum.Reason = pWorkToolSumInfo.reason;
pWorkToolSum.BigMoney = pWorkToolSumInfo.bigMoney;
pWorkToolSum.SmaMoney = pWorkToolSumInfo.smaMoney;
pWorkToolSum.MoneyStyle = pWorkToolSumInfo.moneyStyle;
pWorkToolSum.UseDepartName = pWorkToolSumInfo.useDepartName;
pWorkToolSum.FuTime = pWorkToolSumInfo.fuTime;
pWorkToolSum.ApplyName = pWorkToolSumInfo.applyName;
pWorkToolSum.State = pWorkToolSumInfo.state;
pWorkToolSum.ApplyTime = pWorkToolSumInfo.applyTime;
pWorkToolSum.DepartView = pWorkToolSumInfo.departView;
pWorkToolSum.ManagerView = pWorkToolSumInfo.managerView;
pWorkToolSum.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pWorkToolSum.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(WorkToolSumInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pWorkToolSumInfo.workToolSumId = pWorkToolSum.WorkToolSumId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(WorkToolSumInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(FileApplyInfo pFileApplyInfo, FileApply pFileApply, bool pIsNew)
{
pFileApply.FileApplyId = pFileApplyInfo.fileApplyId;
pFileApply.ApplyTime = pFileApplyInfo.applyTime;
pFileApply.FilesName = pFileApplyInfo.filesName;
pFileApply.FileType = pFileApplyInfo.fileType;
pFileApply.FileDes = pFileApplyInfo.fileDes;
pFileApply.DepartView = pFileApplyInfo.departView;
pFileApply.ManagerView = pFileApplyInfo.managerView;
pFileApply.FileOfApplyId = pFileApplyInfo.fileOfApplyId;
pFileApply.State = pFileApplyInfo.state;
pFileApply.DepartName = pFileApplyInfo.departName;
pFileApply.ApplyName = pFileApplyInfo.applyName;
pFileApply.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pFileApply.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(FileApplyInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pFileApplyInfo.fileApplyId = pFileApply.FileApplyId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(FileApplyInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(TechEmScoreInfo pTechEmScoreInfo, TechEmScore pTechEmScore, bool pIsNew)
{
pTechEmScore.TechEmScoreId = pTechEmScoreInfo.techEmScoreId;
pTechEmScore.SelfPlan = pTechEmScoreInfo.selfPlan;
pTechEmScore.SelfWorkTotal = pTechEmScoreInfo.selfWorkTotal;
pTechEmScore.SelfWorkSpeed = pTechEmScoreInfo.selfWorkSpeed;
pTechEmScore.SelfCommunicate = pTechEmScoreInfo.selfCommunicate;
pTechEmScore.SelfDescipline = pTechEmScoreInfo.selfDescipline;
pTechEmScore.SelfExecute = pTechEmScoreInfo.selfExecute;
pTechEmScore.SelfRoute = pTechEmScoreInfo.selfRoute;
pTechEmScore.SelfProfession = pTechEmScoreInfo.selfProfession;
pTechEmScore.SelfAttitude = pTechEmScoreInfo.selfAttitude;
pTechEmScore.SelfComplex = pTechEmScoreInfo.selfComplex;
pTechEmScore.SelfSpeciality = pTechEmScoreInfo.selfSpeciality;
pTechEmScore.UpPlan = pTechEmScoreInfo.upPlan;
pTechEmScore.UpWorkTotal = pTechEmScoreInfo.upWorkTotal;
pTechEmScore.UpWorkSpeed = pTechEmScoreInfo.upWorkSpeed;
pTechEmScore.UpCommunicate = pTechEmScoreInfo.upCommunicate;
pTechEmScore.UpDescipline = pTechEmScoreInfo.upDescipline;
pTechEmScore.UpExecute = pTechEmScoreInfo.upExecute;
pTechEmScore.UpRoute = pTechEmScoreInfo.upRoute;
pTechEmScore.UpProfession = pTechEmScoreInfo.upProfession;
pTechEmScore.UpAttitude = pTechEmScoreInfo.upAttitude;
pTechEmScore.UpComplex = pTechEmScoreInfo.upComplex;
pTechEmScore.UpSpeciality = pTechEmScoreInfo.upSpeciality;
pTechEmScore.SectPlan = pTechEmScoreInfo.sectPlan;
pTechEmScore.SectWorkTotal = pTechEmScoreInfo.sectWorkTotal;
pTechEmScore.SectWorkSpeed = pTechEmScoreInfo.sectWorkSpeed;
pTechEmScore.SectCommunicate = pTechEmScoreInfo.sectCommunicate;
pTechEmScore.SectDescipline = pTechEmScoreInfo.sectDescipline;
pTechEmScore.SectExecute = pTechEmScoreInfo.sectExecute;
pTechEmScore.SectRoute = pTechEmScoreInfo.sectRoute;
pTechEmScore.SectProfession = pTechEmScoreInfo.sectProfession;
pTechEmScore.SectAttitude = pTechEmScoreInfo.sectAttitude;
pTechEmScore.SectComplex = pTechEmScoreInfo.sectComplex;
pTechEmScore.SectSpeciality = pTechEmScoreInfo.sectSpeciality;
pTechEmScore.PlanFinish = pTechEmScoreInfo.planFinish;
pTechEmScore.ActualFinish = pTechEmScoreInfo.actualFinish;
pTechEmScore.FinishRate = pTechEmScoreInfo.finishRate;
pTechEmScore.FinishScore = pTechEmScoreInfo.finishScore;
pTechEmScore.Reason = pTechEmScoreInfo.reason;
pTechEmScore.AddMinusSocre = pTechEmScoreInfo.addMinusSocre;
pTechEmScore.TotalScore = pTechEmScoreInfo.totalScore;
pTechEmScore.UpViews = pTechEmScoreInfo.upViews;
pTechEmScore.EmployeeId = pTechEmScoreInfo.employeeId;
pTechEmScore.IsSubmit = pTechEmScoreInfo.isSubmit;
pTechEmScore.DateSpan = pTechEmScoreInfo.dateSpan;
pTechEmScore.YearId = pTechEmScoreInfo.yearId;
pTechEmScore.MonthId = pTechEmScoreInfo.monthId;
pTechEmScore.EvaluateLevelId = pTechEmScoreInfo.evaluateLevelId;
pTechEmScore.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pTechEmScore.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(TechEmScoreInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pTechEmScoreInfo.techEmScoreId = pTechEmScore.TechEmScoreId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(TechEmScoreInfo)))
{
ResetCache();
}
}
//数据持久化
internal static void SaveToDb(BusinessExpInfo pBusinessExpInfo, BusinessExp pBusinessExp, bool pIsNew)
{
pBusinessExp.BusinessExpId = pBusinessExpInfo.businessExpId;
pBusinessExp.MainBusinessExpId = pBusinessExpInfo.mainBusinessExpId;
pBusinessExp.SheetNum = pBusinessExpInfo.sheetNum;
pBusinessExp.ApplyPeople = pBusinessExpInfo.applyPeople;
pBusinessExp.Depart = pBusinessExpInfo.depart;
pBusinessExp.Memo = pBusinessExpInfo.memo;
pBusinessExp.Employee1Id = pBusinessExpInfo.employee1Id;
pBusinessExp.Employee2Id = pBusinessExpInfo.employee2Id;
pBusinessExp.ReasonExp = pBusinessExpInfo.reasonExp;
pBusinessExp.ApplyDate = pBusinessExpInfo.applyDate;
pBusinessExp.PreIsApply = pBusinessExpInfo.preIsApply;
pBusinessExp.IsApprove = pBusinessExpInfo.isApprove;
pBusinessExp.IsApply = pBusinessExpInfo.isApply;
pBusinessExp.IsApply1 = pBusinessExpInfo.isApply1;
pBusinessExp.IsApply2 = pBusinessExpInfo.isApply2;
pBusinessExp.PreIsOver = pBusinessExpInfo.preIsOver;
pBusinessExp.IsOver1 = pBusinessExpInfo.isOver1;
pBusinessExp.IsOver2 = pBusinessExpInfo.isOver2;
pBusinessExp.PreApplyTime = pBusinessExpInfo.preApplyTime;
pBusinessExp.ApproveTime = pBusinessExpInfo.approveTime;
pBusinessExp.ApplyTime = pBusinessExpInfo.applyTime;
pBusinessExp.Apply1Time = pBusinessExpInfo.apply1Time;
pBusinessExp.Apply2Time = pBusinessExpInfo.apply2Time;
pBusinessExp.PreEmployeeId = pBusinessExpInfo.preEmployeeId;
pBusinessExp.SendEmployeeId = pBusinessExpInfo.sendEmployeeId;
pBusinessExp.RecvEmployeeId = pBusinessExpInfo.recvEmployeeId;
pBusinessExp.Recv1EmployeeId = pBusinessExpInfo.recv1EmployeeId;
pBusinessExp.Recv2EmployeeId = pBusinessExpInfo.recv2EmployeeId;
pBusinessExp.SendEmployeeName = pBusinessExpInfo.sendEmployeeName;
pBusinessExp.Recv1EmployeeName = pBusinessExpInfo.recv1EmployeeName;
pBusinessExp.Recv2EmployeeName = pBusinessExpInfo.recv2EmployeeName;
pBusinessExp.PreEmployeeName = pBusinessExpInfo.preEmployeeName;
pBusinessExp.RecvEmployeeName = pBusinessExpInfo.recvEmployeeName;
pBusinessExp.IsNewCreate = pBusinessExpInfo.isNewCreate;
pBusinessExp.IsMain = pBusinessExpInfo.isMain;
pBusinessExp.IsMain1 = pBusinessExpInfo.isMain1;
pBusinessExp.IsMain2 = pBusinessExpInfo.isMain2;
pBusinessExp.IsMain3 = pBusinessExpInfo.isMain3;
pBusinessExp.MoneySum = pBusinessExpInfo.moneySum;
pBusinessExp.Today = pBusinessExpInfo.today;
pBusinessExp.SignName = pBusinessExpInfo.signName;
pBusinessExp.Item1 = pBusinessExpInfo.item1;
pBusinessExp.Item2 = pBusinessExpInfo.item2;
pBusinessExp.Item3 = pBusinessExpInfo.item3;
pBusinessExp.Item4 = pBusinessExpInfo.item4;
pBusinessExp.Money1 = pBusinessExpInfo.money1;
pBusinessExp.Money2 = pBusinessExpInfo.money2;
pBusinessExp.Money3 = pBusinessExpInfo.money3;
pBusinessExp.Money4 = pBusinessExpInfo.money4;
pBusinessExp.IsNew = pIsNew;
string UserName = SubsonicHelper.GetUserName();
try
{
pBusinessExp.Save(UserName);
}
catch (Exception ex)
{
LogManager.getInstance().getLogger(typeof(BusinessExpInfo)).Error(ex);
if (ex.Message.Contains("插入重复键")) //违反了唯一键
{
throw new AppException("此对象已经存在"); //此处等待优化可以从唯一约束中直接取出提示来，如果没有的话，默认为原始的出错提示
}
throw new AppException("保存失败");
}
pBusinessExpInfo.businessExpId = pBusinessExp.BusinessExpId;
//如果缓存存在，更新缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(BusinessExpInfo)))
{
ResetCache();
}
}
