public Common.ClientResult.Result InstUAUB([FromBody] METERING_STANDARD_DEVICE entity)
{
Common.ClientResult.Result result = new Common.ClientResult.Result();
if (entity != null && ModelState.IsValid)
{
//string currentPerson = GetCurrentPerson();
//entity.CreateTime = DateTime.Now;
//entity.CreatePerson = currentPerson;
int groups = 1;
Account acc = GetCurrentAccount();
List <UNCERTAINTYTABLE> list = m_BLL.GetByRefMETERING_STANDARD_DEVICEID(entity.ID);
var data = (from f in list select f.GROUPS).Max();
if (data != null)
{
groups = (int)data + 1;
}
else
{
groups = 1;
}
string returnValue = string.Empty;
foreach (var item in entity.UNCERTAINTYTABLE)
{
item.CREATETIME = DateTime.Now;
item.CREATEPERSON = acc.PersonName;
item.ID = Result.GetNewId();
item.GROUPS = groups;
if (m_BLL.Create(ref validationErrors, item))
{
LogClassModels.WriteServiceLog(Suggestion.InsertSucceed + "，不确定度的信息的Id为" + item.ID, "不确定度"
);//写入日志
result.Code = Common.ClientCode.Succeed;
result.Message = Suggestion.InsertSucceed;
//return result; //提示创建成功
}
else
{
if (validationErrors != null && validationErrors.Count > 0)
{
validationErrors.All(a =>
{
returnValue += a.ErrorMessage;
return(true);
});
}
LogClassModels.WriteServiceLog(Suggestion.InsertFail + "，不确定度的信息，" + returnValue, "不确定度"
);//写入日志
result.Code = Common.ClientCode.Fail;
result.Message = Suggestion.InsertFail + returnValue;
return(result); //提示插入失败
}
}
return(result);
}
result.Code = Common.ClientCode.FindNull;
result.Message = Suggestion.InsertFail + "，请核对输入的数据的格式"; //提示输入的数据的格式不对
return(result);
}
/// <summary>
/// 最大允许误差信息
/// </summary>
/// <param name="validationErrors">返回的错误信息</param>
/// <param name="entity">最大允许误差信息 </param>
/// <returns></returns>
public bool EditUpdate(ref ValidationErrors validationErrors, METERING_STANDARD_DEVICE entity)
{
try
{
var data = entity.METERING_STANDARD_DEVICE_CHECK.Where(s => s.ID == null).ToList();
var upda = entity.METERING_STANDARD_DEVICE_CHECK.Where(s => s.ID != null).ToList();
foreach (var item in upda)
{
repository.EditField(db, item);
}
foreach (var item in data)
{
item.ID = Result.GetNewId();
item.METERING_STANDARD_DEVICEID = entity.ID;
repository.Create(item);
}
repository.Save(db);
return(true);
}
catch (Exception ex)
{
validationErrors.Add(ex.Message);
ExceptionsHander.WriteExceptions(ex);
}
return(false);
}
/// <summary>
/// 创建一个标准装置/计量标准器信息
/// </summary>
/// <param name="validationErrors">返回的错误信息</param>
/// <param name="db">数据库上下文</param>
/// <param name="entity">一个标准装置/计量标准器信息</param>
/// <returns></returns>
public bool Create(ref ValidationErrors validationErrors, SysEntities db, METERING_STANDARD_DEVICE entity)
{
int count = 1;
foreach (string item in entity.PREPARE_SCHEMEID.GetIdSort())
{
PREPARE_SCHEME sys = new PREPARE_SCHEME {
ID = item
};
db.PREPARE_SCHEME.Attach(sys);
entity.PREPARE_SCHEME.Add(sys);
count++;
}
repository.Create(db, entity);
if (count == repository.Save(db))
{
return(true);
}
else
{
validationErrors.Add("创建出错了");
}
return(false);
}
/// <summary>
/// 创建一个标准装置/计量标准器信息
/// </summary>
/// <param name="validationErrors">返回的错误信息</param>
/// <param name="db">数据库上下文</param>
/// <param name="entity">一个标准装置/计量标准器信息</param>
/// <returns></returns>
public bool CreateX(ref ValidationErrors validationErrors, SysEntities db, METERING_STANDARD_DEVICE entity)
{
repository.Create(db, entity);
if (repository.Save(db) > 0)
{
return(true);
}
else
{
validationErrors.Add("创建出错了");
}
return(false);
}
/// <summary>
/// 编辑一个标准装置/计量标准器信息
/// </summary>
/// <param name="validationErrors">返回的错误信息</param>
/// <param name="entity">一个标准装置/计量标准器信息</param>
/// <returns></returns>
public bool EditField(ref ValidationErrors validationErrors, METERING_STANDARD_DEVICE entity)
{
try
{
repository.EditField(db, entity);
repository.Save(db);
return(true);
}
catch (Exception ex)
{
validationErrors.Add(ex.Message);
ExceptionsHander.WriteExceptions(ex);
}
return(false);
}
// PUT api/<controller>/5
/// <summary>
/// 编辑
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public Common.ClientResult.Result Put([FromBody] METERING_STANDARD_DEVICE entity)
{
Common.ClientResult.Result result = new Common.ClientResult.Result();
if (entity != null && ModelState.IsValid)
{ //数据校验
string currentPerson = GetCurrentPerson();
foreach (var item in entity.UNCERTAINTYTABLE)
{
item.UPDATETIME = DateTime.Now;
item.UPDATEPERSON = currentPerson;
}
string returnValue = string.Empty;
if (m_BLL.EditUpdate(ref validationErrors, entity))
{
LogClassModels.WriteServiceLog(Suggestion.UpdateSucceed + "，不确定度信息的Id为" + entity.ID, "不确定度"
);//写入日志
result.Code = Common.ClientCode.Succeed;
result.Message = Suggestion.UpdateSucceed;
return(result); //提示更新成功
}
else
{
if (validationErrors != null && validationErrors.Count > 0)
{
validationErrors.All(a =>
{
returnValue += a.ErrorMessage;
return(true);
});
}
LogClassModels.WriteServiceLog(Suggestion.UpdateFail + "，不确定度信息的Id为" + entity.ID + "," + returnValue, "不确定度"
);//写入日志
result.Code = Common.ClientCode.Fail;
result.Message = Suggestion.UpdateFail + returnValue;
return(result); //提示更新失败
}
}
result.Code = Common.ClientCode.FindNull;
result.Message = Suggestion.UpdateFail + "请核对输入的数据的格式";
return(result); //提示输入的数据的格式不对
}
public METERING_STANDARD_DEVICEShow Update(string id)
{
METERING_STANDARD_DEVICEShow msdshow = new METERING_STANDARD_DEVICEShow();
if (!string.IsNullOrWhiteSpace(id))
{
METERING_STANDARD_DEVICE msd = m_BLL.GetById(id);
msdshow.ID = msd.ID;
msdshow.NAME = msd.NAME;
msdshow.TEST_RANGE = msd.TEST_RANGE;
msdshow.FACTORY_NUM = msd.FACTORY_NUM;
msdshow.CATEGORY = msd.CATEGORY;
msdshow.STATUS = msd.STATUS;
msdshow.UNDERTAKE_LABORATORYID = msd.UNDERTAKE_LABORATORYID;
msdshow.CREATETIME = msd.CREATETIME;
msdshow.CREATEPERSON = msd.CREATEPERSON;
msdshow.UPDATETIME = msd.UPDATETIME;
msdshow.UPDATEPERSON = msd.UPDATEPERSON;
msdshow.XINGHAO = msd.XINGHAO;
msdshow.THESUPERIOR = msd.THESUPERIOR;
if (!string.IsNullOrWhiteSpace(msd.THESUPERIOR))
{
METERING_STANDARD_DEVICE msd2 = m_BLL.GetById(msd.THESUPERIOR);
msdshow.THESUPERIORNAME = msd2.ID + "&" + msd2.NAME;
}
if (!string.IsNullOrWhiteSpace(msd.ID))
{
msdshow.IS = "1";
}
else
{
msdshow.IS = "2";
}
}
return(msdshow);
}
/// <summary>
/// 创建一个标准装置/计量标准器信息
/// </summary>
/// <param name="validationErrors">返回的错误信息</param>
/// <param name="entity">一个标准装置/计量标准器信息</param>
/// <returns></returns>
public bool CreateX(ref ValidationErrors validationErrors, METERING_STANDARD_DEVICE entity)
{
try
{
////using (TransactionScope transactionScope = new TransactionScope())
//{
if (CreateX(ref validationErrors, db, entity))
{
////transactionScope.Complete();
return(true);
}
else
{
//Transaction.Current.Rollback();
}
//}
}
catch (Exception ex)
{
validationErrors.Add(ex.Message);
ExceptionsHander.WriteExceptions(ex);
}
return(false);
}
/// <summary>
/// 准确度等级数据展示
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public Common.ClientResult.DataResult ALLOWABLE_ERRORData(string id)
{
int total = 0;
METERING_STANDARD_DEVICE msd = m_BLL.GetById(id);
string CERTIFICATE_NUM = string.Empty; //证书编号
string VALID_TO = string.Empty; //有效期
string MAXCATEGORIES = string.Empty; //最大允许误差
decimal?GROUPS = 0; //组别
string CATEGORY = string.Empty; //类型
//分组
var data = (from f in msd.METERING_STANDARD_DEVICE_CHECK
select f.GROUPS).Distinct();
List <App.Models.ALLOWABLE_ERRORData> alldata = new List <App.Models.ALLOWABLE_ERRORData>();
foreach (var item in data)
{
CERTIFICATE_NUM = null;
VALID_TO = null;
MAXCATEGORIES = null;
//计量标准装置检定/校准信息
foreach (var it in msd.METERING_STANDARD_DEVICE_CHECK.Where(w => w.GROUPS == item))
{
TimeSpan ts = Convert.ToDateTime(it.VALID_TO) - DateTime.Now;
if (ts.Days > 0)
{
CERTIFICATE_NUM += it.CERTIFICATE_NUM + ",";
VALID_TO += Convert.ToDateTime(it.VALID_TO).ToString("yyyy-MM-dd") + ",";
}
GROUPS = it.GROUPS;
CATEGORY = it.CATEGORY;
}
//最大允许误差信息
foreach (var it in msd.ALLOWABLE_ERROR.Where(w => w.GROUPS == item))
{
if (!string.IsNullOrWhiteSpace(VALID_TO))
{
if (!string.IsNullOrWhiteSpace(it.THEACCURACYLEVEL))
{
MAXCATEGORIES += it.THEACCURACYLEVEL + ",";
}
else if (!string.IsNullOrWhiteSpace(it.MAXCATEGORIES) || !string.IsNullOrWhiteSpace(it.MAXVALUE))
{
MAXCATEGORIES += it.MAXCATEGORIES + it.MAXVALUE + ",";
}
else if (!string.IsNullOrWhiteSpace(it.THEUNCERTAINTY) || !string.IsNullOrWhiteSpace(it.THEUNCERTAINTYVALUE) || !string.IsNullOrWhiteSpace(it.THEUNCERTAINTYNDEXL) || !string.IsNullOrWhiteSpace(it.THEUNCERTAINTYVALUEK))
{
MAXCATEGORIES += it.THEUNCERTAINTY + it.THEUNCERTAINTYVALUE + it.THEUNCERTAINTYNDEXL + it.THEUNCERTAINTYVALUEK + ",";
}
}
}
if (!string.IsNullOrWhiteSpace(MAXCATEGORIES))
{
alldata.Add(new ALLOWABLE_ERRORData()
{
CERTIFICATE_NUM = CERTIFICATE_NUM, //证书编号
VALID_TO = VALID_TO, //有效期
ID = id, //id
MAXCATEGORIES = MAXCATEGORIES, //最大允许误差
GROUPS = GROUPS,
CATEGORY = CATEGORY
});
}
}
var show = new Common.ClientResult.DataResult
{
total = total,
rows = alldata.Select(s => new
{
CERTIFICATE_NUM = s.CERTIFICATE_NUM.TrimEnd(','), //证书编号
VALID_TO = s.VALID_TO.TrimEnd(','), //有效期
ID = s.ID, //id
MAXCATEGORIES = s.MAXCATEGORIES.TrimEnd(','), //最大允许误差
GROUPS = s.GROUPS,
CATEGORY = s.CATEGORY
})
};
return(show);
}
/// <summary>
/// 创建
/// </summary>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public Common.ClientResult.Result Post([FromBody] METERING_STANDARD_DEVICE entity)
{
Common.ClientResult.Result result = new Common.ClientResult.Result();
if (entity != null && ModelState.IsValid)
{
string currentPerson = GetCurrentPerson();
string returnValue = string.Empty;
if (!string.IsNullOrWhiteSpace(entity.ID))
{
entity.UPDATEPERSON = currentPerson;
entity.UPDATETIME = DateTime.Now;
if (m_BLL.EditField(ref validationErrors, entity))
{
LogClassModels.WriteServiceLog(Suggestion.InsertSucceed + "，标准装置/计量标准器信息的信息的Id为" + entity.ID, "标准装置/计量标准器信息"
);//写入日志
result.Code = Common.ClientCode.Succeed;
result.Message = Suggestion.UpdateSucceed;
return(result); //提示修改成功
}
else
{
if (validationErrors != null && validationErrors.Count > 0)
{
validationErrors.All(a =>
{
returnValue += a.ErrorMessage;
return(true);
});
}
LogClassModels.WriteServiceLog(Suggestion.UpdateFail + "，标准装置/计量标准器信息的信息，" + returnValue, "标准装置/计量标准器信息"
);//写入日志
result.Code = Common.ClientCode.Fail;
result.Message = Suggestion.UpdateFail + returnValue;
return(result); //提示修改失败
}
}
else
{
entity.ID = Result.GetNewId();
entity.CREATETIME = DateTime.Now;
entity.CREATEPERSON = currentPerson;
if (m_BLL.CreateX(ref validationErrors, entity))
{
LogClassModels.WriteServiceLog(Suggestion.InsertSucceed + "，标准装置/计量标准器信息的信息的Id为" + entity.ID, "标准装置/计量标准器信息"
);//写入日志
result.Code = Common.ClientCode.Succeed;
result.Message = Suggestion.InsertSucceed;
return(result); //提示创建成功
}
else
{
if (validationErrors != null && validationErrors.Count > 0)
{
validationErrors.All(a =>
{
returnValue += a.ErrorMessage;
return(true);
});
}
LogClassModels.WriteServiceLog(Suggestion.InsertFail + "，标准装置/计量标准器信息的信息，" + returnValue, "标准装置/计量标准器信息"
);//写入日志
result.Code = Common.ClientCode.Fail;
result.Message = Suggestion.InsertFail + returnValue;
return(result); //提示插入失败
}
}
}
result.Code = Common.ClientCode.FindNull;
result.Message = Suggestion.InsertFail + "，请核对输入的数据的格式"; //提示输入的数据的格式不对
return(result);
}
/// <summary>
/// 根据ID获取数据模型
/// </summary>
/// <param name="id">编号</param>
/// <returns></returns>
public METERING_STANDARD_DEVICE Get(string id)
{
METERING_STANDARD_DEVICE item = m_BLL.GetById(id);
return(item);
}
public ActionResult Edit(string id)
{
METERING_STANDARD_DEVICEShow msdshow = new METERING_STANDARD_DEVICEShow();
if (!string.IsNullOrWhiteSpace(id))
{
METERING_STANDARD_DEVICE msd = m_BLL.GetById(id.Split('^')[0]); //通过id查询数据
int GROUPS = Convert.ToInt32(id.Split('^')[1]); //组别
string IS = id.Split('^')[2];
if (IS == "A")
{
string CATEGORY = id.Split('^')[3];
var alledata = msd.ALLOWABLE_ERROR.Where(a => a.GROUPS == GROUPS && a.CATEGORY == CATEGORY); //筛选数据
var msdcdata = msd.METERING_STANDARD_DEVICE_CHECK.Where(a => a.GROUPS == GROUPS && a.CATEGORY == CATEGORY); //筛选数据
foreach (var al in alledata) //循环添加数据
{
var alladd = new ALLOWABLE_ERRORShow()
{
ID = al.ID,
THEACCURACYLEVEL = al.THEACCURACYLEVEL,
THEUNCERTAINTYVALUEK = al.THEUNCERTAINTYVALUEK,
THEUNCERTAINTYNDEXL = al.THEUNCERTAINTYNDEXL,
THEUNCERTAINTYVALUE = al.THEUNCERTAINTYVALUE,
THEUNCERTAINTY = al.THEUNCERTAINTY,
MAXVALUE = al.MAXVALUE,
MAXCATEGORIES = al.MAXCATEGORIES,
METERING_STANDARD_DEVICEID = al.METERING_STANDARD_DEVICEID,
GROUPS = al.GROUPS
};
msdshow.ALLOWABLE_ERRORShow.Add(alladd);
}
foreach (var ms in msdcdata)//循环添加数据
{
var msdcadd = new METERING_STANDARD_DEVICE_CHECKShow()
{
ID = ms.ID,
CERTIFICATEUNIT = ms.CERTIFICATEUNIT,
CERTIFICATE_NUM = ms.CERTIFICATE_NUM,
CHECK_DATE = ms.CHECK_DATE,
VALID_TO = ms.VALID_TO,
METERING_STANDARD_DEVICEID = ms.METERING_STANDARD_DEVICEID,
GROUPS = ms.GROUPS
};
msdshow.METERING_STANDARD_DEVICE_CHECKShow.Add(msdcadd);
}
}
else if (IS == "UA" || IS == "UB")
{
var undata = msd.UNCERTAINTYTABLE.Where(a => a.GROUPS == GROUPS && a.CATEGORY == IS); //筛选数据
//undata = undata.Where(b => b.UNCERTAINTYUI != null);
foreach (var al in undata) //循环添加数据
{
var unadd = new UNCERTAINTYTABLEShow()
{
ID = al.ID,
ASSESSMENTITEM = al.ASSESSMENTITEM,
ERRORSOURCES = al.ERRORSOURCES,
ERRORLIMITS = al.ERRORLIMITS,
ERRORLIMITUNIT = al.ERRORLIMITUNIT,
THEERRODISTRIBUTION = al.THEERRODISTRIBUTION,
KVALE = al.KVALE,
THERANGESCOPE = al.THERANGESCOPE,
THEUNIT = al.THEUNIT,
THERELATIONSHIP = al.THERELATIONSHIP,
ENDRANGESCOPE = al.ENDRANGESCOPE,
ENDUNIT = al.ENDUNIT,
ENDRELATIONSHIP = al.ENDRELATIONSHIP,
THEFREQUENCY = al.THEFREQUENCY,
THEUNITFREQUENCY = al.THEUNITFREQUENCY,
THERELATIONSHIPFREQUENCY = al.THERELATIONSHIPFREQUENCY,
ENDFREQUENCY = al.ENDFREQUENCY,
ENDUNITFREQUENCY = al.ENDUNITFREQUENCY,
ENDRELATIONSHIPFREQUENCY = al.ENDRELATIONSHIPFREQUENCY,
INDEX1 = al.INDEX1,
INDEX1UNIT = al.INDEX1UNIT,
INDEX2 = al.INDEX2,
INDEX2UNIT = al.INDEX2UNIT,
NOTE = al.NOTE,
METERING_STANDARD_DEVICEID = al.METERING_STANDARD_DEVICEID,
GROUPS = al.GROUPS,
UNCERTAINTYUI = al.UNCERTAINTYUI,
UNCERTAINTYUIUNIT = al.UNCERTAINTYUIUNIT
};
msdshow.UNCERTAINTYTABLEShow.Add(unadd);
}
}
msdshow.IS = IS;
msdshow.ID = msd.ID;
ViewBag.GROUPS = GROUPS.ToString();
ViewBag.CATEGORY = id.Split('^')[3];
}
return(View(msdshow));
}
/// <summary>
/// 编辑一个标准装置/计量标准器信息
/// </summary>
/// <param name="validationErrors">返回的错误信息</param>
/// <param name="db">数据上下文</param>
/// <param name="entity">一个标准装置/计量标准器信息</param>
/// <returns>是否编辑成功</returns>
public bool Edit(ref ValidationErrors validationErrors, SysEntities db, METERING_STANDARD_DEVICE entity)
{ /*
* 不操作 原有 现有
* 增加 原没 现有
* 删除 原有 现没
*/
if (entity == null)
{
return(false);
}
int count = 1;
var data = (from m in db.METERING_STANDARD_DEVICE
where m.ID == entity.ID
select m).FirstOrDefault();//在数据的原始数据
data.NAME = entity.NAME;
List <string> addPREPARE_SCHEMEID = new List <string>();
List <string> deletePREPARE_SCHEMEID = new List <string>();
DataOfDiffrent.GetDiffrent(entity.PREPARE_SCHEMEID.GetIdSort(), entity.PREPARE_SCHEMEIDOld.GetIdSort(), ref addPREPARE_SCHEMEID, ref deletePREPARE_SCHEMEID);
List <PREPARE_SCHEME> listEntityPREPARE_SCHEME = new List <PREPARE_SCHEME>();
if (deletePREPARE_SCHEMEID != null && deletePREPARE_SCHEMEID.Count() > 0)
{
foreach (var item in deletePREPARE_SCHEMEID)
{
PREPARE_SCHEME sys = new PREPARE_SCHEME {
ID = item
};
listEntityPREPARE_SCHEME.Add(sys);
entity.PREPARE_SCHEME.Add(sys);
}
}
METERING_STANDARD_DEVICE editEntity = repository.Edit(db, entity);
if (addPREPARE_SCHEMEID != null && addPREPARE_SCHEMEID.Count() > 0)
{
foreach (var item in addPREPARE_SCHEMEID)
{
PREPARE_SCHEME sys = new PREPARE_SCHEME {
ID = item
};
db.PREPARE_SCHEME.Attach(sys);
editEntity.PREPARE_SCHEME.Add(sys);
count++;
}
}
if (deletePREPARE_SCHEMEID != null && deletePREPARE_SCHEMEID.Count() > 0)
{
foreach (PREPARE_SCHEME item in listEntityPREPARE_SCHEME)
{
editEntity.PREPARE_SCHEME.Remove(item);
count++;
}
}
if (count == repository.Save(db))
{
return(true);
}
else
{
validationErrors.Add("编辑标准装置/计量标准器信息出错了");
}
return(false);
}
/// <summary>
/// 编辑一个预备方案
/// </summary>
/// <param name="validationErrors">返回的错误信息</param>
/// <param name="db">数据上下文</param>
/// <param name="entity">一个预备方案</param>
/// <returns>是否编辑成功</returns>
public bool Edit(ref ValidationErrors validationErrors, SysEntities db, PREPARE_SCHEME entity)
{ /*
* 不操作 原有 现有
* 增加 原没 现有
* 删除 原有 现没
*/
if (entity == null)
{
return(false);
}
int count = 1;
List <string> addMETERING_STANDARD_DEVICEID = new List <string>();
List <string> deleteMETERING_STANDARD_DEVICEID = new List <string>();
DataOfDiffrent.GetDiffrent(entity.METERING_STANDARD_DEVICEID.GetIdSort(), entity.METERING_STANDARD_DEVICEIDOld.GetIdSort(), ref addMETERING_STANDARD_DEVICEID, ref deleteMETERING_STANDARD_DEVICEID);
List <METERING_STANDARD_DEVICE> listEntityMETERING_STANDARD_DEVICE = new List <METERING_STANDARD_DEVICE>();
if (deleteMETERING_STANDARD_DEVICEID != null && deleteMETERING_STANDARD_DEVICEID.Count() > 0)
{
foreach (var item in deleteMETERING_STANDARD_DEVICEID)
{
METERING_STANDARD_DEVICE sys = new METERING_STANDARD_DEVICE {
ID = item
};
listEntityMETERING_STANDARD_DEVICE.Add(sys);
entity.METERING_STANDARD_DEVICE.Add(sys);
}
}
PREPARE_SCHEME editEntity = repository.Edit(db, entity);
if (addMETERING_STANDARD_DEVICEID != null && addMETERING_STANDARD_DEVICEID.Count() > 0)
{
foreach (var item in addMETERING_STANDARD_DEVICEID)
{
METERING_STANDARD_DEVICE sys = new METERING_STANDARD_DEVICE {
ID = item
};
db.METERING_STANDARD_DEVICE.Attach(sys);
editEntity.METERING_STANDARD_DEVICE.Add(sys);
count++;
}
}
if (deleteMETERING_STANDARD_DEVICEID != null && deleteMETERING_STANDARD_DEVICEID.Count() > 0)
{
foreach (METERING_STANDARD_DEVICE item in listEntityMETERING_STANDARD_DEVICE)
{
editEntity.METERING_STANDARD_DEVICE.Remove(item);
count++;
}
}
if (count == repository.Save(db))
{
return(true);
}
else
{
validationErrors.Add("编辑预备方案出错了");
}
return(false);
}
/// <summary>
/// 创建
/// </summary>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public Common.ClientResult.Result Post([FromBody] METERING_STANDARD_DEVICE entity)
{
Common.ClientResult.Result result = new Common.ClientResult.Result();
string returnValue = string.Empty;
if (entity != null && ModelState.IsValid)
{
string currentPerson = GetCurrentPerson();
entity.CREATETIME = DateTime.Now;
entity.CREATEPERSON = currentPerson;
int groups = 1;
List <ALLOWABLE_ERROR> list = m_BLL.GetByRefMETERING_STANDARD_DEVICEID(entity.ID);
var data = (from f in list select f.GROUPS).Max();
if (data != null)
{
groups = (int)data + 1;
}
string CATEGORY = string.Empty;
foreach (var item in entity.ALLOWABLE_ERROR)
{
item.ID = Result.GetNewId();
item.CREATETIME = DateTime.Now;
item.CREATEPERSON = currentPerson;
item.METERING_STANDARD_DEVICEID = entity.ID;
item.GROUPS = groups;
CATEGORY = item.CATEGORY;
if (m_BLL.Create(ref validationErrors, item))
{
LogClassModels.WriteServiceLog(Suggestion.InsertSucceed + "，最大允许误差信息的信息的Id为" + entity.ID, "最大允许误差信息"
);//写入日志
result.Code = Common.ClientCode.Succeed;
result.Message = Suggestion.InsertSucceed;
//return result; //提示创建成功
}
else
{
if (validationErrors != null && validationErrors.Count > 0)
{
validationErrors.All(a =>
{
returnValue += a.ErrorMessage;
return(true);
});
}
LogClassModels.WriteServiceLog(Suggestion.InsertFail + "，最大允许误差信息的信息，" + returnValue, "最大允许误差信息"
);//写入日志
result.Code = Common.ClientCode.Fail;
result.Message = Suggestion.InsertFail + returnValue;
return(result); //提示插入失败
}
}
foreach (var item in entity.METERING_STANDARD_DEVICE_CHECK)
{
item.ID = Result.GetNewId();
item.CREATETIME = DateTime.Now;
item.CREATEPERSON = currentPerson;
item.METERING_STANDARD_DEVICEID = entity.ID;
item.GROUPS = groups;
item.CATEGORY = CATEGORY;
if (m_BLL2.Create(ref validationErrors, item))
{
LogClassModels.WriteServiceLog(Suggestion.InsertSucceed + "，计量标准装置检定/校准信息的信息的Id为" + entity.ID, "计量标准装置检定/校准信息"
);//写入日志
result.Code = Common.ClientCode.Succeed;
result.Message = Suggestion.InsertSucceed;
//return result; //提示创建成功
}
else
{
if (validationErrors != null && validationErrors.Count > 0)
{
validationErrors.All(a =>
{
returnValue += a.ErrorMessage;
return(true);
});
}
LogClassModels.WriteServiceLog(Suggestion.InsertFail + "，计量标准装置检定/校准信息的信息，" + returnValue, "计量标准装置检定/校准信息"
);//写入日志
result.Code = Common.ClientCode.Fail;
result.Message = Suggestion.InsertFail + returnValue;
return(result); //提示插入失败
}
}
}
return(result);
}
