private bool BuildModelData(ref ModelData modelData, IOpcuaServerApp opcuaServerData, string opcuaAppName, string modelFileName, string modelPath, string typesFileName)
{
// build model data
modelData.Name = modelFileName;
if (!ExtractNodesetUris(ref modelData, modelPath))
{
return(false);
}
modelData.Types = typesFileName;
modelData.NamespaceVariable = Constants.NodesetXml.NamespaceVariablePrefix + _fileSystem.GetFileNameWithoutExtension(modelFileName);
// check if appioproj file already contains model with imported model name
var modelName = modelData.Name;
if (opcuaServerData.Models.Any(x => x.Name == modelName))
{
AppioLogger.Warn(LoggingText.ImportInforamtionModelCommandFailureModelDuplication);
_outputMessages.Add(string.Format(OutputText.ImportInforamtionModelCommandFailureModelNameDuplication, opcuaAppName, modelFileName), string.Empty);
return(false);
}
// check if appioproj file already contains model with imported model namespace uri
var modelUri = modelData.Uri;
if (opcuaServerData.Models.Any(x => x.Uri == modelUri))
{
AppioLogger.Warn(LoggingText.ImportInforamtionModelCommandFailureModelDuplication);
_outputMessages.Add(string.Format(OutputText.ImportInforamtionModelCommandFailureModelUriDuplication, opcuaAppName, modelData.Uri), string.Empty);
return(false);
}
return(true);
}
public CommandResult Execute(IEnumerable <string> inputParams)
{
var outputMessages = new MessageLines();
var(error, stringParams, _) = _resolver.ResolveParams(inputParams);
if (error != null)
{
return(new CommandResult(false, new MessageLines {
{ error, string.Empty }
}));
}
var solutionName = stringParams[ParamId.SolutionName];
if (_fileSystem.GetInvalidFileNameChars().Any(solutionName.Contains))
{
AppioLogger.Warn(LoggingText.InvalidSolutionName);
outputMessages.Add(string.Format(OutputText.NewSlnCommandFailure, solutionName), string.Empty);
return(new CommandResult(false, outputMessages));
}
var solutionFilePath = $"{solutionName}{Constants.FileExtension.Appiosln}";
_fileSystem.CreateFile(solutionFilePath, _fileSystem.LoadTemplateFile(Resources.Resources.AppioSlnTemplateFileName));
AppioLogger.Info(string.Format(LoggingText.NewSlnCommandSuccess, solutionFilePath));
outputMessages.Add(string.Format(OutputText.NewSlnCommandSuccess, solutionName), string.Empty);
return(new CommandResult(true, outputMessages));
}
private static CommandResult FailureMissingClientServer()
{
AppioLogger.Warn(LoggingText.ImportCertificateFailureMissingClientServer);
return(new CommandResult(false, new MessageLines {
{ OutputText.ImportCertificateCommandWrongServerClient, string.Empty }
}));
}
private bool ValidateOpcuaAppName(string opcuaAppName)
{
if (_fileSystem.GetInvalidFileNameChars().Any(opcuaAppName.Contains) || !_fileSystem.DirectoryExists(opcuaAppName))
{
AppioLogger.Warn(LoggingText.InvalidOpcuaappName);
_outputMessages.Add(string.Format(OutputText.ImportInformationModelCommandInvalidOpcuaappName, opcuaAppName), string.Empty);
return(false);
}
return(true);
}
private bool ServerIsNotYetClientsReference(ref OpcuaClientApp opcuaClient, ref OpcuaClientServerApp opcuaClientServer, string clientName, string serverName)
{
if ((opcuaClient != null && opcuaClient.ServerReferences.Any(x => x.Name == serverName)) || (opcuaClientServer != null && opcuaClientServer.ServerReferences.Any(x => x.Name == serverName)))
{
AppioLogger.Warn(LoggingText.ReferenceAddServerIsPartOfClientReference);
_outputMessages.Add(string.Format(OutputText.ReferenceAddServerIsPartOfClientReference, serverName, clientName), string.Empty);
return(false);
}
return(true);
}
private bool ClientIsNotAServer(ref OpcuaClientApp opcuaClient, ref OpcuaClientServerApp opcuaClientServer, string clientName)
{
if ((opcuaClient != null && opcuaClient.Type == Constants.ApplicationType.Server) || (opcuaClientServer != null && opcuaClientServer.Type == Constants.ApplicationType.Server))
{
AppioLogger.Warn(LoggingText.ReferenceAddClientIsAServer);
_outputMessages.Add(string.Format(OutputText.ReferenceAddClientIsAServer, clientName), string.Empty);
return(false);
}
return(true);
}
private bool ValidateServer(string serverName, string serverFullName)
{
// check if server appioproj file exists
if (string.IsNullOrEmpty(serverName) || !_fileSystem.FileExists(serverFullName))
{
AppioLogger.Warn(LoggingText.ReferenceAddServerAppioprojFileNotFound);
_outputMessages.Add(string.Format(OutputText.ReferenceAddServerAppioprojFileNotFound, serverFullName), string.Empty);
return(false);
}
return(true);
}
public CommandResult Execute(IEnumerable <string> inputParams)
{
var projectName = inputParams.ElementAtOrDefault(0);
var outputMessages = new MessageLines();
// validate project name
if (string.IsNullOrEmpty(projectName))
{
AppioLogger.Warn(LoggingText.EmptyOpcuaappName);
outputMessages.Add(OutputText.OpcuaappPublishFailure, string.Empty);
return(new CommandResult(false, outputMessages));
}
// build string with publish command source location
var projectBuildDirectory = _fileSystem.CombinePaths(projectName, Constants.DirectoryName.MesonBuild);
var appClientBuildLocation = _fileSystem.CombinePaths(projectBuildDirectory, Constants.ExecutableName.AppClient);
var appServerBuildLocation = _fileSystem.CombinePaths(projectBuildDirectory, Constants.ExecutableName.AppServer);
// build strings with publish command target location
var projectPublishDirectory = _fileSystem.CombinePaths(projectName, Constants.DirectoryName.Publish);
var appClientPublishLocation = _fileSystem.CombinePaths(projectPublishDirectory, Constants.ExecutableName.AppClient);
var appServerPublishLocation = _fileSystem.CombinePaths(projectPublishDirectory, Constants.ExecutableName.AppServer);
// check if any of client and server executables exist
if ((string.IsNullOrEmpty(appClientBuildLocation) || !_fileSystem.FileExists(appClientBuildLocation)) &&
(string.IsNullOrEmpty(appServerBuildLocation) || !_fileSystem.FileExists(appServerBuildLocation)))
{
AppioLogger.Warn(LoggingText.MissingBuiltOpcuaAppFiles);
outputMessages.Add(string.Format(OutputText.OpcuaappPublishFailureMissingExecutables, projectName), string.Empty);
return(new CommandResult(false, outputMessages));
}
// create publish directory
_fileSystem.CreateDirectory(projectPublishDirectory);
// publish client executable
if (!string.IsNullOrEmpty(appClientBuildLocation) && _fileSystem.FileExists(appClientBuildLocation))
{
_fileSystem.CopyFile(appClientBuildLocation, appClientPublishLocation);
}
// publish server executable
if (!string.IsNullOrEmpty(appServerBuildLocation) && _fileSystem.FileExists(appServerBuildLocation))
{
_fileSystem.CopyFile(appServerBuildLocation, appServerPublishLocation);
}
// return with success
AppioLogger.Info(LoggingText.OpcuaappPublishedSuccess);
outputMessages.Add(string.Format(OutputText.OpcuaappPublishSuccess, projectName), string.Empty);
return(new CommandResult(true, outputMessages));
}
public CommandResult Execute(IEnumerable <string> inputParams)
{
var outputMessages = new MessageLines();
var validationMessages = new SlnUtility.ResultMessages();
var(error, stringParams, _) = _resolver.ResolveParams(inputParams);
if (error != null)
{
return(new CommandResult(false, new MessageLines {
{ error, string.Empty }
}));
}
var solutionName = stringParams[ParamId.SolutionName];
// validate solution name
if (!SlnUtility.ValidateSolution(ref validationMessages, solutionName, _fileSystem))
{
AppioLogger.Warn(validationMessages.LoggerMessage);
outputMessages.Add(validationMessages.OutputMessage, string.Empty);
return(new CommandResult(false, outputMessages));
}
// deserialize *.appiosln file
var solutionFullName = solutionName + Constants.FileExtension.Appiosln;
Solution appioSolution = SlnUtility.DeserializeFile <Solution>(solutionFullName, _fileSystem);
if (appioSolution == null)
{
AppioLogger.Warn(LoggingText.SlnCouldntDeserliazeSln);
outputMessages.Add(string.Format(OutputText.SlnCouldntDeserliazeSln, solutionName), string.Empty);
return(new CommandResult(false, outputMessages));
}
// build projects that are part of solution
foreach (var project in appioSolution.Projects)
{
var commandResult = _subcommand.Execute(new string[] { project.Name });
if (!commandResult.Success)
{
return(commandResult);
}
}
// exit method with success
AppioLogger.Info(SuccessLoggerMessage);
outputMessages.Add(string.Format(SuccessOutputMessage, solutionName), string.Empty);
return(new CommandResult(true, outputMessages));
}
public override CommandResult Execute(IEnumerable <string> inputParams)
{
if (!ExecuteCommon(inputParams))
{
return(new CommandResult(false, _outputMessages));
}
// deserialise client file
OpcuaClientApp opcuaClient = null;
OpcuaClientServerApp opcuaClientServer = null;
RefUtility.DeserializeClient(ref opcuaClient, ref opcuaClientServer, _clientFullName, _fileSystem);
if (opcuaClient == null && opcuaClientServer == null)
{
AppioLogger.Warn(LoggingText.ReferenceCouldntDeserliazeClient);
_outputMessages.Add(string.Format(OutputText.ReferenceCouldntDeserliazeClient, _clientFullName), string.Empty);
return(new CommandResult(false, _outputMessages));
}
// check if server is part of client's reference and remove it
string clientNewContent = string.Empty;
IOpcuaServerApp serverReference = null;
if (opcuaClientServer != null && (serverReference = opcuaClientServer.ServerReferences.SingleOrDefault(x => x.Name == _serverName)) != null)
{
opcuaClientServer.ServerReferences.Remove(serverReference);
clientNewContent = JsonConvert.SerializeObject(opcuaClientServer, Formatting.Indented);
}
else if (opcuaClient != null && (serverReference = opcuaClient.ServerReferences.SingleOrDefault(x => x.Name == _serverName)) != null)
{
opcuaClient.ServerReferences.Remove(serverReference);
clientNewContent = JsonConvert.SerializeObject(opcuaClient, Formatting.Indented);
}
else
{
AppioLogger.Warn(LoggingText.ReferenceRemoveServerIsNotInClient);
_outputMessages.Add(string.Format(OutputText.ReferenceRemoveServerIsNotInClient, _serverName, _clientName), string.Empty);
return(new CommandResult(false, _outputMessages));
}
_fileSystem.WriteFile(_clientFullName, new List <string> {
clientNewContent
});
// exit method with success
AppioLogger.Info(LoggingText.ReferenceRemoveSuccess);
_outputMessages.Add(string.Format(OutputText.ReferenceRemoveSuccess, _clientName, _serverName), string.Empty);
return(new CommandResult(true, _outputMessages));
}
protected bool ExecuteCommon(IEnumerable <string> inputParams)
{
var resolver = new ParameterResolver <ParamId>(Constants.CommandName.Reference + " " + Name, new []
{
new StringParameterSpecification <ParamId>
{
Identifier = ParamId.ClientName,
Short = Constants.ReferenceCommandOptions.Client,
Verbose = Constants.ReferenceCommandOptions.VerboseClient
},
new StringParameterSpecification <ParamId>
{
Identifier = ParamId.ServerName,
Short = Constants.ReferenceCommandOptions.Server,
Verbose = Constants.ReferenceCommandOptions.VerboseServer
}
});
var(error, stringParams, _) = resolver.ResolveParams(inputParams);
if (error != null)
{
_outputMessages = new MessageLines {
{ error, string.Empty }
};
return(false);
}
_serverName = stringParams[ParamId.ServerName];
_clientName = stringParams[ParamId.ClientName];
_outputMessages = new MessageLines();
// check if client appioproj file exists
_clientFullName = _fileSystem.CombinePaths(_clientName, _clientName + Constants.FileExtension.Appioproject);
if (!_fileSystem.FileExists(_clientFullName))
{
AppioLogger.Warn(LoggingText.ReferenceClientAppioprojFileNotFound);
_outputMessages.Add(string.Format(OutputText.ReferenceClientAppioprojFileNotFound, _clientFullName), string.Empty);
return(false);
}
// exit with success
return(true);
}
private bool ValidateModel(string modelPath)
{
// model path validation
if (modelPath == string.Empty)
{
AppioLogger.Warn(LoggingText.InvalidInformationModelMissingModelFile);
_outputMessages.Add(OutputText.ImportInformationModelCommandMissingModelPath, string.Empty);
return(false);
}
if (_fileSystem.GetInvalidPathChars().Any(modelPath.Contains))
{
AppioLogger.Warn(string.Format(LoggingText.InvalidInformationModelPath, modelPath));
_outputMessages.Add(string.Format(OutputText.ImportInformationModelCommandInvalidModelPath, modelPath), string.Empty);
return(false);
}
if (!_fileSystem.FileExists(modelPath))
{
AppioLogger.Warn(string.Format(LoggingText.InvalidInformationModelNotExistingPath, modelPath));
_outputMessages.Add(string.Format(OutputText.ImportInformationModelCommandNotExistingModelPath, modelPath), string.Empty);
return(false);
}
// model file name/extension validation
var modelFileName = _fileSystem.GetFileName(modelPath);
if (_fileSystem.GetExtension(modelPath) != Constants.FileExtension.InformationModel)
{
AppioLogger.Warn(string.Format(LoggingText.InvalidInformationModelExtension, modelFileName));
_outputMessages.Add(string.Format(OutputText.ImportInformationModelCommandInvalidModelExtension, modelFileName), string.Empty);
return(false);
}
// validate model against UANodeSet xsd file
if (!_modelValidator.Validate(modelPath, Resources.Resources.UANodeSetXsdFileName))
{
AppioLogger.Warn(string.Format(LoggingText.NodesetValidationFailure, modelPath));
_outputMessages.Add(string.Format(OutputText.NodesetValidationFailure, modelPath), string.Empty);
return(false);
}
return(true);
}
private bool ExtractNodesetUris(ref ModelData modelData, string nodesetPath)
{
// read XML file
XmlDocument nodesetXml = new XmlDocument();
using (var nodesetStream = _fileSystem.ReadFile(nodesetPath))
{
StreamReader reader = new StreamReader(nodesetStream);
var xmlFileContent = reader.ReadToEnd();
nodesetXml.LoadXml(xmlFileContent);
}
// extract namespace uri
var nsmgr = new XmlNamespaceManager(nodesetXml.NameTable);
nsmgr.AddNamespace(Constants.NodesetXml.UANodeSetNamespaceShortcut, new UriBuilder(Constants.NodesetXml.UANodeSetNamespaceScheme, Constants.NodesetXml.UANodeSetNamespaceHost, Constants.NumericValues.PortNumberNotSpecified, Constants.NodesetXml.UANodeSetNamespaceValuePath).ToString());
var modelNode = nodesetXml.SelectSingleNode(string.Format(Constants.NodesetXml.UANodeSetNamespaceFullPath, Constants.NodesetXml.UANodeSetNamespaceShortcut), nsmgr);
// validate namespace uri
if (modelNode == null || modelNode.Attributes == null || modelNode.Attributes[Constants.NodesetXml.UANodeSetNamespaceModelUri] == null)
{
AppioLogger.Warn(LoggingText.ImportInforamtionModelCommandFailureModelMissingUri);
_outputMessages.Add(string.Format(OutputText.ImportInforamtionModelCommandFailureModelMissingUri, nodesetPath), string.Empty);
return(false);
}
// write namespace uri to model data
modelData.Uri = modelNode.Attributes[Constants.NodesetXml.UANodeSetNamespaceModelUri].Value;
// find required model uris and write them to model data
if (modelNode.ChildNodes.Count > 0)
{
for (int index = 0; index < modelNode.ChildNodes.Count; index++)
{
var requiredModelUri = modelNode.ChildNodes[index].Attributes[Constants.NodesetXml.UANodeSetNamespaceModelUri].Value;
if (requiredModelUri != new UriBuilder(Constants.NodesetXml.UANodeSetNamespaceScheme, Constants.NodesetXml.UANodeSetNamespaceHost, Constants.NumericValues.PortNumberNotSpecified, Constants.NodesetXml.UANodeSetNamespaceBasicValuePath).ToString())
{
modelData.RequiredModelUris.Add(requiredModelUri);
}
}
}
return(true);
}
private bool ValidateTypes(out string typesFileName, string typesPath)
{
typesFileName = _fileSystem.GetFileName(typesPath);
if (_fileSystem.GetExtension(typesPath) != Constants.FileExtension.ModelTypes)
{
AppioLogger.Warn(LoggingText.ImportInformationModelCommandFailureTypesHasInvalidExtension);
_outputMessages.Add(string.Format(OutputText.ImportInformationModelCommandFailureTypesHasInvalidExtension, typesFileName), string.Empty);
return(false);
}
if (!_fileSystem.FileExists(typesPath))
{
AppioLogger.Warn(LoggingText.ImportInformationModelCommandFailureTypesFileDoesNotExist);
_outputMessages.Add(string.Format(OutputText.ImportInformationModelCommandFailureTypesFileDoesNotExist, typesPath), string.Empty);
return(false);
}
return(true);
}
private bool DeserializeAppioprojFile(string appioprojFilePath, out IOpcuaapp opcuaappData)
{
// deserialize appioproj file
opcuaappData = Deserialize.Opcuaapp(appioprojFilePath, _fileSystem);
if (opcuaappData == null)
{
AppioLogger.Warn(LoggingText.ImportInforamtionModelCommandFailureCannotReadAppioprojFile);
_outputMessages.Add(OutputText.ImportInforamtionModelCommandFailureCannotReadAppioprojFile, string.Empty);
return(false);
}
if (opcuaappData.Type == Constants.ApplicationType.Client)
{
AppioLogger.Warn(LoggingText.ImportInformationModelCommandOpcuaappIsAClient);
_outputMessages.Add(OutputText.ImportInformationModelCommandOpcuaappIsAClient, string.Empty);
return(false);
}
return(true);
}
public void Should_LogWarnMessage()
{
// Follow the AAA pattern
// Arrange: Set up data for the test.
var warnWrittenOut = false;
var warnMessage = "warnMsg";
var loggerListenerMock = new Mock <ILoggerListener>();
loggerListenerMock.Setup(loggerListener => loggerListener.Warn(warnMessage)).Callback(delegate { warnWrittenOut = true; });
AppioLogger.RegisterListener(loggerListenerMock.Object);
// Act: Perform the action of the test.
AppioLogger.Warn(warnMessage);
// Assert: Verify the result of the test.
Assert.IsTrue(warnWrittenOut);
CleanupAppioLogger();
}
public CommandResult Execute(IEnumerable <string> inputParams)
{
var inputParamsArray = inputParams.ToArray();
var projectName = inputParamsArray.ElementAtOrDefault(0);
var outputMessages = new MessageLines();
if (string.IsNullOrEmpty(projectName) || !_fileSystem.DirectoryExists(projectName))
{
AppioLogger.Warn(LoggingText.BuildProjectDoesNotExist);
outputMessages.Add(string.Format(OutputText.OpcuaappBuildFailureProjectDoesNotExist, projectName), string.Empty);
return(new CommandResult(false, outputMessages));
}
SetServerHostnameAndPort(projectName);
SetClientReferenceToServers(projectName);
var buildDirectory = _fileSystem.CombinePaths(projectName, Constants.DirectoryName.MesonBuild);
var mesonResult = _fileSystem.CallExecutable(Constants.ExecutableName.Meson, projectName, Constants.DirectoryName.MesonBuild);
if (!mesonResult)
{
AppioLogger.Warn(LoggingText.MesonExecutableFails);
outputMessages.Add(OutputText.OpcuaappBuildFailure, string.Empty);
return(new CommandResult(false, outputMessages));
}
var ninjaResult = _fileSystem.CallExecutable(Constants.ExecutableName.Ninja, buildDirectory, string.Empty);
if (!ninjaResult)
{
AppioLogger.Warn(LoggingText.NinjaExecutableFails);
outputMessages.Add(OutputText.OpcuaappBuildFailure, string.Empty);
return(new CommandResult(false, outputMessages));
}
AppioLogger.Info(LoggingText.BuildSuccess);
outputMessages.Add(string.Format(OutputText.OpcuaappBuildSuccess, projectName), string.Empty);
return(new CommandResult(true, outputMessages));
}
public CommandResult Execute(IEnumerable <string> inputParams)
{
var projectName = inputParams.ElementAtOrDefault(0);
var outputMessages = new MessageLines();
if (string.IsNullOrEmpty(projectName))
{
AppioLogger.Warn(LoggingText.EmptyOpcuaappName);
outputMessages.Add(OutputText.OpcuaappDeployFailure, string.Empty);
return(new CommandResult(false, outputMessages));
}
var projectPublishDirectory = _fileSystem.CombinePaths(projectName, Constants.DirectoryName.Publish);
var appClientPublishLocation = _fileSystem.CombinePaths(projectPublishDirectory, Constants.ExecutableName.AppClient);
var appServerPublishLocation = _fileSystem.CombinePaths(projectPublishDirectory, Constants.ExecutableName.AppServer);
var projectDeployDirectory = _fileSystem.CombinePaths(projectName, Constants.DirectoryName.Deploy);
if (!_fileSystem.FileExists(appClientPublishLocation) && !_fileSystem.FileExists(appServerPublishLocation))
{
AppioLogger.Warn(LoggingText.MissingPublishedOpcuaAppFiles);
outputMessages.Add(string.Format(OutputText.OpcuaappDeployWithNameFailure, projectName), string.Empty);
return(new CommandResult(false, outputMessages));
}
// steps
// create deploy dir
_fileSystem.CreateDirectory(projectDeployDirectory);
// create temp dir
var tempDirectory = _fileSystem.CombinePaths(projectDeployDirectory, Constants.DirectoryName.Temp);
_fileSystem.CreateDirectory(tempDirectory);
// create needed installer structure
var zipSourceLocation = _fileSystem.CombinePaths(projectDeployDirectory, Constants.DirectoryName.Temp, Constants.DirectoryName.OpcuaappInstaller + Constants.FileExtension.ZipFile);
_fileSystem.ExtractFromZip(zipSourceLocation, tempDirectory, Resources.Resources.InstallerZipResourceName);
// copy all needed files to temp dir installer source
if (_fileSystem.FileExists(appClientPublishLocation))
{
var appClientDeployTempLocation = _fileSystem.CombinePaths(tempDirectory, Constants.DirectoryName.OpcuaappInstaller, Constants.DirectoryName.Usr, Constants.DirectoryName.Bin, Constants.ExecutableName.AppClient);
_fileSystem.CopyFile(appClientPublishLocation, appClientDeployTempLocation);
}
if (_fileSystem.FileExists(appServerPublishLocation))
{
var appServerDeployTempLocation = _fileSystem.CombinePaths(tempDirectory, Constants.DirectoryName.OpcuaappInstaller, Constants.DirectoryName.Usr, Constants.DirectoryName.Bin, Constants.ExecutableName.AppServer);
_fileSystem.CopyFile(appServerPublishLocation, appServerDeployTempLocation);
}
// create installer
var debianInstallerResult = _fileSystem.CallExecutable(Constants.ExecutableName.CreateDebianInstaller, tempDirectory, Constants.ExecutableName.CreateDebianInstallerArguments);
if (!debianInstallerResult)
{
AppioLogger.Warn(LoggingText.CreateDebianInstallerFails);
outputMessages.Add(string.Format(OutputText.OpcuaappDeployWithNameFailure, projectName), string.Empty);
return(new CommandResult(false, outputMessages));
}
// move installer to deploy dir
var installerName = Constants.DirectoryName.OpcuaappInstaller + Constants.FileExtension.DebianInstaller;
var createdInstallerPath = _fileSystem.CombinePaths(tempDirectory, installerName);
var installerTargetPath = _fileSystem.CombinePaths(projectDeployDirectory, installerName);
_fileSystem.CopyFile(createdInstallerPath, installerTargetPath);
// remove temp dir
_fileSystem.DeleteDirectory(tempDirectory);
// exit with success result
AppioLogger.Info(LoggingText.OpcuaappDeploySuccess);
outputMessages.Add(string.Format(OutputText.OpcuaappDeploySuccess, projectName), string.Empty);
return(new CommandResult(true, outputMessages));
}
public CommandResult Execute(IEnumerable <string> inputParams)
{
var outputMessages = new MessageLines();
var(error, stringParams, _) = _resolver.ResolveParams(inputParams);
if (error != null)
{
return(new CommandResult(false, new MessageLines {
{ error, string.Empty }
}));
}
var solutionName = stringParams[ParamId.SolutionName];
var projectName = stringParams[ParamId.ProjectName];
// check if solution file is existing
var solutionFullName = _fileSystem.CombinePaths(solutionName + Constants.FileExtension.Appiosln);
if (string.IsNullOrEmpty(solutionName) || !_fileSystem.FileExists(solutionFullName))
{
AppioLogger.Warn(LoggingText.SlnAppioslnFileNotFound);
outputMessages.Add(string.Format(OutputText.SlnAppioslnNotFound, solutionFullName), string.Empty);
return(new CommandResult(false, outputMessages));
}
// deserialise solution file
Solution appioSolution = SlnUtility.DeserializeFile <Solution>(solutionFullName, _fileSystem);
if (appioSolution == null)
{
AppioLogger.Warn(LoggingText.SlnCouldntDeserliazeSln);
outputMessages.Add(string.Format(OutputText.SlnCouldntDeserliazeSln, solutionName), string.Empty);
return(new CommandResult(false, outputMessages));
}
// check if the project to remove is part of the solution
var appioproj = appioSolution.Projects.SingleOrDefault(x => x.Name == projectName);
if (appioproj != null)
{
// remove opcuaapp from sln
appioSolution.Projects.Remove(appioproj);
// serialize and write sln
var slnNewContent = JsonConvert.SerializeObject(appioSolution, Formatting.Indented);
_fileSystem.WriteFile(solutionFullName, new List <string> {
slnNewContent
});
}
else
{
AppioLogger.Warn(LoggingText.SlnRemoveOpcuaappIsNotInSln);
outputMessages.Add(string.Format(OutputText.SlnRemoveOpcuaappIsNotInSln, projectName, solutionName), string.Empty);
return(new CommandResult(false, outputMessages));
}
// exit method with success
AppioLogger.Info(LoggingText.SlnRemoveSuccess);
outputMessages.Add(string.Format(OutputText.SlnRemoveSuccess, projectName, solutionName), string.Empty);
return(new CommandResult(true, outputMessages));
}
public CommandResult Execute(IEnumerable <string> inputParams)
{
var outputMessages = new MessageLines();
var messages = new Messages();
var(error, stringParams, options) = _resolver.ResolveParams(inputParams);
if (error != null)
{
return(new CommandResult(false, new MessageLines {
{ error, string.Empty }
}));
}
var opcuaAppName = stringParams[ParamId.OpcuaAppName];
var applicationType = stringParams[ParamId.ApplicationType];
var url = stringParams[ParamId.Url];
var port = stringParams[ParamId.Port];
// validate opcuaapp name
if (_fileSystem.GetInvalidFileNameChars().Any(opcuaAppName.Contains) ||
_fileSystem.GetInvalidPathChars().Any(opcuaAppName.Contains))
{
AppioLogger.Warn(LoggingText.InvalidOpcuaappName);
outputMessages.Add(string.Format(OutputText.NewOpcuaappCommandFailureInvalidProjectName, opcuaAppName),
string.Empty);
return(new CommandResult(false, outputMessages));
}
// validate opcuaapp type
if (!ValidateApplicationType(ref messages, applicationType, url, port))
{
AppioLogger.Warn(messages.loggerMessage);
outputMessages.Add(messages.outputMessage, string.Empty);
return(new CommandResult(false, outputMessages));
}
// combine project file paths
var projectFilePath =
_fileSystem.CombinePaths(opcuaAppName, $"{opcuaAppName}{Constants.FileExtension.Appioproject}");
var sourceDirectory = _fileSystem.CombinePaths(opcuaAppName, Constants.DirectoryName.SourceCode);
var mesonFilePath = _fileSystem.CombinePaths(opcuaAppName, Constants.FileName.SourceCode_meson_build);
// create project directories
_fileSystem.CreateDirectory(opcuaAppName);
_fileSystem.CreateDirectory(sourceDirectory);
IOpcuaapp opcuaapp = null;
// deploy files for opcuaapp Client
if (applicationType == Constants.ApplicationType.Client)
{
opcuaapp = new OpcuaClientApp(opcuaAppName);
_fileSystem.CreateFile(mesonFilePath,
_fileSystem.LoadTemplateFile(
Resources.Resources.AppioOpcuaAppTemplateFileName_meson_ClientType_build));
DeployTemplateOpcuaClientSourceFiles(sourceDirectory);
}
// deploy files for opcuaapp Server
else if (applicationType == Constants.ApplicationType.Server)
{
opcuaapp = new OpcuaServerApp(opcuaAppName, url, port);
_fileSystem.CreateFile(mesonFilePath,
_fileSystem.LoadTemplateFile(
Resources.Resources.AppioOpcuaAppTemplateFileName_meson_ServerType_build));
CreateModelsDirectory(opcuaAppName);
DeployTemplateOpcuaServerSourceFiles(sourceDirectory);
}
// deploy files for opcuaapp ClientServer
else if (applicationType == Constants.ApplicationType.ClientServer)
{
opcuaapp = new OpcuaClientServerApp(opcuaAppName, url, port);
_fileSystem.CreateFile(mesonFilePath,
_fileSystem.LoadTemplateFile(Resources.Resources
.AppioOpcuaAppTemplateFileName_meson_ClientServerType_build));
CreateModelsDirectory(opcuaAppName);
DeployTemplateOpcuaClientSourceFiles(sourceDirectory);
DeployTemplateOpcuaServerSourceFiles(sourceDirectory);
}
if (!options[ParamId.NoCert])
{
if (applicationType == Constants.ApplicationType.ClientServer)
{
_certificateGenerator.Generate(opcuaAppName, Constants.FileName.ClientCryptoPrefix);
_certificateGenerator.Generate(opcuaAppName, Constants.FileName.ServerCryptoPrefix);
}
else
{
_certificateGenerator.Generate(opcuaAppName);
}
}
// create *.appioproj file
var opcuaappAsJson = JsonConvert.SerializeObject(opcuaapp, Formatting.Indented);
_fileSystem.CreateFile(projectFilePath, opcuaappAsJson);
AppioLogger.Info(string.Format(LoggingText.NewOpcuaappCommandSuccess, opcuaAppName));
outputMessages.Add(string.Format(OutputText.NewOpcuaappCommandSuccess, opcuaAppName), string.Empty);
return(new CommandResult(true, outputMessages));
}
public override CommandResult Execute(IEnumerable <string> inputParams)
{
if (!ExecuteCommon(inputParams))
{
return(new CommandResult(false, _outputMessages));
}
// validate server
var serverFullName = _fileSystem.CombinePaths(_serverName, _serverName + Constants.FileExtension.Appioproject);
if (!ValidateServer(_serverName, serverFullName))
{
return(new CommandResult(false, _outputMessages));
}
// deserialize server file
OpcuaServerApp opcuaServer = SlnUtility.DeserializeFile <OpcuaServerApp>(serverFullName, _fileSystem);
if (opcuaServer == null)
{
AppioLogger.Warn(LoggingText.ReferenceAddCouldntDeserliazeServer);
_outputMessages.Add(string.Format(OutputText.ReferenceAddCouldntDeserliazeServer, serverFullName), string.Empty);
return(new CommandResult(false, _outputMessages));
}
// check if deserialized server is not a client
if (opcuaServer.Type == Constants.ApplicationType.Client)
{
AppioLogger.Warn(LoggingText.ReferenceAddClientCannotBeReferred);
_outputMessages.Add(string.Format(OutputText.ReferenceAddClientCannotBeReferred, _serverName), string.Empty);
return(new CommandResult(false, _outputMessages));
}
// deserialize client file
OpcuaClientApp opcuaClient = null;
OpcuaClientServerApp opcuaClientServer = null;
RefUtility.DeserializeClient(ref opcuaClient, ref opcuaClientServer, _clientFullName, _fileSystem);
if (opcuaClient == null && opcuaClientServer == null)
{
AppioLogger.Warn(LoggingText.ReferenceCouldntDeserliazeClient);
_outputMessages.Add(string.Format(OutputText.ReferenceCouldntDeserliazeClient, _clientFullName), string.Empty);
return(new CommandResult(false, _outputMessages));
}
// check if deserialized client is not a server
if (!ClientIsNotAServer(ref opcuaClient, ref opcuaClientServer, _clientName))
{
return(new CommandResult(false, _outputMessages));
}
// check if server is not already a part of client's references
if (!ServerIsNotYetClientsReference(ref opcuaClient, ref opcuaClientServer, _clientName, opcuaServer.Name))
{
return(new CommandResult(false, _outputMessages));
}
// overwrite client appioproj file with new server reference
string clientNewContent = string.Empty;
if (opcuaClientServer != null)
{
opcuaClientServer.ServerReferences.Add(opcuaServer);
clientNewContent = JsonConvert.SerializeObject(opcuaClientServer, Formatting.Indented);
}
else
{
opcuaClient.ServerReferences.Add(opcuaServer);
clientNewContent = JsonConvert.SerializeObject(opcuaClient, Formatting.Indented);
}
_fileSystem.WriteFile(_clientFullName, new List <string> {
clientNewContent
});
// exit with success
AppioLogger.Info(LoggingText.ReferenceAddSuccess);
_outputMessages.Add(string.Format(OutputText.RefereneceAddSuccess, _serverName, _clientName), string.Empty);
return(new CommandResult(true, _outputMessages));
}
public CommandResult Execute(IEnumerable <string> inputParams)
{
var outputMessages = new MessageLines();
var validationMessages = new SlnUtility.ResultMessages();
var(error, stringParams, _) = _resolver.ResolveParams(inputParams);
if (error != null)
{
return(new CommandResult(false, new MessageLines {
{ error, string.Empty }
}));
}
var solutionName = stringParams[ParamId.SolutionName];
var projectName = stringParams[ParamId.ProjectName];
// validate solution name
if (!SlnUtility.ValidateSolution(ref validationMessages, solutionName, _fileSystem))
{
AppioLogger.Warn(validationMessages.LoggerMessage);
outputMessages.Add(validationMessages.OutputMessage, string.Empty);
return(new CommandResult(false, outputMessages));
}
// check if *.appioproj file exists
var appioprojFilePath = _fileSystem.CombinePaths(projectName, projectName + Constants.FileExtension.Appioproject);
if (string.IsNullOrEmpty(projectName) || !_fileSystem.FileExists(appioprojFilePath))
{
AppioLogger.Warn(LoggingText.SlnAddAppioprojFileNotFound);
outputMessages.Add(string.Format(OutputText.SlnAddOpcuaappNotFound, appioprojFilePath), string.Empty);
return(new CommandResult(false, outputMessages));
}
// deserialize *.appiosln file
var solutionFullName = solutionName + Constants.FileExtension.Appiosln;
Solution appioSolution = SlnUtility.DeserializeFile <Solution>(solutionFullName, _fileSystem);
if (appioSolution == null)
{
AppioLogger.Warn(LoggingText.SlnCouldntDeserliazeSln);
outputMessages.Add(string.Format(OutputText.SlnCouldntDeserliazeSln, solutionName), string.Empty);
return(new CommandResult(false, outputMessages));
}
// deserialize *.appioproj file
OpcuaappReference appioproj = SlnUtility.DeserializeFile <OpcuaappReference>(appioprojFilePath, _fileSystem);
if (appioproj == null)
{
AppioLogger.Warn(LoggingText.SlnAddCouldntDeserliazeOpcuaapp);
outputMessages.Add(string.Format(OutputText.SlnAddCouldntDeserliazeOpcuaapp, projectName), string.Empty);
return(new CommandResult(false, outputMessages));
}
// check if sln does not contain opcuaapp yet
if (!appioSolution.Projects.Any(x => x.Name == appioproj.Name))
{
// add opcuaapp to sln
appioproj.Path = appioprojFilePath;
appioSolution.Projects.Add(appioproj);
// serialize and write sln
var slnNewContent = JsonConvert.SerializeObject(appioSolution, Formatting.Indented);
_fileSystem.WriteFile(solutionFullName, new List <string> {
slnNewContent
});
}
else
{
AppioLogger.Info(LoggingText.SlnAddContainsOpcuaapp);
outputMessages.Add(string.Format(OutputText.SlnAddContainsOpcuaapp, solutionName, projectName), string.Empty);
return(new CommandResult(false, outputMessages));
}
// exit method with success
AppioLogger.Info(LoggingText.SlnAddSuccess);
outputMessages.Add(string.Format(OutputText.SlnAddSuccess, projectName, solutionName), string.Empty);
return(new CommandResult(true, outputMessages));
}
public CommandResult Execute(IEnumerable <string> inputParams)
{
var(error, stringParams, _) = _resolver.ResolveParams(inputParams);
if (error != null)
{
return(new CommandResult(false, new MessageLines {
{ error, string.Empty }
}));
}
var projectName = stringParams[ParamId.AppName];
var outputMessages = new MessageLines();
// deserialize appioproj file
var appioprojFilePath = _fileSystem.CombinePaths(projectName, projectName + Constants.FileExtension.Appioproject);
var opcuaappData = Deserialize.Opcuaapp(appioprojFilePath, _fileSystem);
if (opcuaappData == null)
{
AppioLogger.Warn(LoggingText.GenerateInformationModelFailureCouldntDeserliazeOpcuaapp);
outputMessages.Add(string.Format(OutputText.GenerateInformationModelFailureCouldntDeserliazeOpcuaapp, projectName, appioprojFilePath), string.Empty);
return(new CommandResult(false, outputMessages));
}
if ((opcuaappData as IOpcuaClientApp)?.Type == Constants.ApplicationType.Client)
{
AppioLogger.Warn(LoggingText.GenerateInformationModelFailuteOpcuaappIsAClient);
outputMessages.Add(string.Format(OutputText.GenerateInformationModelFailuteOpcuaappIsAClient, projectName), string.Empty);
return(new CommandResult(false, outputMessages));
}
var opcuaappModels = (opcuaappData as IOpcuaServerApp)?.Models;
// check if models are valid
if (!ValidateModels(opcuaappModels))
{
AppioLogger.Warn(LoggingText.GenerateInformationModelInvalidModelsList);
outputMessages.Add(string.Format(OutputText.GenerateInformationModelInvalidModelsList, projectName), string.Empty);
return(new CommandResult(false, outputMessages));
}
// check if there is any circular dependency between models
if (SearchForCircularDependencies(opcuaappModels))
{
AppioLogger.Warn(LoggingText.GenerateInformationModelCircularDependency);
outputMessages.Add(string.Format(OutputText.GenerateInformationModelCircularDependency, projectName), string.Empty);
return(new CommandResult(false, outputMessages));
}
// sort models
SortModels(opcuaappModels);
// generate models
foreach (var model in opcuaappModels)
{
var requiredModelData = GetListOfRequiredModels(opcuaappModels, model);
if (!_nodesetGenerator.GenerateNodesetSourceCodeFiles(projectName, model, requiredModelData))
{
outputMessages.Add(_nodesetGenerator.GetOutputMessage(), string.Empty);
return(new CommandResult(false, outputMessages));
}
}
// add noodeset variables
CreateNamespaceVariables(projectName, opcuaappModels);
// exit method with positive result
AppioLogger.Info(LoggingText.GenerateInformationModelSuccess);
outputMessages.Add(string.Format(OutputText.GenerateInformationModelSuccess, projectName), string.Empty);
return(new CommandResult(true, outputMessages));
}
public CommandResult Execute(IEnumerable <string> inputParams)
{
var(error, stringParams, _) = _resolver.ResolveParams(inputParams);
if (error != null)
{
return(new CommandResult(false, new MessageLines {
{ error, string.Empty }
}));
}
var appName = stringParams[ParamId.AppName];
uint keySize, days;
try
{
keySize = uint.Parse(stringParams[ParamId.KeySize]);
days = uint.Parse(stringParams[ParamId.Days]);
}
catch (FormatException)
{
AppioLogger.Warn(LoggingText.GenerateCertificateFailureNotParsable);
return(new CommandResult(false, new MessageLines {
{ OutputText.GenerateCertificateCommandFailureNotParsable, string.Empty }
}));
}
Stream appioprojContent;
try
{
appioprojContent = _fileSystem.ReadFile(_fileSystem.CombinePaths(appName, appName + Constants.FileExtension.Appioproject));
}
catch (Exception)
{
AppioLogger.Warn(string.Format(LoggingText.GenerateCertificateFailureNotFound, appName));
return(new CommandResult(false, new MessageLines {
{ string.Format(OutputText.GenerateCertificateCommandFailureNotFound, appName), string.Empty }
}));
}
var reader = new StreamReader(appioprojContent, Encoding.ASCII);
var appType = (string)JObject.Parse(reader.ReadToEnd())["type"];
if (appType == Constants.ApplicationType.ClientServer)
{
_certificateGenerator.Generate(appName, Constants.FileName.ClientCryptoPrefix, keySize,
days, stringParams[ParamId.Org]);
_certificateGenerator.Generate(appName, Constants.FileName.ServerCryptoPrefix, keySize,
days, stringParams[ParamId.Org]);
}
else
{
_certificateGenerator.Generate(appName, string.Empty, keySize, days, stringParams[ParamId.Org]);
}
AppioLogger.Info(LoggingText.GenerateCertificateSuccess);
return(new CommandResult(true, new MessageLines {
{ string.Format(OutputText.GenerateCertificateCommandSuccess, appName), string.Empty }
}));
}
