public IHttpActionResult GetDeviceCurrentDataInside(GetDeviceDataParameter parameter)
{
ReturnItem <List <RetDeviceCurrentData> > r = new ReturnItem <List <RetDeviceCurrentData> >();
List <RetDeviceCurrentData> listinfo = new List <RetDeviceCurrentData>();
List <DeviceDataInfoModel> Devicelist = new List <DeviceDataInfoModel>();
if (parameter.DeviceInfo != "" && parameter.DeviceInfo != null)
{
Devicelist = JsonConvert.DeserializeObject <List <DeviceDataInfoModel> >(parameter.DeviceInfo);
}
DeviceDataBLL device = new DeviceDataBLL();
foreach (var item in Devicelist)
{
var ReturnData = device.GetDeviceCurrentDataInside(item);
if (ReturnData.Code == -1)
{
continue;
}
listinfo.Add(ReturnData.Data);
}
r.Data = listinfo;
r.Msg = "数据获取成功";
r.Code = 0;
return(InspurJson(r, true));
}
public IHttpActionResult GetEquipmentMonitorData(List <DeviceDataModel> model)
{
ReturnItem <List <RetDeviceCurrentData> > r = new ReturnItem <List <RetDeviceCurrentData> >();
List <RetDeviceCurrentData> listinfo = new List <RetDeviceCurrentData>();
DeviceDataBLL data = new DeviceDataBLL();
foreach (var item in model)
{
var get = data.GetCurrentData(item);
RetDeviceCurrentData info = new RetDeviceCurrentData();
if (get.Data == null)
{
info.DeviceId = item.DeviceID;
info.DeviceItemId = item.DeviceItemID;
info.Value = "暂无数据";
}
else if (get.Data != null && get.Data.Data.Count > 0)
{
info.DeviceId = item.DeviceID;
info.DeviceItemId = item.DeviceItemID;
info.Value = get.Data.Data[0].ToString();
}
//data.setAirRank(info);
listinfo.Add(info);
}
data.setAirRank(listinfo);
r.Data = listinfo;
r.Msg = "数据获取成功";
r.Code = 0;
return(InspurJson <List <RetDeviceCurrentData> >(r));
}
public ReturnItem <RetUserLoginInfo> UserLogout(string tokenid)
{
ReturnItem <RetUserLoginInfo> r = new ReturnItem <RetUserLoginInfo>();
r.TimerEnd();
return(r);
}
public IHttpActionResult AddAlertPoliciesInfoList1(AlertPoliciesListModel parameter)
{
UserApi api = new UserApi();
ReturnItem <RetAlertPolicies> get = new ReturnItem <RetAlertPolicies>();
var userApi = api.GetUserInfoByToken();
parameter.CreateUserID = Convert.ToInt32(userApi.Data.UserId);
parameter.OrgID = userApi.Data.OrgID.ToString();
AlertPoliciesInfoBLL device = new AlertPoliciesInfoBLL();
AlertPoliciesModel alert = new AlertPoliciesModel();
alert.StrategyName = parameter.StrategyName;
alert.Remark = parameter.Remark;
alert.CreateTime = parameter.CreateTime;
alert.CreateTime = parameter.CreateTime;
alert.Interval = parameter.Interval;
alert.OrgID = parameter.OrgID;
alert.Active = parameter.Active;
foreach (var item in parameter.DeviceList)
{
alert.DeviceID = item;
foreach (var value in parameter.Property)
{
alert.DataConnectID = value.DataConnectID;
alert.DeviceItemId = value.DeviceItemId;
alert.Compare = value.Compare;
alert.Threshold = value.Threshold;
alert.TagList = value.TagList;
get = device.AddAlertPoliciesInfo(alert);
}
}
return(InspurJson <RetAlertPolicies>(get));
}
/// <summary>
/// 通过id删除历史报警列表记录数据
/// </summary>
public ReturnItem <RetHistoryAlertPolicies> DelHistoryAlertPoliciesData(HistoryAlertPoliciesModel parameter)
{
ReturnItem <RetHistoryAlertPolicies> r = new ReturnItem <RetHistoryAlertPolicies>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
A_AlarmHistory delalert = alert.Set <A_AlarmHistory>().Where(a => a.ID == parameter.ID).FirstOrDefault();
if (delalert != null)
{
var entry = alert.Entry(delalert);
//设置该对象的状态为删除
entry.State = EntityState.Deleted;
alert.SaveChanges();
//保存修改
r.Msg = "信息删除成功";
r.Code = 0;
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
public ActionResult Edit(int Id)
{
ReturnItem objRetItem = new ReturnItem();
ReturnDetailsService objRetService = new ReturnDetailsService();
objRetItem = objRetService.GetById(Id);
#region Bind DropDown Comp
List <CompanyItem> lstComp = new List <CompanyItem>();
lstComp = objRetService.GetAllComp();
objRetItem.ListComp = new List <CompanyItem>();
objRetItem.ListComp.AddRange(lstComp);
#endregion
#region Bind DropDown Emp
List <EmployeeItem> lstEmp = new List <EmployeeItem>();
lstEmp = objRetService.GetEmp();
objRetItem.ListEmp = new List <EmployeeItem>();
objRetItem.ListEmp.AddRange(lstEmp);
#endregion
List <AssestsItem> lstItem = new List <AssestsItem>();
lstItem = objRetService.GetALLItems();
objRetItem.lstAllItem = new List <AssestsItem>();
objRetItem.lstAllItem.AddRange(lstItem);
List <ReturnItem> lstReturn = new List <ReturnItem>();
lstReturn = objRetService.GetALLReturnDetail();
objRetItem.lstReturnItem = new List <ReturnItem>();
objRetItem.lstReturnItem.AddRange(lstReturn);
return(View(objRetItem));
}
/// <summary>
/// 获取报警策略个数
/// </summary>
/// <returns>成功返回设备列表,失败返回Null.</returns>
public ReturnItem <string> GetAlertPoliciesNum(AlertPoliciesModel parameter)
{
ReturnItem <string> r = new ReturnItem <string>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
var OrgID = Convert.ToInt32(parameter.OrgID);
var get = alert.A_AlarmStrategy.Where(s => s.OrgID == OrgID).ToList();
if (get == null)
{
r.Msg = "报警策略信息获取成功";
r.Code = 0;
r.Data = "0";
return(r);
}
if (get != null)
{
r.Msg = "报警策略信息获取成功";
r.Code = 0;
r.Data = get.Count().ToString();
return(r);
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
/// <summary>
/// 新增历史报警策略
/// </summary>
public ReturnItem <RetHistoryAlertPolicies> AddHistoryAlertPolicies(HistoryAlertPoliciesModel parameter)
{
ReturnItem <RetHistoryAlertPolicies> r = new ReturnItem <RetHistoryAlertPolicies>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
//新增历史报警策略
A_AlarmHistory newalert = new A_AlarmHistory()
{
DeviceID = Convert.ToInt32(parameter.DeviceID),
DeviceItemID = Convert.ToInt32(parameter.DeviceItemID),
StrategyID = Convert.ToInt32(parameter.StrategyID),
Value = parameter.Value,
AlarmTime = parameter.AlarmTime,
EndTime = parameter.EndTime,
OrgID = Convert.ToInt32(parameter.OrgID),
};
alert.A_AlarmHistory.Add(newalert);
alert.SaveChanges();
r.Msg = "报警策略新增成功";
r.Code = 0;
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
public IHttpActionResult ValidateSecurityCode(VerificationCodeModel model)
{
var r = new ReturnItem <RetVerificationCode>();
if (CustomConfigParam.IsUseRedis)
{
string key = "VerificationCode:" + model.VerificationCode;
string realCode = new RedisClient(CustomConfigParam.RedisDbNumber).GetString(key);
if (realCode != null)
{
if (realCode.ToLower() == model.Code.ToLower())
{
r.Code = 1;
}
else
{
r.Code = 0;
}
}
else
{
r.Code = -1;
}
}
return(InspurJson <RetVerificationCode>(r));
}
/// <summary>
/// 删除报警策略信息
/// </summary>
public ReturnItem <RetAlertPolicies> DeleteAlertPolicies(AlertPoliciesModel parameter)
{
ReturnItem <RetAlertPolicies> r = new ReturnItem <RetAlertPolicies>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
var delete = alert.A_AlarmStrategy.Where(s => s.ID == parameter.ID).FirstOrDefault();
if (delete != null)
{
var entry = alert.Entry(delete);
//设置该对象的状态为删除
entry.State = EntityState.Deleted;
alert.SaveChanges();
//保存修改
}
r.Msg = "报警策略信息删除成功";
r.Code = 0;
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
public void Delete(int ReturnItemID)
{
ReturnItem _item = QueryByID(ReturnItemID);
_item.Enabled = false;
_context.SaveChanges();
}
public async Task <IActionResult> Edit(int id, [Bind("ReturnItemID,ReturnDate,DefectInfo,NewItemID,OldItemID,ApplicationUserID")] ReturnItem returnItem)
{
if (id != returnItem.ReturnItemID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(returnItem);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ReturnItemExists(returnItem.ReturnItemID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationUserID"] = new SelectList(_context.ApplicationUser, "Id", "Id", returnItem.ApplicationUserID);
ViewData["NewItemID"] = new SelectList(_context.Item, "ItemID", "ItemID", returnItem.NewItemID);
ViewData["OldItemID"] = new SelectList(_context.Item, "ItemID", "ItemID", returnItem.OldItemID);
return(View(returnItem));
}
public IHttpActionResult SendMessage(PhoneCodeModel model)
{
if (model.Phone == null || model.Phone == "")
{
return(InspurJson <string>(new ReturnItem <string>()
{
Code = 0, Msg = "手机号不正确"
}));
}
//
string regex = @"^0?(13[0-9]|15[012356789]|17[013678]|18[0-9]|14[57])[0-9]{8}$";
Match m = Regex.Match(model.Phone, regex);
if (!m.Success)
{
return(InspurJson <string>(new ReturnItem <string>()
{
Code = 0, Msg = "手机号格式不正确"
}));
}
ShortMessageBLL bll = new ShortMessageBLL();
ReturnItem <string> ret = bll.SendMessage(model.Phone, getClientIp(), (int)SmsType.IdentifyingCode_Reg);
return(InspurJson <string>(new ReturnItem <string>()
{
Code = ret.Code, Msg = ret.Msg
}));
}
public void SetTrueAskSell(ReturnItem returnItem)
{
m_AskSell.SetActive(true);
returnItem.m_AskSell = m_AskSell;
m_AskSellYes.onClick.AddListener(delegate { returnItem.RemoveSell(m_AskSellYes); });
}
//获取最近一次设备信息，外部调用
public ReturnItem <RootObject> getLastestDeviceInfoOuter(command c)
{
ReturnItem <RootObject> r = new ReturnItem <RootObject>();
Dictionary <string, Socket> .KeyCollection keyCol = deviceIdToSocket.Keys;
//遍历获取到key对应的socket
foreach (string key in keyCol)
{
if (key.IndexOf(c.deviceId) > -1)
{
DateTime now = DateTime.Now;
DateTime datatime = lastestDeviceInfoTime[key];
double interval = (now - datatime).TotalSeconds;
if (interval < 20)
{
r.Data = lastestDeviceInfo[key];
r.Code = 0;
r.Msg = "获取最近一次风机设备信息成功";
return(r);
}
else
{
break;
}
}
}
r.Data = null;
r.Code = -1;
r.Msg = "风机的最近一次数据不存在";
return(r);
}
/// <summary>
/// 删除实时监测数据位置信息
/// </summary>
public ReturnItem <RetRealTimeMonitor> DeleteData(RealTimeMonitorModel parameter)
{
ReturnItem <RetRealTimeMonitor> r = new ReturnItem <RetRealTimeMonitor>();
using (UserEntities user = new UserEntities())
{
try
{
var deletechart = user.U_HomeConfiguration.Where(s => s.ID == parameter.ID).FirstOrDefault();
if (deletechart != null)
{
var entry = user.Entry(deletechart);
//设置该对象的状态为删除
entry.State = EntityState.Deleted;
user.SaveChanges();
//保存修改
}
r.Msg = "图表删除成功";
r.Code = 0;
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
/// <summary>
/// This method updates furniture quantity
/// </summary>
/// <param name="returnItem"></param>
/// <returns>boolean if update was posted</returns>
public bool UpdateFurnitureQuantity(ReturnItem returnItem)
{
string updateStatement =
@" Update furnitureItem
SET Quantity = Quantity + @quantity
Where Serial# = @serial#";
using (SqlConnection connection = RentMeDBConnection.GetConnection())
{
connection.Open();
using (SqlCommand cmd = new SqlCommand(updateStatement, connection))
{
cmd.Parameters.AddWithValue("@serial#", returnItem.SerialNumber);
cmd.Parameters.AddWithValue("@quantity", returnItem.Quantity);
var result = cmd.ExecuteNonQuery();
connection.Close();
return(result > 0);
}
}
}
/// <summary>
/// 查询设备图表名称是否存在
/// </summary>
public ReturnItem <RetHomeConfiguration> CheckDeviceInfoByChartName(HomeConfigurationModel parameter)
{
ReturnItem <RetHomeConfiguration> r = new ReturnItem <RetHomeConfiguration>();
using (UserEntities user = new UserEntities())
{
try
{
var OrgID = Convert.ToInt32(parameter.OrgID);
var checkchart = user.U_HomeConfiguration.Where(s => s.ChartName == parameter.ChartName && s.OrgID == OrgID).FirstOrDefault();
if (checkchart == null)
{
r.Data = null;
r.Code = 1;
r.Msg = "未找到设备图表";
return(r);
}
if (checkchart != null)
{
r.Msg = "已存在设备图表";
r.Code = 0;
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
public ActionResult Create([Bind(Include = "id,customerid,itemid,returnDate,ammount,description")] ReturnItem returnItem)
{
if (ModelState.IsValid)
{
db.ReturnItems.Add(returnItem);
db.SaveChanges();
var itm = (from item in db.item where item.id == returnItem.itemid select item).FirstOrDefault();
Global.Money = Global.Money - returnItem.ammount;
Customer customer = db.Customers.Where(cus => cus.id == returnItem.customerid).FirstOrDefault();
customer.ammount = customer.ammount - returnItem.ammount;
db.Entry(customer).State = EntityState.Modified;
db.SaveChanges();
Transaction transaction = new Transaction();
transaction.Ammount = returnItem.ammount;
transaction.Balance = customer.ammount;
transaction.Date = returnItem.returnDate;
transaction.Description = "Returned";
transaction.Customer = customer;
transaction.Customerid = customer.id;
transaction.type = TransactionType.Debit;
db.Transactions.Add(transaction);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.customerid = new SelectList(db.Customers, "id", "name", returnItem.customerid);
ViewBag.itemid = new SelectList(db.item, "id", "name", returnItem.itemid);
return(View(returnItem));
}
/// <summary>
/// 用户获取信息列表
/// </summary>
/// <returns>成功返回用户信息,失败返回Null.</returns>
public ReturnItem <List <RetUserMessageRel> > GetAllMessageToUser(UserMessageRelModel parameter, string GetUserID)
{
ReturnItem <List <RetUserMessageRel> > r = new ReturnItem <List <RetUserMessageRel> >();
List <RetUserMessageRel> listinfo = new List <RetUserMessageRel>();
using (UserEntities user = new UserEntities())
{
try
{
var getuserid = Convert.ToInt32(GetUserID);
var messageList = user.U_Message.Join(user.U_UserMessageRel, x => x.ID, x => x.MessageID, (a, b) => new { a, b }).Where(x => x.b.UserID == getuserid).AsQueryable();
if (parameter.Status != null && !"".Equals(parameter.Status))
{
messageList = messageList.Where(x => x.b.Status == parameter.Status);
}
if (!"".Equals(parameter.Type) && parameter.Type != null)
{
messageList = messageList.Where(x => x.a.Type == parameter.Type.ToString());
}
messageList = messageList.OrderByDescending(x => x.a.CreateTime);
if (messageList == null)
{
r.Data = null;
r.Code = -1;
r.Msg = "没有数据";
return(r);
}
if (messageList != null)
{
var list = messageList.ToList();
r.Count = messageList.Count();
r.Msg = "消息列表获取成功";
r.Code = 0;
foreach (var item in list)
{
var info = new RetUserMessageRel();
info.ID = item.a.ID;
info.Type = item.a.Type;
info.Tittle = item.a.Tittle;
info.Text = item.a.Text;
info.CreateTime = item.a.CreateTime;
info.CreateUserID = item.a.CreateUserID;
info.Status = item.b.Status;
listinfo.Add(info);
}
r.Data = listinfo;
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
return(r);
}
}
return(r);
}
public int InsertReturnDetails(ReturnItem model)
{
Mapper.CreateMap <ReturnItem, ReturnDetail>();
ReturnDetail objReturnItem = Mapper.Map <ReturnDetail>(model);
DbContext.ReturnDetails.Add(objReturnItem);
return(DbContext.SaveChanges());
}
public static ReturnValue ToReturnValue(this ReturnItem returnItem)
{
return(returnItem == ReturnItem.New
? ReturnValue.ALL_NEW
: returnItem == ReturnItem.Old
? ReturnValue.ALL_OLD
: ReturnValue.NONE);
}
public ActionResult DeleteConfirmed(int id)
{
ReturnItem returnItem = db.ReturnItems.Find(id);
db.ReturnItems.Remove(returnItem);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IHttpActionResult UpdatePhoneCode(PhoneCodeModel model)
{
var r = new ReturnItem <string>();
PhoneCodeBLL bll = new PhoneCodeBLL();
bll.UpdatePhoneCode(model.Phone);
return(InspurJson <string>(r));
}
/// <summary>
/// 更新报警策略信息
/// </summary>
public ReturnItem <RetAlertPolicies> UpdateAlertPolicies(AlertPoliciesModel parameter)
{
ReturnItem <RetAlertPolicies> r = new ReturnItem <RetAlertPolicies>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
var alertInfo = alert.A_AlarmStrategy.Where(s => s.ID == parameter.ID).FirstOrDefault();
if (alertInfo == null)
{
r.Data = null;
r.Code = -1;
r.Msg = "未找到该设备";
return(r);
}
if (alertInfo != null)
{
string TagMap = "";
if (parameter.TagList.Count > 0)
{
TagMap = JsonConvert.SerializeObject(parameter.TagList);
}
alertInfo.StrategyName = parameter.StrategyName;
alertInfo.DeviceID = Convert.ToInt32(parameter.DeviceID);
alertInfo.DataConnectID = Convert.ToInt32(parameter.DataConnectID);
alertInfo.TagMap = TagMap;
alertInfo.DeviceItemId = Convert.ToInt32(parameter.DeviceItemId);
alertInfo.Compare = parameter.Compare;
alertInfo.Threshold = parameter.Threshold;
alertInfo.Remark = parameter.Remark;
alertInfo.UpdateTime = DateTime.Now;
alertInfo.UpdateUserId = parameter.UpdateUserId;
alertInfo.Interval = Convert.ToInt32(parameter.Interval);
if (parameter.Active == "1")
{
alertInfo.Active = true;
}
else if (parameter.Active == "0")
{
alertInfo.Active = false;
}
alertInfo.OrgID = Convert.ToInt32(parameter.OrgID);
alert.SaveChanges();
r.Msg = "报警策略更新成功";
r.Code = 0;
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
/// <summary>
/// 管理员获取信息列表
/// </summary>
/// <returns>成功返回用户信息,失败返回Null.</returns>
public ReturnItem <List <RetMessageInfo> > GetAllMessageInfo(MessageInfoModel parameter)
{
ReturnItem <List <RetMessageInfo> > r = new ReturnItem <List <RetMessageInfo> >();
List <RetMessageInfo> listinfo = new List <RetMessageInfo>();
using (UserEntities user = new UserEntities())
{
try
{
IQueryable <U_Message> messageList = user.U_Message.AsQueryable <U_Message>();
if (parameter.Tittle != null && !"".Equals(parameter.Tittle))
{
messageList = messageList.Where(x => x.Tittle.IndexOf(parameter.Tittle) >= 0);
}
if (!"".Equals(parameter.Type) && parameter.Type != null)
{
messageList = messageList.Where(x => x.Type == parameter.Type.ToString());
}
messageList = messageList.OrderByDescending(x => x.CreateTime);
if (messageList == null)
{
r.Data = null;
r.Code = -1;
r.Msg = "没有数据";
return(r);
}
if (messageList != null)
{
List <U_Message> list = messageList.ToList <U_Message>();
r.Count = messageList.Count();
r.Msg = "消息列表获取成功";
r.Code = 0;
foreach (var item in list)
{
var info = new RetMessageInfo();
info.ID = item.ID.ToString();
info.Type = item.Type;
info.Tittle = item.Tittle;
info.Text = item.Text;
info.CreateTime = item.CreateTime;
info.CreateUserID = item.CreateUserID;
listinfo.Add(info);
}
r.Data = listinfo;
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
return(r);
}
}
return(r);
}
public ActionResult Edit(ReturnItem Model)
{
ReturnItem objRetItem = new ReturnItem();
ReturnDetailsService objRetService = new ReturnDetailsService();
int i = objRetService.Update(Model);
return(RedirectToAction("Create"));
}
/// <summary>
/// 新增报警信息(内部调用)
/// </summary>
public ReturnItem <string> AddAlarmMessageInside(GetMessageInfoParameter parameter)
{
ReturnItem <string> r = new ReturnItem <string>();
using (UserEntities user = new UserEntities())
{
try
{
//新增报警信息
U_Message message = new U_Message()
{
Type = parameter.Type,
Tittle = parameter.Tittle,
Text = parameter.Text,
CreateTime = DateTime.Now
};
user.U_Message.Add(message);
user.SaveChanges();
//查询当前组织下用户id
int OrgID = Convert.ToInt32(parameter.OrgID);
var getuserinfo = user.U_UserOrganizationRel.Where(m => m.OrgID == OrgID).ToList();
List <string> userinfo = new List <string>();
foreach (var info in getuserinfo)
{
userinfo.Add(info.UserID.ToString());
}
//新增用户消息关联表
var getinfo = user.U_Message.OrderByDescending(m => m.CreateTime).FirstOrDefault();
foreach (var item in userinfo)
{
U_UserMessageRel newrel = new U_UserMessageRel()
{
UserID = Convert.ToInt32(item),
MessageID = getinfo.ID,
Status = "0",
CreateTime = DateTime.Now
};
user.U_UserMessageRel.Add(newrel);
}
user.SaveChanges();
r.Msg = "消息新增成功";
r.Code = 0;
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
r.Code = -1;
r.Data = e.Message;
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
}
}
return(r);
}
/// <summary>
/// This method creates a return item
/// </summary>
/// <param name="returnItem">A ReturnItem</param>
/// <returns>true or false</returns>
public bool CreateReturnItem(ReturnItem returnItem)
{
string insertStatement =
@"INSERT INTO dbo.Returns
(Serial#
, RentalID
, ReturnID
, Quantity
, FineDue
, RefundDue)
SELECT
@serial#
,@rentalID
,@returnID
,@quantity
,@fineDue
,@refundDue
WHERE @quantity <= (SELECT
i.Quantity - coalesce(
(
SELECT SUM(Quantity) From Returns WHERE Serial# = i.Serial# AND RentalID = i.RentalID
),0) AS Quantity
From RentedItem i Where i.RentalID = @rentalID AND (i.Quantity - coalesce(
(
SELECT SUM(Quantity) From Returns WHERE Serial# = i.Serial# AND RentalID = i.RentalID
),0) > 0) AND Serial# = @serial#);";
using (SqlConnection connection = RentMeDBConnection.GetConnection())
{
connection.Open();
using (SqlCommand cmd = new SqlCommand(insertStatement, connection))
{
cmd.Parameters.AddWithValue("@serial#", returnItem.SerialNumber);
cmd.Parameters.AddWithValue("@rentalID", returnItem.RentalID);
cmd.Parameters.AddWithValue("@returnID", returnItem.ReturnID);
cmd.Parameters.AddWithValue("@quantity", returnItem.Quantity);
cmd.Parameters.AddWithValue("@fineDue", returnItem.FineDue);
cmd.Parameters.AddWithValue("@refundDue", returnItem.RefundDue);
var result = cmd.ExecuteNonQuery();
connection.Close();
if (result > 0)
{
UpdateFurnitureQuantity(returnItem);
}
return(result > 0);
}
}
}
public MethodItem(AMemberItem parent, XElement item)
: base(parent, GetMethodName(item, parent), item)
{
TypeDefinition parentType = (parent as TypeItem).Type;
string methodName = item.GetFullName().Substring(parent.Element.GetFullName().Length + 1).Replace('#', '.').Replace('@', '&');
Method = GetMethodDefinition(item, parent, parentType.Methods);
Return = new ReturnItem(this, item.GetReturns() ?? new XElement("returns"));
Parameters = item.GetParameters().Select(e => new ParameterItem(this, e)).ToArray();
}
