public StatusMessage ExecuteService(ExecutableServicesTypes serviceType, IPAddress address)
{
DataActionResult <string> pathResult = GetFilePath(serviceType);
if (pathResult.Status.Failure())
{
return(pathResult.Status);
}
var psi = new ProcessStartInfo(
pathResult.Result,
address.ToString()
)
{
UseShellExecute = true,
};
try
{
Process.Start(psi);
}
catch (Exception)
{
return(StatusMessage.ExecutableServiceStartError);
}
return(StatusMessage.Ok);
}
public async Task <DataActionResult <string> > GetCwsBoundingString(
int nodeId,
int cwsId
)
{
StatusMessage nodeIdValidationStatus = await ValidateNodeId(nodeId);
if (nodeIdValidationStatus.Failure())
{
return(DataActionResult <string> .Failed(nodeIdValidationStatus));
}
StatusMessage cwsIdValidationStatus =
(await GetCwsParamNumber(cwsId)).Status;
if (cwsIdValidationStatus.Failure())
{
return(DataActionResult <string> .Failed(cwsIdValidationStatus));
}
StatusMessage cwsBindingExistsStatus =
await FailIfCWSBinding_DOES_NOT_Exist(nodeId, cwsId);
if (cwsBindingExistsStatus.Failure())
{
return(DataActionResult <string> .Failed(cwsBindingExistsStatus));
}
return(await Repo.GetCwsBoundingString(nodeId, cwsId));
}
DataActionResult <string> GetFilePath(ExecutableServicesTypes key)
{
string path;
lock (_servicesData)
{
path = _servicesData[key].FilePathCache;
if (path == null || !File.Exists(path))
{
DataActionResult <FilePathData[]> pathsSearchResult =
SearchBinDirectoryForFilePaths();
if (pathsSearchResult.Status.Failure())
{
return(DataActionResult <string> .Failed(
pathsSearchResult.Status
));
}
DataActionResult <string> newServicePathResult =
FindServicePath(
_servicesData[key].StrSearchKey,
pathsSearchResult.Result
);
if (newServicePathResult.Status.Failure())
{
return(DataActionResult <string> .Failed(
newServicePathResult.Status
));
}
_servicesData[key].FilePathCache = newServicePathResult.Result;
path = newServicePathResult.Result;
}
}
return(DataActionResult <string> .Successful(path));
}
public async Task <DataActionResult <NtwkNode> > CreateNodeWithParent(
NtwkNode node,
int parentId
)
{
StatusMessage nodeIdValidationStatus = await ValidateNodeId(parentId);
if (nodeIdValidationStatus.Failure())
{
return(DataActionResult <NtwkNode> .Failed(nodeIdValidationStatus));
}
StatusMessage nodeValidationStatus = _validator.Validate(node);
if (nodeValidationStatus.Failure())
{
return(DataActionResult <NtwkNode> .Failed(nodeValidationStatus));
}
StatusMessage nameExistsStatus = await FailIfNodeNameExists(node.Name);
if (nameExistsStatus.Failure())
{
return(DataActionResult <NtwkNode> .Failed(nameExistsStatus));
}
return(FailOrConvert(
await Repo.CreateNodeWithParent(_viewToEfConverter.Convert(node), parentId),
n => _efToViewConverter.Convert(n)
));
}
public async Task <DataActionResult <IEnumerable <PingTestData> > > TestConnectionListAsync(
IEnumerable <IPAddress> ips
)
{
IEnumerable <IPAddress> ipAddresses = ips as IPAddress[] ?? ips.ToArray();
int len = ipAddresses.Count();
var results = new DataActionResult <PingTestData> [len];
int index = 0;
DataActionResult <PingTestData> firstFailed = null;
foreach (var ip in ipAddresses)
{
results[index] = await TestConnectionAsync(ip);
if (results[index].Status.Failure())
{
firstFailed = results[index];
break;
}
index++;
}
return(firstFailed != null
? DataActionResult <IEnumerable <PingTestData> >
.Failed(firstFailed.Status)
: DataActionResult <IEnumerable <PingTestData> >
.Successful(results.Select(r => r.Result)));
}
public override DataActionResult <DataContainer> GetTemplate(DataActionRequest request)
{
DataContainer result = new DataContainer();
//Dim bo As New DTVorgangsuebersichtVKStatus(Mandant)
//'UUIDs müssen erzeugt werden
result.KeyValue = String.Empty;
result.VersionStamp = String.Empty;
result.UuidValue = Guid.NewGuid().ToString();
result.Fill("DTGuid", result.UuidValue);
result.Fill("DTExceldatei", "Excel Datei");
result.Fill("DTArtikelvorlage", "Artikel");
result.Fill("DTLieferant", "Lieferant");
result.Fill("DTCountExcelRows", "2");
RowSet dtoChildExceldaten = new RowSet();
Row dtoChild = new Row();
dtoChild.UuidValue = Guid.NewGuid().ToString();
dtoChild.VersionStamp = string.Empty;
dtoChild.Fill("ID", 1);
dtoChild.Fill("Text", "Text");
dtoChildExceldaten.Add(dtoChild);
result.SetChild(dtoChildExceldaten, "Importdaten");
return(DataActionResult.Succeeded(result));
}
static DataActionResult <FilePathData[]> SearchBinDirectoryForFilePaths()
{
FilePathData[] files;
try
{
files = Directory.GetFiles(Directory.GetCurrentDirectory() + @"/bin")
.Select(f => new FilePathData()
{
FullPath = f,
Filename = Path.GetFileName(f)
})
.ToArray();
}
catch (UnauthorizedAccessException)
{
return(DataActionResult <FilePathData[]> .Failed(
StatusMessage.NotEnoughOsRightsToSearchForExecServices
));
}
catch (DirectoryNotFoundException)
{
return(DataActionResult <FilePathData[]> .Failed(
StatusMessage.CouldNotFindBinDirectoryWhileSearchingForExecutableServices
));
}
catch (IOException)
{
return(DataActionResult <FilePathData[]> .Failed(
StatusMessage.UnknownIoErrorWhileTryingToFindExecutableServices
));
}
return(DataActionResult <FilePathData[]> .Successful(files));
}
StatusMessage FailIfNameExists(DataActionResult <bool> nameExistsResult)
{
return(nameExistsResult.Status.Failure()
? StatusMessage.ErrorWhileCheckingNameExistanceInDatabase
: nameExistsResult.Result
? StatusMessage.NameAlreadyClaimed
: StatusMessage.Ok);
}
protected DataActionResult <TModelOut> FailOrConvert <TModelIn, TModelOut>(
DataActionResult <TModelIn> input,
Func <TModelIn, TModelOut> convert
)
{
return(input.Status.Failure()
? DataActionResult <TModelOut> .Failed(input.Status)
: DataActionResult <TModelOut> .Successful(convert(input.Result)));
}
protected ActionResult ObserveDataOperationResult <T>(
DataActionResult <T> dataResult
)
{
if (dataResult.Status.Failure())
{
return(BadRequest(_errAssembler.AssembleReport(dataResult.Status)));
}
return(Ok(dataResult.Result));
}
StatusMessage DsAreOk(
DataActionResult <bool> validatorResult,
StatusMessage invalidIDsMessage
)
{
return(validatorResult.Status.Failure()
? StatusMessage.ErrorWhileCheckingIdInDatabase
: validatorResult.Result == false
? invalidIDsMessage
: StatusMessage.Ok);
}
protected async Task <DataActionResult <int> > GetCwsParamNumber(int cwsId)
{
DataActionResult <int> paramNumResult =
await Repo.GetCwsParamNumber(cwsId);
return(paramNumResult.Status.Failure()
? DataActionResult <int> .Failed(StatusMessage.ErrorWhileCheckingCwsParamNumberInDatabase)
: paramNumResult.Result == -1
? DataActionResult <int> .Failed(StatusMessage.InvalidWebServiceId)
: paramNumResult);
}
protected async Task <StatusMessage> FailIfCWSBinding_DOES_NOT_Exist(int cwsId, int nodeId)
{
DataActionResult <bool> bindingExists =
await Repo.CheckIfCwsBindingExists(nodeId, cwsId);
return(bindingExists.Status.Failure()
? StatusMessage.ErrorWhileGetingExistanceOfWsBindingFromDatabase
: bindingExists.Result == false
? StatusMessage.BindingBetweenSpecifiedServiceAndNodeDoesNotExist
: StatusMessage.Ok);
}
public async Task <DataActionResult <TagFilterData> > GetProfileMonitorTagFilterData(int profileId)
{
StatusMessage profileIdValidationStatus = await ValidateProfileId(profileId);
if (profileIdValidationStatus.Failure())
{
return(DataActionResult <TagFilterData> .Failed(profileIdValidationStatus));
}
return(await Repo.GetProfileMonitorTagFilterData(profileId));
}
public async Task <DataActionResult <IEnumerable <IPAddress> > > GetNodesIPs(
IEnumerable <int> nodesIDs
)
{
var results = await Task.WhenAll(nodesIDs.Select(GetNodeIp));
var firstFailure = results.FirstOrDefault(r => r.Status.Failure());
return(firstFailure != null
? DataActionResult <IEnumerable <IPAddress> > .Failed(firstFailure.Status)
: DataActionResult <IEnumerable <IPAddress> > .Successful(results.Select(r => r.Result)));
}
public async Task <DataActionResult <IEnumerable <int> > > GetTaggedNodesIDs(
int tagId
)
{
StatusMessage tagIdValidationStatus = await ValidateTagId(tagId);
if (tagIdValidationStatus.Failure())
{
return(DataActionResult <IEnumerable <int> > .Failed(tagIdValidationStatus));
}
return(await Repo.GetTaggedNodesIDs(tagId));
}
async Task <ActionResult> ObserveDataOperationStatusWithIp(
int nodeId,
Func <IPAddress, StatusMessage> operation
)
{
DataActionResult <IPAddress> nodeIpResult = await _data.GetNodeIp(nodeId);
return(nodeIpResult.Status.Failure()
? BadRequest(nodeIpResult.Status)
: ObserveDataOperationStatus(
operation(nodeIpResult.Result)
));
}
async Task <ActionResult> ObserveAsyncDataOperationResultWithIp <T>(
int nodeId,
Func <IPAddress, Task <DataActionResult <T> > > operation
)
{
DataActionResult <IPAddress> nodeIpResult = await _data.GetNodeIp(nodeId);
return(nodeIpResult.Status.Failure()
? BadRequest(nodeIpResult.Status)
: ObserveDataOperationResult(
await operation(nodeIpResult.Result)
));
}
public async Task <ActionResult> OpenWebService(int nodeId, int cwsId)
{
DataActionResult <string> webServiceStringResult =
await _data.GetCwsBoundingString(nodeId, cwsId);
if (webServiceStringResult.Status.Failure())
{
return(ObserveDataOperationStatus(webServiceStringResult.Status));
}
return(ObserveDataOperationStatus(
_webServices.Start(webServiceStringResult.Result)
));
}
public async Task <DataActionResult <Profile> > RemoveProfile(int profileId)
{
StatusMessage profileIdValidationStatus = await ValidateProfileId(profileId);
if (profileIdValidationStatus.Failure())
{
return(DataActionResult <Profile> .Failed(profileIdValidationStatus));
}
return(FailOrConvert(
await Repo.RemoveProfile(profileId),
p => _efToViewConverter.Convert(p)
));
}
protected async Task <StatusMessage> FailIfNodeInSubtree(
int nodeId,
int subtreeRootNodeId
)
{
DataActionResult <bool> nodeInSubtree =
await Repo.CheckIfNodeInSubtree(nodeId, subtreeRootNodeId);
return(nodeInSubtree.Status.Failure()
? StatusMessage.ErrorWhileCheckingIfNodeIsPartOfSubtree
: nodeInSubtree.Result
? StatusMessage.NodeIsPartOfSpecifiedSubtree
: StatusMessage.Ok);
}
public async Task <DataActionResult <NtwkNode> > RemoveNode(int nodeId)
{
StatusMessage nodeIdValidationStatus = await ValidateNodeId(nodeId);
if (nodeIdValidationStatus.Failure())
{
return(DataActionResult <NtwkNode> .Failed(nodeIdValidationStatus));
}
return(FailOrConvert(
await Repo.RemoveNode(nodeId),
n => _efToViewConverter.Convert(n)
));
}
async Task <ActionResult> ObserveAsyncDataOperationResultWithIpList <T>(
IEnumerable <int> nodesIDs,
Func <IEnumerable <IPAddress>, Task <DataActionResult <T> > > operation
)
{
DataActionResult <IEnumerable <IPAddress> > nodesIPsResult =
await _data.GetNodesIPs(nodesIDs);
return(nodesIPsResult.Status.Failure()
? BadRequest(nodesIPsResult.Status)
: ObserveDataOperationResult(
await operation(nodesIPsResult.Result)
));
}
public async Task <DataActionResult <NodeTag> > RemoveTag(int tagId)
{
StatusMessage tagIdValidationStatus = await ValidateTagId(tagId);
if (tagIdValidationStatus.Failure())
{
return(DataActionResult <NodeTag> .Failed(tagIdValidationStatus));
}
return(FailOrConvert(
await Repo.RemoveTag(tagId),
t => _efToViewConverter.Convert(t)
));
}
public async Task <DataActionResult <IPAddress> > GetNodeIp(int nodeId)
{
StatusMessage nodeIdValidationStatus = await ValidateNodeId(nodeId);
if (nodeIdValidationStatus.Failure())
{
return(DataActionResult <IPAddress> .Failed(nodeIdValidationStatus));
}
return(FailOrConvert(
await Repo.GetNodeIp(nodeId),
nIp => new IPAddress(nIp)
));
}
public async Task <DataActionResult <CustomWebService> > RemoveCustomWebService(
int cwsId
)
{
StatusMessage idExistsStatus =
(await GetCwsParamNumber(cwsId)).Status;
if (idExistsStatus.Failure())
{
return(DataActionResult <CustomWebService> .Failed(idExistsStatus));
}
return(FailOrConvert(
await Repo.RemoveCustomWebService(cwsId),
cws => _efToViewConverter.Convert(cws)
));
}
public async Task <DataActionResult <MonitoringSession> > GetNewSession(
int profileId
)
{
StatusMessage profIdValidationStatus =
await ValidateProfileId(profileId);
if (profIdValidationStatus.Failure())
{
return(DataActionResult <MonitoringSession> .Failed(profIdValidationStatus));
}
return(FailOrConvert(
await Repo.GetNewSession(profileId),
session => _efToViewConverter.Convert(session)
));
}
public async Task <DataActionResult <IEnumerable <MonitoringSession> > > GetSessionsForProfile(int profileId)
{
StatusMessage profIdValidationStatus =
await ValidateProfileId(profileId);
if (profIdValidationStatus.Failure())
{
return(DataActionResult <IEnumerable <MonitoringSession> > .Failed(
profIdValidationStatus
));
}
return(FailOrConvert(
await Repo.GetSessionsForProfile(profileId),
sessions => sessions.Select(s => _efToViewConverter.Convert(s))
));
}
//includes messages
public async Task <DataActionResult <IEnumerable <MonitoringPulseResult> > > GetSessionReport(
int monitoringSessionId)
{
StatusMessage sessionIdValidationStatus =
await ValidateSessionId(monitoringSessionId);
if (sessionIdValidationStatus.Failure())
{
return(DataActionResult <IEnumerable <MonitoringPulseResult> > .Failed(
sessionIdValidationStatus
));
}
return(FailOrConvert(
await Repo.GetSessionReport(monitoringSessionId),
pulses => pulses.Select(ConvertPulseResult)
));
}
public async Task <DataActionResult <PingTestData> > TestConnectionAsync(
IPAddress ip
)
{
List <PingTestData> pingReplies = new List <PingTestData>();
for (int i = 0; i < _maxRetry; i++)
{
DataActionResult <PingTestData> pingResult = await PingAsync(
_ping,
ip,
_timeout,
_buffer,
_options
);
if (pingResult.Status.Failure())
{
return(DataActionResult <PingTestData> .Failed(pingResult.Status));
}
pingReplies.Add(pingResult.Result);
if (pingResult.Result.Avg < 50 && pingResult.Result.Failed == 0)
{
break;
}
}
PingTestData result = pingReplies.Aggregate((current, next) =>
{
current.Num += next.Num;
current.Avg += next.Avg;
current.Failed += next.Failed;
return(current);
});
int successful = result.Num - result.Failed;
if (successful != 0)
{
result.Avg /= successful;
}
return(DataActionResult <PingTestData> .Successful(result));
}
