public async Task <IList <IErrorInfo> > ValidateDualStateSwitches(DeviceConfigSwitchesRequest request)
{
IList <IErrorInfo> errors = new List <IErrorInfo>();
var cachedParamValues = await _attrCache.Get(request.DeviceType, request.ParameterGroupName);
foreach (var cacheParam in cachedParamValues)
{
DeviceConfigurationDefaultsAndConfigurations switchParams = JsonConvert.DeserializeObject <DeviceConfigurationDefaultsAndConfigurations>(cacheParam.DefaultValueJSON);
if (!switchParams.Configurations.SwitchesConfig.isSingleState)
{
return(errors);
}
}
errors.Add(GetValidationResult(ErrorCodes.DeviceTypeNotSupported, string.Format(Utils.GetEnumDescription(ErrorCodes.DeviceTypeNotSupported), request.DeviceType), true, MethodBase.GetCurrentMethod().Name));
return(errors);
}
public async Task <IList <IErrorInfo> > Validate(DeviceConfigSwitchesRequest request)
{
IList <IErrorInfo> errors = new List <IErrorInfo>();
SwitchActiveState activeState;
const string InvalidStringValue = "$#$#$";
SwitchMonitoringStatus switchmonitoringStatus;
var cachedParamValues = await _attrCache.Get(request.DeviceType, request.ParameterGroupName);
if (request.SingleStateSwitches != null)
{
foreach (var singleStateSwitch in request.SingleStateSwitches)
{
var switchParams = JsonConvert.DeserializeObject <DeviceConfigurationDefaultsAndConfigurations>(cachedParamValues.First(param => string.Compare(singleStateSwitch.SwitchParameterName, param.ParameterName, true) == 0).DefaultValueJSON);
if (string.IsNullOrEmpty(singleStateSwitch.SwitchName))
{
errors.Add(GetValidationResult(ErrorCodes.SwitchNameNull, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchNameNull), singleStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (!string.IsNullOrEmpty(singleStateSwitch.SwitchName) && singleStateSwitch.SwitchName.Length > 64)
{
errors.Add(GetValidationResult(ErrorCodes.SwitchNameInvalid, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchNameInvalid), singleStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (string.IsNullOrEmpty(Convert.ToString(singleStateSwitch.SwitchSensitivity)))
{
errors.Add(GetValidationResult(ErrorCodes.SwitchSensitivityNull, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchSensitivityNull), singleStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (singleStateSwitch.SwitchSensitivity > 6550 || singleStateSwitch.SwitchSensitivity < 0)
{
errors.Add(GetValidationResult(ErrorCodes.SwitchSensitivityInvalid, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchSensitivityInvalid), singleStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (!string.IsNullOrEmpty(singleStateSwitch.SwitchActiveState) && !(Enum.TryParse(singleStateSwitch.SwitchActiveState, out activeState)))
{
errors.Add(GetValidationResult(ErrorCodes.SwitchActiveStatusInvalid, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchActiveStatusInvalid), singleStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (!string.IsNullOrEmpty(singleStateSwitch.SwitchMonitoringStatus) && !(Enum.TryParse(singleStateSwitch.SwitchMonitoringStatus, out switchmonitoringStatus)))
{
errors.Add(GetValidationResult(ErrorCodes.SwitchMonitoringStatusInvalid, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchMonitoringStatusInvalid), singleStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (singleStateSwitch.SwitchNumber != switchParams.Configurations.SwitchesConfig.SwitchNumber)
{
errors.Add(GetValidationResult(ErrorCodes.SwitchNumberInvalid, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchNumberInvalid), singleStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (!cachedParamValues.Any(paramValue => string.Compare(paramValue.ParameterName, singleStateSwitch.SwitchParameterName) == 0))
{
errors.Add(GetValidationResult(ErrorCodes.InvalidParameters, Utils.GetEnumDescription(ErrorCodes.InvalidParameters), true, MethodBase.GetCurrentMethod().Name));
}
var propNames = singleStateSwitch.GetType().GetProperties().Select(props => props.Name);
var attributeNames = propNames.Distinct();
var requestAttributesId = _attributeMaps.Values.Where(maps => attributeNames.Contains(maps.Value)).ToDictionary(key => key.Key);
var paramAttrId = cachedParamValues.Where(paramValue => string.Compare(paramValue.ParameterName, singleStateSwitch.SwitchParameterName) == 0);
var uniqueAttributeIdsForDevice = paramAttrId.Select(paramValues => paramValues.AttributeName.ToString()).Distinct();
if (uniqueAttributeIdsForDevice.Any(attrID => !requestAttributesId.ContainsKey(attrID)))
{
errors.Add(GetValidationResult(ErrorCodes.InvalidAttributes, Utils.GetEnumDescription(ErrorCodes.InvalidAttributes), true, MethodBase.GetCurrentMethod().Name));
}
}
}
if (request.DualStateSwitches != null)
{
foreach (var dualStateSwitch in request.DualStateSwitches)
{
DeviceConfigurationDefaultsAndConfigurations switchParams = JsonConvert.DeserializeObject <DeviceConfigurationDefaultsAndConfigurations>(cachedParamValues.First(param => string.Compare(dualStateSwitch.SwitchParameterName, param.ParameterName, true) == 0).DefaultValueJSON);
if (!Convert.ToBoolean(dualStateSwitch.SwitchEnabled))
{
continue;
}
if (dualStateSwitch.SwitchNumber != switchParams.Configurations.SwitchesConfig.SwitchNumber || dualStateSwitch.SwitchNumber == 0)
{
errors.Add(GetValidationResult(ErrorCodes.SwitchNumberInvalid, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchNumberInvalid), dualStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (string.IsNullOrEmpty(dualStateSwitch.SwitchName))
{
errors.Add(GetValidationResult(ErrorCodes.SwitchNameNull, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchNameNull), dualStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (!string.IsNullOrEmpty(dualStateSwitch.SwitchName) && dualStateSwitch.SwitchName.Length > 64)
{
errors.Add(GetValidationResult(ErrorCodes.SwitchNameInvalid, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchNameInvalid), dualStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (string.IsNullOrEmpty(dualStateSwitch.SwitchOpen))
{
errors.Add(GetValidationResult(ErrorCodes.SwitchOpenNull, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchOpenNull), dualStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (string.IsNullOrEmpty(dualStateSwitch.SwitchClosed))
{
errors.Add(GetValidationResult(ErrorCodes.SwitchCloseNull, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchCloseNull), dualStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (!string.IsNullOrEmpty(dualStateSwitch.SwitchOpen) && dualStateSwitch.SwitchOpen.Length > 64)
{
errors.Add(GetValidationResult(ErrorCodes.SwitchOpenInvalid, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchOpenInvalid), dualStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (!string.IsNullOrEmpty(dualStateSwitch.SwitchClosed) && dualStateSwitch.SwitchClosed.Length > 64)
{
errors.Add(GetValidationResult(ErrorCodes.SwitchClosedInvalid, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchClosedInvalid), dualStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (dualStateSwitch.SwitchSensitivity > 6550 || dualStateSwitch.SwitchSensitivity < 0)
{
errors.Add(GetValidationResult(ErrorCodes.SwitchSensitivityDualStateSwitchInvalid, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchSensitivityDualStateSwitchInvalid), dualStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (!(string.IsNullOrEmpty(dualStateSwitch.SwitchMonitoringStatus) || string.Compare(dualStateSwitch.SwitchMonitoringStatus, InvalidStringValue, StringComparison.OrdinalIgnoreCase) == 0) && !(Enum.TryParse(dualStateSwitch.SwitchMonitoringStatus, out switchmonitoringStatus)))
{
errors.Add(GetValidationResult(ErrorCodes.SwitchActiveStatusInvalid, string.Format(Utils.GetEnumDescription(ErrorCodes.SwitchActiveStatusInvalid), dualStateSwitch.SwitchParameterName), true, MethodBase.GetCurrentMethod().Name));
}
if (!cachedParamValues.Any(paramValue => string.Compare(paramValue.ParameterName, dualStateSwitch.SwitchParameterName) == 0))
{
errors.Add(GetValidationResult(ErrorCodes.InvalidParameters, Utils.GetEnumDescription(ErrorCodes.InvalidParameters), true, MethodBase.GetCurrentMethod().Name));
}
var propNames = dualStateSwitch.GetType().GetProperties().Select(props => props.Name);
var attributeNames = propNames.Distinct();
var requestAttributesId = _attributeMaps.Values.Where(maps => attributeNames.Contains(maps.Value)).ToDictionary(key => key.Key);
var paramAttrId = cachedParamValues.Where(paramValue => string.Compare(paramValue.ParameterName, dualStateSwitch.SwitchParameterName) == 0);
var uniqueAttributeIdsForDevice = paramAttrId.Select(paramValues => paramValues.AttributeName.ToString()).Distinct();
if (uniqueAttributeIdsForDevice.Any(attrID => !requestAttributesId.ContainsKey(attrID)))
{
errors.Add(GetValidationResult(ErrorCodes.InvalidAttributes, Utils.GetEnumDescription(ErrorCodes.InvalidAttributes), true, MethodBase.GetCurrentMethod().Name));
}
}
}
return(errors);
}
public async override Task <DeviceConfigServiceResponse <ParameterDetails> > Fetch(DeviceConfigParameterRequest request)
{
try
{
List <IErrorInfo> errorsInfo = new List <IErrorInfo>();
base._loggingService.Debug("Started executing method", string.Format(logMethodFormat, "Fetch"));
base._loggingService.Debug("Started validation for request : " + JsonConvert.SerializeObject(request), string.Format(logMethodFormat, "Fetch"));
errorsInfo.AddRange(await base.Validate <DeviceConfigParameterRequest>(_parameterGroupValidators, request));
errorsInfo.AddRange(await base.Validate <DeviceConfigRequestBase>(_deviceConfigBaseValidators, request));
errorsInfo.AddRange(await base.Validate <IServiceRequest>(_serviceRequestValidators, request));
base.CheckForInvalidRecords(request, errorsInfo, false);
base._loggingService.Debug("Ended validation", string.Format(logMethodFormat, "Fetch"));
base._loggingService.Info("Device Type Parameter for request : " + JsonConvert.SerializeObject(request), string.Format(logMethodFormat, "Fetch"));
var parametersDto = await this._deviceConfigParamRepository.FetchDeviceTypeParameters(new DeviceParamDto
{
TypeName = request.DeviceType,
ParameterGroupId = request.ParameterGroupID,
ParameterGroupName = request.ParameterGroupName
});
var parameterDetails = base._mapper.Map <List <ParameterDetails> >(parametersDto);
base._loggingService.Debug("Ended executing method", string.Format(logMethodFormat, "Fetch"));
if (request.ParameterGroupID == 4)
{
var cacheParameter = await _parameterAttributeCache.Get(request.DeviceType);
parameterDetails = new List <ParameterDetails>();
parametersDto.ToList()
.ForEach(dto =>
{
DeviceConfigurationDefaultsAndConfigurations switchParams = JsonConvert.DeserializeObject <DeviceConfigurationDefaultsAndConfigurations>(cacheParameter.First(param => String.Compare(dto.Name, param.ParameterName, StringComparison.OrdinalIgnoreCase) == 0).DefaultValueJSON);
if (!parameterDetails.Any(det => det.Id == dto.Id) && !switchParams.Configurations.SwitchesConfig.isTampered)
{
parameterDetails.Add(_mapper.Map <ParameterDetails>(dto));
}
});
parameterDetails.ForEach(paramDet =>
{
DeviceConfigurationDefaultsAndConfigurations switchParams = JsonConvert.DeserializeObject <DeviceConfigurationDefaultsAndConfigurations>(cacheParameter.First(param => string.Compare(paramDet.Name, param.ParameterName, StringComparison.OrdinalIgnoreCase) == 0).DefaultValueJSON);
paramDet.Attributes = parametersDto.Where(paramObj => paramDet.Id == paramObj.Id && paramDet.Name == paramObj.Name)
.Select(paramObj =>
new Attributes
{
AttributeId = paramObj.AttributeId,
AttributeName = paramObj.AttributeName,
DisplayName = paramObj.AttributeName
}).ToArray();
paramDet.settings = new Dictionary <string, string>();
paramDet.settings.Add("type", switchParams.Configurations.SwitchesConfig.isSingleState ? SwitchType.SingleStateSwitch.ToString() : SwitchType.DualStateSwitch.ToString());
paramDet.settings.Add("switchNumber", Convert.ToString(switchParams.Configurations.SwitchesConfig.MaskedSwitchNumber == 0 ? switchParams.Configurations.SwitchesConfig.SwitchNumber : switchParams.Configurations.SwitchesConfig.MaskedSwitchNumber));
paramDet.settings.Add("switchPhysicalNumber", Convert.ToString(switchParams.Configurations.SwitchesConfig.SwitchNumber));
paramDet.settings.Add("switchLabel", Convert.ToString(switchParams.Configurations.SwitchesConfig.SwitchLabel));
if (!switchParams.Configurations.SwitchesConfig.isSingleState)
{
paramDet.settings.Add("switchPowerType", Convert.ToString(switchParams.Configurations.SwitchesConfig.SwitchPowerType));
}
});
}
return(new DeviceConfigServiceResponse <ParameterDetails>(parameterDetails, errorsInfo));
}
catch (Exception ex)
{
this._loggingService.Error("An Exception has occurred", string.Format(logMethodFormat, "Fetch"), ex);
throw ex;
}
}
protected override IList <TOut> BuildResponse <TIn, TOut>(TIn request, IList <DeviceConfigDto> deviceConfigDtos)
{
this._loggingService.Info("Building Response objects from DeviceConfigDtos", "DeviceConfigMetersService.BuildResponse");
List <TOut> deviceConfigServiceResponseDetails = new List <TOut>();
var cachedParameterAttributes = this._parameterAttributeCache.Get(request.DeviceType, request.ParameterGroupName).Result;
var assetDevices = this._assetDeviceRepository.Fetch(string.Join(",", request.AssetUIDs.Select(assetUID => "UNHEX('" + assetUID + "')").ToArray())).Result;
var hoursMeter = cachedParameterAttributes.FirstOrDefault(x => x.AttributeName == "HoursMeter");
var odometer = cachedParameterAttributes.FirstOrDefault(x => x.AttributeName == "Odometer");
var smhOdometerConfig = cachedParameterAttributes.FirstOrDefault(x => x.AttributeName == "SMHOdometerConfig");
foreach (var deviceConfigs in deviceConfigDtos.GroupBy(x => x.AssetUIDString))
{
DeviceConfigMetersDetails result = new DeviceConfigMetersDetails();
DeviceConfigDto configDto = null;
DeviceConfigurationDefaultsAndConfigurations hourMeterDeserializedObject = null;
DeviceConfigurationDefaultsAndConfigurations odoMeterDeserializedObject = null;
var metersRequest = request as DeviceConfigMetersRequest;
if (odometer != null)
{
result.OdoMeter = new MeterModel();
result.OdoMeter.CanUpdate = true;
}
if (hoursMeter != null)
{
result.HoursMeter = new MeterModel();
result.HoursMeter.CanUpdate = true;
}
if (hoursMeter != null && !string.IsNullOrEmpty(hoursMeter.DefaultValueJSON))
{
hourMeterDeserializedObject = JsonConvert.DeserializeObject <DeviceConfigurationDefaultsAndConfigurations>(hoursMeter.DefaultValueJSON);
}
if (odometer != null && !string.IsNullOrEmpty(odometer.DefaultValueJSON))
{
odoMeterDeserializedObject = JsonConvert.DeserializeObject <DeviceConfigurationDefaultsAndConfigurations>(odometer.DefaultValueJSON);
}
if (odoMeterDeserializedObject != null && odoMeterDeserializedObject.Configurations != null)
{
if (result.OdoMeter != null)
{
result.OdoMeter.AllowBackward = odoMeterDeserializedObject.Configurations.MetersConfig.AllowBackward;
}
}
if (hourMeterDeserializedObject != null && hourMeterDeserializedObject.Configurations != null)
{
if (result.HoursMeter != null)
{
result.HoursMeter.AllowBackward = hourMeterDeserializedObject.Configurations.MetersConfig.AllowBackward;
}
}
if (smhOdometerConfig != null)
{
if (deviceConfigs.Any(x => x.AttributeName == "SMHOdometerConfig" && x.AttributeValue == MetersSmhOdometerConfig.J1939.ToString()))
{
if (result.HoursMeter != null)
{
result.HoursMeter.CanUpdate = false;
}
}
}
if (assetDevices != null && assetDevices.Count() > 0)
{
var device = assetDevices.FirstOrDefault(x => x.AssetUID == deviceConfigs.FirstOrDefault().AssetUID&& string.Compare(x.DeviceType, request.DeviceType) == 0);
//CatVIMS check
if (device != null &&
hourMeterDeserializedObject != null &&
hourMeterDeserializedObject.Configurations != null &&
hourMeterDeserializedObject.Configurations.MetersConfig != null &&
hourMeterDeserializedObject.Configurations.MetersConfig.NotAllowedModuleType != null &&
hourMeterDeserializedObject.Configurations.MetersConfig.NotAllowedModuleType.Contains(device.ModuleType))
{
if (result.HoursMeter != null)
{
result.HoursMeter.CanUpdate = false;
}
}
}
foreach (var deviceConfig in deviceConfigs)
{
switch (deviceConfig.AttributeName)
{
case "SMHOdometerConfig":
result.SmhOdometerConfig = deviceConfig.AttributeValue;
break;
case "Odometer":
if (!string.IsNullOrEmpty(deviceConfig.AttributeValue))
{
result.OdoMeter.Value = Convert.ToDouble(deviceConfig.AttributeValue);
}
break;
case "HoursMeter":
if (!string.IsNullOrEmpty(deviceConfig.AttributeValue))
{
result.HoursMeter.Value = Convert.ToDouble(deviceConfig.AttributeValue);
}
break;
}
if (configDto == null)
{
configDto = deviceConfig;
}
}
if (configDto != null)
{
result.AssetUID = Guid.Parse(configDto.AssetUIDString);
result.LastUpdatedOn = Convert.ToDateTime(configDto.UpdateUTC);
}
deviceConfigServiceResponseDetails.Add(result as TOut);
}
return(deviceConfigServiceResponseDetails);
}
