public void ExecutionDtoExtentions_CreateResponseWriter_WasInternalService_And_ExecuteMessageXML_Success()
{
//-------------------------------Arrange----------------------------------
var mockDSFDataObject = new Mock <IDSFDataObject>();
mockDSFDataObject.Setup(o => o.Environment.HasErrors()).Returns(false);
var esbExecuteRequestMessage = "<xml>test message</xml>";
var executeMessage = new ExecuteMessage();
executeMessage.Message.Append(esbExecuteRequestMessage);
var jsonSerializer = new Dev2JsonSerializer();
var serExecuteMessage = jsonSerializer.Serialize(executeMessage);
var executionDto = new ExecutionDto
{
DataObject = mockDSFDataObject.Object,
ErrorResultTO = new ErrorResultTO(),
Request = new EsbExecuteRequest {
WasInternalService = true, ExecuteResult = new StringBuilder(serExecuteMessage)
},
Serializer = jsonSerializer,
};
var executionDtoExtentions = new ExecutionDtoExtentions(executionDto);
//-------------------------------Act--------------------------------------
executionDtoExtentions.CreateResponseWriter(new StringResponseWriterFactory());
//-------------------------------Assert-----------------------------------
Assert.AreEqual(expected: esbExecuteRequestMessage, actual: executionDto.PayLoad);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage msg = new ExecuteMessage();
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
Dev2Logger.Info("Get Dll Listings");
StringBuilder dllListing;
values.TryGetValue("currentDllListing", out dllListing);
if (dllListing != null)
{
var src = serializer.Deserialize(dllListing.ToString(), typeof(IFileListing)) as IFileListing;
try
{
msg.HasError = false;
var fileListings = GetDllListing(src);
msg.Message = serializer.SerializeToBuilder(fileListings);
}
catch (Exception ex)
{
Dev2Logger.Error(ex);
msg.HasError = true;
msg.SetMessage(ex.Message);
}
}
return(serializer.SerializeToBuilder(msg));
}
public void ExecutionDtoExtentions_CreateResponseWriter_NotWasInternalService_And_HasErrors_ShouldReturnError_Success()
{
//-------------------------------Arrange----------------------------------
var mockDSFDataObject = new Mock <IDSFDataObject>();
mockDSFDataObject.Setup(o => o.Environment.HasErrors()).Returns(true);
var esbExecuteRequest = "<xml> Execute Request test message</xml>";
var executeMessage = new ExecuteMessage();
executeMessage.Message.Append(esbExecuteRequest);
var jsonSerializer = new Dev2JsonSerializer();
var serExecuteMessage = jsonSerializer.Serialize(executeMessage);
var executionDto = new ExecutionDto
{
DataObject = mockDSFDataObject.Object,
DataListFormat = DataListFormat.CreateFormat("XML", EmitionTypes.XML, "application/xml"),
ErrorResultTO = new ErrorResultTO(),
Request = new EsbExecuteRequest {
WasInternalService = true, ExecuteResult = new StringBuilder(serExecuteMessage)
},
Serializer = jsonSerializer,
};
var executionDtoExtentions = new ExecutionDtoExtentions(executionDto);
//-------------------------------Act--------------------------------------
executionDtoExtentions.CreateResponseWriter(new StringResponseWriterFactory());
//-------------------------------Assert-----------------------------------
Assert.AreEqual(expected: esbExecuteRequest, actual: executionDto.PayLoad);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Persistence Settings Service", GlobalConstants.WarewolfInfo);
values.TryGetValue(Warewolf.Service.SavePersistenceSettings.PersistenceSettings, out StringBuilder settings);
var updatedPersistenceSettings = serializer.Deserialize <PersistenceSettingsData>(settings);
Config.Persistence.PersistenceDataSource = updatedPersistenceSettings.PersistenceDataSource;
Config.Persistence.EncryptDataSource = updatedPersistenceSettings?.EncryptDataSource ?? false;
Config.Persistence.Enable = updatedPersistenceSettings.Enable ?? false;
Config.Persistence.PrepareSchemaIfNecessary = updatedPersistenceSettings.PrepareSchemaIfNecessary ?? true;
Config.Persistence.PersistenceScheduler = updatedPersistenceSettings.PersistenceScheduler;
Config.Persistence.DashboardHostname = updatedPersistenceSettings.DashboardHostname;
Config.Persistence.DashboardName = updatedPersistenceSettings.DashboardName;
Config.Persistence.DashboardPort = updatedPersistenceSettings.DashboardPort;
Config.Persistence.ServerName = updatedPersistenceSettings.ServerName;
msg.Message = new StringBuilder();
msg.HasError = false;
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
}
return(serializer.SerializeToBuilder(msg));
}
public void PerfcounterViewModel_ResetCounters_Command_Error_ShouldCallCommunicationsController()
{
//------------Setup for test--------------------------
var mockPopupController = new Mock <IPopupController>();
mockPopupController.Setup(controller => controller.Show(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <MessageBoxButton>(), It.IsAny <MessageBoxImage>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>())).Verifiable();
CustomContainer.Register(mockPopupController.Object);
var performanceCounterTo = new PerformanceCounterTo();
performanceCounterTo.NativeCounters.Add(new TestCounter(WarewolfPerfCounterType.AverageExecutionTime));
performanceCounterTo.NativeCounters.Add(new TestCounter(WarewolfPerfCounterType.ConcurrentRequests));
var resourceId = Guid.NewGuid();
performanceCounterTo.ResourceCounters.Add(new TestResourceCounter(WarewolfPerfCounterType.AverageExecutionTime, resourceId));
performanceCounterTo.ResourceCounters.Add(new TestResourceCounter(WarewolfPerfCounterType.RequestsPerSecond, resourceId));
var perfcounterViewModel = new PerfcounterViewModel(performanceCounterTo, new Mock <IServer>().Object, () => new Mock <IResourcePickerDialog>().Object);
var mockCommsController = new Mock <ICommunicationController>();
mockCommsController.SetupAllProperties();
var executeMessage = new ExecuteMessage {
HasError = true, Message = new StringBuilder("Error")
};
mockCommsController.Setup(controller => controller.ExecuteCommand <IExecuteMessage>(It.IsAny <IEnvironmentConnection>(), It.IsAny <Guid>())).Returns(executeMessage);
perfcounterViewModel.CommunicationController = mockCommsController.Object;
//------------Execute Test---------------------------
perfcounterViewModel.ResetCountersCommand.Execute(null);
//------------Assert Results-------------------------
Assert.AreEqual("ResetPerformanceCounters", perfcounterViewModel.CommunicationController.ServiceName);
mockCommsController.Verify(controller => controller.ExecuteCommand <IExecuteMessage>(It.IsAny <IEnvironmentConnection>(), It.IsAny <Guid>()));
mockPopupController.Verify(controller => controller.Show(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <MessageBoxButton>(), It.IsAny <MessageBoxImage>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>()));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
StringBuilder resourceDefinition;
values.TryGetValue("ResourceDefinition", out resourceDefinition);
Dev2Logger.Log.Info(String.Format("Deploy Resource."));
if (resourceDefinition == null || resourceDefinition.Length == 0)
{
Dev2Logger.Log.Info(String.Format("Roles or ResourceDefinition missing"));
throw new InvalidDataContractException("Roles or ResourceDefinition missing");
}
var msg = ResourceCatalog.Instance.SaveResource(WorkspaceRepository.ServerWorkspaceID, resourceDefinition, null, "Deploy", "unknown");
WorkspaceRepository.Instance.RefreshWorkspaces();
var result = new ExecuteMessage {
HasError = false
};
result.SetMessage(msg.Message);
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return(serializer.SerializeToBuilder(result));
}
public void WorkspaceItemRepositoryAddWorkspaceItemWithNewModelWithSameNameExpectedInvokesWrite()
{
Guid workspaceID = Guid.NewGuid();
Guid serverID = Guid.NewGuid();
Guid envID = Guid.NewGuid();
var mockConn = new Mock <IEnvironmentConnection>();
mockConn.Setup(c => c.IsConnected).Returns(true);
ExecuteMessage msg = new ExecuteMessage();
msg.SetMessage("Workspace item updated");
var payload = JsonConvert.SerializeObject(msg);
mockConn.Setup(c => c.ExecuteCommand(It.IsAny <StringBuilder>(), It.IsAny <Guid>())).Returns(new StringBuilder(payload)).Verifiable();
var model1 = CreateModel(ResourceType.Service, mockConn, workspaceID, serverID, envID);
workspaceID = Guid.NewGuid();
serverID = Guid.NewGuid();
envID = Guid.NewGuid();
var model2 = CreateModel(ResourceType.Service, mockConn, workspaceID, serverID, envID);
var repositoryPath = GetUniqueRepositoryPath();
Assert.IsFalse(File.Exists(repositoryPath));
var repository = new WorkspaceItemRepository(repositoryPath);
repository.AddWorkspaceItem(model1.Object);
repository.AddWorkspaceItem(model2.Object);
Assert.IsTrue(repository.WorkspaceItems.Count == 2);
Assert.IsTrue(File.Exists(repositoryPath));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Resource Service", GlobalConstants.WarewolfInfo);
values.TryGetValue("WcfSource", out StringBuilder resourceDefinition);
var src = serializer.Deserialize <WcfServiceSourceDefinition>(resourceDefinition);
var source = new WcfSource()
{
EndpointUrl = src.EndpointUrl
};
source.Execute();
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
}
return(serializer.SerializeToBuilder(msg));
}
public void ClientScheduledResourceModel_SaveScheduledResource_HasError_CallsCommunicationsController()
{
//------------Setup for test--------------------------
var scheduledResourceForTest = new ScheduledResourceForTest();
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
var serializeObject = serializer.SerializeToBuilder(scheduledResourceForTest);
var esbPayLoad = new EsbExecuteRequest {
ServiceName = "AddScheduledResourceService"
};
esbPayLoad.AddArgument("Resource", serializeObject);
var returnMessage = new ExecuteMessage {
HasError = true, Message = new StringBuilder("Error occurred")
};
var serializedReturnMessage = serializer.SerializeToBuilder(returnMessage);
var mockEnvironmentModel = new Mock <IEnvironmentModel>();
var mockConnection = new Mock <IEnvironmentConnection>();
mockConnection.Setup(connection => connection.IsConnected).Returns(true);
mockConnection.Setup(connection => connection.ExecuteCommand(It.IsAny <StringBuilder>(), It.IsAny <Guid>(), It.IsAny <Guid>())).Verifiable();
mockConnection.Setup(connection => connection.ExecuteCommand(It.IsAny <StringBuilder>(), It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(serializedReturnMessage);
mockConnection.Setup(connection => connection.WorkspaceID).Returns(Guid.NewGuid());
mockEnvironmentModel.Setup(model => model.Connection).Returns(mockConnection.Object);
var clientScheduledResourceModel = new ClientScheduledResourceModel(mockEnvironmentModel.Object);
//------------Execute Test---------------------------
string errorMessage;
var saved = clientScheduledResourceModel.Save(scheduledResourceForTest, out errorMessage);
//------------Assert Results-------------------------
mockConnection.Verify(connection => connection.ExecuteCommand(It.IsAny <StringBuilder>(), It.IsAny <Guid>(), It.IsAny <Guid>()), Times.Once());
Assert.IsFalse(saved);
Assert.AreEqual("Error occurred", errorMessage);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var result = new ExecuteMessage {
HasError = false
};
Dev2Logger.Info("Delete Scheduled Resource Service");
StringBuilder tmp;
values.TryGetValue("Resource", out tmp);
var serializer = new Dev2JsonSerializer();
if (tmp != null)
{
var res = serializer.Deserialize <IScheduledResource>(tmp);
Dev2Logger.Info("Delete Scheduled Resource Service." + res);
using (var model = SchedulerFactory.CreateModel(GlobalConstants.SchedulerFolderId, SecurityWrapper))
{
model.DeleteSchedule(res);
}
}
else
{
Dev2Logger.Info("Delete Scheduled Resource Service. No Resource Selected");
result.Message.Append("No Resource Selected");
result.HasError = true;
}
return(serializer.SerializeToBuilder(result));
}
public void RunTestStringArgs <T>(string svcName, ExecuteMessage message, IList <Tuple <string, Object> > args, Action <T> resultAction, Func <IQueryManager, T> action)
{
//------------Setup for test--------------------------
CustomContainer.Register <IPopupController>(new PopupController());
var comms = new Mock <ICommunicationControllerFactory>();
var env = new Mock <IEnvironmentConnection>();
env.Setup(a => a.WorkspaceID).Returns(Guid.NewGuid);
env.Setup(a => a.DisplayName).Returns("localhost");
env.Setup(a => a.IsConnected).Returns(true);
var controller = new Mock <ICommunicationController>();
comms.Setup(a => a.CreateController(svcName)).Returns(controller.Object);
var queryManagerProxy = new QueryManagerProxy(comms.Object, env.Object);
controller.Setup(a => a.ExecuteCommand <ExecuteMessage>(env.Object, It.IsAny <Guid>())).Returns(message);
//------------Execute Test---------------------------
var res = action(queryManagerProxy);
//------------Assert Results-------------------------
foreach (var tuple in args)
{
controller.Verify(a => a.AddPayloadArgument(tuple.Item1, It.IsAny <string>()));
}
resultAction(res);
}
public void WorkspaceItemRepositoryRemoveWithExistingModelExpectedInvokesWrite()
{
string resourceName;
Guid workspaceID;
Guid serverID;
var mockConn = new Mock <IEnvironmentConnection>();
mockConn.Setup(c => c.IsConnected).Returns(true);
ExecuteMessage msg = new ExecuteMessage();
msg.SetMessage("Workspace item updated");
var payload = JsonConvert.SerializeObject(msg);
mockConn.Setup(c => c.ExecuteCommand(It.IsAny <StringBuilder>(), It.IsAny <Guid>())).Returns(new StringBuilder(payload)).Verifiable();
var mockResourceRepo = new Mock <IResourceRepository>();
mockResourceRepo.Setup(resourceRepository => resourceRepository.DeleteResourceFromWorkspaceAsync(It.IsAny <IContextualResourceModel>()));
var model = CreateModel(ResourceType.Service, mockConn, out resourceName, out workspaceID, out serverID, mockResourceRepo);
var repositoryPath = GetUniqueRepositoryPath();
Assert.IsFalse(File.Exists(repositoryPath));
var repository = new WorkspaceItemRepository(repositoryPath);
repository.AddWorkspaceItem(model.Object);
if (File.Exists(repositoryPath))
{
File.Delete(repositoryPath);
}
repository.Remove(model.Object);
Assert.IsTrue(File.Exists(repositoryPath));
mockResourceRepo.Verify(resourceRepository => resourceRepository.DeleteResourceFromWorkspaceAsync(It.IsAny <IContextualResourceModel>()), Times.Once());
}
/// <summary>
/// Executes the service
/// </summary>
/// <param name="values">The values.</param>
/// <param name="theWorkspace">The workspace.</param>
/// <returns></returns>
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
Dev2Logger.Info("Get COMDll Listings");
try
{
List <DllListing> dllListings;
using (Isolated <ComDllLoaderHandler> isolated = new Isolated <ComDllLoaderHandler>())
{
var openBaseKey = RegistryKey.OpenBaseKey(RegistryHive.ClassesRoot, RegistryView.Registry32);
dllListings = isolated.Value.GetListings(openBaseKey);
openBaseKey = RegistryKey.OpenBaseKey(RegistryHive.ClassesRoot, RegistryView.Registry64);
dllListings.AddRange(isolated.Value.GetListings(openBaseKey));
}
msg.Message = serializer.SerializeToBuilder(dllListings);
}
catch (COMException ex)
{
msg.HasError = true;
msg.SetMessage(ex.Message);
}
catch (Exception ex)
{
Dev2Logger.Error(ex);
msg.HasError = true;
msg.SetMessage(ex.Message);
}
return(serializer.SerializeToBuilder(msg));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
if (values == null)
{
throw new InvalidDataException("Empty values passed.");
}
StringBuilder settingsJson;
values.TryGetValue("Settings", out settingsJson);
if (settingsJson == null || settingsJson.Length == 0)
{
throw new InvalidDataException("Error: Unable to parse values.");
}
var serializer = new Dev2JsonSerializer();
var result = new ExecuteMessage {
HasError = false, Message = new StringBuilder()
};
try
{
var settings = serializer.Deserialize <Settings>(settingsJson.ToString());
WriteSecuritySettings(theWorkspace, settings, result);
WriteLoggingSettings(theWorkspace, settings, result);
}
catch (Exception ex)
{
Dev2Logger.Log.Error("Error writing settings.", ex);
result.HasError = true;
result.Message.AppendLine("Error writing settings.");
}
return(serializer.SerializeToBuilder(result));
}
public void JsonSerializer_Deserializer_WhenUsingStream_ExpectValidObject()
{
//------------Setup for test--------------------------
var theMessage =
@"Much evil soon high in hope do view. Out may few northward believing attempted. Yet timed being songs marry one defer men our. Although finished blessing do of. Consider speaking me prospect whatever if. Ten nearer rather hunted six parish indeed number. Allowance repulsive sex may contained can set suspected abilities cordially. Do part am he high rest that. So fruit to ready it being views match.
Knowledge nay estimable questions repulsive daughters boy. Solicitude gay way unaffected expression for. His mistress ladyship required off horrible disposed rejoiced. Unpleasing pianoforte unreserved as oh he unpleasant no inquietude insipidity. Advantages can discretion possession add favourable cultivated admiration far. Why rather assure how esteem end hunted nearer and before. By an truth after heard going early given he. Charmed to it excited females whether at examine. Him abilities suffering may are yet dependent.
Why end might ask civil again spoil.";
ExecuteMessage msg = new ExecuteMessage {
HasError = false
};
msg.SetMessage(theMessage);
StringBuilder buffer = new StringBuilder(JsonConvert.SerializeObject(msg));
//------------Execute Test---------------------------
Dev2JsonSerializer js = new Dev2JsonSerializer();
var result = js.Deserialize <ExecuteMessage>(buffer);
//------------Assert Results-------------------------
Assert.AreEqual(theMessage, result.Message.ToString());
}
void TryExecute(Dictionary <string, StringBuilder> values, ExecuteMessage result, StringBuilder tmp, Dev2JsonSerializer serializer)
{
if (tmp != null)
{
var res = serializer.Deserialize <IScheduledResource>(tmp);
Dev2Logger.Info("Save Scheduled Resource. Scheduled Resource:" + res, GlobalConstants.WarewolfInfo);
using (var model = SchedulerFactory.CreateModel(GlobalConstants.SchedulerFolderId, SecurityWrapper))
{
values.TryGetValue("UserName", out StringBuilder userName);
values.TryGetValue("Password", out StringBuilder password);
if (userName == null || password == null)
{
result.Message.Append(ErrorResource.NoUserNameAndPassword);
result.HasError = true;
}
else
{
values.TryGetValue("PreviousResource", out StringBuilder previousTask);
model.Save(res, userName.ToString(), password.ToString());
if (!string.IsNullOrEmpty(previousTask?.ToString()) && previousTask.ToString() != res.Name)
{
model.DeleteSchedule(new ScheduledResource(previousTask.ToString(), SchedulerStatus.Disabled, DateTime.MaxValue, null, null, Guid.NewGuid().ToString()));
}
}
}
}
else
{
result.Message.Append(ErrorResource.NoResourceSelected);
result.HasError = true;
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var result = new ExecuteMessage {
HasError = false
};
Dev2Logger.Log.Info("Find Log Directory");
try
{
var logdir = Dev2Logger.GetDirectoryPath(SettingsProvider.Instance.Configuration.Logging);
var cleanedDir = CleanUp(logdir);
result.Message.Append("<JSON>");
result.Message.Append(@"{""PathToSerialize"":""");
result.Message.Append(cleanedDir);
result.Message.Append(@"""}");
result.Message.Append("</JSON>");
}
catch (Exception ex)
{
Dev2Logger.Log.Error(ex);
result.Message.Append(ex.Message);
result.HasError = true;
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return(serializer.SerializeToBuilder(result));
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
try
{
Dev2Logger.Info("Fetch Server Log Started", GlobalConstants.WarewolfInfo);
var result = new ExecuteMessage {
HasError = false
};
if (File.Exists(_serverLogPath))
{
var fileStream = File.Open(_serverLogPath, FileMode.Open, FileAccess.Read, FileShare.Read);
using (var streamReader = new StreamReader(fileStream))
{
while (!streamReader.EndOfStream)
{
result.Message.Append(streamReader.ReadLine());
}
}
}
var serializer = new Dev2JsonSerializer();
return(serializer.SerializeToBuilder(result));
}
catch (Exception err)
{
Dev2Logger.Error("Fetch Server Log Error", err, GlobalConstants.WarewolfError);
throw;
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Test Redis Source", GlobalConstants.WarewolfInfo);
msg.HasError = false;
values.TryGetValue(Warewolf.Service.TestRedisSource.RedisSource, out StringBuilder resourceDefinition);
var redisServiceSourceDefinition = serializer.Deserialize <RedisSourceDefinition>(resourceDefinition);
var con = new RedisSources();
var result = con.Test(new RedisSource
{
HostName = redisServiceSourceDefinition.HostName,
Port = redisServiceSourceDefinition.Port,
AuthenticationType = redisServiceSourceDefinition.AuthenticationType,
Password = redisServiceSourceDefinition.Password
});
msg.HasError = false;
msg.Message = new StringBuilder(result.IsValid ? serializer.Serialize(result.Result) : result.ErrorMessage);
msg.HasError = !result.IsValid;
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
}
return(serializer.SerializeToBuilder(msg));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Resource Service", GlobalConstants.WarewolfInfo);
values.TryGetValue("ServerSettings", out StringBuilder resourceDefinition);
var updatedServerSettings = serializer.Deserialize <ServerSettingsData>(resourceDefinition);
var auditsFilePath = updatedServerSettings.AuditFilePath;
Config.Server.SaveLoggingPath(auditsFilePath);
msg.Message = new StringBuilder();
msg.HasError = false;
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
}
return(serializer.SerializeToBuilder(msg));
}
public void WorkspaceItemRepositoryUpdateWorkspaceItemWithExistingModelExpectedInvokesExecuteCommand()
{
const string ExpectedResult = "Workspace item updated";
string resourceName;
Guid workspaceID;
Guid serverID;
var mockConn = new Mock <IEnvironmentConnection>();
mockConn.Setup(c => c.IsConnected).Returns(true);
ExecuteMessage msg = new ExecuteMessage();
msg.SetMessage("Workspace item updated");
var payload = JsonConvert.SerializeObject(msg);
mockConn.Setup(c => c.ExecuteCommand(It.IsAny <StringBuilder>(), It.IsAny <Guid>())).Returns(new StringBuilder(payload)).Verifiable();
var model = CreateModel(ResourceType.Service, mockConn, out resourceName, out workspaceID, out serverID);
#region Setup ImportService - GRRR!
#endregion
var repository = new WorkspaceItemRepository(GetUniqueRepositoryPath());
repository.AddWorkspaceItem(model.Object);
var result = repository.UpdateWorkspaceItem(model.Object, true);
mockConn.Verify(c => c.ExecuteCommand(It.IsAny <StringBuilder>(), It.IsAny <Guid>()), Times.Once());
Assert.AreEqual(ExpectedResult, result.Message.ToString());
}
void CreateMessagesPrepared(CommandBehavior behavior)
{
for (var i = 0; i < _queries.Count; i++)
{
BindMessage bindMessage;
ExecuteMessage executeMessage;
if (i == 0)
{
bindMessage = _connector.BindMessage;
executeMessage = _connector.ExecuteMessage;
}
else
{
bindMessage = new BindMessage();
executeMessage = new ExecuteMessage();
}
var query = _queries[i];
bindMessage.Populate(_connector.TypeHandlerRegistry, query.InputParameters, "", query.PreparedStatementName);
if (AllResultTypesAreUnknown)
{
bindMessage.AllResultTypesAreUnknown = AllResultTypesAreUnknown;
}
else if (i == 0 && UnknownResultTypeList != null)
{
bindMessage.UnknownResultTypeList = UnknownResultTypeList;
}
_connector.AddMessage(bindMessage);
_connector.AddMessage(executeMessage.Populate("", (behavior & CommandBehavior.SingleRow) != 0 ? 1 : 0));
}
_connector.AddMessage(SyncMessage.Instance);
}
public void WorkspaceItemRepositoryRemoveWithNonExistingModelExpectedDoesNothing()
{
string resourceName;
Guid workspaceID;
Guid serverID;
var mockConn = new Mock <IEnvironmentConnection>();
mockConn.Setup(c => c.IsConnected).Returns(true);
ExecuteMessage msg = new ExecuteMessage();
msg.SetMessage("Workspace item updated");
var payload = JsonConvert.SerializeObject(msg);
mockConn.Setup(c => c.ExecuteCommand(It.IsAny <StringBuilder>(), It.IsAny <Guid>())).Returns(new StringBuilder(payload)).Verifiable();
var model = CreateModel(ResourceType.Service, mockConn, out resourceName, out workspaceID, out serverID);
var repository = new WorkspaceItemRepository(GetUniqueRepositoryPath());
repository.AddWorkspaceItem(model.Object);
Assert.AreEqual(1, repository.WorkspaceItems.Count);
model.Setup(m => m.ResourceName).Returns("Test_" + Guid.NewGuid());
repository.Remove(model.Object);
Assert.AreEqual(1, repository.WorkspaceItems.Count);
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
if (values == null)
{
throw new InvalidDataException(ErrorResource.EmptyValuesPassed);
}
values.TryGetValue("Settings", out StringBuilder settingsJson);
if (settingsJson == null || settingsJson.Length == 0)
{
throw new InvalidDataException("Error: Unable to parse values.");
}
var serializer = new Dev2JsonSerializer();
var result = new ExecuteMessage {
HasError = false, Message = new StringBuilder()
};
try
{
var settings = serializer.Deserialize <Settings>(settingsJson.ToString());
WriteSecuritySettings(theWorkspace, settings, result);
WriteLoggingSettings(theWorkspace, settings, result);
WritePerfCounterSettings(theWorkspace, settings, result);
}
catch (Exception ex)
{
Dev2Logger.Error(ErrorResource.ErrorWritingSettings, ex, GlobalConstants.WarewolfError);
result.HasError = true;
result.Message.AppendLine(ErrorResource.ErrorWritingSettings);
}
return(serializer.SerializeToBuilder(result));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Test connection Service", GlobalConstants.WarewolfInfo);
values.TryGetValue("ServerSource", out StringBuilder resourceDefinition);
IServerSource src = serializer.Deserialize <ServerSource>(resourceDefinition);
var connection = new Connection
{
Address = src.Address,
AuthenticationType = src.AuthenticationType,
UserName = src.UserName,
Password = src.Password
};
var result = _connections.CanConnectToServer(connection);
msg.HasError = false;
msg.Message = new StringBuilder(result.IsValid ? "" : result.ErrorMessage);
msg.HasError = !result.IsValid;
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
}
return(serializer.SerializeToBuilder(msg));
}
static T CheckAuthorization <T>(ExecuteMessage message) where T : class
{
if (message != null)
{
var s = ContainsAuthorizationError(message.Message.ToString(), out bool containsAuthorization);
if (containsAuthorization)
{
ShowAuthorizationErrorPopup(s);
if (typeof(T) == typeof(IExplorerRepositoryResult))
{
var explorerRepositoryResult = new ExplorerRepositoryResult(ExecStatus.Fail, s);
return(explorerRepositoryResult as T);
}
if (typeof(T) == typeof(ExecuteMessage))
{
var returnMessage = new ExecuteMessage
{
HasError = true,
Message = new StringBuilder(s)
};
return(returnMessage as T);
}
}
else
{
if (typeof(T) == typeof(ExecuteMessage))
{
return(message as T);
}
}
}
return(default(T));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
if (values == null)
{
throw new InvalidDataContractException(ErrorResource.NoParameter);
}
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Delete Trigger Queue Service", GlobalConstants.WarewolfInfo);
msg.HasError = false;
values.TryGetValue("TriggerQueue", out StringBuilder resourceDefinition);
var triggerQueue = serializer.Deserialize <ITriggerQueue>(resourceDefinition);
TriggersCatalog.Instance.DeleteTriggerQueue(triggerQueue);
return(serializer.SerializeToBuilder(msg));
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error("Delete Queue Service Failed: " + err.Message, GlobalConstants.WarewolfError);
return(serializer.SerializeToBuilder(msg));
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
values.TryGetValue("savePath", out StringBuilder savePathValue);
if (savePathValue == null)
{
throw new InvalidDataContractException("SavePath is missing");
}
values.TryGetValue("ResourceDefinition", out StringBuilder resourceDefinition);
Dev2Logger.Info("Deploy Resource.", GlobalConstants.WarewolfInfo);
if (resourceDefinition == null || resourceDefinition.Length == 0)
{
Dev2Logger.Info("Roles or ResourceDefinition missing", GlobalConstants.WarewolfInfo);
throw new InvalidDataContractException("Roles or ResourceDefinition missing");
}
var msg = ResourceCatalog.Instance.SaveResource(WorkspaceRepository.ServerWorkspaceID, resourceDefinition, savePathValue.ToString(), GlobalConstants.SaveReasonForDeploy, "unknown");
WorkspaceRepository.Instance.RefreshWorkspaces();
var result = new ExecuteMessage {
HasError = msg.Status != ExecStatus.Success
};
result.SetMessage(msg.Message);
var serializer = new Dev2JsonSerializer();
return(serializer.SerializeToBuilder(result));
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
Dev2Logger.Info("Get Files", GlobalConstants.WarewolfInfo);
values.TryGetValue("fileListing", out StringBuilder currentFolder);
if (currentFolder != null)
{
var src = serializer.Deserialize(currentFolder.ToString(), typeof(IFileListing)) as IFileListing;
try
{
msg.HasError = false;
var filesAndFolders = GetFilesAndFolders(src);
msg.Message = serializer.SerializeToBuilder(filesAndFolders);
}
catch (Exception ex)
{
Dev2Logger.Error(ex, GlobalConstants.WarewolfError);
msg.HasError = true;
msg.SetMessage(ex.Message);
}
}
else
{
msg.HasError = false;
msg.Message = serializer.SerializeToBuilder(GetFilesAndFolders(null));
}
return(serializer.SerializeToBuilder(msg));
}
private Task <ExecuteMessage> ValueFunction()
{
var executeMessage = new ExecuteMessage();
var fromResult = Task.FromResult(executeMessage);
return(fromResult);
}
private void Process(ExecuteMessage executeMessage)
{
this._ExchangeDataManager.ProcessExecuteMessage(executeMessage);
}
private static Message Convert(string exchangeCode, ExecuteCommand executeCommand)
{
XmlNode transactionNode = executeCommand.Content["Transaction"];
Transaction[] transactions;
Order[] orders;
OrderRelation[] orderRelations;
//Not Need AccountNode
CommandConvertor.Parse(exchangeCode,transactionNode, out transactions, out orders, out orderRelations);
ExecuteMessage executeMessage = new ExecuteMessage(exchangeCode, transactions, orders, orderRelations);
return executeMessage;
}
