/// <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);
}
}
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)
{
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)
{
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, 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;
}
}
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 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 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 GetVersions_Execute_NullValuesParameter_ErrorResult()
{
//------------Setup for test--------------------------
var getVersions = new GetServerVersion();
var serializer = new Dev2JsonSerializer();
//------------Execute Test---------------------------
StringBuilder jsonResult = getVersions.Execute(null, null);
var result = serializer.Deserialize<string>(jsonResult);
//------------Assert Results-------------------------
Assert.IsNotNull(result);
}
public void GetVersions_Execute_NullValuesParameter_ErrorResult()
{
//------------Setup for test--------------------------
var getVersions = new GetVersions();
var serializer = new Dev2JsonSerializer();
//------------Execute Test---------------------------
StringBuilder jsonResult = getVersions.Execute(null, null);
IExplorerRepositoryResult result = serializer.Deserialize<IExplorerRepositoryResult>(jsonResult);
//------------Assert Results-------------------------
Assert.AreEqual(ExecStatus.Fail, result.Status);
}
public void MoveItem_Execute_ItemToRenameNotInValues_ErrorResult()
{
//------------Setup for test--------------------------
var values = new Dictionary<string, StringBuilder> { { "item", new StringBuilder() } };
var MoveItemService = new MoveItemService();
var serializer = new Dev2JsonSerializer();
//------------Execute Test---------------------------
StringBuilder jsonResult = MoveItemService.Execute(values, null);
IExplorerRepositoryResult result = serializer.Deserialize<IExplorerRepositoryResult>(jsonResult);
//------------Assert Results-------------------------
Assert.AreEqual(ExecStatus.Fail, result.Status);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
var result = new ExecuteMessage { HasError = false };
StringBuilder tmp;
values.TryGetValue("Resource", out tmp);
var serializer = new Dev2JsonSerializer();
try
{
if(tmp != null)
{
var res = serializer.Deserialize<IScheduledResource>(tmp);
Dev2Logger.Log.Info("Save Scheduled Resource. Scheduled Resource:" +res);
using(var model = SchedulerFactory.CreateModel(GlobalConstants.SchedulerFolderId, SecurityWrapper))
{
StringBuilder userName;
StringBuilder password;
values.TryGetValue("UserName", out userName);
values.TryGetValue("Password", out password);
if(userName == null || password == null)
{
result.Message.Append("No UserName or password provided");
result.HasError = true;
}
else
{
StringBuilder previousTask;
values.TryGetValue("PreviousResource", out previousTask);
model.Save(res, userName.ToString(), password.ToString());
if(previousTask != null && !String.IsNullOrEmpty(previousTask.ToString()) && previousTask.ToString() != res.Name)
{
model.DeleteSchedule(new ScheduledResource(previousTask.ToString(), SchedulerStatus.Disabled, DateTime.MaxValue, null, null));
}
}
}
}
else
{
result.Message.Append("No Resource Selected");
result.HasError = true;
}
}
catch(Exception e)
{
Dev2Logger.Log.Error(e);
result.Message.Append(string.Format("Error while saving: {0}", e.Message.Remove(e.Message.IndexOf('.'))));
result.HasError = true;
}
return serializer.SerializeToBuilder(result);
}
public void ResourceTypeConvertor_ConvertToJson_EnumAsString_Deserialise_ExpectConvert_OldServer_IsServer()
{
//------------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"));
data = data.Replace(@"""ResourceType"": ""DbService""", @"""ResourceType"": ""1024""");
var item = (ServerExplorerItem)serializer.Deserialize(data, typeof(ServerExplorerItem));
Assert.AreEqual(ResourceType.Server, item.ResourceType);
//------------Assert Results-------------------------
}
public void RolbackTo_Execute_InvalidParams()
{
//------------Setup for test--------------------------
var rolbackTo = new RollbackTo();
var serializer = new Dev2JsonSerializer();
var ws = new Mock<IWorkspace>();
//------------Execute Test---------------------------
var ax = rolbackTo.Execute(new Dictionary<string, StringBuilder>(), ws.Object);
//------------Assert Results-------------------------
var des =serializer.Deserialize<ExecuteMessage>(ax);
Assert.AreEqual(des.HasError,true);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
var itemToAdd = serializer.Deserialize<ServerExplorerItem>(values["itemToAdd"]);
Dev2Logger.Log.Info("Add Folder Service." +itemToAdd);
itemToAdd.Permissions = Permissions.Contribute;
if(itemToAdd.ResourcePath.ToLower().StartsWith("root\\"))
{
itemToAdd.ResourcePath = itemToAdd.ResourcePath.Remove(0, 5);
}
var item = ServerExplorerRepo.AddItem(itemToAdd, theWorkspace.ID);
return serializer.SerializeToBuilder(item);
}
public void Ping_Execute_Returns_Pong()
{
//------------Setup for test--------------------------
var now = DateTime.Now;
var ping = new Ping { Now = () => now };
var expected = "Pong @ " + now.ToString("yyyy-MM-dd hh:mm:ss.fff");
//------------Execute Test---------------------------
var result = ping.Execute(It.IsAny<Dictionary<string, StringBuilder>>(), It.IsAny<IWorkspace>());
var ser = new Dev2JsonSerializer();
var msg = ser.Deserialize<ExecuteMessage>(result);
//------------Assert Results-------------------------
Assert.AreEqual(expected, msg.Message.ToString());
}
public IList<IExplorerItem> DeleteVersion(Guid resourceId, string versionNumber)
{
var workSpaceId = Guid.NewGuid();
var controller = CommunicationControllerFactory.CreateController("DeleteVersion");
controller.AddPayloadArgument("resourceId", resourceId.ToString());
controller.AddPayloadArgument("versionNumber", versionNumber);
var result = controller.ExecuteCommand<ExecuteMessage>(Connection, workSpaceId);
if (result == null || result.HasError)
{
return null;
}
var serializer = new Dev2JsonSerializer();
return serializer.Deserialize<IList<IExplorerItem>>(result.Message);
}
public void GetVersions_Execute_ExpectName()
{
//------------Setup for test--------------------------
var getVersions = new GetVersions();
var resourceId = Guid.NewGuid();
ServerExplorerItem item = new ServerExplorerItem("a", Guid.NewGuid(), ResourceType.Folder, null, Permissions.DeployFrom, "");
var repo = new Mock<IServerVersionRepository>();
var ws = new Mock<IWorkspace>();
repo.Setup(a => a.GetVersions(resourceId)).Returns(new List<IExplorerItem> {item});
var serializer = new Dev2JsonSerializer();
ws.Setup(a => a.ID).Returns(Guid.Empty);
getVersions.ServerVersionRepo = repo.Object;
//------------Execute Test---------------------------
var ax = getVersions.Execute(new Dictionary<string, StringBuilder> {{"resourceId",new StringBuilder( resourceId.ToString())}}, ws.Object);
//------------Assert Results-------------------------
repo.Verify(a => a.GetVersions(It.IsAny<Guid>()));
Assert.AreEqual(serializer.Deserialize<IList<IExplorerItem>>(ax.ToString())[0].ResourceId, item.ResourceId);
}
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);
}
/// <summary>
/// Parses the items.
/// </summary>
/// <param name="data">The data.</param>
public static IList<IDebugState> ParseItems(string data)
{
try
{
// Amend for namespace change ;)
var parseData = data.Replace("Dev2.Diagnostics.DebugState", "Dev2.Diagnostics.Debug.DebugState");
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
IList<IDebugState> debugItems = serializer.Deserialize<List<IDebugState>>(parseData);
return debugItems;
}
catch(Exception e)
{
Dev2Logger.Log.Error("RemoteDebugItemParser", e);
}
return null;
}
public void Ping_Execute_Returns_Pong()
{
//------------Setup for test--------------------------
var now = DateTime.Now;
var ping = new Ping {
Now = () => now
};
var expected = "Pong @ " + now.ToString("yyyy-MM-dd hh:mm:ss.fff");
//------------Execute Test---------------------------
var result = ping.Execute(It.IsAny <Dictionary <string, StringBuilder> >(), It.IsAny <IWorkspace>());
var ser = new Dev2JsonSerializer();
var msg = ser.Deserialize <ExecuteMessage>(result);
//------------Assert Results-------------------------
Assert.AreEqual(expected, msg.Message.ToString());
}
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 sourceFilePath = Config.Server.AuditFilePath;
var auditsFilePath = updatedServerSettings.AuditFilePath;
if (sourceFilePath != auditsFilePath)
{
var source = Path.Combine(sourceFilePath, "auditDB.db");
IFile _file = new FileWrapper();
if (_file.Exists(source))
{
var destination = Path.Combine(auditsFilePath, "auditDB.db");
CreateIfNotExists(auditsFilePath);
_file.Move(source, destination);
Config.Server.AuditFilePath = auditsFilePath;
msg.Message = new StringBuilder("Moved");
}
}
else
{
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 StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage msg = new ExecuteMessage();
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Resource Service");
StringBuilder resourceDefinition;
values.TryGetValue("EmailServiceSource", out resourceDefinition);
IEmailServiceSource src = serializer.Deserialize <EmailServiceSourceDefinition>(resourceDefinition);
EmailSource con = new EmailSource
{
Host = src.HostName,
UserName = src.UserName,
Password = src.Password,
Port = src.Port,
EnableSsl = src.EnableSsl,
Timeout = src.Timeout
};
try
{
con.Send(new MailMessage(src.EmailFrom, src.EmailTo, "Test Email Service Source", "Test message from Warewolf for Email Service Source"));
}
catch (SmtpException e)
{
msg.HasError = false;
msg.Message = new StringBuilder(e.Message);
return(serializer.SerializeToBuilder(msg));
//msg.HasError = true;
//msg.Message = new StringBuilder(e.Message);
}
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err);
}
return(serializer.SerializeToBuilder(msg));
}
public bool SaveTasks()
{
if (_schedulerViewModel.CurrentEnvironment.IsConnected)
{
var authService = _schedulerViewModel.CurrentEnvironment.AuthorizationService;
if (authService != null && authService.IsAuthorized(AuthorizationContext.Administrator, null))
{
if (!ValidateSelectedTask())
{
return(false);
}
GetCredentials(_schedulerViewModel.SelectedTask);
string errorMessage;
if (!_schedulerViewModel.ScheduledResourceModel.Save(_schedulerViewModel.SelectedTask, out errorMessage))
{
_schedulerViewModel.ShowSaveErrorDialog(errorMessage);
_schedulerViewModel.ShowError(errorMessage);
return(false);
}
Dev2Logger.Info($"Save Schedule. Environment: {_schedulerViewModel.CurrentEnvironment.Name} Name:{(_schedulerViewModel.SelectedTask != null ? _schedulerViewModel.SelectedTask.Name : string.Empty)} ");
if (_schedulerViewModel.SelectedTask != null)
{
_schedulerViewModel.SelectedTask.Errors.ClearErrors();
_schedulerViewModel.NotifyOfPropertyChange(() => _schedulerViewModel.Error);
_schedulerViewModel.NotifyOfPropertyChange(() => _schedulerViewModel.Errors);
_schedulerViewModel.SelectedTask.OldName = _schedulerViewModel.SelectedTask.Name;
_schedulerViewModel.SelectedTask.IsNew = false;
_schedulerViewModel.Item = _ser.Deserialize <IScheduledResource>(_ser.SerializeToBuilder(_schedulerViewModel.SelectedTask));
_schedulerViewModel.NotifyOfPropertyChange(() => _schedulerViewModel.IsDirty);
}
_schedulerViewModel.NotifyOfPropertyChange(() => _schedulerViewModel.TaskList);
}
else
{
_schedulerViewModel.ShowError(@"Error while saving: You don't have permission to schedule on this server. You need Administrator permission.");
return(false);
}
return(true);
}
_schedulerViewModel.ShowError(Core.SchedulerNotConnectedErrorMessage);
return(false);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage msg = new ExecuteMessage();
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Resource Service");
StringBuilder resourceDefinition;
values.TryGetValue("ServerSource", out resourceDefinition);
IServerSource src = serializer.Deserialize <ServerSource>(resourceDefinition);
Connection con = new Connection();
int portIndex = GetSpecifiedIndexOf(src.Address, ':', 2);
string port = src.Address.Substring(portIndex + 1);
con.Address = src.Address;
con.AuthenticationType = src.AuthenticationType;
con.UserName = src.UserName;
con.Password = src.Password;
con.ResourceName = src.Name;
con.ResourceID = src.ID;
con.WebServerPort = int.Parse(port);
Connections tester = new Connections();
var res = tester.CanConnectToServer(con);
if (res.IsValid)
{
ResourceCatalog.Instance.SaveResource(GlobalConstants.ServerWorkspaceID, con, src.ResourcePath);
}
ServerExplorerRepo.UpdateItem(con);
msg.HasError = false;
msg.Message = new StringBuilder(res.IsValid ? "" : res.ErrorMessage);
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err);
}
return(serializer.SerializeToBuilder(msg));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Test Wcf Service", GlobalConstants.WarewolfInfo);
values.TryGetValue("wcfService", out StringBuilder resourceDefinition);
var service = serializer.Deserialize <IWcfService>(resourceDefinition);
var source = ResourceCatalog.Instance.GetResource <WcfSource>(GlobalConstants.ServerWorkspaceID, service.Source.Id);
var parameters = service.Inputs?.Select(a => new MethodParameter {
EmptyToNull = a.EmptyIsNull, IsRequired = a.RequiredField, Name = a.Name, Value = a.Value, TypeName = a.TypeName
}).ToList() ?? new List <MethodParameter>();
var res = new WcfService
{
Method = new ServiceMethod(service.Action.Method, service.Name, parameters, new OutputDescription(), new List <MethodOutput>(), service.Action.Method),
ResourceName = service.Name,
ResourceID = service.Id,
Source = source
};
var services = new ServiceModel.Services();
var output = services.WcfTest(res, GlobalConstants.ServerWorkspaceID, Guid.Empty);
msg.HasError = false;
msg.Message = serializer.SerializeToBuilder(new RecordsetListWrapper()
{
Description = output.Description, RecordsetList = output
});
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
}
return(serializer.SerializeToBuilder(msg));
}
public void TestElasticsearchSource_Execute_Auth_Password_GivenResourceDefinition_ShouldTestNewSourceReturnResourceDefinitionMsg()
{
//---------------Set up test pack-------------------
var serializer = new Dev2JsonSerializer();
var dependency = new Depends(Depends.ContainerType.AnonymousElasticsearch);
var hostName = "http://" + dependency.Container.IP;
var source = new ElasticsearchSourceDefinition()
{
Id = Guid.Empty,
Name = "Name",
HostName = hostName,
Port = dependency.Container.Port,
Username = "******",
Password = "******",
SearchIndex = "warewolftestlogs",
AuthenticationType = Dev2.Runtime.ServiceModel.Data.AuthenticationType.Password
};
var testElasticsearchSource = new TestElasticsearchSource();
var values = new Dictionary <string, StringBuilder>
{
{ "ElasticsearchSource", source.SerializeToJsonStringBuilder() }
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
try
{
var jsonResult = testElasticsearchSource.Execute(values, null);
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
//---------------Test Result -----------------------
Assert.IsFalse(result.HasError, result.Message.ToString());
}
catch (Exception e)
{
if (e.Message.Contains("could not connect to elasticsearch Instance"))
{
Assert.Inconclusive(e.Message);
}
else
{
throw;
}
}
}
private List <SpecAssignValue> GetCachedData(RedisCacheImpl impl, string key)
{
var activities = new List <SpecAssignValue>();
var actualCacheData = impl.Get(key);
if (actualCacheData != null)
{
var serializer = new Dev2JsonSerializer();
var actualData = serializer.Deserialize <IDictionary <string, string> >(actualCacheData);
foreach (var item in actualData)
{
activities.Add(new SpecAssignValue {
Name = item.Key, Value = item.Value
});
}
}
return(activities);
}
public void SaveTriggers_Execute_GivenResourceMoved_ShouldReturnResourceMovedMsg()
{
//------------Setup for test--------------------------
var serializer = new Dev2JsonSerializer();
var inputs = new Dictionary <string, StringBuilder>();
var resourceId = Guid.NewGuid();
var saveTriggers = new SaveTriggers();
var triggerQueues = new List <ITriggerQueue>
{
new TriggerQueue
{
QueueName = "Test Queue"
}
};
var mockResource = new Mock <IResource>();
mockResource.SetupGet(resource => resource.ResourceID).Returns(resourceId);
mockResource.Setup(resource => resource.GetResourcePath(It.IsAny <Guid>())).Returns("somePath");
var mockTriggersCatalog = new Mock <ITriggersCatalog>();
var mockResourceCatalog = new Mock <IResourceCatalog>();
mockResourceCatalog.Setup(catalog => catalog.GetResource(GlobalConstants.ServerWorkspaceID, resourceId)).Returns(mockResource.Object);
mockTriggersCatalog.Setup(a => a.SaveTriggers(It.IsAny <Guid>(), It.IsAny <List <ITriggerQueue> >())).Verifiable();
var ws = new Mock <IWorkspace>();
inputs.Add("resourceID", new StringBuilder(resourceId.ToString()));
var compressedExecuteMessage = new CompressedExecuteMessage();
compressedExecuteMessage.SetMessage(serializer.Serialize(triggerQueues));
inputs.Add("triggerDefinitions", serializer.SerializeToBuilder(compressedExecuteMessage));
inputs.Add("resourcePath", "otherPath".ToStringBuilder());
saveTriggers.TriggersCatalog = mockTriggersCatalog.Object;
saveTriggers.ResourceCatalog = mockResourceCatalog.Object;
//------------Execute Test---------------------------
var stringBuilder = saveTriggers.Execute(inputs, ws.Object);
//------------Assert Results-------------------------
var msg = serializer.Deserialize <ExecuteMessage>(stringBuilder);
Assert.IsFalse(msg.HasError);
Assert.IsTrue(msg.Message.Contains("Resource otherPath has changed to somePath. Triggers have been saved for this resource."));
}
/// <summary>
/// Tests if a valid connection to a server can be made returns 'Success' on a successful connection
/// </summary>
/// <param name="resource"></param>
/// <returns></returns>
/// <exception cref="WarewolfTestException">Unable to contact Server</exception>
public IList <string> TestDbConnection(IDbSource resource)
{
var con = Connection;
var comsController = CommunicationControllerFactory.CreateController("TestDbSourceService");
Dev2JsonSerializer 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));
}
/// <summary>
/// Delete a version o a resource
/// </summary>
/// <param name="resourceId">the resource</param>
/// <param name="versionNumber">the version to delete</param>
/// <param name="resourcePath"></param>
/// <returns></returns>
public IList <IExplorerItem> DeleteVersion(Guid resourceId, string versionNumber, string resourcePath)
{
var workSpaceId = Guid.NewGuid();
var controller = CommunicationControllerFactory.CreateController("DeleteVersion");
controller.AddPayloadArgument("resourceId", resourceId.ToString());
controller.AddPayloadArgument("versionNumber", versionNumber);
controller.AddPayloadArgument("resourcePath", resourcePath);
var result = controller.ExecuteCommand <ExecuteMessage>(_connection, workSpaceId);
if (result == null || result.HasError)
{
return(null);
}
var serializer = new Dev2JsonSerializer();
return(serializer.Deserialize <IList <IExplorerItem> >(result.Message));
}
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("DbService", out StringBuilder resourceDefinition);
IDatabaseService service = serializer.Deserialize <DatabaseService>(resourceDefinition);
var parameters = service.Inputs?.Select(a => new MethodParameter()
{
EmptyToNull = a.EmptyIsNull, IsRequired = a.RequiredField, Name = a.Name, Value = a.Value
}).ToList() ?? new List <MethodParameter>();
var source = ResourceCatalog.Instance.GetResource <DbSource>(GlobalConstants.ServerWorkspaceID, service.Source.Id);
var output = new List <MethodOutput>(service.OutputMappings.Select(a => new MethodOutput(a.MappedFrom, a.MappedTo, "", false, a.RecordSetName, false, "", false, "", false)));
var recset = new Recordset();
recset.Fields.AddRange(new List <RecordsetField>(service.OutputMappings.Select(a => new RecordsetField {
Name = a.MappedFrom, Alias = a.MappedTo, RecordsetAlias = a.RecordSetName, Path = new DataTablePath(a.RecordSetName, a.MappedFrom)
})));
recset.Name = service.Name;
var res = new DbService
{
Method = new ServiceMethod(service.Action.Name, service.Name, parameters, null, output, service.Action.Name),
ResourceName = service.Name,
ResourceID = service.Id,
Source = source,
Recordset = recset
};
ResourceCatalog.Instance.SaveResource(GlobalConstants.ServerWorkspaceID, res, service.Path);
ServerExplorerRepo.UpdateItem(res);
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 FetchPerformanceCounters_Manager_ExecuteReturnsAValidTo()
{
//------------Setup for test--------------------------
var mng = new Mock <IPerformanceCounterRepository>();
mng.Setup(a => a.Counters).Returns(new PerformanceCounterTo(new List <IPerformanceCounter>(), new List <IPerformanceCounter>()));
CustomContainer.Register(mng.Object);
var fetchPerformanceCounters = new FetchPerformanceCounters();
//------------Execute Test---------------------------
var output = fetchPerformanceCounters.Execute(new Dictionary <string, StringBuilder>(), new Mock <IWorkspace>().Object);
//------------Assert Results-------------------------
Assert.IsNotNull(output);
Dev2JsonSerializer ser = new Dev2JsonSerializer();
var res = ser.Deserialize <IPerformanceCounterTo>(output);
Assert.IsNotNull(res);
}
public IRollbackResult RollbackTo(Guid resourceId, string versionNumber)
{
var workSpaceId = Guid.NewGuid();
var controller = CommunicationControllerFactory.CreateController("RollbackTo");
controller.AddPayloadArgument("resourceId", resourceId.ToString());
controller.AddPayloadArgument("versionNumber", versionNumber);
var result = controller.ExecuteCommand <ExecuteMessage>(Connection, workSpaceId);
if (result == null || result.HasError)
{
return(null);
}
var serializer = new Dev2JsonSerializer();
return(serializer.Deserialize <IRollbackResult>(result.Message));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Com Plugin Source", GlobalConstants.WarewolfInfo);
values.TryGetValue("ComPluginSource", out StringBuilder resourceDefinition);
var src = serializer.Deserialize <ComPluginSourceDefinition>(resourceDefinition);
if (src.ResourcePath == null)
{
src.ResourcePath = string.Empty;
}
if (src.ResourcePath.EndsWith("\\"))
{
src.ResourcePath = src.ResourcePath.Substring(0, src.ResourcePath.LastIndexOf("\\", StringComparison.Ordinal));
}
ComPluginSource res1;
var existingSource = ResourceCat.GetResource(GlobalConstants.ServerWorkspaceID, src.Name);
res1 = existingSource != null ? existingSource as ComPluginSource : new ComPluginSource
{
ResourceID = src.Id,
ClsId = src.ClsId,
Is32Bit = src.Is32Bit,
ComName = src.SelectedDll.Name,
ResourceName = src.ResourceName
};
ResourceCat.SaveResource(GlobalConstants.ServerWorkspaceID, res1, src.ResourcePath);
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 TestCatalog_SaveTests_WhenResourceIdList_ShouldSaveTestAsAddToList()
{
//------------Setup for test--------------------------
var testCatalog = new TestCatalog();
var resourceID = Guid.NewGuid();
var testToSave = new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 1"
};
var testToSave2 = new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 2"
};
testCatalog.SaveTest(resourceID, testToSave);
//------------Execute Test---------------------------
testCatalog.SaveTest(resourceID, testToSave2);
//------------Assert Results-------------------------
var path = EnvironmentVariables.TestPath + "\\" + resourceID;
Assert.IsTrue(Directory.Exists(path));
var testFiles = Directory.EnumerateFiles(path).ToList();
var test2FilePath = path + "\\" + "Test 2.test";
Assert.AreEqual(test2FilePath, testFiles[1]);
var test2String = File.ReadAllText(test2FilePath);
var serializer = new Dev2JsonSerializer();
var test1 = serializer.Deserialize <IServiceTestModelTO>(test2String);
Assert.AreEqual("Test 2", test1.TestName);
Assert.IsFalse(test1.Enabled);
var testInList = testCatalog.FetchTest(resourceID, "Test 2");
Assert.IsNotNull(testInList);
Assert.AreEqual("Test 2", testInList.TestName);
}
/// <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)
{
if (values == null)
{
throw new InvalidDataContractException("No parameter values provided.");
}
string serializedSource = null;
StringBuilder tmp;
values.TryGetValue("SharepointServer", out tmp);
if (tmp != null)
{
serializedSource = tmp.ToString();
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
if (string.IsNullOrEmpty(serializedSource))
{
var res = new ExecuteMessage();
res.HasError = true;
res.SetMessage("No sharepoint server set");
Dev2Logger.Log.Debug("No sharepoint server set.");
return(serializer.SerializeToBuilder(res));
}
try
{
var sharepointSource = serializer.Deserialize <SharepointSource>(serializedSource);
var result = sharepointSource.TestConnection();
var sharepointSourceTo = new SharepointSourceTo
{
TestMessage = result,
IsSharepointOnline = sharepointSource.IsSharepointOnline
};
return(serializer.SerializeToBuilder(sharepointSourceTo));
}
catch (Exception ex)
{
Dev2Logger.Log.Error(ex);
var res = new DbColumnList(ex);
return(serializer.SerializeToBuilder(res));
}
}
public void GetResourceDefinition_CorrectServiceDef_MessageHasNoErrors()
{
//------------Setup for test--------------------------
var model = new ResourceDefinationCleaner();
var a = XmlResource.Fetch("Utility - Assign");
var dev2JsonSerializer = new Dev2JsonSerializer();
//------------Execute Test---------------------------
Assert.IsNotNull(model);
var cleanDef = model.GetResourceDefinition(false, Guid.NewGuid(), new System.Text.StringBuilder(a.ToString()));
var message = dev2JsonSerializer.Deserialize <ExecuteMessage>(cleanDef);
//------------Assert Results-------------------------
Assert.IsNotNull(cleanDef);
Assert.IsNotNull(message);
var hasError = message.HasError == false;
Assert.IsTrue(hasError);
}
public void RolbackTo_Execute_Valid_ExpectServerCalled()
{
//------------Setup for test--------------------------
var rolbackTo = new RollbackTo();
var serializer = new Dev2JsonSerializer();
var ws = new Mock <IWorkspace>();
var server = new Mock <IServerVersionRepository>();
var res = Guid.NewGuid();
//------------Execute Test---------------------------
rolbackTo.ServerVersionRepo = server.Object;
var ax = rolbackTo.Execute(new Dictionary <string, StringBuilder> {
{ "resourceId", new StringBuilder(res.ToString()) }, { "versionNumber", new StringBuilder("1") }
}, ws.Object);
//------------Assert Results-------------------------
serializer.Deserialize <ExecuteMessage>(ax);
server.Verify(a => a.RollbackTo(res, "1"));
}
public IEnumerable <IInputOutputViewModel> DeserializeMappings(bool isInput, XElement input)
{
try
{
var serializer = new Dev2JsonSerializer();
var defs = serializer.Deserialize <List <Dev2Definition> >(input.Value);
IList <IDev2Definition> idefs = new List <IDev2Definition>(defs);
var newMappings = isInput
? InputOutputViewModelFactory.CreateListToDisplayInputs(idefs)
: InputOutputViewModelFactory.CreateListToDisplayOutputs(idefs);
return(newMappings);
}
catch (Exception e)
{
Dev2Logger.Error(e, "Warewolf Error");
}
return(new List <IInputOutputViewModel>());
}
public void Dev2JsonSerializer_Deserializer_WhenUsingStreamWithLargePayload_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. She dinner she our horses depend. Remember at children by reserved to vicinity. In affronting unreserved delightful simplicity ye. Law own advantage furniture continual sweetness bed agreeable perpetual. Oh song well four only head busy it. Afford son she had lively living. Tastes lovers myself too formal season our valley boy. Lived it their their walls might to by young.
On insensible possession oh particular attachment at excellence in. The books arose but miles happy she. It building contempt or interest children mistress of unlocked no. Offending she contained mrs led listening resembled. Delicate marianne absolute men dashwood landlord and offended. Suppose cottage between and way. Minuter him own clothes but observe country. Agreement far boy otherwise rapturous incommode favourite.
Inquietude simplicity terminated she compliment remarkably few her nay. The weeks are ham asked jokes. Neglected perceived shy nay concluded. Not mile draw plan snug next all. Houses latter an valley be indeed wished merely in my. Money doubt oh drawn every or an china. Visited out friends for expense message set eat.
By so delight of showing neither believe he present. Deal sigh up in shew away when. Pursuit express no or prepare replied. Wholly formed old latter future but way she. Day her likewise smallest expenses judgment building man carriage gay. Considered introduced themselves mr to discretion at. Means among saw hopes for. Death mirth in oh learn he equal on.
Exquisite cordially mr happiness of neglected distrusts. Boisterous impossible unaffected he me everything. Is fine loud deal an rent open give. Find upon and sent spot song son eyes. Do endeavor he differed carriage is learning my graceful. Feel plan know is he like on pure. See burst found sir met think hopes are marry among. Delightful remarkably new assistance saw literature mrs favourable.
Behind sooner dining so window excuse he summer. Breakfast met certainty and fulfilled propriety led. Waited get either are wooded little her. Contrasted unreserved as mr particular collecting it everything as indulgence. Seems ask meant merry could put. Age old begin had boy noisy table front whole given.
Boy favourable day can introduced sentiments entreaties. Noisier carried of in warrant because. So mr plate seems cause chief widen first. Two differed husbands met screened his. Bed was form wife out ask draw. Wholly coming at we no enable. Offending sir delivered questions now new met. Acceptance she interested new boisterous day discretion celebrated.
That know ask case sex ham dear her spot. Weddings followed the all marianne nor whatever settling. Perhaps six prudent several her had offence. Did had way law dinner square tastes. Recommend concealed yet her procuring see consulted depending. Adieus hunted end plenty are his she afraid. Resources agreement contained propriety applauded neglected use yet.
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right at the coast of the Semantics, a large language ocean. A small river named Duden flows by their place and supplies it with the necessary regelialia. It is a paradisematic country, in which roasted parts of sentences fly into your mouth. Even the all-powerful
Pointing has no control about the blind texts it is an almost unorthographic life One day however a small line of blind text by the name of Lorem Ipsum decided to leave for the far World of Grammar. The Big Oxmox advised her not to do so, because there were thousands of bad Commas, wild Question Marks and devious Semikoli, but the Little Blind Text didn't listen. She packed her seven versalia, put her initial into the belt and made herself on the way. When she reached the first hills of the Italic Mountains, she had a last view back on the skyline of her hometown Bookmarksgrove, the headline of ";
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 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("EmailServiceSource", out StringBuilder resourceDefinition);
IEmailServiceSource src = serializer.Deserialize <EmailServiceSourceDefinition>(resourceDefinition);
var con = new EmailSource
{
Host = src.HostName,
UserName = src.UserName,
Password = src.Password,
Port = src.Port,
EnableSsl = src.EnableSsl,
Timeout = src.Timeout
};
try
{
var mailMessage = new MailMessage(src.EmailFrom, src.EmailTo, Messages.Test_EmailServerSource_Header, Messages.Test_EmailServerSource_EmailBody);
con.Send(mailMessage);
}
catch (SmtpException e)
{
msg.HasError = true;
msg.Message = new StringBuilder(e.Message);
return(serializer.SerializeToBuilder(msg));
}
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
}
return(serializer.SerializeToBuilder(msg));
}
/// <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)
{
if(values == null)
{
throw new InvalidDataContractException("No parameter values provided.");
}
string serializedSource = null;
StringBuilder tmp;
values.TryGetValue("SharepointServer", out tmp);
if(tmp != null)
{
serializedSource = tmp.ToString();
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
if(string.IsNullOrEmpty(serializedSource))
{
var res = new ExecuteMessage();
res.HasError = true;
res.SetMessage("No sharepoint server set");
Dev2Logger.Log.Debug("No sharepoint server set.");
return serializer.SerializeToBuilder(res);
}
try
{
var sharepointSource = serializer.Deserialize<SharepointSource>(serializedSource);
var result = sharepointSource.TestConnection();
var sharepointSourceTo = new SharepointSourceTo
{
TestMessage = result,
IsSharepointOnline = sharepointSource.IsSharepointOnline
};
return serializer.SerializeToBuilder(sharepointSourceTo);
}
catch(Exception ex)
{
Dev2Logger.Log.Error(ex);
var res = new DbColumnList(ex);
return serializer.SerializeToBuilder(res);
}
}
public void TestWebService_Execute_Source_NotFound_ExpectHasError()
{
var serializer = new Dev2JsonSerializer();
var sut = new TestWebService();
var webService = new WebServiceDefinition();
var values = new Dictionary <string, StringBuilder>
{
{ "WebService", webService.SerializeToJsonStringBuilder() }
};
var result = sut.Execute(values, null);
var executeMessage = serializer.Deserialize <ExecuteMessage>(result);
Assert.IsNotNull(result);
Assert.IsTrue(executeMessage.HasError);
Assert.IsTrue(executeMessage.Message.Contains("Parameter name: source"));
}
public void WorkflowResume_Values_resourceID_Missing_Fails()
{
//------------Setup for test--------------------------
var values = new Dictionary <string, StringBuilder>
{
{ "environment", new StringBuilder("NewEnvironment") },
{ "startActivityId", new StringBuilder("4032a11e-4fb3-4208-af48-b92a0602ab4b") },
{ "versionNumber", new StringBuilder("1") },
{ "currentuserprincipal", new StringBuilder("username") }
};
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("resourceID is missing", result.Message.ToString());
}
public void GetLogDataService_Execute_WithExecutionId_ShouldFilterLogData()
{
//------------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.AreEqual("{ \"Message\": \"Hello World.\"}", logEntry.Result);
}
public void WorkflowResume_Values_startActivityId_Missing_Fails()
{
//------------Setup for test--------------------------
var values = new Dictionary <string, StringBuilder>
{
{ "resourceID", new StringBuilder("ab04663e-1e09-4338-8f61-a06a7ae5ebab") },
{ "environment", new StringBuilder("NewEnvironment") },
{ "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("no startActivityId passed.", result.Message.ToString());
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Manager.Save(serializer.Deserialize <IPerformanceCounterTo>(values["PerformanceCounterTo"]));
msg.HasError = false;
msg.Message = new StringBuilder();
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
}
return(serializer.SerializeToBuilder(msg));
}
public void SaveTriggerQueueService_Execute()
{
var serializer = new Dev2JsonSerializer();
var source = new TriggerQueueForTest();
var values = new Dictionary <string, StringBuilder>
{
{ "TriggerQueue", source.SerializeToJsonStringBuilder() }
};
var saveTriggerQueueService = new SaveTriggerQueueService();
var jsonResult = saveTriggerQueueService.Execute(values, null);
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
Assert.IsFalse(result.HasError);
var triggerId = Guid.Parse(result.Message.ToString());
Assert.IsTrue(triggerId != Guid.Empty);
}
public Guid GetResourceID(Dictionary <string, StringBuilder> requestArgs)
{
if (requestArgs != null && requestArgs.Count > 0)
{
requestArgs.TryGetValue("ResourceXml", out StringBuilder resourceDefinition);
if (resourceDefinition != null && resourceDefinition.Length > 0)
{
var 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);
}
void ShouldExecuteDeploy(Dictionary <string, StringBuilder> values, List <DeployResult> toReturn, Dev2JsonSerializer serializer, IHubProxy proxy, StringBuilder roles, StringBuilder deployTests, StringBuilder deployTriggers)
{
var doTestDeploy = bool.Parse(deployTests.ToString());
var doTriggerDeploy = bool.Parse(deployTriggers.ToString());
values.TryGetValue("resourceIDsToDeploy", out StringBuilder resourceIDsToDeploy);
var idsToDeploy = new List <Guid>();
idsToDeploy.AddRange(serializer.Deserialize <List <Guid> >(resourceIDsToDeploy));
if (idsToDeploy.Any())
{
var counter = 0;
var count = idsToDeploy.Count;
var amountToTake = 10;
while (counter < count)
{
var diff = count - counter;
if (diff < 10)
{
amountToTake = diff;
}
var throttledIds = idsToDeploy.Skip(counter).Take(amountToTake);
var taskList = new List <Task>();
foreach (var resourceId in throttledIds)
{
var lastTask = GetTaskForDeploy(resourceId, roles, serializer, proxy, doTestDeploy, doTriggerDeploy, toReturn);
taskList.Add(lastTask);
}
Task.WaitAll(taskList.ToArray());
counter = counter + 10;
}
}
else
{
toReturn.Add(new DeployResult(new ExecuteMessage {
HasError = true, Message = new StringBuilder("No resources specified")
}, "An Error has occurred"));
}
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
if(values == null)
{
throw new InvalidDataException("Empty values passed.");
}
StringBuilder securitySettings;
values.TryGetValue("SecuritySettings", out securitySettings);
StringBuilder timeoutPeriodString;
values.TryGetValue("TimeoutPeriod", out timeoutPeriodString);
if(securitySettings == null || securitySettings.Length == 0)
{
throw new InvalidDataException("Empty Security Settings passed.");
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
try
{
var securitySettingsTo = serializer.Deserialize<SecuritySettingsTO>(securitySettings);
if(securitySettingsTo == null)
{
throw new InvalidDataException("The security settings are not valid.");
}
Write(securitySettings);
ServerAuthorizationService.Instance.SecurityService.Read();
}
catch(Exception e)
{
throw new InvalidDataException(string.Format("The security settings are not valid. Error: {0}", e.Message));
}
ExecuteMessage msg = new ExecuteMessage { HasError = false };
msg.SetMessage("Success");
return serializer.SerializeToBuilder(msg);
}
public void JsonSerializer_SerializeToBuffer_WhenEsbExecuteRequest_ValidObjectStringBuffer()
{
//------------Setup for test--------------------------
Dev2JsonSerializer js = new Dev2JsonSerializer();
EsbExecuteRequest 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-------------------------
Assert.AreEqual(679, result.Length);
var resultObj = js.Deserialize<EsbExecuteRequest>(result);
// check service name hydration
Assert.AreEqual(request.ServiceName, resultObj.ServiceName);
// ensure args hydrate ;)
Assert.AreEqual(request.Args["key1"].ToString(), resultObj.Args["key1"].ToString());
Assert.AreEqual(request.Args["key2"].ToString(), resultObj.Args["key2"].ToString());
}
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 SerializableResource FetchRemoteResource(Guid serviceId, string serviceName, bool isDebugMode)
{
var connection = GetConnection(DataObject.EnvironmentID);
if (connection == null)
{
return null;
}
try
{
var returnData = ExecuteGetRequest(connection, "FindResourceService", string.Format("ResourceType={0}&ResourceName={1}&ResourceId={2}", "TypeWorkflowService", serviceName, serviceId), isDebugMode);
if (!string.IsNullOrEmpty(returnData))
{
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
var serializableResources = serializer.Deserialize<IList<SerializableResource>>(returnData);
return serializableResources.FirstOrDefault(resource => resource.ResourceType == ResourceType.WorkflowService);
}
}
catch (Exception)
{
return null;
}
return null;
}
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);
}
/// <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);
var resource = Resources.GetResource(theWorkspace.ID, version.ResourceId);
if (resource != null && resource.ResourceType == ResourceType.DbSource)
{
res.Message.Append(result);
}
else
{
var startIdx = result.IndexOf(PayloadStart, 0, false);
if (startIdx >= 0)
{
// remove beginning junk
startIdx += PayloadStart.Length;
result = result.Remove(0, startIdx);
startIdx = result.IndexOf(PayloadEnd, 0, false);
if (startIdx > 0)
{
var len = result.Length - startIdx;
result = result.Remove(startIdx, len);
res.Message.Append(result.Unescape());
}
}
else
{
// handle services ;)
startIdx = result.IndexOf(AltPayloadStart, 0, false);
if (startIdx >= 0)
{
// remove begging junk
startIdx += AltPayloadStart.Length;
result = result.Remove(0, startIdx);
startIdx = result.IndexOf(AltPayloadEnd, 0, false);
if (startIdx > 0)
{
var len = result.Length - startIdx;
result = result.Remove(startIdx, len);
res.Message.Append(result.Unescape());
}
}
else
{
// send the entire thing ;)
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);
}
}
/// <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)
{
if(values == null)
{
throw new InvalidDataContractException("No parameter values provided.");
}
string database = null;
string tableName = null;
string schema = null;
StringBuilder tmp;
values.TryGetValue("Database", out tmp);
if(tmp != null)
{
database = tmp.ToString();
}
values.TryGetValue("TableName", out tmp);
if(tmp != null)
{
tableName = tmp.ToString();
}
values.TryGetValue("Schema", out tmp);
if(tmp != null)
{
schema = tmp.ToString();
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
if(string.IsNullOrEmpty(database))
{
var res = new DbColumnList("No database set.");
Dev2Logger.Log.Debug("No database set.");
return serializer.SerializeToBuilder(res);
}
if(string.IsNullOrEmpty(tableName))
{
var res = new DbColumnList("No table name set.");
Dev2Logger.Log.Debug("No table name set.");
return serializer.SerializeToBuilder(res);
}
Dev2Logger.Log.Info(String.Format("Get Database Columns For Table. Database:{0} Schema:{1} Table{2}" ,database,schema,tableName));
try
{
var dbSource = serializer.Deserialize<DbSource>(database);
var runtTimedbSource = ResourceCatalog.Instance.GetResource<DbSource>(theWorkspace.ID, dbSource.ResourceID);
DataTable columnInfo;
switch (dbSource.ServerType)
{
case enSourceType.MySqlDatabase:
{
using (var connection = new MySqlConnection(runtTimedbSource.ConnectionString))
{
// Connect to the database then retrieve the schema information.
connection.Open();
var sql = @"select * from " + tableName.Trim('"').Replace("[","").Replace("]","") + " Limit 1 ";
using (var sqlcmd = new MySqlCommand(sql, connection))
{
// force it closed so we just get the proper schema ;)
using (var sdr = sqlcmd.ExecuteReader(CommandBehavior.CloseConnection))
{
columnInfo = sdr.GetSchemaTable();
}
}
}
break;
}
default:
{
using (var connection = new SqlConnection(runtTimedbSource.ConnectionString))
{
// Connect to the database then retrieve the schema information.
connection.Open();
// GUTTED TO RETURN ALL REQUIRED DATA ;)
if (schema == null)
{
schema = string.Empty;
}
var sql = @"select top 1 * from " + schema.Trim('"') + "." + tableName.Trim('"');
using (var sqlcmd = new SqlCommand(sql, connection))
{
// force it closed so we just get the proper schema ;)
using (var sdr = sqlcmd.ExecuteReader(CommandBehavior.CloseConnection))
{
columnInfo = sdr.GetSchemaTable();
}
}
}
break;
}
}
var dbColumns = new DbColumnList();
if(columnInfo != null)
{
foreach(DataRow row in columnInfo.Rows)
{
var columnName = row["ColumnName"] as string;
var isNullable = row["AllowDBNull"] is bool && (bool)row["AllowDBNull"];
var isIdentity = row["IsIdentity"] is bool && (bool)row["IsIdentity"];
var dbColumn = new DbColumn { ColumnName = columnName, IsNullable = isNullable, IsAutoIncrement = isIdentity };
SqlDbType sqlDataType;
var typeValue = dbSource.ServerType == enSourceType.SqlDatabase? row["DataTypeName"] as string:((Type)row["DataType"]).Name;
if(Enum.TryParse(typeValue, true, out sqlDataType))
{
dbColumn.SqlDataType = sqlDataType;
}
var columnLength = row["ColumnSize"] is int ? (int)row["ColumnSize"] : -1;
dbColumn.MaxLength = columnLength;
dbColumns.Items.Add(dbColumn);
}
}
return serializer.SerializeToBuilder(dbColumns);
}
catch(Exception ex)
{
Dev2Logger.Log.Error(ex);
var res = new DbColumnList(ex);
return serializer.SerializeToBuilder(res);
}
}
