public ActionResult Edit(DeviceTypeModel model)
{
try
{
// TODO: Add update logic here
DeviceTypeDto deviceTypedto = new DeviceTypeDto();
//Mapper.AssertConfigurationIsValid();
Mapper.CreateMap <DeviceTypeDto, DeviceTypeModel>();
deviceTypedto = Mapper.Map <DeviceTypeModel, DeviceTypeDto>(model);
var result = _deviceTypeAction.UpdateDeviceType(deviceTypedto);
if (result > 0)
{
return(RedirectToAction("Index"));
}
else
{
return(View(model));
}
}
catch
{
return(View());
}
}
public ActionResult Edit(DeviceTypeDto model)
{
ResultHelper result = JsonConvert.DeserializeObject <ResultHelper>(deviceTypeService.SetDeviceType(model));
ViewBag.Message = Helper.GetResultMessage(result.Result, result.ResultDescription);
return(View());
}
public int DeleteDeviceType(DeviceTypeDto model)
{
DeviceType tblDevice = Mapper.Map <DeviceTypeDto, DeviceType>(model);
_deviceTypeRepository.DeleteDeviceType(tblDevice, _dbContext);
return(_dbContext.SaveChanges());
}
public ActionResult <DeviceTypeDto> CreateDeviceType(DeviceTypeDto deviceTypeDto)
{
var deviceTypeModel = _mapper.Map <DeviceType>(deviceTypeDto);
_repository.AddDeviceType(deviceTypeModel);
var newDeviceTypeDto = _mapper.Map <DeviceTypeDto>(deviceTypeModel);
return(CreatedAtRoute(nameof(GetDeviceTypeByName), new { name = newDeviceTypeDto.name },
newDeviceTypeDto));
}
public int UpdateDeviceType(DeviceTypeDto model)
{
DeviceType tblDeviceType = Mapper.Map <DeviceTypeDto, DeviceType>(model);
var existingDeviceTypeData = _deviceTypeRepository.GetAllDeviceType(_dbContext)
.Where(x => x.DeviceTypeId == model.DeviceTypeId)
.FirstOrDefault();
_deviceTypeRepository.UpdateDeviceType(existingDeviceTypeData, tblDeviceType, _dbContext);
return(_dbContext.SaveChanges());
}
public DeviceTypeDto GetDeviceTypeById(int Id)
{
DeviceTypeDto result = new DeviceTypeDto();
var received = _deviceTypeRepository.GetAllDeviceType(_dbContext)
.Where(x => x.DeviceTypeId == Id)
.FirstOrDefault();
Mapper.CreateMap <DeviceType, DeviceTypeDto>();
result = Mapper.Map <DeviceType, DeviceTypeDto>(received);
return(result);
}
public async Task <IEnumerable <DeviceTypeDto> > FetchAllDeviceTypes(DeviceTypeDto deviceTypeDto)
{
try
{
return(await this._transactions.GetAsync <DeviceTypeDto>(Queries.FetchAllDeviceTypes, deviceTypeDto));
}
catch (Exception ex)
{
this._loggingService.Error("An Unhandled Exception has occurred", "DeviceTypeRepository.FetchAllDeviceTypes", ex);
throw;
}
}
public async Task <IHttpActionResult> GetDeviceType(string deviceId)
{
return(await ResultFactory.Create(ModelState, async arg =>
{
var device = await deviceService.GetByIdAsync(deviceId);
DeviceTypeDto deviceType = null;
if (device != null)
{
deviceType = await deviceTypeService.GetByIdWithRedisAsync(device.DeviceTypeSerialnum);
}
return new ApiResult(ExceptionCode.Success, "", deviceType);
}, deviceId, "success", "请检查请求参数"));
}
public ActionResult UpdateDeviceType(string name, DeviceTypeDto deviceTypeDto)
{
var deviceTypeFromRepo = _repository.GetDeviceType(name);
deviceTypeDto.name = deviceTypeFromRepo.name;
if (deviceTypeFromRepo == null)
{
return(NotFound());
}
_mapper.Map(deviceTypeDto, deviceTypeFromRepo);
_repository.UpdateDeviceType(deviceTypeFromRepo);
return(NoContent());
}
public ResultHelper SetDeviceType(DeviceTypeDto deviceTypeDto)
{
try
{
devicetype item = new devicetype();
item.DeviceTypeID = deviceTypeDto.DeviceTypeID;
item.Name = deviceTypeDto.Name;
using (UnitOfWork unitOfWork = new UnitOfWork())
{
unitOfWork.GetRepository <devicetype>().Update(item);
unitOfWork.saveChanges();
return(new ResultHelper(true, item.DeviceTypeID, ResultHelper.SuccessMessage));
}
}
catch (Exception ex)
{
return(new ResultHelper(false, 0, ResultHelper.UnSuccessMessage));
}
}
public DeviceTypeDto GetDeviceType(int deviceTypeID)
{
try
{
using (UnitOfWork unitofWork = new UnitOfWork())
{
devicetype item = new devicetype();
item = unitofWork.GetRepository <devicetype>().GetById(x => x.DeviceTypeID == deviceTypeID);
DeviceTypeDto deviceTypeDto = new DeviceTypeDto();
deviceTypeDto.DeviceTypeID = item.DeviceTypeID;
deviceTypeDto.Name = item.Name;
return(deviceTypeDto);
}
}
catch (Exception ex)
{
return(null);
}
}
/// <summary>
/// Insert or Update DeviceType
/// Return all DeviceTypes
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public IEnumerable <DeviceTypePropertiesNestedDto> CreateOrUpdateDeviceType(DeviceTypeDto input)
{
if (input.Id == 0)
{
var newDeviceType = ObjectMapper.Map <DeviceType>(input);
var lastInsertedDeviceTypeId = _deviceTypeRepository.InsertAndGetId(newDeviceType);
var deviceTypes = GetDeviceTypesWithProperties(lastInsertedDeviceTypeId);
return(deviceTypes);
}
var deviceType = _deviceTypeRepository.Get(input.Id);
ObjectMapper.Map(input, deviceType);
var updatedDeviceTypes = GetDeviceTypesWithProperties(deviceType.Id);
return(updatedDeviceTypes);
}
//Kreiranje Tipa
public IEnumerable <DeviceTypePropertiesDto> CreateUpdateDeviceType(DeviceTypeDto deviceTypeDto)
{
if (deviceTypeDto.Id == 0)
{
Models.DeviceType newType = _objectMapper.Map <Models.DeviceType>(deviceTypeDto);
var id = _repositoryDeviceType.InsertAndGetId(newType);
var deviceTypes = GetDeviceTypesFlatList(id);
return(deviceTypes);
}
var targetDeviceType = _repositoryDeviceType.Get(deviceTypeDto.Id);
_objectMapper.Map(deviceTypeDto, targetDeviceType);
var updatedDeviceTypes = GetDeviceTypesFlatList(targetDeviceType.Id);
return(updatedDeviceTypes);
}
public int UpdateDeviceType(DeviceTypeDto model)
{
return(_deviceTypeAdapter.UpdateDeviceType(model));
}
public int DeleteDeviceType(DeviceTypeDto model)
{
return(_deviceTypeAdapter.DeleteDeviceType(model));
}
public int CreateDeviceType(DeviceTypeDto model)
{
return(_deviceTypeAdapter.CreateDeviceType(model));
}
public string SetDeviceType(DeviceTypeDto deviceTypeDto)
{
return(JsonConvert.SerializeObject(deviceTypeLogic.SetDeviceType(deviceTypeDto)));
}
