/// <summary>
/// 以设备Id返回所有通道
/// </summary>
/// <param name="device">DeviceId</param>
/// <param name="customerToken">token</param>
/// <param name="deviceFlag">返回结果 设备</param>
/// <returns></returns>
public ResponseBaseDto GetChannelByDeviceId(Device device, string customerToken, ref IList <Channel> channeFlag)
{
ResponseBaseDto dto = new ResponseBaseDto();
UserTokenCache utc = UserTokenCache.GetInstance();
TokenCacheProperty tcp = new TokenCacheProperty();
try
{
if (utc.IsValid(customerToken) == false)
{
dto.Code = (int)CodeEnum.TokenTimeOut;
dto.Message = "用户token已失效，请重新登录后继续";
}
dto = bllHelper.CheckCustomer(dto, customerToken, ref tcp);
if (dto.Code != 0)
{
return(dto);
}
else
{
channeFlag = channelServer.SelectChannelByDeviceId(device);
dto.Code = 0;
dto.Message = "通道数据获取已完成";
}
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "网络异常，请刷新页面后继续";
myLog.ErrorFormat("GetChannelByDeviceId方法异常,设备Id:{0}", ex, device.DeviceId);
}
return(dto);
}
//添加一条收藏
public AddUserFavoriteResponseDto AddUserFavorite(AddUserFavoriteRequestDto req)
{
AddUserFavoriteResponseDto auf = new AddUserFavoriteResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
auf.Code = (int)CodeEnum.ReqNoToken;
auf.Message = RestHelper.SecNoTokenMessage;
}
else
{
if (req.NodeType == 0)
{
//默认设定为通道
req.NodeType = 1;
}
Model.Entities.UserFavorite userFavorite = new Model.Entities.UserFavorite();
userFavorite.UserFavoriteType = req.NodeType;
userFavorite.UserFavoriteTypeId = req.NodeId;
userFavorite.AliasName = req.AliasName;
int userFavoriteId = 0;
ResponseBaseDto dto = userFavoriteBLL.AddUserFavorite(userFavorite, customerToken, ref userFavoriteId);
auf.Code = dto.Code;
auf.Message = dto.Message;
auf.UserFavoriteId = userFavoriteId;
}
return(auf);
}
//查询设备状态
public GetServerDeviceStateResponseDto GetServerDeviceState(GetServerDeviceStateRequestDto req)
{
GetServerDeviceStateResponseDto gdsr = new GetServerDeviceStateResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
gdsr.Code = (int)CodeEnum.ReqNoToken;
gdsr.Message = RestHelper.SecNoTokenMessage;
}
else
{
List <DeviceResponse> deviceResponseFlag = new List <DeviceResponse>();
ResponseBaseDto dto = deviceBLL.GetServerDeviceState(req.DeviceIdList, customerToken, ref deviceResponseFlag);
List <DeviceState> deviceStateFlag = new List <DeviceState>();
if (dto.Code == 0)
{
for (int i = 0; i < deviceResponseFlag.Count; i++)
{
DeviceState ds = new DeviceState();
ds.DeviceId = deviceResponseFlag[i].DeviceId;
ds.State = deviceResponseFlag[i].BPServerDeviceState;
deviceStateFlag.Add(ds);
}
}
gdsr.deviceState = deviceStateFlag;
gdsr.Code = dto.Code;
gdsr.Message = dto.Message;
}/*end if(!RestHelper.SecurityCheck(ref customerToken))*/
return(gdsr);
}
UserTokenCache userTokenCache = UserTokenCache.GetInstance(); //缓存全局
//添加分组
public AddGroupByNameResponseDto AddGroupByName(AddGroupByNameRequestDto req)
{
AddGroupByNameResponseDto arb = new AddGroupByNameResponseDto();
//收集信息 :BstarCloud-User-Token
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
arb.Code = (int)CodeEnum.ReqNoToken;
arb.Message = RestHelper.SecNoTokenMessage;
}
else
{
//收集信息 pid:用户的父级节点Id,rgName:分组名称
Bsr.Cloud.Model.Entities.ResourceGroup res =
new Model.Entities.ResourceGroup()
{
ResourceGroupName = req.ResourceGroupName
, ParentResourceGroupId = req.ParentResourceGroupId
};
//传递数据 token + 分组名 + 分组父节点
ResponseBaseDto dto = resourceGroupBLL.AddResourceGroupByName(res, customerToken);
arb.Code = dto.Code;
arb.Message = dto.Message;
}
return(arb);
}
//添加通道（暂时不使用）
public AddChannelResponseDto AddChannel(AddChannelRequestDto req)
{
//暂时不使用
AddChannelResponseDto ard = new AddChannelResponseDto();
//收集信息:BstarCloud-User-Token
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
ard.Code = (int)CodeEnum.ReqNoToken;
ard.Message = RestHelper.SecNoTokenMessage;
}
else
{
//收集信息:Channel对象
Bsr.Cloud.Model.Entities.Channel channel = new Bsr.Cloud.Model.Entities.Channel();
channel.ChannelName = req.ChannelName;
channel.ChannelNumber = Convert.ToInt32(req.ChannelNumber);
channel.DeviceId = Convert.ToInt32(req.DeviceId);
//设置返回通道Id 为0
int channelId = 0;
ResponseBaseDto dto = resourceGroupBLL.AddChannel(channel, customerToken, ref channelId);
ard.Code = dto.Code;
ard.Message = dto.Message;
ard.ChannelId = channelId;
ard.ChannelName = req.ChannelName;
ard.ChannelNumber = req.ChannelNumber;
ard.DeviceId = req.DeviceId;
}
return(ard);
}
//主用户查看子用户的登陆分页信息
public GetSubCustomerLoginInfoResponseBaseDto GetSubCustomerLoginInfo(GetSubCustomerLoginInfoRequestBaseDto req)
{
GetSubCustomerLoginInfoResponseBaseDto gpcl = new GetSubCustomerLoginInfoResponseBaseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
gpcl.Code = (int)CodeEnum.ReqNoToken;
gpcl.Message = RestHelper.SecNoTokenMessage;
}
else
{
int pageCount = 0;
Model.Entities.Customer subCustomer = new Model.Entities.Customer();
subCustomer.CustomerId = req.SubCustomerId;
IList <Bsr.Cloud.Model.Entities.OperaterLog> operaterLogFlag = null;
ResponseBaseDto dto = operaterLogBLL.GetPrimaryOrSubLoginInfo(subCustomer, req.RequestCount, req.StartCount, customerToken, ref pageCount, ref operaterLogFlag);
gpcl.Code = dto.Code;
gpcl.Message = dto.Message;
List <OperaterLogResponse> operaterLogResponseFlag = new List <OperaterLogResponse>();
for (int i = 0; i < operaterLogFlag.Count; i++)
{
OperaterLogResponse operaterLogResponse = new OperaterLogResponse();
operaterLogResponse.AgentType = operaterLogFlag[i].AgentType;
operaterLogResponse.AgentVersion = operaterLogFlag[i].AgentVersion;
operaterLogResponse.OperaterTime =
operaterLogFlag[i].OperaterTime == DateTime.MinValue ? string.Empty : operaterLogFlag[i].OperaterTime.ToString();
operaterLogResponse.OperaterId = operaterLogFlag[i].OperaterId;
operaterLogResponseFlag.Add(operaterLogResponse);
}
gpcl.operaterLogList = operaterLogResponseFlag;
}
return(gpcl);
}
/// <summary>
/// 查询用户设备下的通道
/// </summary>
/// <param name="customer">customerId</param>
/// <param name="customerToken">token</param>
/// <param name="deviceChannel">返回数据：通道</param>
/// <returns></returns>
public ResponseBaseDto GetChannelByCustomerId(string customerToken, ref IList <Channel> deviceChannel)
{
ResponseBaseDto dto = new ResponseBaseDto();
UserTokenCache utc = UserTokenCache.GetInstance();
TokenCacheProperty tcp = new TokenCacheProperty();
int customerId = 0;
if (utc.IsValid(customerToken) == false)
{
dto.Code = (int)CodeEnum.ServerNoToken;
dto.Message = "用户token已失效，请重新登录后继续";
}
else
{
try
{
dto = bllHelper.CheckCustomer(dto, customerToken, ref tcp);
if (dto.Code != 0)
{
return(dto);
}
else
{
//获取当前用户所有的Device
//区分主用户与子用户
Customer customer = new Customer();
customer.CustomerId = tcp.CustomerId;
customerId = tcp.CustomerId;
IList <Customer> customerFlag = customerServer.SelectCustomerByCustomerId(customer);
if (customerFlag[0].ParentId != 0 && customerFlag[0].SignInType != 2)
{
//子账户将查询主用户的分组信息
customerFlag[0].CustomerId = customerFlag[0].ParentId;
}
//获取用户下的设备
IList <Device> customerDevice = deviceServer.SelectDeviceCustomerId(customer);
//获取设备下的通道
if (customerDevice != null && customerDevice.Count != 0)
{
List <int> deviceIdFlag = new List <int>();
for (int i = 0; i < customerDevice.Count; i++)
{
deviceIdFlag.Add(customerDevice[0].DeviceId);
}
deviceChannel = channelServer.SelectChannelByDeviceIdList(deviceIdFlag);
}
dto.Code = (int)CodeEnum.Success;
dto.Message = "设备数据获取完成";
}
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "网络异常，请刷新页面后继续";
myLog.WarnFormat("GetChannelByCustomerId方法异常,用户Id:{0},", ex, customerId);
}
}
return(dto);
}
/// <summary>
/// 添加通道分组 AddResourceGroupByName
/// </summary>
/// <param name="resourceGroup">分组中的 分组名与 分组的父节点</param>
/// <param name="customerToken">用户的唯一Token</param>
/// <returns>0 表示成功 3 代表服务器异常 5 代表失效</returns>
public ResponseBaseDto AddResourceGroupByName(ResourceGroup resourceGroup, string customerToken)
{
ResponseBaseDto dto = new ResponseBaseDto();
OperaterLog oLog = new OperaterLog();
oLog.Action = "添加分组";
//校验token
UserTokenCache utc = UserTokenCache.GetInstance();
TokenCacheProperty tcp = new TokenCacheProperty();
int customerId = 0;
if (utc.IsValid(customerToken) == false)
{
dto.Code = (int)CodeEnum.ServerNoToken;
dto.Message = "用户token已失效，请重新登录后继续";
}
else
{
try
{
dto = bllHelper.CheckCustomer(dto, customerToken, ref tcp);
if (dto.Code != 0)
{
oLog.Remarks = dto.Message;
oLog.Result = dto.Code;
bllHelper.AddOperaterLog(oLog, tcp);
return(dto);
}
//添加组
customerId = tcp.CustomerId;
resourceGroup.CustomerId = tcp.CustomerId;
int resourceGroupId = (int)resourceGroupServer.InsertResourceGorup(resourceGroup);
oLog.TargetId = resourceGroupId;
if (resourceGroupId > 0)
{
dto.Code = (int)CodeEnum.Success;
dto.Message = "添加通道分组已完成";
}
else
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "分组添加异常";
}
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "网络异常，添加分组失败！";
myLog.ErrorFormat("AddResourceGroupByName方法异常,用户Id:{0},添加的分组名:{2}", ex, customerId, resourceGroup.ResourceGroupName);
}
}
oLog.TargetType = (int)OperaterLogEnum.ResourceGroup;
oLog.Remarks = dto.Message;
oLog.Result = dto.Code;
bllHelper.AddOperaterLog(oLog, tcp);
return(dto);
}
/// <summary>
/// 修改通道是否启用 EnableChannel
/// </summary>
/// <param name="channel">Channel.ChannelId</param>
/// <param name="customerToken">token</param>
/// <returns></returns>
public ResponseBaseDto EnableChannel(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);
}
else
{
IList <Channel> channelFlag = channelServer.SelectChannelByChannelId(channel);
oLog.TargetId = channel.ChannelId;
if (channelFlag == null)
{
dto.Code = (int)CodeEnum.NoHardWare;
dto.Message = "需要修改的通道不存在";
}
else
{
string originalChannelName = channelFlag[0].ChannelName;
channelFlag[0].IsEnable = channel.IsEnable;
channelServer.UpdateChannel(channelFlag[0]);
dto.Code = 0;
dto.Message = originalChannelName;
dto.Message += channel.IsEnable == 1 ? "通道已启用" : "通道已禁用";
}
}/*end if(utc.IsValid(customerToken) == false)*/
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "网络异常，请刷新页面后继续";
myLog.WarnFormat("EnableChannel方法异常,用户Id:{0},通道Id:{1}", ex, tcp.CustomerId, channel.ChannelId);
}
oLog.TargetType = (int)OperaterLogEnum.Channel;
oLog.Remarks = dto.Message;
oLog.Result = dto.Code;
bllHelper.AddOperaterLog(oLog, tcp);
return(dto);
}
/// <summary>
/// 删除1-n个收藏 以NodeId
/// </summary>
/// <param name="nodeType"></param>
/// <param name="nodeIdList"></param>
/// <param name="customerToken"></param>
/// <returns></returns>
public ResponseBaseDto DeleteUserFavorite(int nodeType, int[] nodeIdList, string customerToken)
{
UserTokenCache utc = UserTokenCache.GetInstance();
TokenCacheProperty tcp = new TokenCacheProperty();
ResponseBaseDto dto = new ResponseBaseDto();
OperaterLog oLog = new OperaterLog();
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)
{
return(dto);
}
if (nodeType == 0 || nodeIdList.Length == 0)
{
dto.Code = (int)CodeEnum.NoComplete;
dto.Message = "用户数据提交不完整！";
return(dto);
}
string nodeidListStr = "";
for (int i = 0; i < nodeIdList.Length; i++)
{
if (i != nodeIdList.Length - 1)
{
nodeidListStr += nodeIdList[i] + ",";
}
else
{
nodeidListStr += nodeIdList[i];
}
}
userFavoriteServer.DeleteUserFavorite(tcp.CustomerId, nodeType, nodeidListStr);
oLog.Remarks = tcp.CustomerName + "批量删除收藏类型:" + nodeType + " 收藏nodeId:" + nodeidListStr;
oLog.TargetType = (int)OperaterLogEnum.Favorite;
dto.Code = (int)CodeEnum.Success;
dto.Message = "已完成批量删除！";
oLog.Remarks += dto.Message;
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "网络异常！,删除收藏失败！";
myLog.ErrorFormat("DeleteUserFavorite方法异常,收藏类型:{0},收藏NodeId集合:{0}", ex, nodeType, nodeIdList.ToString());
}
return(dto);
}
/// <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);
}
//检索通道并分页
public SearchChannelByPageResponseDto SearchChannelByPage(SearchChannelByPageRequestDto req)
{
SearchChannelByPageResponseDto scbp = new SearchChannelByPageResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
scbp.Code = (int)CodeEnum.ReqNoToken;
scbp.Message = RestHelper.SecNoTokenMessage;
}
else
{
IList <GroupChannelResponse> groupChannelResponseFlag = new List <GroupChannelResponse>();
int total = 0;
ResponseBaseDto dto = null;
if (req.IsGroup != 0)
{
dto = resourceGroupBLL.GetChannelByPageOrResourceGroupId(
new Model.Entities.ResourceGroup()
{
ResourceGroupId = req.ResouceGroupId
},
req.StartCount,
req.RequestCount,
req.KeyWord,
customerToken,
ref groupChannelResponseFlag,
ref total);
}
else //if(req.IsGroup==0)
{
dto = channelBLL.GetChannelByPage(
req.StartCount,
req.RequestCount,
req.KeyWord,
customerToken,
ref groupChannelResponseFlag,
ref total);
}
scbp.Code = dto.Code;
scbp.Message = dto.Message;
scbp.groupChannelResponseList = (List <GroupChannelResponse>)groupChannelResponseFlag;
scbp.Total = total;
}
return(scbp);
}
//删除1-n个收藏 以NodeId
public DeleteUserFavoriteByTidResponseDto DeleteUserFavoriteByTid(DeleteUserFavoriteByTidRequestDto req)
{
DeleteUserFavoriteByTidResponseDto duf = new DeleteUserFavoriteByTidResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
duf.Code = (int)CodeEnum.ReqNoToken;
duf.Message = RestHelper.SecNoTokenMessage;
}
else
{
ResponseBaseDto dto = userFavoriteBLL.DeleteUserFavorite(req.NodeType, req.NodeId, customerToken);
duf.Code = dto.Code;
duf.Message = dto.Message;
}
return(duf);
}
/// <summary>
/// 前台管理员对指定的主用户查询登陆日志
/// </summary>
/// <param name="requestCount">请求条数</param>
/// <param name="startCount">起始条数</param>
/// <param name="customerToken">token</param>
/// <param name="Total">总条数</param>
/// <param name="operaterLogFlag">ref 结果集对象</param>
/// <returns></returns>
public ResponseBaseDto GetPrimaryOrSubLoginInfo(Customer psCustomer, int requestCount, int startCount,
string customerToken, ref int Total, ref IList <OperaterLog> operaterLogFlag)
{
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已失效";
return(dto);
}
dto = bllHelper.CheckCustomer(dto, customerToken, ref tcp);
if (dto.Code != 0)
{
return(dto);
}
else
{
List <int> customerIdList = new List <int>();
//当前用户Id
customerIdList.Add(psCustomer.CustomerId);
string actionWhere = "登录";
startCount -= 1;
startCount = startCount < 0 ? 0 : startCount;
operaterLogFlag = operaterLogServer.OperaterLogForPage(customerIdList, requestCount, startCount, actionWhere);
Total = operaterLogServer.OperaterLogForPageCount(customerIdList, actionWhere);
dto.Code = (int)CodeEnum.Success;
dto.Message = "用户登陆信息已获取完成！";
}/*end if(utc.IsValid(customerToken) == false)*/
}
catch (Exception ex)
{
dto.Code = (int)CodeEnum.ApplicationErr;
dto.Message = "网络异常，用户登陆信息获取失败！";
myLog.WarnFormat("GetPrimaryOrSubLoginInfo方法异常,用户id(查询者):{0},用户id(被查询者):{1},起始条数:{2},请求条数:{3}",
ex, tcp.CustomerId, psCustomer.CustomerId, startCount, requestCount);
}
return(dto);
}
//查询单一通道
public GetSingleChannelResponseDto GetSingleChannel(GetSingleChannelRequestDto req)
{
GetSingleChannelResponseDto cscr = new GetSingleChannelResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
cscr.Code = (int)CodeEnum.ReqNoToken;
cscr.Message = RestHelper.SecNoTokenMessage;
}
else
{
GroupChannelResponse groupChannelResponse = new GroupChannelResponse();
ResponseBaseDto dto = channelBLL.GetSingleChannel(req.ChannelId, customerToken, ref groupChannelResponse);
cscr.Code = dto.Code;
cscr.Message = dto.Message;
cscr.groupChannel = groupChannelResponse;
}
return(cscr);
}
//添加设备
public AddDeviceResponseDto AddDevice(AddDeviceRequestDto req)
{
AddDeviceResponseDto ard = new AddDeviceResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
ard.Code = (int)CodeEnum.ReqNoToken;
ard.Message = RestHelper.SecNoTokenMessage;
}
else
{
//code
ResponseBaseDto dto = deviceBLL.AddDevice
(req.DeviceName, req.SerialNumber, customerToken);
ard.Code = dto.Code;
ard.Message = dto.Message;
}
return(ard);
}
//检索设备
public SearchDeviceResponseDto SearchDevice(SearchDeviceRequestDto req)
{
SearchDeviceResponseDto sdrd = new SearchDeviceResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
sdrd.Code = (int)CodeEnum.ReqNoToken;
sdrd.Message = RestHelper.SecNoTokenMessage;
}
else
{
IList <Bsr.Cloud.Model.Entities.Device> deviceFlag = null;
ResponseBaseDto dto = deviceBLL.SearchDevice(req.KeyWord, customerToken, ref deviceFlag);
sdrd.Code = dto.Code;
sdrd.Message = dto.Message;
sdrd.deviceList = (List <Bsr.Cloud.Model.Entities.Device>)deviceFlag;
}
return(sdrd);
}
//设置通道码流
public UpdateChannelEncoderInfoResponseDto UpdateChannelEncoderInfo(UpdateChannelEncoderInfoRequestDto req)
{
UpdateChannelEncoderInfoResponseDto ucei = new UpdateChannelEncoderInfoResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
ucei.Code = (int)CodeEnum.ReqNoToken;
ucei.Message = RestHelper.SecNoTokenMessage;
}
else
{
//code
Bsr.Cloud.Model.Entities.Channel channel = new Model.Entities.Channel();
ResponseBaseDto dto = channelBLL.UpdateChannelEncoderInfo(req.ChannelId, req.StreamType, customerToken);
ucei.Code = dto.Code;
ucei.Message = dto.Message;
}
return(ucei);
}
//查询设备SN是否已存在
public IsExistSNResponseDto IsExistSN(IsExistSNRequestDto req)
{
IsExistSNResponseDto iesn = new IsExistSNResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
iesn.Code = (int)CodeEnum.ReqNoToken;
iesn.Message = RestHelper.SecNoTokenMessage;
}
else
{
int isExist = 0;
ResponseBaseDto dto = deviceBLL.GetDeviceBySN(req.SerialNumber, ref isExist);
iesn.Code = dto.Code;
iesn.Message = dto.Message;
iesn.IsExist = isExist;
}
return(iesn);
}
//更新通道图片
public UpLoadChannelImageResponseDto UpLoadChannelImage(UpLoadChannelImageRequestDto req)
{
UpLoadChannelImageResponseDto uird = new UpLoadChannelImageResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
uird.Code = (int)CodeEnum.ReqNoToken;
uird.Message = RestHelper.SecNoTokenMessage;
}
else
{
int channelId = req.ChannelId;
string imageBase64 = req.ImageByteBase64;
string extName = req.extName;
if (extName == null || extName.Length == 0)
{
extName = "jpg";
}
if (channelId > 0 && imageBase64.Length > 0)
{
string imagePath = "";
// 解码图片二进制数据, bin为还原后的Byte[]
byte[] bin = Base64.FromBase64ToByte(imageBase64);
ResponseBaseDto dto = channelBLL.UpdateChanneImagePathlByChannelId(
channelId, bin, extName, customerToken, ref imagePath);
uird.Code = dto.Code;
uird.Message = dto.Message;
uird.ImagePath = imagePath;
}
else
{
myLog.WarnFormat("上传通道图片时参数错误, channelId:{0}", channelId);
uird.Code = (int)CodeEnum.NoComplete;
uird.Message = "数据请求不完整";
}
}
return(uird);
}
//删除一个分组且删除分组下的通道关系
public DeleteResourceGroupResponseDto DeleteResourceGroup(DeleteResourceGroupRequestDto req)
{
DeleteResourceGroupResponseDto ddr = new DeleteResourceGroupResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
ddr.Code = (int)CodeEnum.ReqNoToken;
ddr.Message = RestHelper.SecNoTokenMessage;
}
else
{
//code
Bsr.Cloud.Model.Entities.ResourceGroup resourceGroup = new Model.Entities.ResourceGroup();
resourceGroup.ResourceGroupId = req.ResourceGroupId;
ResponseBaseDto dto = resourceGroupBLL.RemoveResourceGroup(resourceGroup, customerToken);
ddr.Code = dto.Code;
ddr.Message = dto.Message;
}
return(ddr);
}
//查询当前用的通道
public GetChannelResponseDto GetChannel(GetChannelRequestDto req)
{
GetChannelResponseDto scr = new GetChannelResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
scr.Code = (int)CodeEnum.ReqNoToken;
scr.Message = RestHelper.SecNoTokenMessage;
}
else
{
IList <Bsr.Cloud.Model.Entities.Channel> channel = null;
ResponseBaseDto dto =
resourceGroupBLL.GetChannelByCustomerId(customerToken, ref channel);
scr.Code = dto.Code;
scr.Message = dto.Message;
scr.channelList = (List <Bsr.Cloud.Model.Entities.Channel>)channel;
}
return(scr);
}
//以通道集合移动至一个分组内
public MoveChannelListByResourceGroupIdResponseDto MoveChannelListByResourceGroupId(MoveChannelListByResourceGroupIdRequestDto req)
{
MoveChannelListByResourceGroupIdResponseDto mcbr = new MoveChannelListByResourceGroupIdResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
mcbr.Code = (int)CodeEnum.ReqNoToken;
mcbr.Message = RestHelper.SecNoTokenMessage;
}
else
{
Model.Entities.ResourceGroup resourceGroup = new Model.Entities.ResourceGroup();
resourceGroup.ResourceGroupId = req.ResourceGroupId;
ResponseBaseDto dto =
resourceGroupBLL.UpdateChannelListByResourceGroupId(resourceGroup, req.Channel, customerToken);
mcbr.Code = dto.Code;
mcbr.Message = dto.Message;
}
return(mcbr);
}
internal ResponseBaseDto CheckCustomer(ResponseBaseDto dto, string customerToken, ref TokenCacheProperty tcp)
{
UserTokenCache utc = UserTokenCache.GetInstance();
tcp = utc.FindByCustomerToken(customerToken);
Customer customer = new Customer();
if (tcp == null)
{
dto.Message = "请求的用户未找到";
dto.Code = (int)CodeEnum.NoUser;
return(dto);
}
else if (tcp.IsEnable == 0)
{
dto.Message = "此账户已被冻结,无法使用此功能";
dto.Code = (int)CodeEnum.NoAuthorization;
return(dto);
}//Wait....
return(dto);
}
//移动分组
public MoveResourceGroupResponseDto MoveResourceGroup(MoveResourceGroupRequestDto req)
{
MoveResourceGroupResponseDto mrgr = new MoveResourceGroupResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
mrgr.Code = (int)CodeEnum.ReqNoToken;
mrgr.Message = RestHelper.SecNoTokenMessage;
}
else
{
//code
Bsr.Cloud.Model.Entities.ResourceGroup resourceGroup = new Model.Entities.ResourceGroup();
resourceGroup.ResourceGroupId = req.ResourceGroupId;
resourceGroup.ParentResourceGroupId = req.ParentResourceGroupId;
ResponseBaseDto dto = resourceGroupBLL.UpdateResourceGroupByParentId(resourceGroup, customerToken);
mrgr.Code = dto.Code;
mrgr.Message = dto.Message;
}
return(mrgr);
}
//通道分页提供数据
public GetChannelByPageResponseDto GetChannelByPage(GetChannelByPageRequestDto req)
{
GetChannelByPageResponseDto gbrd = new GetChannelByPageResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
gbrd.Code = (int)CodeEnum.ReqNoToken;
gbrd.Message = RestHelper.SecNoTokenMessage;
}
else
{
IList <GroupChannelResponse> groupChannelResponseFlag = new List <GroupChannelResponse>();
int total = 0;
ResponseBaseDto dto = channelBLL.GetChannelByPage(req.StartCount, req.RequestCount, string.Empty, customerToken, ref groupChannelResponseFlag, ref total);
gbrd.Code = dto.Code;
gbrd.Message = dto.Message;
gbrd.groupChannelResponseList = (List <GroupChannelResponse>)groupChannelResponseFlag;
gbrd.Total = total;
}
return(gbrd);
}
//查询当前用户的分组
public GetResourceGroupResponseDto GetResourceGroup(GetResourceGroupRequestDto req)
{
GetResourceGroupResponseDto srgr = new GetResourceGroupResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
srgr.Code = (int)CodeEnum.ReqNoToken;
srgr.Message = RestHelper.SecNoTokenMessage;
}
else
{
IList <ResourceGroupResponse> resourceGroupResponse = new List <ResourceGroupResponse>();
ResponseBaseDto dto =
resourceGroupBLL.GetGroupByCustomerId(customerToken, ref resourceGroupResponse);
srgr.Code = dto.Code;
srgr.Message = dto.Message;
srgr.resourceGroupList = (List <ResourceGroupResponse>)resourceGroupResponse;
}
return(srgr);
}
//更新分组名称
public UpdateResourceGroupNameResponseDto UpdateResourceGroupName(UpdateResourceGroupNameRequestDto req)
{
UpdateResourceGroupNameResponseDto urgn = new UpdateResourceGroupNameResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
urgn.Code = (int)CodeEnum.ReqNoToken;
urgn.Message = RestHelper.SecNoTokenMessage;
}
else
{
//code
Bsr.Cloud.Model.Entities.ResourceGroup resourceGroup = new Model.Entities.ResourceGroup();
resourceGroup.ResourceGroupId = req.ResourceGroupId;
resourceGroup.ResourceGroupName = req.ResourceGroupName;
ResponseBaseDto dto = resourceGroupBLL.UpdateResourceGorupByName(resourceGroup, customerToken);
urgn.Code = dto.Code;
urgn.Message = dto.Message;
}
return(urgn);
}
public UpdateChannelNameResponseDto UpdateChannelName(UpdateChannelNameRequestDto req)
{
UpdateChannelNameResponseDto ucnr = new UpdateChannelNameResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
ucnr.Code = (int)CodeEnum.ReqNoToken;
ucnr.Message = RestHelper.SecNoTokenMessage;
}
else
{
//code
Bsr.Cloud.Model.Entities.Channel channel = new Model.Entities.Channel();
channel.ChannelName = req.NewChannelName;
channel.ChannelId = req.ChannelId;
ResponseBaseDto dto = channelBLL.UpdateChannelByChannelId(channel, customerToken);
ucnr.Code = dto.Code;
ucnr.Message = dto.Message;
}
return(ucnr);
}
//开启或关闭一个通道
public EnableChannelResponseDto EnableChannel(EnableChannelRequestDto req)
{
EnableChannelResponseDto ucnr = new EnableChannelResponseDto();
string customerToken = "";
if (!RestHelper.SecurityCheck(ref customerToken))
{
ucnr.Code = (int)CodeEnum.ReqNoToken;
ucnr.Message = RestHelper.SecNoTokenMessage;
}
else
{
//code
Bsr.Cloud.Model.Entities.Channel channel = new Model.Entities.Channel();
channel.IsEnable = req.IsEnable;
channel.ChannelId = req.ChannelId;
ResponseBaseDto dto = channelBLL.EnableChannel(channel, customerToken);
ucnr.Code = dto.Code;
ucnr.Message = dto.Message;
}
return(ucnr);
}
