/// <summary>
/// 将设备天数据批量放入缓存
/// 由于输入的对象开始经过缓存和数据取得了，所以这时直接放入缓存即可
/// </summary>
/// <param name="dayDatas"></param>
public void batchToCache(IList <IDictionary <string, DeviceDayData> > devicedayDataMapList)
{
string cachekey = string.Empty;
//int[] mtkeys = collectordayDataMap.Keys.ToArray();
foreach (IDictionary <string, DeviceDayData> tmp in devicedayDataMapList)
{
//string[] keys = tmp.Keys.ToArray();
DeviceDayData dayData = null;
foreach (string key in tmp.Keys)
{
if (key == null || !tmp.ContainsKey(key))
{
continue;
}
dayData = tmp[key];
if (dayData == null || !dayData.changed)
{
continue;
}
//加入缓存，设置两天为缓存过期时间，避免时差问题
cachekey = CacheKeyUtil.buildDeviceDayDataKey(dayData.deviceID, dayData.yearmonth, dayData.sendDay, dayData.monitorCode);
mcs.Set(cachekey, dayData, DateTime.Now.AddDays(2));
//if (!persistentListKey.Contains(cachekey)) persistentListKey.Add(cachekey);
//dayData.changed = false;
}
}
}
/// <summary>
/// 缓存集合
/// </summary>
/// <param name="devicedayDataMapList"></param>
public void batchToCacheList()
{
iswork = true;
string cachekey = string.Empty;
IDictionary <string, DeviceDayData> devicedayDataMap = BaseMessage.devicedayDataMapList[mtKey];
DeviceDayData dayData = null;
ICollection <string> keys;
try
{
keys = devicedayDataMap.Keys.ToArray();
}
catch (Exception ee) {
LogUtil.error(ee.Message);
return;
}
foreach (string key in keys)
{
try{
if (key == null || !devicedayDataMap.ContainsKey(key))
{
continue;
}
dayData = devicedayDataMap[key];
if (dayData == null || !dayData.changed)
{
continue;
}
//加入缓存，设置两天为缓存过期时间，避免时差问题
cachekey = CacheKeyUtil.buildDeviceDayDataKey(dayData.deviceID, dayData.yearmonth, dayData.sendDay, dayData.monitorCode);
MemcachedClientSatat.getInstance().Set(cachekey, dayData, DateTime.Now.AddDays(2));
//这里当数量大得时候，list结构插入很慢
//if (!DeviceDayDataService.persistentListKey.Contains(cachekey)) DeviceDayDataService.persistentListKey.Add(cachekey);
//dayData.changed = false;
}
catch (Exception onee)
{
LogUtil.writeline("handle one devicedayDataMap in devicedayDataMapList ,the mtkey is: " + mtKey + "DeviceDayData is " + key + "error:" + onee.Message);
iswork = false;//出异常了让程序停止工作
}
}
iswork = false;
}
/// <summary>
/// 删除天数据，按照id
/// add by qhb in 20120828
/// </summary>
/// <param name="dayData"></param>
/// <returns></returns>
public bool Delete(DeviceDayData dayData)
{
return(_DevicePowerDaydataDao.Remove(dayData) > 0 ? true : false);
}
/// <summary>
/// 批量保持设备日数据对象
/// </summary>
/// <param name="unitDayDatas"></param>
public void batchSave(IList <IDictionary <string, DeviceDayData> > devicedayDataMapList)
{
//从需要持久化的list中取出对象
String[] keyArr;
foreach (IDictionary <string, DeviceDayData> datadic in devicedayDataMapList)
{
keyArr = datadic.Keys.ToArray();
foreach (string key in keyArr)
{
object obj = MemcachedClientSatat.getInstance().Get(key);
if (obj == null)
{
LogUtil.warn(key + "in cache is empty of device day data ");
continue;
}
DeviceDayData collectorDayData = (DeviceDayData)obj;
if (!collectorDayData.changed)
{
continue;
}
//持久化到数据库
if (collectorDayData.id == 0)
{
try
{
_DevicePowerDaydataDao.Insert(collectorDayData);
//添加id信息
MemcachedClientSatat.getInstance().Set(key, collectorDayData);
if (datadic.ContainsKey(key))
{
datadic[key].id = collectorDayData.id;
}
}
catch (Exception e)
{
LogUtil.error("insert device day data fail:" + e.Message);
//添加id信息
MemcachedClientSatat.getInstance().Set(key, collectorDayData);
if (datadic.ContainsKey(key))
{
datadic[key].id = collectorDayData.id;
}
}
}
else
{
try
{
_DevicePowerDaydataDao.Update(collectorDayData);
}
catch (Exception e)
{
//这里有些问题，稍后要调试下有插入索引约束异常
LogUtil.error("update" + collectorDayData.deviceType + " device day data fail:" + e.Message);
}
}
//将变化标识置为false
datadic[key].changed = false;
}
}
}
/// <summary>
/// 取得设备天数据列表
/// </summary>
/// <returns></returns>
public void getDeviceDayDataList()
{
if (this.listTcpbody != null && listTcpbody.Count > 0)
{
Device device = null;
int collectorID = GetCollectorId();
DeviceDayData mdd = null;
foreach (DeviceDataBase ddb in ListTcpbody)
{
int deviceID = GetDeviceId(collectorID, ddb.deviceAddress);
if (deviceID == 0)
{
//构造设备
device = new Device();
device.collectorID = collectorID;
device.deviceAddress = ddb.deviceAddress.ToString();
//根据协议类型取得说属大类型
device.deviceTypeCode = DeviceData.getProtocolTypeByCode(ddb.protocolType).deviceType.code;
device.deviceModel = new DeviceModel()
{
code = ddb.deviceXh
};
device.status = ddb.deviceState.ToString();
deviceID = DeviceService.GetInstance().Save(device);
LogUtil.info("has new device,collectorID is " + collectorID + ",deviceAddress is " + device.deviceAddress);
//有新设备要更新bank缓存
HttpClientUtil.requestUrl(bank_url);
}
else
{
//这里影响解析性能，出了型号会变，设备类型也会变所以也要更新
device = DeviceService.GetInstance().get(deviceID);
if (ddb.deviceXh != device.deviceModelCode || (DeviceData.getProtocolTypeByCode(ddb.protocolType).typecode != device.deviceTypeCode))
{ //型号有变化更新设备信息
device.deviceModelCode = ddb.deviceXh;
device.deviceModel = new DeviceModel()
{
code = ddb.deviceXh
};
device.deviceTypeCode = DeviceData.getProtocolTypeByCode(ddb.protocolType).typecode;
device.name = "";
LogUtil.info("has device update,collectorID is " + collectorID + ",deviceAddress is " + device.deviceAddress);
DeviceService.GetInstance().Save(device);
//设备类型编号也要更新bank缓存
HttpClientUtil.requestUrl(bank_url);
}
}
//设置设备的发电量
if (ddb.todayEnergy > -1)
{
deviceEnergyMap[deviceID + ":" + messageHeader.year + messageHeader.month + messageHeader.day] = ddb.todayEnergy;
}
//设置设备的增量日照强度，参照发电量记录，用发电量的记录逻辑，因为发电量的设备id是逆变器，现在时环境监测仪所以不会重复，可以用发电量的结构
//如果增量日照强度大于0则表示有就记录下来，用于后面的累计 add by qianhb in 2012/01/13
if (ddb.todaySunshine > -1)
{
deviceEnergyMap[deviceID + ":" + messageHeader.year + messageHeader.month + messageHeader.day] = ddb.todaySunshine;
}
//这里需要改进为依据设备时间，防止设备数据的时间和采集器的时间是不一致的
string mapObjectKey;
IDictionary <string, DeviceDayData> tmpdic = null;
foreach (int key in ddb.historyMonitorMap.Keys)
{
tmpdic = devicedayDataMapList[deviceID % 50];
mapObjectKey = CacheKeyUtil.buildDeviceDayDataKey(deviceID, messageHeader.year + messageHeader.month, int.Parse(messageHeader.day), key);
if (!tmpdic.ContainsKey(mapObjectKey))
{
//先从缓存中取得
mdd = DeviceDayDataService.GetInstance().getDeviceDayData(deviceID, key, int.Parse(messageHeader.day), int.Parse(messageHeader.year), int.Parse(messageHeader.month));
if (mdd == null)
{
mdd = new DeviceDayData()
{
deviceID = deviceID, sendDay = int.Parse(messageHeader.day), monitorCode = key, deviceType = ddb.deviceType
}
}
;
else
{
if (mdd.id == 0)
{
LogUtil.warn("mdd id is 0" + deviceID + "-" + key + "-" + ddb.deviceType);
}
}
tmpdic[mapObjectKey] = mdd;
}
else
{
mdd = tmpdic[mapObjectKey];
}
//非持久化属性赋值，用于指定所在表
mdd.yearmonth = messageHeader.year + messageHeader.month;
float newValue = ddb.historyMonitorMap[key] == null ? 0 : float.Parse(ddb.historyMonitorMap[key].ToString());
mdd.dataContent += "#" + messageHeader.hour + messageHeader.minute + messageHeader.second + ":" + newValue;
mdd.sendtime = messageHeader.TimeNow;
mdd.localAcceptTime = DateTime.Now;
mdd.deviceType = ddb.deviceType;
mdd.changed = true;
//将功率和关照的最大发生时间记录下来,稍后在优化下
if (key == MonitorType.MIC_INVERTER_TOTALYGPOWER || key == MonitorType.MIC_DETECTOR_SUNLINGHT || key == MonitorType.MIC_BUSBAR_TOTALCURRENT)
{
deviceDataCounts.Add(new DeviceDataCount()
{
deviceId = deviceID, monitorCode = key, year = int.Parse(messageHeader.year), month = int.Parse(messageHeader.month), day = int.Parse(messageHeader.day), deviceTable = TableUtil.DEVICE, maxValue = newValue, maxTime = messageHeader.TimeNow, localAcceptTime = DateTime.Now
});
}
}
}
}
}
