/// <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 serializer = new Dev2JsonSerializer();
try
{
var res = new ExecuteMessage { HasError = false };
if (values == null)
{
throw new ArgumentNullException("values");
}
if (!values.ContainsKey("versionInfo"))
{
// ReSharper disable NotResolvedInText
throw new ArgumentNullException("No resourceId was found in the incoming data");
// ReSharper restore NotResolvedInText
}
var version = serializer.Deserialize<IVersionInfo>(values["versionInfo"]);
Dev2Logger.Log.Info("Get Version. " + version);
var result = ServerVersionRepo.GetVersion(version);
res.Message.Append(result);
Dev2XamlCleaner dev2XamlCleaner = new Dev2XamlCleaner();
res.Message = dev2XamlCleaner.StripNaughtyNamespaces(res.Message);
return serializer.SerializeToBuilder(res);
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
IExplorerRepositoryResult error = new ExplorerRepositoryResult(ExecStatus.Fail, e.Message);
return serializer.SerializeToBuilder(error);
}
}
private ExecuteMessage RunOutput(bool expectCorrectInput)
{
var esbMethod = new DeleteScheduledResource();
var factory = new Mock<IServerSchedulerFactory>();
var model = new Mock<IScheduledResourceModel>();
var ws = new Mock<IWorkspace>();
var trigger = new ScheduleTrigger(TaskState.Disabled,
new Dev2DailyTrigger(new TaskServiceConvertorFactory(), new DailyTrigger(21)),
new Dev2TaskService(new TaskServiceConvertorFactory()),
new TaskServiceConvertorFactory());
var res = new ScheduledResource("a", SchedulerStatus.Enabled, DateTime.Now, trigger, "dave");
var security = new Mock<ISecurityWrapper>();
esbMethod.SecurityWrapper = security.Object;
Dictionary<string, StringBuilder> inp = new Dictionary<string, StringBuilder>();
factory.Setup(
a =>
a.CreateModel(GlobalConstants.SchedulerFolderId, It.IsAny<ISecurityWrapper>())).Returns(model.Object);
Dev2JsonSerializer serialiser = new Dev2JsonSerializer();
if(expectCorrectInput)
{
model.Setup(a => a.DeleteSchedule(It.IsAny<ScheduledResource>())).Verifiable();
inp.Add("Resource", serialiser.SerializeToBuilder(res));
}
esbMethod.SchedulerFactory = factory.Object;
var output = esbMethod.Execute(inp, ws.Object);
if(expectCorrectInput)
model.Verify(a => a.DeleteSchedule(It.IsAny<ScheduledResource>()));
return serialiser.Deserialize<ExecuteMessage>(output);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
string type = null;
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
StringBuilder tmp;
values.TryGetValue("ResourceID", out tmp);
Guid resourceId = Guid.Empty;
if(tmp != null)
{
if(!Guid.TryParse(tmp.ToString(), out resourceId))
{
Dev2Logger.Log.Info("Delete Resource Service. Invalid Parameter Guid:");
var failureResult = new ExecuteMessage { HasError = true };
failureResult.SetMessage("Invalid guid passed for ResourceID");
return serializer.SerializeToBuilder(failureResult);
}
}
values.TryGetValue("ResourceType", out tmp);
if(tmp != null)
{
type = tmp.ToString();
}
Dev2Logger.Log.Info("Delete Resource Service. Resource:" + resourceId);
// BUG 7850 - TWR - 2013.03.11 - ResourceCatalog refactor
var msg = ResourceCatalog.Instance.DeleteResource(theWorkspace.ID, resourceId, type);
var result = new ExecuteMessage { HasError = false };
result.SetMessage(msg.Message);
result.HasError = msg.Status != ExecStatus.Success;
return serializer.SerializeToBuilder(result);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
IExplorerRepositoryResult item;
var serializer = new Dev2JsonSerializer();
try
{
if(values == null)
{
throw new ArgumentNullException("values");
}
StringBuilder itemBeingDeleted;
if(!values.TryGetValue("itemToDelete", out itemBeingDeleted))
{
throw new ArgumentException("itemToDelete value not supplied.");
}
var itemToDelete = serializer.Deserialize<ServerExplorerItem>(itemBeingDeleted);
Dev2Logger.Log.Info("Delete Item Service."+itemToDelete);
item = ServerExplorerRepo.DeleteItem(itemToDelete, GlobalConstants.ServerWorkspaceID);
}
catch(Exception e)
{
Dev2Logger.Log.Error("Delete Item Error" ,e);
item = new ExplorerRepositoryResult(ExecStatus.Fail, e.Message);
}
return serializer.SerializeToBuilder(item);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
IExplorerRepositoryResult item;
var serializer = new Dev2JsonSerializer();
try
{
if (values == null)
{
throw new ArgumentNullException("values");
}
StringBuilder itemToBeRenamed;
StringBuilder newPath;
if (!values.TryGetValue("itemToMove", out itemToBeRenamed))
{
throw new ArgumentException("itemToMove value not supplied.");
}
if (!values.TryGetValue("newPath", out newPath))
{
throw new ArgumentException("newName value not supplied.");
}
var itemToMove = serializer.Deserialize<ServerExplorerItem>(itemToBeRenamed);
Dev2Logger.Log.Info(String.Format("Move Item. Path:{0} NewPath:{1}", itemToBeRenamed, newPath));
item = ServerExplorerRepo.MoveItem(itemToMove, newPath.ToString(), GlobalConstants.ServerWorkspaceID);
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
item = new ExplorerRepositoryResult(ExecStatus.Fail, e.Message);
}
return serializer.SerializeToBuilder(item);
}
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());
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
if (values == null)
{
throw new ArgumentNullException("values");
}
if( !values.ContainsKey("resourceId"))
{
// ReSharper disable NotResolvedInText
throw new ArgumentNullException("No resourceId was found in the incoming data");
// ReSharper restore NotResolvedInText
}
var id = Guid.Parse( values["resourceId"].ToString());
Dev2Logger.Log.Info("Get Versions. " + id);
var item = ServerVersionRepo.GetVersions(id);
return serializer.SerializeToBuilder(item);
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
IExplorerRepositoryResult error = new ExplorerRepositoryResult(ExecStatus.Fail, e.Message);
return serializer.SerializeToBuilder(error);
}
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
IExplorerRepositoryResult item;
try
{
if(values == null)
{
throw new ArgumentNullException("values");
}
if(theWorkspace == null)
{
throw new ArgumentNullException("theWorkspace");
}
StringBuilder path;
if(!values.TryGetValue("path", out path))
{
throw new ArgumentException("path value not supplied.");
}
StringBuilder newPath;
if(!values.TryGetValue("newPath", out newPath))
{
throw new ArgumentException("newPath value not supplied.");
}
Dev2Logger.Log.Info(String.Format("Reanme Folder. Path:{0} NewPath:{1}",path,newPath));
item = ServerExplorerRepository.Instance.RenameFolder(path.ToString(), newPath.ToString(), theWorkspace.ID);
}
catch(Exception e)
{
Dev2Logger.Log.Error(e);
item = new ExplorerRepositoryResult(ExecStatus.Fail, e.Message);
}
var serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(item);
}
public IExplorerRepositoryResult DeleteItem(IExplorerItem itemToRename, Guid workSpaceId)
{
var controller = CommunicationControllerFactory.CreateController("DeleteItemService");
var serializer = new Dev2JsonSerializer();
controller.AddPayloadArgument("itemToDelete", serializer.SerializeToBuilder(itemToRename).ToString());
return controller.ExecuteCommand<IExplorerRepositoryResult>(Connection, workSpaceId);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
var result = new ExecuteMessage { HasError = false };
Dev2Logger.Log.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.Log.Info("Delete Scheduled Resource Service." +res);
using(var model = SchedulerFactory.CreateModel(GlobalConstants.SchedulerFolderId, SecurityWrapper))
{
model.DeleteSchedule(res);
}
}
else
{
Dev2Logger.Log.Info("Delete Scheduled Resource Service. No Resource Selected");
result.Message.Append("No Resource Selected");
result.HasError = true;
}
return serializer.SerializeToBuilder(result);
}
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 StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
try
{
string guidCsv = string.Empty;
string type = null;
StringBuilder tmp;
values.TryGetValue("GuidCsv", out tmp);
if(tmp != null)
{
guidCsv = tmp.ToString();
}
values.TryGetValue("ResourceType", out tmp);
if(tmp != null)
{
type = tmp.ToString();
}
Dev2Logger.Log.Info("Find Resource By Id. "+guidCsv);
// BUG 7850 - TWR - 2013.03.11 - ResourceCatalog refactor
var resources = ResourceCatalog.Instance.GetResourceList(theWorkspace.ID, guidCsv, type);
IList<SerializableResource> resourceList = resources.Select(new FindResourceHelper().SerializeResourceForStudio).ToList();
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(resourceList);
}
catch (Exception err)
{
Dev2Logger.Log.Error(err);
throw;
}
}
public SharepointServerSourceViewModel(SharepointServerSource serverSource, IEnvironmentModel environment)
{
IsLoading = false;
TestComplete = false;
_environment = environment;
ServerName = "";
AuthenticationType = AuthenticationType.Windows;
IsWindows = true;
SaveCommand = new RelayCommand(o =>
{
serverSource.DialogResult = true;
serverSource.Close();
}, o => TestComplete);
CancelCommand = new RelayCommand(o =>
{
serverSource.DialogResult = false;
serverSource.Close();
});
TestCommand = new RelayCommand(o =>
{
IsLoading = true;
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
var source = CreateSharepointServerSource();
var comsController = new CommunicationController { ServiceName = "TestSharepointServerService" };
comsController.AddPayloadArgument("SharepointServer", serializer.SerializeToBuilder(source));
TestResult = comsController.ExecuteCommand<string>(environment.Connection, GlobalConstants.ServerWorkspaceID);
IsLoading = false;
}, o => !TestComplete);
}
/// <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)
{
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
var execMessage = new ExecuteMessage { HasError = false };
if(!values.ContainsKey("resourceId"))
{
Dev2Logger.Log.Info("Delete Version. Invalid Resource Id");
execMessage.HasError = true;
execMessage.Message = new StringBuilder( "No resourceId sent to server");
}
else if(!values.ContainsKey("versionNumber") )
{
Dev2Logger.Log.Info("Delete Version. Invalid Version number");
execMessage.HasError = true;
execMessage.Message = new StringBuilder("No versionNumber sent to server");
}
else
{
try
{
var guid = Guid.Parse(values["resourceId"].ToString());
var version = values["versionNumber"].ToString();
Dev2Logger.Log.Info(String.Format("Delete Version. ResourceId:{0} VersionNumber{1}",guid,version));
var res = ServerVersionRepo.DeleteVersion(guid,version);
execMessage.Message = serializer.SerializeToBuilder(res);
}
catch (Exception e)
{
Dev2Logger.Log.Error(String.Format("Delete Version Error."),e);
execMessage.HasError = true;
execMessage.Message = new StringBuilder( e.Message);
}
}
return serializer.SerializeToBuilder(execMessage);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, Workspaces.IWorkspace theWorkspace)
{
try
{
StringBuilder tmp;
values.TryGetValue("Resource", out tmp);
var serializer = new Dev2JsonSerializer();
if (tmp != null)
{
var res = serializer.Deserialize<IScheduledResource>(tmp);
Dev2Logger.Log.Info("Get Scheduled History. " +tmp);
IList<IResourceHistory> resources;
using (var model = SchedulerFactory.CreateModel(GlobalConstants.SchedulerFolderId, SecurityWrapper))
{
resources = model.CreateHistory(res);
}
return serializer.SerializeToBuilder(resources);
}
Dev2Logger.Log.Debug("No resource Provided");
return serializer.SerializeToBuilder(new List<IResourceHistory>());
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
throw;
}
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
var result = new ExecuteMessage { HasError = false };
Dev2Logger.Log.Info("Find Log Directory");
try
{
var logdir = WorkflowLoggger.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 StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
try
{
Dev2Logger.Log.Info("Fetch Server Log Started");
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());
}
}
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(result);
}
catch (Exception err)
{
Dev2Logger.Log.Error("Fetch Server Log Error", err);
throw;
}
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
string domain = null;
string username = null;
string password = null;
StringBuilder tmp;
values.TryGetValue("Domain", out tmp);
if(tmp != null)
{
domain = tmp.ToString();
}
values.TryGetValue("Username", out tmp);
if(tmp != null)
{
username = tmp.ToString();
}
values.TryGetValue("Password", out tmp);
if(tmp != null)
{
password = tmp.ToString();
}
if(string.IsNullOrEmpty(domain) || string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
{
throw new InvalidDataContractException("Domain or Username or Password is missing");
}
var result = new ExecuteMessage { HasError = false };
try
{
if(domain.Equals("."))
{
domain = Environment.UserDomainName;
}
bool isValid;
using(var context = new PrincipalContext(ContextType.Domain, domain))
{
isValid = context.ValidateCredentials(username, password);
context.Dispose();
}
result.SetMessage(isValid ? "<result>Connection successful!</result>" : "<result>Connection failed. Ensure your username and password are valid</result>");
}
catch
{
result.SetMessage("<result>Connection failed. Ensure your username and password are valid</result>");
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(result);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
try
{
Dev2Logger.Log.Info("Find Dependencies");
var result = new ExecuteMessage { HasError = false };
string resourceId = null;
string dependsOnMeString = null;
bool dependsOnMe = false;
StringBuilder tmp;
values.TryGetValue("ResourceId", out tmp);
if(tmp != null)
{
resourceId = tmp.ToString();
}
values.TryGetValue("GetDependsOnMe", out tmp);
if(tmp != null)
{
dependsOnMeString = tmp.ToString();
}
if (string.IsNullOrEmpty(resourceId))
{
throw new InvalidDataContractException("ResourceName is empty or null");
}
var resource= ResourceCatalog.Instance.GetResource(theWorkspace.ID, Guid.Parse(resourceId));
var resourceName = resource.ResourcePath;
if(!string.IsNullOrEmpty(dependsOnMeString))
{
if(!bool.TryParse(dependsOnMeString, out dependsOnMe))
{
dependsOnMe = false;
}
}
if(dependsOnMe)
{
result.Message.Append(string.Format("<graph title=\"Local Dependants Graph: {0}\">", resourceName));
result.Message.Append(FindWhatDependsOnMe(resource, theWorkspace.ID));
result.Message.Append("</graph>");
}
else
{
result.Message.Append(string.Format("<graph title=\"Dependency Graph Of {0}\">", resourceName));
result.Message.Append(FindDependenciesRecursive(resource.ResourceID, theWorkspace.ID));
result.Message.Append("</graph>");
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(result);
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
throw;
}
}
public void DeleteSchedule(IScheduledResource resource)
{
Dev2JsonSerializer jsonSerializer = new Dev2JsonSerializer();
var builder = jsonSerializer.SerializeToBuilder(resource);
var controller = new CommunicationController { ServiceName = "DeleteScheduledResourceService" };
controller.AddPayloadArgument("Resource", builder);
controller.ExecuteCommand<string>(_model.Connection, _model.Connection.WorkspaceID);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
string serviceId = null;
string workspaceId = null;
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
var result = new ExecuteMessage { HasError = false };
StringBuilder tmp;
values.TryGetValue("ServiceID", out tmp);
if(tmp != null)
{
serviceId = tmp.ToString();
}
values.TryGetValue("WorkspaceID", out tmp);
if(tmp != null)
{
workspaceId = tmp.ToString();
}
values.TryGetValue("FilterList", out tmp);
if(tmp != null)
{
}
if(string.IsNullOrEmpty(serviceId) || string.IsNullOrEmpty(workspaceId))
{
throw new InvalidDataContractException("Null or empty ServiceID or WorkspaceID");
}
Guid wGuid;
Guid sGuid;
Guid.TryParse(workspaceId, out wGuid);
Guid.TryParse(serviceId, out sGuid);
var thisService = ResourceCatalog.Instance.GetResource(wGuid, sGuid);
if(thisService != null)
{
var deps = thisService.Dependencies;
CompileMessageType[] filters = null; // TODO : Convert string list to enum array ;)
// ReSharper disable ExpressionIsAlwaysNull
CompileMessageList msgs = CompileMessageRepo.Instance.FetchMessages(wGuid, sGuid, deps, filters);
// ReSharper restore ExpressionIsAlwaysNull
result.Message.Append(serializer.SerializeToBuilder(msgs));
}
else
{
result.Message.Append("Could not locate service with ID [ " + sGuid + " ]");
result.HasError = true;
}
return serializer.SerializeToBuilder(result);
}
protected override List<WindowsGroupPermission> ReadPermissions()
{
var reader = new SecurityRead();
var result = reader.Execute(null, null);
var serializer = new Dev2JsonSerializer();
SecuritySettingsTO securitySettingsTO = serializer.Deserialize<SecuritySettingsTO>(result);
TimeOutPeriod = securitySettingsTO.CacheTimeout;
return securitySettingsTO.WindowsGroupPermissions;
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
var folderToDelete = values["folderToDelete"].ToString();
var deleteContents = bool.Parse(values["deleteContents"].ToString());
var item = ServerExplorerRepository.DeleteItem(folderToDelete, deleteContents, theWorkspace.ID);
return serializer.SerializeToBuilder(item);
}
public void GetVersions_Execute_ExpectException_NoArgs()
{
//------------Setup for test--------------------------
var getVersions = new GetVersion();
Dev2JsonSerializer serialiser = new Dev2JsonSerializer();
//------------Execute Test---------------------------
var ax = getVersions.Execute(new Dictionary<string, StringBuilder>(), new Workspace(Guid.NewGuid()));
Assert.AreEqual(ExecStatus.Fail, serialiser.Deserialize<ExplorerRepositoryResult>(ax).Status);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage msg = new ExecuteMessage {HasError = false};
msg.SetMessage("Pong @ " + Now.Invoke().ToString("yyyy-MM-dd hh:mm:ss.fff"));
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(msg);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage msg = new ExecuteMessage { HasError = false };
msg.SetMessage(values["payload"].ToString());
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(msg);
}
public void ResourceTypeConvertor_ConvertToJson_EnumAsString_ExpectConvert()
{
//------------Setup for test--------------------------
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
var data = serializer.Serialize(new ServerExplorerItem("a", Guid.Empty, ResourceType.DbService, null, Permissions.Administrator, "bob"));
//------------Execute Test---------------------------
Assert.IsTrue(data.Contains("DbService"));
//------------Assert Results-------------------------
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
StringBuilder itemXml;
string isLocal = string.Empty;
StringBuilder tmp;
values.TryGetValue("ItemXml", out itemXml);
values.TryGetValue("IsLocalSave", out tmp);
if (tmp != null)
{
isLocal = tmp.ToString();
}
bool isLocalSave;
bool.TryParse(isLocal, out isLocalSave);
var res = new ExecuteMessage { HasError = false};
if(itemXml == null || itemXml.Length == 0)
{
res.SetMessage("Invalid workspace item definition " + DateTime.Now);
res.HasError = true;
}
else
{
try
{
XElement xe = itemXml.ToXElement();
var workspaceItem = new WorkspaceItem(xe);
if (workspaceItem.WorkspaceID != theWorkspace.ID)
{
res.SetMessage("Cannot update a workspace item from another workspace " + DateTime.Now);
res.HasError = true;
}
else
{
theWorkspace.Update(workspaceItem, isLocalSave);
res.SetMessage("Workspace item updated " + DateTime.Now);
}
}
catch(Exception ex)
{
res.SetMessage("Error updating workspace item " + DateTime.Now);
res.SetMessage(ex.Message);
res.SetMessage(ex.StackTrace);
res.HasError = true;
}
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(res);
}
public void MoveItem_Execute_NullValues_ErrorResult()
{
//------------Setup for test--------------------------
var MoveItemService = new MoveItemService();
var serializer = new Dev2JsonSerializer();
//------------Execute Test---------------------------
StringBuilder jsonResult = MoveItemService.Execute(null, null);
IExplorerRepositoryResult result = serializer.Deserialize<IExplorerRepositoryResult>(jsonResult);
//------------Assert Results-------------------------
Assert.AreEqual(ExecStatus.Fail, result.Status);
}
public void Save(IScheduledResource resource, string userName, string password)
{
Dev2JsonSerializer jsonSerializer = new Dev2JsonSerializer();
var builder = jsonSerializer.SerializeToBuilder(resource);
var controller = new CommunicationController { ServiceName = "SaveScheduledResourceService" };
controller.AddPayloadArgument("Resource", builder);
controller.AddPayloadArgument("UserName", userName);
controller.AddPayloadArgument("Password", password);
controller.ExecuteCommand<string>(_model.Connection, _model.Connection.WorkspaceID);
resource.IsDirty = false;
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
IWebSocketWrapper client = null;
Dev2Logger.Info("Get Log Data Service", GlobalConstants.WarewolfInfo);
var serializer = new Dev2JsonSerializer();
var result = new List <Audit>();
var response = "";
var message = new AuditCommand()
{
Type = "LogQuery",
Query = values
};
try
{
client = _webSocketPool.Acquire(Config.Auditing.Endpoint).Connect();
var ewh = new EventWaitHandle(false, EventResetMode.ManualReset);
client.OnMessage((msgResponse, socket) =>
{
response = msgResponse;
result.AddRange(serializer.Deserialize <List <Audit> >(response));
ewh.Set();
});
client.SendMessage(serializer.Serialize(message));
ewh.WaitOne(_waitTimeOut);
LogDataCache.CurrentResults = result;
return(serializer.SerializeToBuilder(result));
}
catch (Exception e)
{
Dev2Logger.Info("Get Log Data ServiceError", e, GlobalConstants.WarewolfInfo);
}
finally
{
_webSocketPool.Release(client);
}
return(serializer.SerializeToBuilder(""));
}
public void FetchTriggerQueues_Execute_ExpectTestList()
{
//------------Setup for test--------------------------
var fetchTriggerQueues = new FetchTriggerQueues();
var triggerQueue1 = new TriggerQueue();
triggerQueue1.WorkflowName = "My WF";
var triggerQueue2 = new TriggerQueue();
triggerQueue2.TriggerId = Guid.NewGuid();
var triggerQueue3 = new TriggerQueue();
triggerQueue3.QueueName = "My Queue Name";
var listOfTriggerQueues = new List <ITriggerQueue>
{
triggerQueue1, triggerQueue2, triggerQueue3
};
var repo = new Mock <ITriggersCatalog>();
var ws = new Mock <IWorkspace>();
repo.Setup(a => a.Queues).Returns(listOfTriggerQueues).Verifiable();
var serializer = new Dev2JsonSerializer();
var inputs = new Dictionary <string, StringBuilder>();
var resourceID = Guid.NewGuid();
inputs.Add("resourceID", new StringBuilder(resourceID.ToString()));
fetchTriggerQueues.TriggersCatalog = repo.Object;
//------------Execute Test---------------------------
var res = fetchTriggerQueues.Execute(inputs, ws.Object);
var msg = serializer.Deserialize <CompressedExecuteMessage>(res);
var triggerQueues = serializer.Deserialize <List <ITriggerQueue> >(msg.GetDecompressedMessage());
//------------Assert Results-------------------------
repo.Verify(a => a.Queues);
Assert.AreEqual(listOfTriggerQueues.Count, triggerQueues.Count);
Assert.AreEqual(listOfTriggerQueues[0].WorkflowName, triggerQueues[0].WorkflowName);
Assert.AreEqual(listOfTriggerQueues[1].TriggerId, triggerQueues[1].TriggerId);
Assert.AreEqual(listOfTriggerQueues[2].QueueName, triggerQueues[2].QueueName);
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
var res = new ExecuteMessage {
HasError = false
};
if (values == null)
{
throw new ArgumentNullException("values");
}
if (!values.ContainsKey("versionInfo"))
{
throw new ArgumentNullException(ErrorResource.NoResourceIdInTheIncomingData);
}
var version = serializer.Deserialize <IVersionInfo>(values["versionInfo"]);
Dev2Logger.Info("Get Version. " + version, GlobalConstants.WarewolfInfo);
var resourceId = Guid.Empty;
values.TryGetValue("resourceId", out StringBuilder tmp);
if (tmp != null)
{
resourceId = Guid.Parse(tmp.ToString());
}
var resourcePath = ResourceCatalog.GetResourcePath(theWorkspace.ID, resourceId);
var result = ServerVersionRepo.GetVersion(version, resourcePath);
res.Message.Append(result);
var dev2XamlCleaner = new Dev2XamlCleaner();
res.Message = dev2XamlCleaner.StripNaughtyNamespaces(res.Message);
return(serializer.SerializeToBuilder(res));
}
catch (Exception e)
{
Dev2Logger.Error(e, GlobalConstants.WarewolfError);
IExplorerRepositoryResult error = new ExplorerRepositoryResult(ExecStatus.Fail, e.Message);
return(serializer.SerializeToBuilder(error));
}
}
void Verify_EnvironmentConnection_NetworkStateChanged(NetworkState fromState, NetworkState toState)
{
//------------Setup for test--------------------------
var workspaceID = Guid.NewGuid();
var dataListID = Guid.Empty;
var serializer = new Dev2JsonSerializer();
var requestResult = serializer.SerializeToBuilder(new SecuritySettingsTO());
StringBuilder actualRequest = null;
var connection = new Mock <IEnvironmentConnection>();
connection.Setup(c => c.ServerEvents).Returns(new Mock <IEventPublisher>().Object);
connection.Setup(c => c.WorkspaceID).Returns(workspaceID);
connection.Setup(c => c.IsConnected).Returns(true);
connection.Setup(c => c.ExecuteCommand(It.IsAny <StringBuilder>(), workspaceID))
.Callback((StringBuilder xmlRequest, Guid wsID) => { actualRequest = xmlRequest; })
.Returns(requestResult)
.Verifiable();
new ClientSecurityService(connection.Object);
//------------Execute Test---------------------------
connection.Raise(c => c.NetworkStateChanged += null, new NetworkStateEventArgs(fromState, toState));
// wait for ReadAsync to finish
Thread.Sleep(1000);
//------------Assert Results-------------------------
if (toState == NetworkState.Online)
{
connection.Verify(c => c.ExecuteCommand(It.IsAny <StringBuilder>(), workspaceID), Times.Never());
Assert.IsNull(actualRequest);
}
else
{
connection.Verify(c => c.ExecuteCommand(It.IsAny <StringBuilder>(), workspaceID), Times.Never());
Assert.IsNull(actualRequest);
}
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
var pluginSource = values["source"].DeserializeToObject <PluginSourceDefinition>();
var ns = values["namespace"].DeserializeToObject <INamespaceItem>();
var services = new PluginServices();
var src = Resources.GetResource <PluginSource>(GlobalConstants.ServerWorkspaceID, pluginSource.Id);
var svc = new PluginService();
if (ns != null)
{
svc.Namespace = ns.FullName;
svc.Source = src;
}
else
{
svc.Source = src;
}
var serviceConstructorList = services.Constructors(svc, Guid.Empty, Guid.Empty);
var constructors = serviceConstructorList.Select(a => new PluginConstructor
{
ConstructorName = BuildConstructorName(a.Parameters.Select(parameter => parameter.ShortTypeName)),
Inputs = a.Parameters.Cast <IConstructorParameter>().ToList(),
} as IPluginConstructor).ToList();
var executeMessage = new ExecuteMessage {
HasError = false, Message = constructors.SerializeToJsonStringBuilder()
};
return(executeMessage.SerializeToJsonStringBuilder());
}
catch (Exception e)
{
return(serializer.SerializeToBuilder(new ExecuteMessage
{
HasError = true,
Message = new StringBuilder(e.Message)
}));
}
}
public void ConflictModelFactory_GivenDsfDecisionConflictNode_ShouldReturnMergeToolModel()
{
//------------Setup for test--------------------------
var adapter = new Mock<IApplicationAdaptor>();
adapter.Setup(p => p.TryFindResource(It.IsAny<object>())).Returns(new object());
CustomContainer.Register(adapter.Object);
var node = new Mock<IConflictTreeNode>();
var contextualResource = new Mock<IContextualResourceModel>();
var dev2DecisionStack = new Dev2DecisionStack
{
TheStack = new List<Dev2Decision>(),
TrueArmText = "a",
FalseArmText = "a",
DisplayText = "a",
Mode = Dev2DecisionMode.AND
};
var serializer = new Dev2JsonSerializer();
var serialize = serializer.Serialize(dev2DecisionStack);
var condition = new DsfFlowDecisionActivity
{
ExpressionText = serialize
};
var value = new DsfDecision(condition)
{
Conditions = dev2DecisionStack
};
var assignStep = new FlowStep
{
Action = value
};
node.Setup(p => p.Activity).Returns(value);
var toolConflictItem = new ToolConflictItem(new ViewModels.Merge.Utils.ConflictRowList(new Mock<IConflictModelFactory>().Object, new Mock<IConflictModelFactory>().Object, new List<ConflictTreeNode>(), new List<ConflictTreeNode>()), ViewModels.Merge.Utils.ConflictRowList.Column.Current);
//------------Execute Test---------------------------
var completeConflict = new ConflictModelFactory(toolConflictItem, contextualResource.Object, node.Object);
//------------Assert Results-------------------------
Assert.IsNotNull(completeConflict);
adapter.Verify(p => p.TryFindResource(It.IsAny<object>()));
var mergeToolModel = completeConflict.CreateModelItem(toolConflictItem, node.Object);
Assert.AreEqual("a", mergeToolModel.MergeDescription);
Assert.AreEqual(typeof(DecisionDesignerViewModel).FullName, ((ToolConflictItem)mergeToolModel).ActivityDesignerViewModel.GetType().FullName);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
if (values == null)
{
throw new InvalidDataException("Empty values passed.");
}
StringBuilder loggingSettingsBuilder;
values.TryGetValue("LoggingSettings", out loggingSettingsBuilder);
if (loggingSettingsBuilder == null || loggingSettingsBuilder.Length == 0)
{
throw new InvalidDataException("Empty Logging Settings passed.");
}
var serializer = new Dev2JsonSerializer();
try
{
var loggingSettingsTo = serializer.Deserialize <LoggingSettingsTo>(loggingSettingsBuilder);
if (loggingSettingsTo == null)
{
throw new InvalidDataException("The security settings are not valid.");
}
Write(loggingSettingsTo);
}
catch (Exception e)
{
throw new InvalidDataException(string.Format("The security settings are not valid. Error: {0}", e.Message));
}
var msg = new ExecuteMessage {
HasError = false
};
msg.SetMessage("Success");
return(serializer.SerializeToBuilder(msg));
}
public void ClearLogExecuteWithValidPathAndLockedExpectedReturnsError()
{
var serializer = new Dev2JsonSerializer();
lock (SyncRoot)
{
//setup
var fileName1 = Guid.NewGuid().ToString() + "_Test.log";
var fileName2 = Guid.NewGuid().ToString() + "_Test.log";
var path1 = Path.Combine(_testDir, fileName1);
File.WriteAllText(path1, @"hello test");
Assert.IsTrue(File.Exists(path1));
var path2 = Path.Combine(_testDir, fileName2);
File.WriteAllText(path2, @"hello test");
Assert.IsTrue(File.Exists(path2));
var fs = File.OpenRead(path2);
//execute
StringBuilder result;
try
{
var values = new Dictionary <string, StringBuilder> {
{ "Directory", new StringBuilder(_testDir) }
};
var esb = new ClearLog();
result = esb.Execute(values, GetWorkspace().Object);
}
finally
{
fs.Close();
}
var msg = serializer.Deserialize <ExecuteMessage>(result.ToString());
//assert
Assert.IsTrue(msg.Message.ToString().StartsWith("Error clearing "));
}
}
private List <IResourceHistory> RunOutput(bool expectCorrectInput)
{
var esbMethod = new GetScheduledResourceHistory();
var security = new Mock <ISecurityWrapper>();
esbMethod.SecurityWrapper = security.Object;
var factory = new Mock <IServerSchedulerFactory>();
var model = new Mock <IScheduledResourceModel>();
var ws = new Mock <IWorkspace>();
var history = new List <IResourceHistory>
{
new ResourceHistory("", new List <IDebugState> {
new DebugState()
},
new EventInfo(DateTime.MinValue, TimeSpan.MaxValue, DateTime.MaxValue, ScheduleRunStatus.Error, "115"),
"leon")
};
var trigger = new ScheduleTrigger(TaskState.Disabled,
new Dev2DailyTrigger(new TaskServiceConvertorFactory(), new DailyTrigger(21)),
new Dev2TaskService(new TaskServiceConvertorFactory()),
new TaskServiceConvertorFactory());
var res = new ScheduledResource("a", SchedulerStatus.Enabled, DateTime.Now, trigger, "dave");
Dictionary <string, StringBuilder> inp = new Dictionary <string, StringBuilder>();
factory.Setup(
a =>
a.CreateModel(GlobalConstants.SchedulerFolderId, It.IsAny <ISecurityWrapper>())).Returns(model.Object);
Dev2JsonSerializer serialiser = new Dev2JsonSerializer();
if (expectCorrectInput)
{
model.Setup(a => a.CreateHistory(It.IsAny <ScheduledResource>())).Returns(history).Verifiable();
inp.Add("Resource", serialiser.SerializeToBuilder(res));
}
esbMethod.SchedulerFactory = factory.Object;
var output = esbMethod.Execute(inp, ws.Object);
return(serialiser.Deserialize <List <IResourceHistory> >(output));
}
public void FetchTests_Execute_ExpectTestList()
{
//------------Setup for test--------------------------
var fetchTests = new FetchTestsForDeploy();
var listOfTests = new List <IServiceTestModelTO>
{
new ServiceTestModelTO
{
AuthenticationType = AuthenticationType.Public,
Enabled = true,
TestName = "Test MyWF",
Password = "******"
}
};
var repo = new Mock <ITestCatalog>();
var ws = new Mock <IWorkspace>();
var resID = Guid.Empty;
repo.Setup(a => a.Fetch(It.IsAny <Guid>())).Callback((Guid id) =>
{
resID = id;
}).Returns(listOfTests).Verifiable();
var serializer = new Dev2JsonSerializer();
var inputs = new Dictionary <string, StringBuilder>();
var resourceID = Guid.NewGuid();
inputs.Add("resourceID", new StringBuilder(resourceID.ToString()));
fetchTests.TestCatalog = repo.Object;
//------------Execute Test---------------------------
var res = fetchTests.Execute(inputs, ws.Object);
var msg = serializer.Deserialize <CompressedExecuteMessage>(res);
var testModels = serializer.Deserialize <List <IServiceTestModelTO> >(msg.GetDecompressedMessage());
//------------Assert Results-------------------------
repo.Verify(a => a.Fetch(It.IsAny <Guid>()));
Assert.AreEqual(listOfTests.Count, testModels.Count);
Assert.AreEqual(listOfTests[0].TestName, testModels[0].TestName);
Assert.AreEqual(resourceID, resID);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
if (values == null)
{
throw new InvalidDataException(ErrorResource.EmptyValuesPassed);
}
StringBuilder loggingSettingsBuilder;
values.TryGetValue("LoggingSettings", out loggingSettingsBuilder);
if (loggingSettingsBuilder == null || loggingSettingsBuilder.Length == 0)
{
throw new InvalidDataException(ErrorResource.EmptyLoggingSettingsPassed);
}
var serializer = new Dev2JsonSerializer();
try
{
var loggingSettingsTo = serializer.Deserialize <LoggingSettingsTo>(loggingSettingsBuilder);
if (loggingSettingsTo == null)
{
throw new InvalidDataException(ErrorResource.InvalidSecuritySettings);
}
Write(loggingSettingsTo);
}
catch (Exception e)
{
throw new InvalidDataException(ErrorResource.InvalidSecuritySettings + $" Error: {e.Message}");
}
var msg = new ExecuteMessage {
HasError = false
};
msg.SetMessage("Success");
return(serializer.SerializeToBuilder(msg));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Delete Test Service");
StringBuilder resourceIdString;
values.TryGetValue("resourceID", out resourceIdString);
if (resourceIdString == null)
{
throw new InvalidDataContractException("resourceID is missing");
}
Guid resourceId;
if (!Guid.TryParse(resourceIdString.ToString(), out resourceId))
{
throw new InvalidDataContractException("resourceID is not a valid GUID.");
}
StringBuilder testName;
values.TryGetValue("testName", out testName);
if (string.IsNullOrEmpty(testName?.ToString()))
{
throw new InvalidDataContractException("testName is missing");
}
TestCatalog.DeleteTest(resourceId, testName.ToString());
CompressedExecuteMessage message = new CompressedExecuteMessage {
HasError = false
};
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err);
var res = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
if (values == null)
{
throw new InvalidDataException(ErrorResource.EmptyValuesPassed);
}
values.TryGetValue("SecuritySettings", out StringBuilder securitySettings);
values.TryGetValue("TimeoutPeriod", out StringBuilder timeoutPeriodString);
if (securitySettings == null || securitySettings.Length == 0)
{
throw new InvalidDataException(ErrorResource.EmptySecuritySettingsPassed);
}
var serializer = new Dev2JsonSerializer();
try
{
var securitySettingsTo = serializer.Deserialize <SecuritySettingsTO>(securitySettings);
if (securitySettingsTo == null)
{
throw new InvalidDataException(ErrorResource.InvalidSecuritySettings);
}
Write(securitySettings);
ServerAuthorizationService.Instance.SecurityService.Read();
}
catch (Exception e)
{
throw new InvalidDataException(ErrorResource.InvalidSecuritySettings + $" Error: {e.Message}");
}
var msg = new ExecuteMessage {
HasError = false
};
msg.SetMessage("Success");
return(serializer.SerializeToBuilder(msg));
}
public void GetLogDataService_Execute_WithExecutionId_ShouldFilterLogData_NewFormat()
{
//------------Setup for test--------------------------
const string LogFilePath = @"TextFiles\LogFileWithFlatResultsNEwFormat.txt";
var getLogDataService = new GetServiceExecutionResult {
ServerLogFilePath = LogFilePath
};
//---------------Assert Precondition----------------
Assert.IsNotNull(getLogDataService);
//------------Execute Test---------------------------
var stringBuilders = new Dictionary <string, StringBuilder> {
{ "ExecutionId", new StringBuilder("06385e0f-ac27-4cf0-af55-7642c3c08ba3") }
};
var logEntriesJson = getLogDataService.Execute(stringBuilders, null);
var serializer = new Dev2JsonSerializer();
var logEntry = serializer.Deserialize <LogEntry>(logEntriesJson.ToString());
Assert.IsNotNull(logEntry);
}
public IList <IFileListing> FetchFiles()
{
var serializer = new Dev2JsonSerializer();
var comsController = CommunicationControllerFactory.CreateController("GetFiles");
var workspaceId = Connection.WorkspaceID;
var result = comsController.ExecuteCommand <ExecuteMessage>(Connection, workspaceId);
if (result.HasError)
{
if (!Connection.IsConnected)
{
ShowServerDisconnectedPopup();
return(new List <IFileListing>());
}
throw new WarewolfSupportServiceException(result.Message.ToString(), null);
}
var fileListings = serializer.Deserialize <List <IFileListing> >(result.Message.ToString());
return(fileListings);
}
public IList <string> TestDbConnection(IDbSource resource)
{
var con = Connection;
var comsController = CommunicationControllerFactory.CreateController("TestDbSourceService");
var serialiser = new Dev2JsonSerializer();
comsController.AddPayloadArgument("DbSource", serialiser.SerializeToBuilder(resource));
var output = comsController.ExecuteCommand <IExecuteMessage>(con, GlobalConstants.ServerWorkspaceID);
if (output == null)
{
throw new WarewolfTestException(ErrorResource.UnableToContactServer, null);
}
if (output.HasError)
{
throw new WarewolfTestException(output.Message.ToString(), null);
}
return(serialiser.Deserialize <List <string> >(output.Message));
}
public void QueryManagerProxy_FetchConstructors_GivenEnvHasObjectVariablesAddsvariables()
{
var ser = new Dev2JsonSerializer();
var res = ser.SerializeToBuilder(new List <IPluginConstructor>());
var aggr = new Mock <IEventAggregator>();
var dataListViewModel = new DataListViewModel(aggr.Object);
dataListViewModel.Add(new ComplexObjectItemModel("Name", null, enDev2ColumnArgumentDirection.Both));
DataListSingleton.SetDataList(dataListViewModel);
var ns = new Mock <INamespaceItem>();
RunTest("FetchPluginConstructors", new ExecuteMessage
{
HasError = false,
Message = res
}
, new List <Tuple <string, object> >
{
new Tuple <string, object>("source", new PluginSourceDefinition())
}, a => Assert.AreEqual(1, a.Count), a => a.PluginConstructors(new PluginSourceDefinition(), ns.Object));
}
public string TestConnection(IElasticsearchSourceDefinition elasticsearchServiceSource)
{
var con = Connection;
var comsController = CommunicationControllerFactory.CreateController(nameof(TestElasticsearchSource));
var serialiser = new Dev2JsonSerializer();
comsController.AddPayloadArgument(nameof(ElasticsearchSource), serialiser.SerializeToBuilder(elasticsearchServiceSource));
var output = comsController.ExecuteCommand <IExecuteMessage>(con, GlobalConstants.ServerWorkspaceID);
if (output == null)
{
throw new WarewolfTestException(ErrorResource.UnableToContactServer, null);
}
if (output.HasError)
{
throw new WarewolfTestException(output.Message.ToString(), null);
}
return(output.Message.ToString());
}
public string TestComPluginService(IComPluginService inputValues)
{
var con = Connection;
var comsController = CommunicationControllerFactory.CreateController("TestComPluginService");
var serialiser = new Dev2JsonSerializer();
comsController.AddPayloadArgument("ComPluginService", serialiser.SerializeToBuilder(inputValues));
var output = comsController.ExecuteCommand <IExecuteMessage>(con, GlobalConstants.ServerWorkspaceID);
if (output == null)
{
throw new WarewolfTestException(ErrorResource.UnableToContactServer, null);
}
if (output.HasError)
{
throw new WarewolfTestException(output.Message.ToString(), null);
}
return(output.Message.ToString());
}
public void Dev2JsonSerializer_Deserializer_WhenUsingStream_ExpectValidObject()
{
//------------Setup for test--------------------------
const string 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.";
var msg = new ExecuteMessage {
HasError = false
};
msg.SetMessage(theMessage);
var buffer = new StringBuilder(JsonConvert.SerializeObject(msg));
//------------Execute Test---------------------------
var js = new Dev2JsonSerializer();
var result = js.Deserialize <ExecuteMessage>(buffer);
//------------Assert Results-------------------------
Assert.AreEqual(theMessage, result.Message.ToString());
}
public void Dev2JsonSerializer_SerializeToBuffer_WhenEsbExecuteRequest_ValidObjectStringBuffer()
{
//------------Setup for test--------------------------
var js = new Dev2JsonSerializer();
var request = new EsbExecuteRequest {
ServiceName = "Foobar"
};
request.AddArgument("key1", new StringBuilder("value1"));
request.AddArgument("key2", new StringBuilder("value2"));
//------------Execute Test---------------------------
var result = js.SerializeToBuilder(request);
//------------Assert Results-------------------------
var resultObj = js.Deserialize <EsbExecuteRequest>(result);
Assert.AreEqual(request.ServiceName, resultObj.ServiceName);
Assert.AreEqual(request.Args["key1"].ToString(), resultObj.Args["key1"].ToString());
Assert.AreEqual(request.Args["key2"].ToString(), resultObj.Args["key2"].ToString());
}
public void WorkflowResume_Values_startActivityId_NotValidGUID_Fails()
{
//------------Setup for test--------------------------
var values = new Dictionary <string, StringBuilder>
{
{ "resourceID", new StringBuilder("ab04663e-1e09-4338-8f61-a06a7ae5ebab") },
{ "environment", new StringBuilder("NewEnvironment") },
{ "startActivityId", new StringBuilder("4fb3-4208-af48-b92a0602ab4b") },
{ "versionNumber", new StringBuilder("1") },
{ "currentuserprincipal", new StringBuilder("currentuserprincipal") }
};
var workflowResume = new WorkflowResume();
//------------Execute Test---------------------------
var jsonResult = workflowResume.Execute(values, null);
//------------Assert Results-------------------------
var serializer = new Dev2JsonSerializer();
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
Assert.IsTrue(result.HasError);
Assert.AreEqual("startActivityId is not a valid GUID.", result.Message.ToString());
}
public Guid GetResourceID(Dictionary <string, StringBuilder> requestArgs)
{
if (requestArgs != null && requestArgs.Count > 0)
{
StringBuilder resourceDefinition;
requestArgs.TryGetValue("ResourceXml", out resourceDefinition);
if (resourceDefinition != null && resourceDefinition.Length > 0)
{
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
resourceDefinition = new StringBuilder(serializer.Deserialize <CompressedExecuteMessage>(resourceDefinition).GetDecompressedMessage());
var xml = resourceDefinition.ToXElement();
var resource = new Resource(xml);
var res = ResourceCatalog.Instance.GetResource(GlobalConstants.ServerWorkspaceID, resource.ResourceID);
if (res != null)
{
return(res.ResourceID);
}
}
}
return(Guid.Empty);
}
public void FetchExplorerItems_Execute_ExpectName()
{
//------------Setup for test--------------------------
var fetchExplorerItems = new FetchExplorerItems();
ServerExplorerItem item = new ServerExplorerItem("a", Guid.NewGuid(), ResourceType.Folder, null, Permissions.DeployFrom, "");
var repo = new Mock <IExplorerServerResourceRepository>();
var ws = new Mock <IWorkspace>();
repo.Setup(a => a.Load(It.IsAny <Guid>())).Returns(item).Verifiable();
var serializer = new Dev2JsonSerializer();
ws.Setup(a => a.ID).Returns(Guid.Empty);
fetchExplorerItems.ServerExplorerRepo = repo.Object;
//------------Execute Test---------------------------
var ax = fetchExplorerItems.Execute(new Dictionary <string, StringBuilder>(), ws.Object);
//------------Assert Results-------------------------
repo.Verify(a => a.Load(It.IsAny <Guid>()));
Assert.AreEqual(serializer.Deserialize <IExplorerItem>(ax.ToString()).ResourceId, item.ResourceId);
}
public void SaveServerSettings_Execute_SaveServerSettingsData()
{
//------------Setup for test--------------------------
var serializer = new Dev2JsonSerializer();
var workspaceMock = new Mock <IWorkspace>();
var settingsData = new ServerSettingsData()
{
ExecutionLogLevel = LogLevel.DEBUG.ToString()
};
var requestArgs = new Dictionary <string, StringBuilder>();
requestArgs.Add("ServerSettings", new StringBuilder(serializer.SerializeToBuilder(settingsData).ToString()));
var saveServerSettings = new SaveServerSettings();
//------------Execute Test---------------------------
var jsonResult = saveServerSettings.Execute(requestArgs, workspaceMock.Object);
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
//------------Assert Results-------------------------
Assert.IsFalse(result.HasError);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var result = new ExecuteMessage {
HasError = false
};
values.TryGetValue("Resource", out StringBuilder tmp);
var serializer = new Dev2JsonSerializer();
try
{
TryExecute(values, result, tmp, serializer);
}
catch (Exception e)
{
Dev2Logger.Error(e, GlobalConstants.WarewolfError);
result.Message.Append($"Error while saving: {e.Message.Remove(e.Message.IndexOf('.'))}");
result.HasError = true;
}
return(serializer.SerializeToBuilder(result));
}
public void Execute_GivenNoArgs_Exception()
{
//------------Setup for test-------------------------
var findResource = new FindResource();
var workspaceMock = new Mock <IWorkspace>();
var resId = Guid.NewGuid();
//------------Execute Test---------------------------
var requestArgs = new Dictionary <string, StringBuilder>
{
{ "FindResourceTests", "SomeName".ToStringBuilder() },
{ "ResourceType", "ResourceType".ToStringBuilder() }
};
var executeResults = findResource.Execute(requestArgs, workspaceMock.Object);
var jsonSerializer = new Dev2JsonSerializer();
Assert.IsNotNull(executeResults);
var deserializedResults = jsonSerializer.Deserialize <IList <SerializableResource> >(executeResults);
//------------Assert Results-------------------------
Assert.IsNotNull(deserializedResults);
}
/// <summary>
/// Add a folder to a warewolf server
/// </summary>
/// <param name="path"></param>
/// <param name="name"></param>
/// <param name="id"></param>
public void AddFolder(string path, string name, Guid id)
{
var controller = CommunicationControllerFactory.CreateController("AddFolderService");
string resourcePath = String.IsNullOrEmpty(path) ? name : $"{path}\\{name}";
Dev2JsonSerializer serialiser = new Dev2JsonSerializer();
ServerExplorerItem explorerItemModel = new ServerExplorerItem
{
DisplayName = name,
ResourceType = "Folder",
ResourcePath = resourcePath,
ResourceId = id
};
controller.AddPayloadArgument("itemToAdd", serialiser.SerializeToBuilder(explorerItemModel));
var result = controller.ExecuteCommand <IExplorerRepositoryResult>(Connection, GlobalConstants.ServerWorkspaceID);
if (result.Status != ExecStatus.Success)
{
throw new WarewolfSaveException(result.Message, null);
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
try
{
var fileLogLevel = Dev2Logger.GetFileLogLevel();
var eventLogLevel = Dev2Logger.GetEventLogLevel();
var logMaxSize = Dev2Logger.GetLogMaxSize();
var loggingSettings = new LoggingSettingsTo {
FileLoggerLogLevel = fileLogLevel, EventLogLoggerLogLevel = eventLogLevel, FileLoggerLogSize = logMaxSize
};
var serializer = new Dev2JsonSerializer();
var serializeToBuilder = serializer.SerializeToBuilder(loggingSettings);
return(serializeToBuilder);
}
catch (Exception e)
{
Dev2Logger.Error("LoggingSettingsRead", e);
}
return(null);
}
public StringBuilder ProcessRequest(EsbExecuteRequest request, Guid workspaceId, Guid dataListId, string connectionId)
{
var channel = new EsbServicesEndpoint();
var isManagementResource = ProcessDsfDataObject(request, workspaceId, dataListId, connectionId, channel);
if (!DsfDataObject.Environment.HasErrors())
{
return(ProcessRequest(request, workspaceId, channel, DsfDataObject, isManagementResource));
}
var msg = new ExecuteMessage {
HasError = true
};
msg.SetMessage(string.Join(Environment.NewLine, DsfDataObject.Environment.Errors));
var serializer = new Dev2JsonSerializer();
return(serializer.SerializeToBuilder(msg));
}
