/// <summary>
/// Rules enable you to monitor your devices in near real-time and automatically invoke actions, such as send emails, show UI notifications, etc.
/// whenever the rule is matched. In a rule, you can define the condition for which you wish to monitor your device and configure the corresponding actions.
/// Rule triggers when the selected device telemetry crosses a specified threshold mentioned in the condition.
/// This API endpoint allows you to create rules.Here name, templateGuid, severityLevelGuid,
/// ruleType and applyTo are mandatory for any template rule.conditionText needs a condition on attribute values.If the condition is true,
/// it is considered as the rule matched.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <DataResponse <AddRuleResult> > Add(AddRuleModel model)
{
try
{
var json = JsonConvert.SerializeObject(model);
var errorList = Helper.ValidateObject(model);
if (model?.deliveryMethod == null)
{
ErrorItemModel errorItemModel = new ErrorItemModel()
{
Message = "DeliveryMethod is required",
Param = "deliveryMethod"
};
errorList.Add(errorItemModel);
}
if (errorList?.Count > 0)
{
return(new DataResponse <AddRuleResult>(null)
{
errorMessages = errorList,
message = "Data Error",
status = false
});
}
var portalApi = await _ioTConnectAPIDiscovery.GetPortalUrl(_envCode, _solutionKey, IoTConnectBaseURLType.DeviceBaseUrl);
string accessTokenUrl = string.Concat(portalApi, RuleApi.RuleAdd);
string formattedUrl = String.Format(accessTokenUrl, Constants.userVersion);
var result = await formattedUrl.WithHeaders(new { Content_type = Constants.contentType, Authorization = Constants.bearerTokenType + _token })
.PostJsonAsync(model).ReceiveJson <DataResponse <List <AddRuleResult> > >();
return(new DataResponse <AddRuleResult>(null)
{
data = result.data.FirstOrDefault(),
message = result.message,
status = true,
});
}
catch (IoTConnectException ex)
{
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
errorItemModels.AddRange(ex.error);
return(new DataResponse <AddRuleResult>(null)
{
errorMessages = errorItemModels,
message = ex.message,
status = false
});
}
catch (Exception ex)
{
await _ioTConnectAPIDiscovery.LoggedException(_envCode, ex, "Rule", "Add()");
throw ex;
}
}
/// <summary>
/// Make User active or inactive.
/// </summary>
/// <param name="UserGuid">User Unique Identifier.</param>
/// <param name="Status">Status.</param>
/// <returns></returns>
public async Task <DataResponse <UpdateRoleStatusResult> > UpdateRoleStatus(string RoleGuid, bool Status)
{
try
{
if (string.IsNullOrEmpty(RoleGuid))
{
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
ErrorItemModel errorItemModel = new ErrorItemModel()
{
Message = "RoleGuid is required",
Param = "RoleGuid"
};
errorItemModels.Add(errorItemModel);
return(new DataResponse <UpdateRoleStatusResult>(null)
{
errorMessages = errorItemModels,
status = false
});
}
UpdateRoleStatusModel request = new UpdateRoleStatusModel {
isActive = Status
};
var portalApi = await _ioTConnectAPIDiscovery.GetPortalUrl(_envCode, _solutionKey, IoTConnectBaseURLType.UserBaseUrl);
string accessTokenUrl = string.Concat(portalApi, UserApi.UpdateRoleStatus);
string formattedUrl = String.Format(accessTokenUrl, Constants.userVersion, RoleGuid);
var result = await formattedUrl.WithHeaders(new { Content_type = Constants.contentType, Authorization = Constants.bearerTokenType + _token })
.PutJsonAsync(request).ReceiveJson <DataResponse <List <UpdateRoleStatusResult> > >();
return(new DataResponse <UpdateRoleStatusResult>(null)
{
data = result.data.FirstOrDefault(),
message = result.message,
status = true
});
}
catch (IoTConnectException ex)
{
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
errorItemModels.AddRange(ex.error);
return(new DataResponse <UpdateRoleStatusResult>(null)
{
errorMessages = errorItemModels,
message = ex.message,
status = false
});
}
catch (Exception ex)
{
await _ioTConnectAPIDiscovery.LoggedException(_envCode, ex, "User", "UpdateRoleStatus()");
throw ex;
}
}
/// <summary>
/// Get User information by user id.
/// </summary>
/// <param name="userGuid">User id.</param>
/// <param name="userInfoFlag">(Optional)User info. Default null.</param>
/// <returns></returns>
public async Task <DataResponse <ResponseGetUserDetailById> > Single(string userGuid, bool?userInfoFlag = null)
{
try
{
if (string.IsNullOrEmpty(userGuid))
{
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
ErrorItemModel errorItemModel = new ErrorItemModel()
{
Message = "UserGuid is required",
Param = "UserGuid"
};
errorItemModels.Add(errorItemModel);
return(new DataResponse <ResponseGetUserDetailById>(null)
{
errorMessages = errorItemModels,
message = "Data Error",
status = false
});
}
var portalApi = await _ioTConnectAPIDiscovery.GetPortalUrl(_envCode, _solutionKey, IoTConnectBaseURLType.UserBaseUrl);
string accessTokenUrl = string.Concat(portalApi, UserApi.Get);
string formattedUrl = String.Format(accessTokenUrl, Constants.userVersion, userGuid);
var user = await formattedUrl.WithHeaders(new { Content_type = Constants.contentType, Authorization = Constants.bearerTokenType + _token })
.SetQueryParam("userInfoFlag", userInfoFlag)
.GetJsonAsync <DataResponse <List <ResponseGetUserDetailById> > >();
return(new DataResponse <ResponseGetUserDetailById>(null)
{
data = user.data.FirstOrDefault(),
message = user.message,
status = true
});
}
catch (IoTConnectException ex)
{
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
errorItemModels.AddRange(ex.error);
return(new DataResponse <ResponseGetUserDetailById>(null)
{
errorMessages = errorItemModels,
message = ex.message,
status = false
});
}
catch (Exception ex)
{
await _ioTConnectAPIDiscovery.LoggedException(_envCode, ex, "User", "Single()");
throw ex;
}
}
/// <summary>
/// This API endpoint allows you to delete a rule. For that, you need to send ruleGuid in request url.
/// </summary>
/// <param name="ruleGuid"></param>
/// <returns></returns>
public async Task <DataResponse <DeleteRuleResult> > Delete(string ruleGuid)
{
try
{
if (string.IsNullOrEmpty(ruleGuid))
{
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
ErrorItemModel errorItemModel = new ErrorItemModel()
{
Message = "RuleGuid is required",
Param = "RuleGuid"
};
errorItemModels.Add(errorItemModel);
return(new DataResponse <DeleteRuleResult>(null)
{
errorMessages = errorItemModels,
status = false
});
}
DeleteRuleResult deleteTemplate = new DeleteRuleResult();
var portalApi = await _ioTConnectAPIDiscovery.GetPortalUrl(_envCode, _solutionKey, IoTConnectBaseURLType.DeviceBaseUrl);
string accessTokenUrl = string.Concat(portalApi, RuleApi.RuleDelete);
string formattedUrl = String.Format(accessTokenUrl, Constants.deviceVersion, ruleGuid);
var ruleDelete = await formattedUrl.WithHeaders(new { Content_type = Constants.contentType, Authorization = Constants.bearerTokenType + _token })
.SendJsonAsync(HttpMethod.Delete, deleteTemplate).ReceiveJson <DataResponse <List <DeleteRuleResult> > >();
return(new DataResponse <DeleteRuleResult>(null)
{
data = ruleDelete.data.FirstOrDefault(),
message = ruleDelete.message,
status = ruleDelete.status
});
}
catch (IoTConnectException ex)
{
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
errorItemModels.AddRange(ex.error);
return(new DataResponse <DeleteRuleResult>(null)
{
errorMessages = errorItemModels,
message = ex.message,
status = false
});
}
catch (Exception ex)
{
await _ioTConnectAPIDiscovery.LoggedException(_envCode, ex, "Rule", "Delete()");
throw ex;
}
}
/// <summary>
/// Get entity detail.
/// </summary>
/// <param name="entityGuid">The entity unique identifier.</param>
/// <returns></returns>
public async Task <DataResponse <SingleEntityResult> > Single(string entityGuid)
{
try
{
if (string.IsNullOrEmpty(entityGuid))
{
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
ErrorItemModel errorItemModel = new ErrorItemModel()
{
Message = "EntityGuid is required",
Param = "EntityGuid"
};
errorItemModels.Add(errorItemModel);
return(new DataResponse <SingleEntityResult>(null)
{
errorMessages = errorItemModels,
status = false
});
}
var portalApi = await _ioTConnectAPIDiscovery.GetPortalUrl(_envCode, _solutionKey, IoTConnectBaseURLType.UserBaseUrl);
string accessTokenUrl = string.Concat(portalApi, EntityApi.Single);
string formattedUrl = String.Format(accessTokenUrl, Constants.entityVersion, entityGuid);
var entity = await formattedUrl.WithHeaders(new { Content_type = Constants.contentType, Authorization = Constants.bearerTokenType + _token })
.GetJsonAsync <DataResponse <List <SingleEntityResult> > >();
return(new DataResponse <SingleEntityResult>(null)
{
data = entity.data.FirstOrDefault(),
message = entity.message,
status = entity.status
});
}
catch (IoTConnectException ex)
{
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
errorItemModels.AddRange(ex.error);
return(new DataResponse <SingleEntityResult>(null)
{
errorMessages = errorItemModels,
message = ex.message,
status = false
});
}
catch (Exception ex)
{
await _ioTConnectAPIDiscovery.LoggedException(_envCode, ex, "Entity", "Single()");
throw ex;
}
}
/// <summary>
/// This API endpoint gives you the list of delivery methods for the event.
/// For that, you need to send the event’s eventId in request url.
/// </summary>
/// <param name="eventId"></param>
/// <returns></returns>
public async Task <DataResponse <List <EventDeliveryMethod> > > EventDeliveryMethod(string eventId)
{
try
{
if (string.IsNullOrEmpty(eventId))
{
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
ErrorItemModel errorItemModel = new ErrorItemModel()
{
Message = "The value 'delivery-method' is not valid.",
Param = "eventId"
};
errorItemModels.Add(errorItemModel);
return(new DataResponse <List <EventDeliveryMethod> >(null)
{
errorMessages = errorItemModels,
status = false
});
}
var portalApi = await _ioTConnectAPIDiscovery.GetPortalUrl(_envCode, _solutionKey, IoTConnectBaseURLType.EventBaseUrl);
string accessTokenUrl = string.Concat(portalApi, RuleApi.EventDeliveryMethod);
string formattedUrl = String.Format(accessTokenUrl, Constants.eventVersion, eventId);
var deliveryMethods = await formattedUrl.WithHeaders(new { Content_type = Constants.contentType, Authorization = Constants.bearerTokenType + _token })
.GetJsonAsync <DataResponse <List <EventDeliveryMethod> > >();
return(new DataResponse <List <EventDeliveryMethod> >(null)
{
data = deliveryMethods.data,
message = deliveryMethods.message,
status = true
});
}
catch (IoTConnectException ex)
{
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
errorItemModels.AddRange(ex.error);
return(new DataResponse <List <EventDeliveryMethod> >(null)
{
errorMessages = errorItemModels,
message = ex.message,
status = false
});
}
catch (Exception ex)
{
await _ioTConnectAPIDiscovery.LoggedException(_envCode, ex, "Rule", "EventDeliveryMethod()");
throw ex;
}
}
/// <summary>
/// This Method provides you the lookup list of available template attributes in your device template. For that, you need to send deviceTemplateGuid in request url.
/// </summary>
/// <param name="deviceTemplateGuid">Device Template Guid</param>
/// <returns></returns>
public async Task <DataResponse <List <TemplateAttributeLookupResult> > > AllAttributeLookup(string deviceTemplateGuid)
{
try
{
if (string.IsNullOrEmpty(deviceTemplateGuid))
{
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
ErrorItemModel errorItemModel = new ErrorItemModel()
{
Message = "DeviceTemplateGuid is required",
Param = "DeviceTemplateGuid"
};
errorItemModels.Add(errorItemModel);
return(new DataResponse <List <TemplateAttributeLookupResult> >(null)
{
errorMessages = errorItemModels,
status = false
});
}
var portalApi = await _ioTConnectAPIDiscovery.GetPortalUrl(_envCode, _solutionKey, IoTConnectBaseURLType.DeviceBaseUrl);
string accessTokenUrl = string.Concat(portalApi, MasterApi.AllAttributeLookup);
string formattedUrl = String.Format(accessTokenUrl, Constants.deviceVersion, deviceTemplateGuid);
var result = await formattedUrl.WithHeaders(new { Content_type = Constants.contentType, Authorization = Constants.bearerTokenType + _token })
.GetJsonAsync <DataResponse <List <TemplateAttributeLookupResult> > >();
return(result);
}
catch (IoTConnectException ex)
{
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
errorItemModels.AddRange(ex.error);
return(new DataResponse <List <TemplateAttributeLookupResult> >(null)
{
errorMessages = errorItemModels,
message = ex.message,
status = false
});
}
catch (Exception ex)
{
await _ioTConnectAPIDiscovery.LoggedException(_envCode, ex, "Master", "AllAttributeLookup()");
throw ex;
}
}
public static List <ErrorItemModel> ValidateObject(this object model)
{
List <ValidationResult> errors = new List <ValidationResult>();
List <ErrorItemModel> errorItemModels = new List <ErrorItemModel>();
ValidationContext context = new ValidationContext(model, null, null);
if (!Validator.TryValidateObject(model, context, errors, true))
{
for (int i = 0; i < errors?.Count; i++)
{
ErrorItemModel errorItemModel = new ErrorItemModel();
errorItemModel.Message = errors[i].ErrorMessage;
errorItemModel.Param = errors[i].MemberNames.FirstOrDefault();
errorItemModels.Add(errorItemModel);
}
return(errorItemModels);
}
return(errorItemModels);
}
