/// <summary>
/// 添加设备
/// </summary>
/// <param name="serialNumber">设备号</param>
/// <returns></returns>
private AddDeviceResponseDto AddDeviceMethod(string serialNumber)
{
var deviceTypeEntity = GetDeviceTypeEntity(WellKnownVenderName.BSR, WellKnownSdkNames.LimitDevice);
DockDeviceEntity deviceEntity = new DockDeviceEntity();
deviceEntity.DeviceType = deviceTypeEntity;
deviceEntity.ChannelCount = 0;
deviceEntity.ControlPort = 3721;
deviceEntity.DataPort = 3720;
deviceEntity.DefaultConn = 0;
deviceEntity.DownloadPort = 3720;
deviceEntity.Password = "******";
deviceEntity.Protocol = 0;
deviceEntity.User = "******";
deviceEntity.HardwareType = (short)HardwareType.Unknown;
deviceEntity.IsFetchChannel = true;
deviceEntity.MulticastAddress = "";
deviceEntity.MulticastPort = 0;
if (serialNumber.IndexOf(".") != -1)
{
deviceEntity.Ip = serialNumber;
deviceEntity.AddMode = 0;
deviceEntity.Host = "";
}
else
{
deviceEntity.Ip = "";
deviceEntity.AddMode = 3;
deviceEntity.Host = serialNumber;
}
deviceEntity.Host = serialNumber;
deviceEntity.Name = serialNumber;
deviceEntity.RegisterServerId = deviceEntity.RegisterType = 0;
deviceEntity.RegisterAliases = deviceEntity.RegisterSerialNumber = deviceEntity.RegisterMACAddress = "";
AddDeviceRequestDto addDto = new AddDeviceRequestDto();
addDto.MaxCount = 512;
addDto.AddDeviceEntity = deviceEntity;
Bsr.ServiceProxy.Utils.ServiceFactory serviceFactory = new ServiceProxy.Utils.ServiceFactory();
DDNSConfigDto tmp = new DDNSConfigDto();
var seviceAddr = bllHelper.GetServerModelStr();
AddDeviceResponseDto result = null;
serviceFactory.GetProxy <IDevice>(new Uri(seviceAddr)).Use(
p =>
{
result = p.Add(addDto, tmp);
}
);
return(result);
}
/// <summary>
/// BP4Server修改设备名
/// </summary>
/// <param name="deleteMode"></param>
/// <param name="ip"></param>
/// <param name="host"></param>
public void UpdateDeviceNameMethod(int serverDeviceId, string serverDeviceName)
{
Bsr.ServiceProxy.Utils.ServiceFactory serviceFactory = new ServiceProxy.Utils.ServiceFactory();
var seviceAddr = bllHelper.GetServerModelStr();
serviceFactory.GetProxy <IDevice>(new Uri(seviceAddr)).Use(
p =>
{
p.UpdateName(serverDeviceId, serverDeviceName);
}
);
}
/// <summary>
/// 获取设备SN 并返回是否可以添加以及设备硬件类型 CheckDeviceBySN
/// </summary>
/// <param name="SerialNumber">SN码</param>
/// <param name="isExist">1已存在 0不存在</param>
/// <param name="online">设备是否在线</param>
/// <param name="hardwareType">硬件类型</param>
/// <returns></returns>
public ResponseBaseDto CheckDeviceBySN(string serialNumber, ref int isEnable, ref int isOnline, ref int hardwareType)
{
ResponseBaseDto dto = new ResponseBaseDto();
try
{
IList <Device> deviceFlag =
deviceServer.SelectDeviceSerialNumber(new Device()
{
SerialNumber = serialNumber
});
if (deviceFlag != null && deviceFlag.Count != 0)
{
isEnable = 0;//设备已存在，不可用
hardwareType = deviceFlag[0].HardwareType;
dto.Code = (int)CodeEnum.Success;
dto.Message = "SN已验证完毕！";
return(dto);
}
else
{
//向BP4Server请求SN码
Bsr.ServiceProxy.Utils.ServiceFactory serviceFactory = new ServiceProxy.Utils.ServiceFactory();
string seviceAddr = bllHelper.GetServerModelStr();
HardwareTypeDto htDto = new HardwareTypeDto();
htDto.IsOnline = 0;
htDto.Type = HardwareType.Unknown;
serviceFactory.GetProxy <IDevice>(new Uri(seviceAddr)).Use(
p =>
{
htDto = p.GetHardwareTypeBySerialNumber(serialNumber);
}
);
if (htDto.IsOnline != 0)
{
isEnable = 1;
isOnline = htDto.IsOnline;
hardwareType = (int)htDto.Type;
}
}
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "网络异常，请刷新页面后继续";
myLog.ErrorFormat("GetDeviceBySN方法异常,设备serialNumber:{0}", ex, serialNumber);
}
return(dto);
}
/// <summary>
/// 删除BP4Server服务器的设备
/// </summary>
/// <param name="deleteMode"></param>
/// <param name="ip"></param>
/// <param name="host"></param>
public bool DeleteDeviceMethod(int serverDeviceId)
{
bool bFlag = false;
Bsr.ServiceProxy.Utils.ServiceFactory serviceFactory = new ServiceProxy.Utils.ServiceFactory();
var seviceAddr = bllHelper.GetServerModelStr();
serviceFactory.GetProxy <IDevice>(new Uri(seviceAddr)).Use(
p =>
{
bFlag = p.Delete(serverDeviceId);
}
);
return(bFlag);
}
/// <summary>
/// 通过设备产商名和类型，向bp4server获取到DeviceTypeEntity，这个参数用在添加设备到bp4server时使用
/// </summary>
/// <param name="venderName"></param>
/// <param name="deviceKey"></param>
/// <returns></returns>
private DeviceTypeEntity GetDeviceTypeEntity(string venderName, string deviceKey)
{
Bsr.ServiceProxy.Utils.ServiceFactory serviceFactory = new ServiceProxy.Utils.ServiceFactory();
var seviceAddr = bllHelper.GetServerModelStr();
IList <DeviceTypeEntity> typeList = null;
serviceFactory.GetProxy <IDeviceType>(new Uri(seviceAddr)).Use(
c =>
{
DeviceTypeCondDto typeDto = new DeviceTypeCondDto(null, null, (int)DeviceTypeLevel.Vender, null);
var venderList = c.GetDeviceTypeListFor(typeDto, int.MaxValue, 1);
int parentId = venderList.Where(p => p.Name == venderName).First().Id;
typeDto = new DeviceTypeCondDto(null, null, (int)DeviceTypeLevel.Model, parentId);
typeList = c.GetDeviceTypeListFor(typeDto, int.MaxValue, 1);
}
);
return(typeList.Where(p => p.Key == deviceKey).First());
}
/// <summary>
/// 设置通道码流
/// </summary>
/// <param name="channelId">通道id</param>
/// <param name="streamType">码流类型</param>
/// <param name="customerToken">用户token</param>
/// <returns></returns>
public ResponseBaseDto UpdateChannelEncoderInfo(int channelId, int streamType, string customerToken)
{
ResponseBaseDto dto = new ResponseBaseDto();
UserTokenCache utc = UserTokenCache.GetInstance();
OperaterLog oLog = new OperaterLog();
TokenCacheProperty tcp = new TokenCacheProperty();
oLog.Action = "设置通道码流";
try
{
if (utc.IsValid(customerToken) == false)
{
dto.Code = (int)CodeEnum.ServerNoToken;
dto.Message = "用户token已失效，请重新登录后继续";
return(dto);
}
dto = bllHelper.CheckCustomer(dto, customerToken, ref tcp);
if (dto.Code != 0)
{
oLog.TargetType = (int)OperaterLogEnum.Channel;
oLog.Remarks = dto.Message;
oLog.Result = dto.Code;
bllHelper.AddOperaterLog(oLog, tcp);
return(dto);
}
else
{
IList <Channel> channelFlag = channelServer.SelectChannelByChannelId(new Channel()
{
ChannelId = channelId
});
oLog.TargetId = channelId;
if (channelFlag == null)
{
dto.Code = (int)CodeEnum.NoHardWare;
dto.Message = "需要修改的通道不存在";
}
else if (streamType == 0)
{
dto.Code = (int)CodeEnum.NoHardWare;
dto.Message = "未选中码流类型";
}
else
{
try
{
//获取已预制的码流配置
IDictionary <int, AVEncoderInfoDto> avEncoderInfoList = GetXMLChannelEncoderList();
AVEncoderInfoDto enCoderInfo = avEncoderInfoList[streamType];
//调用BP4Server 设置码流
Bsr.ServiceProxy.Utils.ServiceFactory serviceFactory = new ServiceProxy.Utils.ServiceFactory();
var seviceAddr = bllHelper.GetServerModelStr();
serviceFactory.GetProxy <ICamera>(new Uri(seviceAddr)).Use(
p =>
{
if (streamType == 1)
{
//主码流
p.UpdateEncoderInfo(channelFlag[0].BPServerChannelId, (byte)(1), enCoderInfo);
}
else if (streamType == 2 || streamType == 3)
{
//选择码流类型（streamType）在BP4Server中 2和3都属于子码流
p.UpdateEncoderInfo(channelFlag[0].BPServerChannelId, (byte)(1 << 1), enCoderInfo);
}
else
{
//第3码流
p.UpdateEncoderInfo(channelFlag[0].BPServerChannelId, (byte)(1 << 2), enCoderInfo);
}
});
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "通道所属设备已离线！离线状态无法修改通道码流";
myLog.ErrorFormat("UpdateChannelEncoderInfo（BP4Server设备已离线）通道Id:{0}", ex, channelId);
return(dto);
}
}
}/*end if(utc.IsValid(customerToken) == false)*/
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "网络异常，请刷新页面后继续";
myLog.WarnFormat("UpdateChannelEncoderInfo方法异常,用户Id:{0},通道Id:{1}", ex, tcp.CustomerId, channelId);
}
oLog.TargetType = (int)OperaterLogEnum.Channel;
oLog.Remarks = dto.Message;
oLog.Result = dto.Code;
bllHelper.AddOperaterLog(oLog, tcp);
return(dto);
}
/// <summary>
/// 修改通道名
/// </summary>
/// <param name="channel">Channel.ChannelId</param>
/// <param name="customerToken">token</param>
/// <returns></returns>
public ResponseBaseDto UpdateChannelByChannelId(Channel channel, string customerToken)
{
ResponseBaseDto dto = new ResponseBaseDto();
UserTokenCache utc = UserTokenCache.GetInstance();
OperaterLog oLog = new OperaterLog();
TokenCacheProperty tcp = new TokenCacheProperty();
oLog.Action = "修改通道名";
try
{
if (utc.IsValid(customerToken) == false)
{
dto.Code = (int)CodeEnum.ServerNoToken;
dto.Message = "用户token已失效，请重新登录后继续";
return(dto);
}
dto = bllHelper.CheckCustomer(dto, customerToken, ref tcp);
if (dto.Code != 0)
{
oLog.TargetType = (int)OperaterLogEnum.Channel;
oLog.Remarks = dto.Message;
oLog.Result = dto.Code;
bllHelper.AddOperaterLog(oLog, tcp);
return(dto);
}
if (tcp.SignInType == (int)CustomerSignInTypeEnum.SubCustomer)
{
dto.Code = (int)CodeEnum.ServerNoToken;
dto.Message = "子用户状态无法修改通道名！";
return(dto);
}
else
{
IList <Channel> channelFlag = channelServer.SelectChannelByChannelId(channel);
oLog.TargetId = channel.ChannelId;
if (channelFlag == null)
{
dto.Code = (int)CodeEnum.NoHardWare;
dto.Message = "需要修改的通道不存在！";
}
else
{
try
{
Bsr.ServiceProxy.Utils.ServiceFactory serviceFactory = new ServiceProxy.Utils.ServiceFactory();
var seviceAddr = bllHelper.GetServerModelStr();
serviceFactory.GetProxy <ICamera>(new Uri(seviceAddr)).Use(
p =>
{
p.UpdateName(channelFlag[0].BPServerChannelId, channel.ChannelName);
}
);
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "修改失败，连接服务器超时！";
myLog.ErrorFormat("UpdateChannelByChannelId（Adapter服务器端没有做出响应）通道Id:{0},待修改的通道名:{1}", ex, channel.ChannelId, channel.ChannelName);
return(dto);
}
string originalChannelName = channelFlag[0].ChannelName;
channelFlag[0].ChannelName = channel.ChannelName;
channelServer.UpdateChannel(channelFlag[0]);
dto.Code = 0;
dto.Message = "通道名 " + originalChannelName + "修改为 " + channel.ChannelName + " 已完成！";
}
}/*end if(utc.IsValid(customerToken) == false)*/
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "无法连接服务器,请保证您的网络通畅！";
myLog.ErrorFormat("UpdateChannelByChannelId方法异常,通道Id:{0},待修改的通道名:{1}", ex, channel.ChannelId, channel.ChannelName);
}
oLog.TargetType = (int)OperaterLogEnum.Channel;
oLog.Remarks = dto.Message;
oLog.Result = dto.Code;
bllHelper.AddOperaterLog(oLog, tcp);
return(dto);
}
/// <summary>
/// 获取设备状态
/// </summary>
/// <param name="deviceIdList">Device.DeviceId</param>
/// <param name="deviceResponseFlag">ref 集合对象</param>
/// <returns></returns>
public ResponseBaseDto GetServerDeviceState(int[] deviceIdList, string customerToken, ref List <DeviceResponse> deviceResponseFlag)
{
ResponseBaseDto dto = new ResponseBaseDto();
UserTokenCache utc = UserTokenCache.GetInstance();
TokenCacheProperty tcp = new TokenCacheProperty();
try
{
if (utc.IsValid(customerToken) == false)
{
dto.Code = (int)CodeEnum.ServerNoToken;
dto.Message = "用户token已失效";
}
dto = bllHelper.CheckCustomer(dto, customerToken, ref tcp);
if (dto.Code != 0)
{
return(dto);
}
else
{
IList <DeviceTokenDto> deviceTokenDtoFlag = new List <DeviceTokenDto>();
for (int i = 0; i < deviceIdList.Length; i++)
{
//缓存里是否有这个设备
DeviceResponse deviceResponse = deviceCache.FindByDeviceKey(GetDeivceKey(deviceIdList[i]));
if (deviceResponse != null)
{
deviceResponseFlag.Add(deviceResponse);
}
else
{
DeviceTokenDto deviceTokenDto = new DeviceTokenDto();
//服务器的设备ID
IList <Device> dFlag =
deviceServer.SelectDeviceByDeviceId(new Device()
{
DeviceId = deviceIdList[i]
});
if (dFlag != null && dFlag.Count != 0)
{
deviceTokenDto.ID = dFlag[0].BPServerDeviceId;
deviceTokenDtoFlag.Add(deviceTokenDto);
}
}
}
try
{
Bsr.ServiceProxy.Utils.ServiceFactory serviceFactory = new ServiceProxy.Utils.ServiceFactory();
string seviceAddr = bllHelper.GetServerModelStr();
IDictionary <int, DeviceStateDto> deviceState = null;
serviceFactory.GetProxy <IDevice>(new Uri(seviceAddr)).Use(
p =>
{
deviceState = p.RefreshDevices(deviceTokenDtoFlag);
}
);
for (int i = 0; i < deviceTokenDtoFlag.Count; i++)
{
DeviceStateDto dsDto = deviceState[(deviceTokenDtoFlag[i].ID)];
IList <Device> dbDeviceFlag =
deviceServer.SelectDeviceByBPServerDeviceId(new Device()
{
BPServerDeviceId = deviceTokenDtoFlag[i].ID
});
if (dbDeviceFlag != null && dbDeviceFlag.Count == 1)
{
Device device = dbDeviceFlag[i];
DeviceResponse deviceResponse = new DeviceResponse();
deviceResponse.DeviceId = device.DeviceId;
if (dsDto.IsOnline == true)
{
deviceResponse.BPServerDeviceState = 1;
}
else
{
deviceResponse.BPServerDeviceState = 0;
}
//数据放入缓存
DateTime dt = DateTime.Now.AddSeconds(300);//失效时间定义为5分钟
deviceCache.AddDeviceCache(GetDeivceKey(dbDeviceFlag[0].DeviceId), deviceResponse, dt);
deviceResponseFlag.Add(deviceResponse);
}
}
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "服务未开启";
myLog.WarnFormat("GetServerGetDeviceState方法异常,BP4Server服务未开启！", ex);
}
dto.Code = (int)CodeEnum.Success;
dto.Message = "设备状态已获取完成";
}/*end if(utc.IsValid(customerToken) == false)*/
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "网络异常，请刷新页面后继续";
myLog.ErrorFormat("GetServerGetDeviceState方法异常,设备Id{0}", ex, deviceIdList.ToString());
}
return(dto);
}
/// <summary>
/// 以用户Id返回所有设备
/// </summary>
/// <param name="customer">CustomerId</param>
/// <param name="customerToken">token</param>
/// <param name="deviceFlag">返回结果 设备</param>
/// <returns></returns>
public ResponseBaseDto GetDeviceByCustomerId(string customerToken, ref List <DeviceResponse> deviceResponseFlag)
{
ResponseBaseDto dto = new ResponseBaseDto();
UserTokenCache utc = UserTokenCache.GetInstance();
TokenCacheProperty tcp = new TokenCacheProperty();
int customerId = 0;
try
{
if (utc.IsValid(customerToken) == false)
{
dto.Code = (int)CodeEnum.TokenTimeOut;
dto.Message = "用户token已失效，请重新登录后继续";
return(dto);
}
dto = bllHelper.CheckCustomer(dto, customerToken, ref tcp);
if (dto.Code != 0)
{
return(dto);
}
else if (tcp.SignInType != (int)CustomerSignInTypeEnum.PrimaryCustomer)
{
dto.Code = (int)CodeEnum.NoUser;
dto.Message = "没有权限";
return(dto);
}
else
{
Customer customer = new Customer();
customerId = tcp.CustomerId;
customer.CustomerId = tcp.CustomerId;
List <int> authorizeDeviceIdList = new List <int>();
//当前主账号下的设备
IList <Device> deviceFlag = deviceServer.SelectDeviceCustomerId(customer);
//准备返回的结果集
deviceResponseFlag = new List <DeviceResponse>();
//添加授权的设备
IList <Permission> permissionFlag = permissionServer.SelectPermissionByCustomerId(customer);
for (int j = 0; j < permissionFlag.Count; j++)
{
//判定当前用户对授权设备是否是可用的
if (permissionFlag[j].IsEnable == 1 && permissionFlag[j].NodeType == 1)
{
IList <Device> otherDeviceFalg =
deviceServer.SelectDeviceByDeviceId(new Device()
{
DeviceId = permissionFlag[j].NodeId
});
if (otherDeviceFalg != null && otherDeviceFalg.Count == 1)
{
authorizeDeviceIdList.Add(otherDeviceFalg[0].DeviceId);
deviceFlag.Add(otherDeviceFalg[0]);
}
}
}
Bsr.ServiceProxy.Utils.ServiceFactory serviceFactory = new ServiceProxy.Utils.ServiceFactory();
var seviceAddr = bllHelper.GetServerModelStr();
for (int i = 0; i < deviceFlag.Count; i++)
{
DeviceResponse dr = new DeviceResponse();
Bsr.Cloud.Model.Entities.Device device = deviceFlag[i];
dr.DeviceId = device.DeviceId;
dr.DeviceName = device.DeviceName;
dr.DeviceType = device.DeviceType;
dr.SerialNumber = device.SerialNumber;
dr.HardwareType = device.HardwareType;
dr.IsAuthorize = 0;
if (authorizeDeviceIdList.Contains(device.DeviceId))
{
dr.IsAuthorize = 1;
}
deviceResponseFlag.Add(dr);
}
dto.Code = (int)CodeEnum.Success;
dto.Message = "设备已获取完成";
}
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "网络异常，请刷新页面后继续";
myLog.ErrorFormat("GetDeviceByCustomerId方法异常, 用户Id:{0}", ex, customerId);
}
return(dto);
}
