public async Task <ActionResult <ServiceResult> > UpdateAsync(EquipmentRequestModel requestModel)
{
#region Input Validation
EquipmentModel equipment = (await _equipmentService.GetAsync(e => e.Id == requestModel.Id)).FirstOrDefault();
if (equipment is null)
{
return(new ServiceResult
{
StatusCode = HttpStatusCode.BadRequest,
Message = $"Equipment not found"
});
}
bool equipmentWithNameExists = await _equipmentService.AnyAsync(c => c.Id != requestModel.Id && c.Name == requestModel.Name);
if (equipmentWithNameExists)
{
return(new ServiceResult
{
StatusCode = HttpStatusCode.BadRequest,
Message = $"Equipment with name {requestModel.Name} already exists"
});
}
#endregion
equipment = _mapper.Map <EquipmentModel>(requestModel);
_equipmentService.Update(equipment);
await _equipmentService.SaveChangesAsync();
return(new ServiceResult
{
StatusCode = HttpStatusCode.OK,
Message = "Success",
Data = equipment
});
}
private OpResult EditEquipmentRecord(EquipmentModel model)
{
SetEquipmentMaintenanceRule(model);
SetEquipmentCheckRule(model);
return(irep.Update(u => u.Id_Key == model.Id_Key, model).ToOpResult_Eidt("设备档案"));
}
public override WebSocketBehavior CreateService(EquipmentModel equipment)
{
// 获取设备信息
CardService service = new CardService();
return(service);
}
public ActionResult Index(EquipmentModel model)
{
equipment.userID = Convert.ToInt32(Session["UserId"]);
equipment.ProblemType = model.ProblemType;
equipment.Problem = model.Problem;
equipment.Solution = model.Solution;
equipment.StatusTime = model.StatusTime;
equipment.CompletedTime = model.CompletedTime;
equipment.EquipNumber = model.EquipNumber;
equipment.Replacement = model.Replacement;
equipment.Details = model.Details;
equipment.problemID = model.problemID;
equipment.Corrected = model.Corrected;
actionResult = equipmentAction.EquipmentProblems_AddEdit(equipment);
if (actionResult.IsSuccess)
{
TempData["SuccessMessage"] = "Successfully Saved !!";
}
else
{
TempData["ErrorMessage"] = "Error in Request !!";
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult <EquipmentModel> > Post(int employeeId, EquipmentModel model)
{
try
{
//Make sure EquipmentId is not already taken
var existing = await _repository.GetEquipmentAsync(employeeId, model.Id);
if (existing != null)
{
return(BadRequest("Equipment Id in Use"));
}
//map
var Equipment = _mapper.Map <Equipment>(model);
//save and return
if (!await _repository.StoreNewEquipmentAsync(employeeId, Equipment))
{
return(BadRequest("Bad request, could not create record!"));
}
else
{
var location = _linkGenerator.GetPathByAction("Get",
"Equipment",
new { employeeId = Equipment.EmployeeId, Equipment.Id });
return(Created(location, _mapper.Map <EquipmentModel>(Equipment)));
}
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
}
public void AddEquipment(EquipmentModel equipmentModel)
{
var equipment = factoryContext.Equipment.Where(eq => eq.Title == equipmentModel.Title).ToList();
if (equipment.Count == 0)
{
factoryContext.Equipment.Add(new Equipment()
{
Title = equipmentModel.Title
});
factoryContext.RoomEquipment.Add(new RoomEquipment()
{
RoomId = (int)equipmentModel.RoomId,
EquipmentId = equipmentModel.Id,
EquipmentNumber = equipmentModel.Number
});
}
else
{
var equipmentForRoom = factoryContext.RoomEquipment.Find(equipmentModel.RoomId, equipment[0].Id);
equipmentForRoom.EquipmentNumber += equipmentModel.Number;
factoryContext.Entry(equipmentForRoom).State = EntityState.Modified;
}
factoryContext.SaveChanges();
}
public ActionResult Create(EquipmentModel equipmentModel, HttpPostedFileBase ImageEquip)
{
var equipment = new Equipment();
equipment.Name = equipmentModel.Name;
equipment.SerialNumber = equipmentModel.SerialNumber;
equipment.NextControlDate = DateConverter.StringToDateTime(equipmentModel.NextControlDate);
if (ImageEquip != null && ImageEquip.ContentLength > 0)
{
equipment.Image = new byte[ImageEquip.ContentLength]; // ImageEquip to store image in binary formate
ImageEquip.InputStream.Read(equipment.Image, 0, ImageEquip.ContentLength);
}
try
{
if (ModelState.IsValid)
{
var inserted = equipmentService.Insert(equipment);
return(RedirectToAction("Index"));
}
}
catch (DataException /* dex */)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return(View(equipmentModel));
}
public EquipmentModel GetEquipment(string equipmentId)
{
var equipment = new EquipmentModel();
equipment.EquipmentId = equipmentId;
var dtEquipment = new DalEquipment().GetEquipment(equipmentId);
if (dtEquipment.Rows.Count == 0)
{
return(equipment);
}
equipment.EquipmentName = dtEquipment.Rows[0]["EquipmentName"].ToString();
if (dtEquipment.Rows[0]["DTUID"] == null || string.IsNullOrEmpty(dtEquipment.Rows[0]["DTUID"].ToString()))
{
return(equipment);
}
equipment.Items = new List <ItemModel>();
for (var i = 2; i < dtEquipment.Columns.Count; i++)
{
equipment.Items.Add(new ItemModel {
Name = dtEquipment.Columns[i].ColumnName, Value = dtEquipment.Rows[0][i].ToString()
});
}
return(equipment);
}
public Response <Equipment> Update([FromBody] EquipmentModel equipment)
{
var model = _mapper.Map <Equipment>(equipment);
var response = _equipmentService.Update(model);
return(response);
}
public async Task <ActionResult> DeleteEquipment(int id, EquipmentModel equipmentModel)
{
try
{
if (!ModelState.IsValid)
{
return(View(equipmentModel));
}
var email = User?.Claims.First(c => c.Type == Email).Value;
HttpResponseMessage response = await _httpClient.DeleteAsync(_url + "/DeleteEquipment/" + id);
if (!response.IsSuccessStatusCode)
{
return(View("Error", new ErrorViewModel()));
}
var x = await response.Content.ReadAsAsync <IEnumerable <ActionResult> >();
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
/// <summary>
/// Получаем с БД оборудование и доп.опции и возвращаем готовую модель
/// </summary>
private EquipmentModel EquipmentModelLoad(SQLiteDataReader reader)
{
if (!reader.HasRows)
{
return(null);
}
EquipmentModel equipment = new EquipmentModel
{
Engine = new EngineModel()
{
ID = Convert.ToInt64(reader["carEnID"]),
Name = reader["carEnName"].ToString(),
Power = Convert.ToDouble(reader["Power"]),
Expenditure = Convert.ToDouble(reader["Expenditure"])
},
Extras = new ExtrasModel()
{
ID = Convert.ToInt64(reader["carExID"]),
AndroidSystem = Convert.ToBoolean(reader["AndroidSystem"]),
CastWheel = Convert.ToBoolean(reader["CastWheel"]),
CruiseControl = Convert.ToBoolean(reader["CruiseControl"])
}
};
return(equipment);
}
public async Task <ActionResult> EditEquipment(EquipmentModel equipmentModel)
{
try
{
if (!ModelState.IsValid)
{
return(View(equipmentModel));
}
var email = User?.Claims.First(c => c.Type == Email).Value;
HttpResponseMessage response = await _httpClient.GetAsync(_url + "/account/" + email);
if (!response.IsSuccessStatusCode)
{
return(View("Error", new ErrorViewModel()));
}
PlayerModel player = await response.Content.ReadAsAsync <PlayerModel>();
response = await _httpClient.PostAsJsonAsync(_url + "/Equipment/" + player.PlayerId, equipmentModel);
if (!response.IsSuccessStatusCode)
{
return(View("Error", new ErrorViewModel()));
}
var x = await response.Content.ReadAsAsync <IEnumerable <ActionResult> >();
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
/// <summary>
/// 电子称
/// </summary>
/// <returns></returns>
private EquipmentModel GetElectronicScaleEquipmentModel()
{
EquipmentAgreementModel am = new EquipmentAgreementModel
{
AgreementType = "electronicScale",
ConnectionEntry = "ElectronicScaleService",
WebSocketIp = "ws://127.0.0.1",
WebSocketPort = "8099",
Bps = 9600,
EndPosition = 1,
DataBit = 8,
CheckPoint = "无",
Com = "COM1"
};
EquipmentModel em = new EquipmentModel
{
Name = "电子秤",
Manufacturer = "moxa",
Model = "201-31240-9",
EquipmentAgreement = am
};
return(em);
}
/// <summary>
/// 游标卡尺
/// </summary>
/// <returns></returns>
private EquipmentModel GetVernierEquipmentModel()
{
EquipmentAgreementModel am = new EquipmentAgreementModel
{
AgreementType = "vernier",
ConnectionEntry = "VernierCaliperService",
WebSocketIp = "ws://127.0.0.1",
WebSocketPort = "8089",
Bps = 9600,
EndPosition = 1,
DataBit = 8,
CheckPoint = "无",
Com = "COM4"
};
EquipmentModel em = new EquipmentModel
{
Name = "游标卡尺",
Manufacturer = "广陆制造",
Model = "201-31240-9",
EquipmentAgreement = am
};
return(em);
}
/// <summary>
/// 温湿度传感器
/// </summary>
/// <returns></returns>
private EquipmentModel GetSensorEquipmentModel()
{
EquipmentAgreementModel am = new EquipmentAgreementModel
{
AgreementType = "sensor",
ConnectionEntry = "SensorService",
SendMessage = "ReadData1",
WebSocketIp = "ws://127.0.0.1",
WebSocketPort = "8087",
EquipmentIp = "192.168.1.56",
EquipmentPort = "10006"
};
EquipmentModel em = new EquipmentModel
{
Name = "温湿度传感器",
Manufacturer = "山东瀛海",
Model = "20-1240-9",
ClientIp = "192.168.1.56",
ClientPort = 10006,
EquipmentAgreement = am
};
return(em);
}
public string Update(EquipmentModel input)
{
var nullableParentId = "null";
if (input.ParentId != null)
{
nullableParentId = Convert.ToInt32(input.ParentId).ToString();
}
var nullableIsMark = "null";
if (input.IsMark != null)
{
nullableIsMark = Convert.ToInt32(input.IsMark).ToString();
}
return($@"
update {Table} set
EquipmentId = '{input.EquipmentId}',
ModelId = '{input.ModelId}',
ParentId = {nullableParentId} ,
IsMark = {nullableIsMark}
where id = {input.Id}
");
//return $@"
// update {Table} set
// ChangeDate = '{input.ChangeDate}', ChangeUserId = '{input.ChangeUserId}', CheckListType = {input.CheckListType},
// Droped = {input.Droped} , End = {input.End} , PlanedInspectionRouteId = {input.PlanedInspectionRouteId}, Start = {input.Start}
// where id = {input.Id}
// ";
}
public ActionResult Withdraw(EquipmentModel equipment)
{
using (db)
{
var equipments = db.Equipments.Where(equip => equip.EquipmentId == equipment.EquipmentId).SingleOrDefault();
var equipmentcategory = db.EquipmentCategories.Where(equip => equip.EquipmentCategoryId == equipment.EquipmentCategoryId).SingleOrDefault();
if (equipmentcategory.EquipmentCategoryIsReusable)
{
equipments.PatientId = null;
equipments.EquipmentInUseCount = 0;
db.SaveChanges();
TempData["msg"] = "<script>alert('Withdraw Successfull');</script>";
}
else if (equipment.quantity >= 0 && equipments.EquipmentTotalQuantity >= equipment.quantity)
{
equipments.EquipmentTotalQuantity = equipments.EquipmentTotalQuantity - equipment.quantity;
db.SaveChanges();
TempData["msg"] = "<script>alert('Withdraw Successfull');</script>";
}
else
{
TempData["msg"] = "<script>alert('Withdraw Unsuccessfull. Not Enough Quantity');</script>";
}
}
return(RedirectToAction("Index", "EquipmentCheckout"));
}
/// <summary>
/// Creates new record in RoomEquipment table.
/// If the room name is not found, the exception will be thrown.
/// If the equipment name is not found, it will be added.
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
private async Task AddEquipmentItem(EquipmentModel item)
{
//find room by name
var room = await context.Rooms
.Include(e => e.Building)
.FirstOrDefaultAsync(x => $"{x.Floor}.{x.Building.Number}/{x.Number}".Equals(item.RoomName))
?? throw new NotFoundException(typeof(Room), item.RoomName);
// find equipment by name
var equipment = await context.Equipment.FirstOrDefaultAsync(x => x.Name == item.EquipmentName);
// If the equipment does not exist, create a new one.
if (equipment == null)
{
equipment = mapper.Map <Equipment>(item);
context.Equipment.Add(equipment);
}
var roomEquipment = new RoomEquipment()
{
Amount = item.Amount,
Equipment = equipment,
Room = room,
IsAvailable = true,
};
context.RoomEquipment.Add(roomEquipment);
}
public ActionResult Edit(EquipmentModel equipmentModel, HttpPostedFileBase ImageEquip)
{
if (ModelState.IsValid)
{
var oldEquipment = equipmentService.GetById(equipmentModel.Id);
var equipment = new Equipment();
equipment.Name = equipmentModel.Name;
equipment.SerialNumber = equipmentModel.SerialNumber;
equipment.NextControlDate = DateConverter.StringToDateTime(equipmentModel.NextControlDate);
if (ImageEquip != null && ImageEquip.ContentLength > 0)
{
equipment.Image = new byte[ImageEquip.ContentLength]; // ImageEquip to store image in binary formate
ImageEquip.InputStream.Read(equipment.Image, 0, ImageEquip.ContentLength);
}
/* Other Method : Insert image into folder and insert image path into database and display image in
* view from image folder based on path given(stored) in database. */
//if (ImageEquip == null)
//{
// string ImageName = System.IO.Path.GetFileName(ImageEquip.FileName); //file2 to store path and url
// string physicalPath = Server.MapPath("~/img/" + ImageName);
// // save image in folder
// ImageEquip.SaveAs(physicalPath);
// equip.PathPhoto = "img/" + ImageName;
//}
var updated = equipmentService.Update(oldEquipment, equipment);
return(RedirectToAction("Index"));
}
return(View(equipmentModel));
}
/// <summary>
/// 修改数据仓库 model.OpSign = add/edit/delete
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public OpResult Store(EquipmentModel model)
{
OpResult result = OpResult.SetSuccessResult("财产编号不能为空！", false);
if (model == null || model.AssetNumber.IsNullOrEmpty())
{
return(result);
}
try
{
switch (model.OpSign)
{
case OpMode.Add: //新增
result = AddEquipmentRecord(model);
break;
case OpMode.Edit: //修改
result = EditEquipmentRecord(model);
break;
case OpMode.Delete: //删除
result = DeleteEquipmentRecord(model);
break;
default:
result = OpResult.SetErrorResult("操作模式溢出");
break;
}
}
catch (Exception ex) { throw new Exception(ex.InnerException.Message); }
return(result);
}
public static void mountItemForInventory(EquipedModel equiped, string slot_name, string item_data)
{
object equipment;
int inv_idx = String_functions.getFirstNumberFromString(slot_name);
string item_type = item_data.Split(',')[0];
switch (item_type)
{
case "Weapon":
equipment = new WeaponModel(item_data);
break;
case "Food":
equipment = new FoodModel(item_data);
break;
case "Potions":
equipment = new PotionModel(item_data);
break;
case "Runes":
equipment = new ItemModel(item_data);
break;
default:
equipment = new EquipmentModel(item_type, item_data);
break;
}
equiped.InventoryItem[inv_idx] = equipment;
}
private OpResult AddEquipmentRecord(EquipmentModel model)
{
DateTime defaultDate = DateTime.Now.ToDate();
//基础设置
model.DeliveryDate = defaultDate;
model.InputDate = defaultDate;
model.OpDate = defaultDate;
model.OpTime = DateTime.Now;
model.PlannedCheckDate = defaultDate;
model.PlannedMaintenanceDate = defaultDate;
SetEquipmentMaintenanceRule(model);
SetEquipmentCheckRule(model);
//设备状态初始化
if (model.State == null)
{
model.State = "运行正常";
}
if (model.IsScrapped == null)
{
model.IsScrapped = "否";
}
//仓储操作
return(irep.Insert(model).ToOpResult_Add("设备档案", model.Id_Key));
}
private void PickBestEquipment(CharacterBuild build, SlotID equipType, Action <CharacterBuild, EquipmentModel> setEquipment)
{
DamageList highest = null;
EquipmentModel highestEquipment = default;
var usedTypes = build.GetDamageTypes();
var relevantGear = new List <EquipmentModel>();
foreach (var type in usedTypes)
{
relevantGear.AddRange(Database.GetDamageBonusEquipment(equipType, type));
}
foreach (var option in relevantGear)
{
var clone = build.Clone();
setEquipment.Invoke(clone, option);
var newDmg = clone.GetWeaponDamage(Enemy, NaturalHexes, ConsiderWeaponHex);
if (highest == null || newDmg.TotalDamage > highest.TotalDamage)
{
highestEquipment = option;
highest = newDmg;
}
}
setEquipment.Invoke(build, highestEquipment);
}
public IHttpActionResult CreateEquipmentFormData([FromBody] EquipmentModel.Format_Create Equipment)
{
int companyId = Global.GetCompanyIdFromToken();
string logForm = "Form : " + JsonConvert.SerializeObject(Equipment);
string logAPI = "[Post] " + Request.RequestUri.ToString();
if (!ModelState.IsValid || Equipment == null)
{
Global._appLogger.Warn(logAPI + " || Input Parameter not expected || " + logForm);
return(Content(HttpStatusCode.BadRequest, HttpResponseFormat.InvaildData()));
}
EquipmentModel EquipmentModel = new EquipmentModel();
try
{
int id = EquipmentModel.Create(companyId, Equipment);
return(Content(HttpStatusCode.OK, HttpResponseFormat.Success(id)));
}
catch (CDSException cdsEx)
{
return(Content(HttpStatusCode.BadRequest, CDSException.GetCDSErrorMessageByCode(cdsEx.ErrorId)));
}
catch (Exception ex)
{
StringBuilder logMessage = LogHelper.BuildExceptionMessage(ex);
logMessage.AppendLine(logForm);
Global._appLogger.Error(logAPI + logMessage);
return(Content(HttpStatusCode.InternalServerError, ex));
}
}
public async Task <EquipmentUI> AddOrUpdateEquipment(EquipmentUI ces)
{
using (var conn = new SqlConnection(AppSettings.ConnectionString))
{
if (ces.Id == 0)
{
//insert new EquipmentModel, get Id
var em = new EquipmentModel
{
ModelId = ces.ModelId,
EquipmentId = ces.Equipment.Id,
ParentId = ces.ParentId,
IsMark = ces.IsMark
};
var mr = new ModelRepository(_logger);
em = await mr.AddEquipmentToModel(em);
ces.Id = em.Id;
}
else
{
var mr = new ModelRepository(_logger);
await mr.UpdateEquipment(new EquipmentModel
{
EquipmentId = ces.Equipment.Id,
Id = ces.Id,
IsMark = ces.IsMark
});
}
var shit = await GetEquipmentModelById(ces.Id);
return(shit);
}
}
public ActionResult CreateEdit(int id = 0)
{
EquipmentModel model = new EquipmentModel();
if (id > 0)
{
model = (new EquipmentDB()).GetEquipmentbyId(id);
ViewBag.Action = "Edit";
}
else
{
ViewBag.Action = "Create";
}
ViewBag.AllEquipments = (from p in oDB.tblEquipments
where p.COntractor_id == SessionManager.ContractorId
select new EquipmentModel
{
id = p.id,
Equipment_name = p.Equipment_name
}).ToList();
return(View(model));
}
public IActionResult Buy(string id)
{
EquipmentModel equipmentModel = new EquipmentModel();
if (SessionHelper.GetObjectFromJson <List <Item> >(HttpContext.Session, "cart") == null)
{
List <Item> cart = new List <Item>();
cart.Add(new Item {
Equipment = equipmentModel.find(id), Quantity = 1
});
SessionHelper.SetObjectAsJson(HttpContext.Session, "cart", cart);
}
else
{
List <Item> cart = SessionHelper.GetObjectFromJson <List <Item> >(HttpContext.Session, "cart");
int index = isExist(id);
if (index != -1)
{
cart[index].Quantity++;
}
else
{
cart.Add(new Item {
Equipment = equipmentModel.find(id), Quantity = 1
});
}
SessionHelper.SetObjectAsJson(HttpContext.Session, "cart", cart);
}
return(RedirectToAction("Index"));
}
public ActionResult IndustrialEquipmentEdit(string SecurityId)
{
var model = new EquipmentModel();
SelectList brandList = new SelectList(_clsAsset.GetBrand(false), "value", "label");
ViewBag.EquipmentBrand = brandList;
SelectList modelList = new SelectList(new List <CommonDropDown>(), "value", "label");
SelectList year = new SelectList(new List <SelectListItem>(), "Value", "Text");
ViewBag.Years = year;
SelectList lstType = new SelectList(_clsGlobal.GetListOfValue("SECURITY_ITEM_STATUS", "", "O", "", ""), "Value", "Text");
ViewBag.StatusList = lstType;
if (!string.IsNullOrEmpty(SecurityId))
{
model = _clsSecurity.GetEquipmentDetails(SecurityId, false);
modelList = new SelectList(_clsAsset.GetModelByBrand(model.Brand, false), "value", "label");
}
ViewBag.EquipmentModel = modelList;
ViewBag.Check = "I";
ViewBag.Viewable = false;
return(View("Equipmentview", model));
}
public void CreateItem(object e)
{
var newItem = new EquipmentModel();
newItem.InventoryId = Id;
newItem.Class = Class;
bool result = decimal.TryParse(Price, out decimal price);
newItem.Price = price;
var itemStatus = new EquipmentStatusModel
{
Id = 2
};
newItem.Status = itemStatus;
newItem.Brand = Brand;
newItem.PurchaseDate = PurchaseDate;
newItem.SerialNumber = SerialNumber;
newItem.Description = Description;
newItem.Documents = SelectedFiles;
result = int.TryParse(WarrantyMonths, out int warrantyMonths);
newItem.WarrantyMonths = warrantyMonths;
SaveItemDocument();
SendData.CreateItem(newItem);
Id = string.Empty;
Description = string.Empty;
Class = null;
Brand = string.Empty;
Model = string.Empty;
SerialNumber = string.Empty;
WarrantyMonths = string.Empty;
Price = string.Empty;
PO = string.Empty;
SelectedFiles.Clear();
}
public void Get_Update_Success()
{
// arrange
var date = new DateTime(2017, 1, 18);
var equipment = new Equipment()
{
Id = 1,
Name = "Test Equipment",
IsActive = true,
CreatedDate = date,
};
var equipmentModel = new EquipmentModel()
{
Id = 1,
Name = "Test Equipment"
};
var response = new Response <Equipment>()
{
IsSucceed = true,
ErrorMessage = null,
Result = equipment
};
_equipmentService.Setup(x => x.Update(It.IsAny <Equipment>())).Returns(response);
// act
var result = _equipmentsController.Update(equipmentModel);
// assert
Assert.AreEqual(response, result);
}
public static string NewSerialNumber(EquipmentModel model, string portNumber)
{
string serialNum = DateTime.Now.ToString("ddyyhhmmssff");
string port = string.Empty;
if (model.TypeDescription.Contains("GI Digital"))
{
return serialNum;
}
else if (model.ModelDescription.Contains("Data"))
{
port = string.Format("D{0}", portNumber);
}
else if (model.ModelDescription.Contains("Phone"))
{
port = string.Format("P{0}", portNumber);
}
else if (model.ModelDescription.Contains("MoCA"))
{
port = string.Format("M{0}", portNumber);
}
else if (model.ModelDescription.Contains("Video"))
{
port = string.Format("V{0}", portNumber);
}
serialNum = string.Format("{0}{1}", serialNum, port);
return serialNum;
}
public static Equipment NewEquipment(string devID, EquipmentModel equipModel, string unitAddr, string status)
{
Equipment equip = new Equipment();
equip.SerialNumber = devID;
equip.EquipmentModel = equipModel;
equip.UnitAddress = unitAddr;
equip.Status = status;
return equip;
}
){kind=link}