public async Task <IActionResult> AddFacility(FacilityDto model)
{
//check if model state is not valid
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//Create facility object
var facility = new Facility
{
Name = model.Name,
RegistrationNo = model.RegistrationNo,
Address = model.Address,
ContactNo = model.ContactNo,
CreatedBy = model.CreatedBy,
Created = DateTime.Now
};
//save facility to database
_db.Facilities.Add(facility);
if (await _db.SaveChangesAsync() > 0)
{
return(Ok()); // save operation successful
}
return(BadRequest("Could not save facility")); // save operation failed
}
public async Task <string> UpdateFacility(string guid, [FromBody] FacilityDto facilityDto)
{
facilityDto.Guid = new Guid(guid);
await _facilityService.UpdateFacility(facilityDto);
return(facilityDto.Name);
}
public static Dictionary <FacilityDto, List <DomainDto> > LoadAllFacilityDomains()
{
Dictionary <FacilityDto, List <DomainDto> > facilityDomains = new Dictionary <FacilityDto, List <DomainDto> >();
using (ScidynContext ctx = new ScidynContext())
{
List <DomainFacility> domainFacilities = ctx.DomainFacilities.Include("Domain").Include("Facility").ToList();
// Convert list of domains and the facilities they belong to into
// a list of facilities and what domains contain them.
foreach (DomainFacility domainFacility in domainFacilities)
{
DomainDto domainDto = domainFacility.Domain.ConvertToDto();
FacilityDto key = facilityDomains.Keys.FirstOrDefault(k => k.SiteId == domainFacility.Facility.SiteId);
if (key == null)
{
facilityDomains.Add(domainFacility.Facility.ConvertToDto(), new List <DomainDto> {
domainDto
});
}
else
{
facilityDomains[key].Add(domainDto);
}
}
}
return(facilityDomains);
}
public void Find()
{
FacilityGateway gateway = new FacilityGateway();
FacilityDto result = gateway.Find(_facilityId);
Assert.IsNotNull(result);
}
public async Task CreateFacility(FacilityDto facilityDto)
{
var facility = _mapper.Map <Facility>(facilityDto);
facility.Guid = Guid.NewGuid();
facility.CreationDate = DateTime.Now;
_facilityRepository.Add(facility);
await _facilityRepository.SaveChangesAsync();
}
public async Task <IHttpActionResult> GetByUser(string userId)
{
return(await ResultFactory.Create(ModelState, async arg =>
{
var companyUser = await companyUserService.GetBySysUserIdAsync(userId);
FacilityDto facility = null;
if (companyUser != null)
{
facility = await facilityService.GetByIdWithRedisAsync(companyUser.FacilitySerialnum);
}
return new ApiResult(ExceptionCode.Success, "", facility);
}, userId, "success", "请检查请求参数"));
}
public IHttpActionResult GetFacilities(int id)
{
var list = Svc.GetFacilities(id);
var source = list.Items.Select(i =>
{
var item = new FacilityDto();
item.LoadFromEntity(i);
return(item);
});
return(Json(new PagedList <FacilityDto>(source, list.PageIndex, list.PageSize, list.TotalCount)));
}
public async Task UpdateFacility(FacilityDto facilityDto)
{
var facility = await _facilityRepository.GetByGuid(facilityDto.Guid.ToString());
if (facility == null)
{
throw new KeyNotFoundException($"Cannot update Facility. Facility with guid {facility.Guid} does not exist");
}
_mapper.Map(facilityDto, facility);
_facilityRepository.Update(facility);
await _facilityRepository.SaveChangesAsync();
}
/// <summary>
/// 处理设施添加数据
/// </summary>
/// <param name="facility">设施添加数据</param>
/// <returns></returns>
public async Task <XResponseMessage> ProcessAsync(FacilityModel facility)
{
if (facility == null)
{
return(null);
}
if (!await _farmService.ExistsAsync(facility.Farm))
{
return(ResultHelper.CreateMessage("基地不存在", ErrorType.FarmNotExists));
}
var facilityType = await _facilityTypeService.GetByIdAsync(facility.FacilityType); //不存在的设施类型无法添加
if (facilityType == null)
{
return(ResultHelper.CreateMessage("设施类型不存在", ErrorType.FacilityTypeNotExists));
}
var item = await _facilityService.GetFacilityByIdAsny(facility.Serialnum);
//数据库中不存在该设施
if (item != null)
{
return(null);
}
item = new FacilityDto
{
Serialnum = facility.Serialnum,
Name = facility.Name,
FarmSerialnum = facility.Farm,
FacilityTypeSerialnum = facility.FacilityType,
CreateTime = DateTime.Now,
UpdateTime = facility.CreateTime ?? DateTime.Now,
Status = 1,
Sort = 0
};
try
{
var result = await _facilityService.AddFacility(item);
LogHelper.Info("[设施]设施{0}{1}添加{2}", item.Name, item.Serialnum, result);
return(ResultHelper.CreateMessage($"添加设施{(result ? "成功" : "失败")}",
result ? ErrorType.NoError : ErrorType.InternalError));
}
catch (AggregateException ex)
{
return(ResultHelper.CreateExceptionMessage(ex, "添加设施失败"));
}
}
public IHttpActionResult AddFacility(int id, [FromBody] NewFacilityDto value)
{
var entity = Svc.GetById(id);
if (entity == null)
{
return(NotFound());
}
var facility = value.ToEntity();
int facilityId = Svc.AddFacility(id, facility);
var createdDto = new FacilityDto();
createdDto.LoadFromEntity(facility);
return(CreatedAtRoute("GetFacilityById", new { id = facilityId }, createdDto));
}
/// <summary>
/// 处理设施添加数据(旧的版本)
/// </summary>
/// <param name="facilityAddData">设施添加数据</param>
/// <returns></returns>
public async Task ProcessAsync(FacilityAddData facilityAddData)
{
if (facilityAddData == null || facilityAddData.Facility == null)
{
return;
}
var facility = facilityAddData.Facility;
if (!_facilityService.CheckCode(facilityAddData.Facility.Serialnum))
{
return;
}
var facilityType = await _facilityTypeService.GetByIdAsync(facility.FacilityType); //不存在的设施类型无法添加
if (facilityType == null)
{
return;
}
var item = await _facilityService.GetFacilityByIdAsny(facility.Serialnum);
//数据库中不存在该设施
if (item == null)
{
if (facility.CreateTime != null)
{
item = new FacilityDto
{
Serialnum = facility.Serialnum,
Name = facility.Name,
FarmSerialnum = facility.Farm,
FacilityTypeSerialnum = facility.FacilityType,
CreateTime = (DateTime)facility.CreateTime,
UpdateTime = (DateTime)facility.CreateTime,
Status = 1,
Sort = 0
}
}
;
await _facilityService.AddFacility(item);
}
}
#endregion
}
/// <summary>
/// 添加摄像机
/// </summary>
/// <param name="item"></param>
/// <param name="facilityDb"></param>
public static async Task AddCamera(FacilityAddData item, FacilityDto facilityDb)
{
var cameras = item.Cameras;
List <FacilityCameraDto> cameraList = null;
if (_redis.Exists("facilityCamera") == 1)
{
cameraList = _redis.Smember <FacilityCameraDto>("facilityCamera", DataType.Protobuf);
}
var camerasDb = cameraList != null ? cameraList : await _facilityCameraService.GetFacilityCamerasByFacilityIdAsny(facilityDb.Serialnum);
if (cameras != null && cameras.Any())
{
cameras.ForEach(async c =>
{
await CollectDataProcessor.AddCamera(c);
});
}
}
/// <summary>
/// 添加设施
/// </summary>
/// <param name="item">
/// <see cref="FacilityAddData" />
/// </param>
/// <returns></returns>
public static async Task <FacilityDto> AddFacility(FacilityAddData item)
{
try
{
var facilityModel = item.Facility;
//_redis.Delete("facility");
FacilityDto facility = null;
if (_redis.Exists("facility") == 1)
{
facility = _redis.Smember <FacilityDto>("facility", DataType.Protobuf).Find(f => f.Serialnum.EqualIgnoreCase(facilityModel.Serialnum));
}
var facilityDb = facility != null ? facility : await _facilityService.GetFacilityByIdAsny(facilityModel.Serialnum);
if (facilityDb == null && _facilityService.CheckCode(facilityModel.Serialnum)) //添加设施
{
facilityDb = new FacilityDto
{
Serialnum = facilityModel.Serialnum,
Name = facilityModel.Name,
FarmSerialnum = facilityModel.Farm,
FacilityTypeSerialnum = facilityModel.FacilityType,
Status = 1,
Sort = 0,
//Address = facilityModel.Address,
//PhotoUrl = facilityModel.PhotoUrl,
//ContactMan = facilityModel.ContactMan,
//ContactMobile = facilityModel.ContactMobile,
//ContactPhone = facilityModel.ContactPhone,
CreateTime = facilityModel.CreateTime ?? DateTime.Now
};
_redis.Sadd("facility", facilityDb, DataType.Protobuf);//将facilityDb加入到缓冲facility集合
//await _facilityService.AddFacility(facilityDb);
ServiceLogger.Current.WriteDebugLog("添加设施 {0}", facilityDb.Name);
}
return(facilityDb);
}
catch (Exception ex)
{
throw;
}
}
/// <summary>
/// 添加设备
/// </summary>
/// <param name="item"></param>
/// <param name="facilityDb"></param>
private static async Task AddDevice(FacilityAddData item, FacilityDto facilityDb)
{
TaskScheduler.UnobservedTaskException += (_, ev) => Console.WriteLine(ev.Exception);
try
{
var devices = item.Devices;
if (devices == null)
{
return;
}
devices.ForEach(async devModel =>
{
if (devModel.FacilitySerialnum.EqualIgnoreCase(facilityDb.Serialnum))
{
DeviceDto dev = null;
if (_redis.Exists("device") == 1)
{
dev = _redis.Smember <DeviceDto>("device", DataType.Protobuf).Find(d => d.Serialnum.EqualIgnoreCase(devModel.Serialnum));
}
var devDb = dev != null ? dev : await _deviceService.GetDeviceByIdAsny(devModel.Serialnum);
if (devDb == null)
{
devDb = new DeviceDto()
{
Serialnum = devModel.Serialnum,
Name = devModel.Name,
FacilitySerialnum = facilityDb.Serialnum,
DeviceTypeSerialnum = devModel.DeviceTypeSerialnum,
Unit = devModel.Unit,
CreateTime = DateTime.Now,
UpdateTime = DateTime.Now,
OnlineStatus = true,
IsException = false,
Status = 1,
Sort = 0
};
XTrace.WriteLine("{0} {1}", DateTime.Now.ToShortTimeString(), devModel.Serialnum);
//await _deviceService.AddDevice(devDb);
//if (dev != null) _redis.Srem("device", dev, DataType.Protobuf);
_redis.Sadd("device", devDb, DataType.Protobuf);//加入到缓存中
/* ServiceLogger.Current.WriteDebugLog("添加设备 {0}", devDb.Name);0
*
* var sets = await _deviceExceptionSetService.GetDeviceExceptionSetsByDeviceIdAsny(devDb.Serialnum);
* if (sets == null || sets.Count() == 0)
* {
* var set = new DeviceExceptionSetDto
* {
* Serialnum = devDb.Serialnum + "-" + DateTime.Now.ToLongTimeString(),
* DeviceSerialnum = devDb.Serialnum,
* Max = devModel.Max ?? 0,
* Min = devModel.Min ?? -1,
* CreateTime = DateTime.Now
* };
* await _deviceExceptionSetService.AddDeviceExceptionSet(set);//保存
* ServiceLogger.Current.WriteDebugLog("添加设备上下限 {0} [{1}-{2}]", devDb.Name, set.Min, set.Max);
* }*/
}
#if DEBUG
else
{
devDb.UpdateTime = DateTime.Now;
if (dev != null)
{
_redis.Srem("device", dev, DataType.Protobuf);
}
_redis.Sadd("device", devDb, DataType.Protobuf);//加入到缓存中
//await _deviceService.UpdateDevice(devDb);//保存
}
#endif
}
else
{
ServiceLogger.Current.WriteDebugLog("{0} 设备的设施编码不正确", devModel.Name);
}
});
}
catch (NotSupportedException ex)
{
}
catch (NotImplementedException ex)
{
}
catch (AggregateException ex)
{
}
catch (Exception ex)
{
throw;
}
//while (true)
//{
// Thread.Sleep(1000);
// GC.Collect();
//}
}
public async Task <string> CreateFacility([FromBody] FacilityDto facilityDto)
{
await _facilityService.CreateFacility(facilityDto);
return(facilityDto.Name);
}