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)
{
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 static ExecuteMessage MakeMessage(string msg)
{
var result = new ExecuteMessage { HasError = false };
result.SetMessage(msg);
return result;
}
public void WorkspaceItemRepositoryWorkspaceItemsExpectedInvokesReadFirstTime()
{
string resourceName;
Guid workspaceID;
Guid serverID;
var mockConn = new Mock<IEnvironmentConnection>();
mockConn.Setup(c => c.IsConnected).Returns(true);
ExecuteMessage msg = new ExecuteMessage { HasError = false };
msg.SetMessage("Workspace item updated");
var payload = JsonConvert.SerializeObject(msg);
mockConn.Setup(c => c.ExecuteCommand(It.IsAny<StringBuilder>(), It.IsAny<Guid>())).Returns(new StringBuilder(payload)).Verifiable();
var model = CreateModel(ResourceType.Service, mockConn, out resourceName, out workspaceID, out serverID);
var repositoryPath = GetUniqueRepositoryPath();
// Create repository file with one item in it
var repository = new WorkspaceItemRepository(repositoryPath);
repository.AddWorkspaceItem(model.Object);
// Now create a new repository from the previous file
repository = new WorkspaceItemRepository(repositoryPath);
// Access items for the first time
var items = repository.WorkspaceItems;
Assert.AreEqual(1, items.Count);
Assert.AreEqual(workspaceID, items[0].WorkspaceID);
Assert.AreEqual(serverID, items[0].ServerID);
Assert.AreEqual(resourceName, items[0].ServiceName);
Assert.AreEqual(WorkspaceItem.ServiceServiceType, items[0].ServiceType);
}
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 void ExecuteMessage_Constructor_WhenSettingHasErrors_ExpectHasErrorsTrue()
{
//------------Setup for test--------------------------
var executeMessage = new ExecuteMessage { HasError = true};
executeMessage.SetMessage("the message");
//------------Assert Results-------------------------
Assert.IsTrue(executeMessage.HasError);
}
public void ExecuteMessage_Constructor_WhenSettingMessage_ExpectMessageWithNoErrors()
{
//------------Setup for test--------------------------
var executeMessage = new ExecuteMessage { HasError = false};
executeMessage.SetMessage("the message");
//------------Assert Results-------------------------
Assert.AreEqual("the message", executeMessage.Message.ToString());
}
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 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, Workspaces.IWorkspace theWorkspace)
{
string resourceIdString = null;
StringBuilder tmp;
values.TryGetValue("ResourceID", out tmp);
if (tmp != null)
{
resourceIdString = tmp.ToString();
}
if(resourceIdString == null)
{
throw new InvalidDataContractException("ResourceID is missing");
}
var res = new ExecuteMessage { HasError = false };
Guid resourceId;
var hasResourceId = Guid.TryParse(resourceIdString, out resourceId);
if(!hasResourceId)
{
res.SetMessage(Resources.CompilerError_TerminationFailed);
res.HasError = true;
}
var service = ExecutableServiceRepository.Instance.Get(theWorkspace.ID, resourceId);
if(service == null)
{
res.SetMessage(Resources.CompilerError_TerminationFailed);
res.HasError = true;
}
if(service != null)
{
service.Terminate();
res.SetMessage(Resources.CompilerMessage_TerminationSuccess);
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(res);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
string oldCategory = null;
string newCategory = null;
string resourceType = null;
if(values == null)
{
throw new InvalidDataContractException("No parameter values provided.");
}
StringBuilder tmp;
values.TryGetValue("OldCategory", out tmp);
if(tmp != null)
{
oldCategory = tmp.ToString();
}
values.TryGetValue("NewCategory", out tmp);
if(tmp != null)
{
newCategory = tmp.ToString();
}
values.TryGetValue("ResourceType", out tmp);
if(tmp != null)
{
resourceType = tmp.ToString();
}
if(oldCategory == null)
{
throw new InvalidDataContractException("No value provided for OldCategory parameter.");
}
if(String.IsNullOrEmpty(newCategory))
{
throw new InvalidDataContractException("No value provided for NewCategory parameter.");
}
if(String.IsNullOrEmpty(resourceType))
{
throw new InvalidDataContractException("No value provided for ResourceType parameter.");
}
Dev2Logger.Log.Info(String.Format( "Rename Category. Old {0} New {1} Type{2}",oldCategory,newCategory,resourceType));
var saveResult = ResourceCatalog.Instance.RenameCategory(Guid.Empty, oldCategory, newCategory);
ExecuteMessage msg = new ExecuteMessage { HasError = false };
msg.SetMessage(saveResult.Message);
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(msg);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage res = new ExecuteMessage { HasError = false };
string editedItemsXml = null;
StringBuilder tmp;
values.TryGetValue("EditedItemsXml", out tmp);
if(tmp != null)
{
editedItemsXml = tmp.ToString();
}
try
{
var editedItems = new List<string>();
if(!string.IsNullOrWhiteSpace(editedItemsXml))
{
editedItems.AddRange(XElement.Parse(editedItemsXml)
.Elements()
.Select(x => x.Attribute("ServiceName").Value));
}
WorkspaceRepository.Instance.GetLatest(theWorkspace, editedItems);
res.SetMessage("Workspace updated " + DateTime.Now);
}
catch(Exception ex)
{
res.SetMessage("Error updating workspace " + DateTime.Now);
Dev2Logger.Log.Error(ex);
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(res);
}
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);
}
/// <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 StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
StringBuilder resourceDefinition;
values.TryGetValue("ResourceDefinition", out resourceDefinition);
Dev2Logger.Log.Info(String.Format("Deploy Resource."));
if(resourceDefinition == null || resourceDefinition.Length == 0)
{
Dev2Logger.Log.Info(String.Format("Roles or ResourceDefinition missing"));
throw new InvalidDataContractException("Roles or ResourceDefinition missing");
}
var msg = ResourceCatalog.Instance.SaveResource(WorkspaceRepository.ServerWorkspaceID, resourceDefinition,null,"Deploy","unknown");
WorkspaceRepository.Instance.RefreshWorkspaces();
var result = new ExecuteMessage { HasError = false };
result.SetMessage(msg.Message);
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(result);
}
public 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 WorkspaceItemRepositoryAddWorkspaceItemWithExistingModelExpectedDoesNothing()
{
string resourceName;
Guid workspaceID;
Guid serverID;
var mockConn = new Mock<IEnvironmentConnection>();
mockConn.Setup(c => c.IsConnected).Returns(true);
ExecuteMessage msg = new ExecuteMessage();
msg.SetMessage("Workspace item updated");
var payload = JsonConvert.SerializeObject(msg);
mockConn.Setup(c => c.ExecuteCommand(It.IsAny<StringBuilder>(), It.IsAny<Guid>())).Returns(new StringBuilder(payload)).Verifiable();
var model = CreateModel(ResourceType.Service, mockConn, out resourceName, out workspaceID, out serverID);
var repository = new WorkspaceItemRepository(GetUniqueRepositoryPath());
repository.AddWorkspaceItem(model.Object);
Assert.AreEqual(1, repository.WorkspaceItems.Count);
repository.AddWorkspaceItem(model.Object);
Assert.AreEqual(1, repository.WorkspaceItems.Count);
}
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);
}
protected void CreateResourceRepo()
{
var msg = new ExecuteMessage { HasError = false };
msg.SetMessage("");
EnvironmentModel = CreateMockEnvironment();
ResourceRepo = new Mock<IResourceRepository>();
ResourceRepo.Setup(r => r.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>())).Returns(new ExecuteMessage());
ResourceRepo.Setup(r => r.GetDependenciesXml(It.IsAny<IContextualResourceModel>(), It.IsAny<bool>())).Returns(msg);
FirstResource = CreateResource(ResourceType.WorkflowService);
var coll = new Collection<IResourceModel> { FirstResource.Object };
ResourceRepo.Setup(c => c.All()).Returns(coll);
EnvironmentModel.Setup(m => m.ResourceRepository).Returns(ResourceRepo.Object);
}
static TestSettingsViewModel CreateSettingsViewModel(IPopupController popupController, string executeCommandReadResult = "", string executeCommandWriteResult = "", SecurityViewModel securityViewModel = null)
{
var viewModel = new TestSettingsViewModel(new Mock<IEventAggregator>().Object, popupController, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, new Mock<IWin32Window>().Object) { TheSecurityViewModel = securityViewModel };
var mockResourceRepo = new Mock<IResourceRepository>();
ExecuteMessage writeMsg = null;
if(!string.IsNullOrEmpty(executeCommandWriteResult))
{
writeMsg = new ExecuteMessage { HasError = executeCommandWriteResult != "Success" };
writeMsg.SetMessage(executeCommandWriteResult);
}
mockResourceRepo.Setup(c => c.ReadSettings(It.IsAny<IEnvironmentModel>())).Returns(executeCommandReadResult == null ? null : new Dev2JsonSerializer().Deserialize<Data.Settings.Settings>(executeCommandReadResult));
mockResourceRepo.Setup(c => c.WriteSettings(It.IsAny<IEnvironmentModel>(), It.IsAny<Data.Settings.Settings>())).Returns(writeMsg);
var environment = new Mock<IEnvironmentModel>();
environment.Setup(e => e.IsConnected).Returns(true);
environment.Setup(c => c.ResourceRepository).Returns(mockResourceRepo.Object);
Mock<IAuthorizationService> authService = new Mock<IAuthorizationService>();
authService.Setup(c => c.IsAuthorized(It.IsAny<AuthorizationContext>(), It.IsAny<string>())).Returns(true);
environment.Setup(c => c.AuthorizationService).Returns(authService.Object);
// simulate auto-loading of ConnectControl ComboBox
viewModel.ServerChangedCommand.Execute(environment.Object);
return viewModel;
}
public void WorkspaceItemRepositoryRemoveWithExistingModelExpectedInvokesWrite()
{
string resourceName;
Guid workspaceID;
Guid serverID;
var mockConn = new Mock<IEnvironmentConnection>();
mockConn.Setup(c => c.IsConnected).Returns(true);
ExecuteMessage msg = new ExecuteMessage();
msg.SetMessage("Workspace item updated");
var payload = JsonConvert.SerializeObject(msg);
mockConn.Setup(c => c.ExecuteCommand(It.IsAny<StringBuilder>(), It.IsAny<Guid>())).Returns(new StringBuilder(payload)).Verifiable();
var mockResourceRepo = new Mock<IResourceRepository>();
mockResourceRepo.Setup(resourceRepository => resourceRepository.DeleteResourceFromWorkspace(It.IsAny<IContextualResourceModel>()));
var model = CreateModel(ResourceType.Service, mockConn, out resourceName, out workspaceID, out serverID, mockResourceRepo);
var repositoryPath = GetUniqueRepositoryPath();
Assert.IsFalse(File.Exists(repositoryPath));
var repository = new WorkspaceItemRepository(repositoryPath);
repository.AddWorkspaceItem(model.Object);
if(File.Exists(repositoryPath))
{
File.Delete(repositoryPath);
}
repository.Remove(model.Object);
Assert.IsTrue(File.Exists(repositoryPath));
mockResourceRepo.Verify(resourceRepository => resourceRepository.DeleteResourceFromWorkspace(It.IsAny<IContextualResourceModel>()), Times.Once());
}
/// <summary>
/// Executes the service
/// </summary>
/// <param name="values">The values.</param>
/// <param name="theWorkspace">The workspace.</param>
/// <returns></returns>
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
if(values == null)
{
throw new InvalidDataContractException("No parameter values provided.");
}
string serializedSource = null;
string listName = null;
string editableOnly = null;
StringBuilder tmp;
values.TryGetValue("SharepointServer", out tmp);
if(tmp != null)
{
serializedSource = tmp.ToString();
}
values.TryGetValue("ListName", out tmp);
if(tmp != null)
{
listName = tmp.ToString();
}
values.TryGetValue("OnlyEditable", out tmp);
if (tmp != null)
{
editableOnly = 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);
}
if(string.IsNullOrEmpty(listName))
{
var res = new ExecuteMessage();
res.HasError = true;
res.SetMessage("No sharepoint list name set");
Dev2Logger.Log.Debug("No sharepoint list name set.");
return serializer.SerializeToBuilder(res);
}
var editableFieldsOnly = false;
if(!string.IsNullOrEmpty(editableOnly))
{
editableFieldsOnly = serializer.Deserialize<bool>(editableOnly);
}
try
{
listName = serializer.Deserialize<string>(listName);
var sharepointSource = serializer.Deserialize<SharepointSource>(serializedSource);
var source = ResourceCatalog.Instance.GetResource<SharepointSource>(theWorkspace.ID, sharepointSource.ResourceID);
if (source == null)
{
var contents = ResourceCatalog.Instance.GetResourceContents(theWorkspace.ID, sharepointSource.ResourceID);
source = new SharepointSource(contents.ToXElement());
}
List<ISharepointFieldTo> fields = source.LoadFieldsForList(listName, editableFieldsOnly);
return serializer.SerializeToBuilder(fields);
}
catch(Exception ex)
{
Dev2Logger.Log.Error(ex);
var res = new DbColumnList(ex);
return serializer.SerializeToBuilder(res);
}
}
public void WorkspaceItemRepositoryUpdateWorkspaceItemWithExistingModelExpectedInvokesExecuteCommand()
{
const string ExpectedResult = "Workspace item updated";
string resourceName;
Guid workspaceID;
Guid serverID;
var mockConn = new Mock<IEnvironmentConnection>();
mockConn.Setup(c => c.IsConnected).Returns(true);
ExecuteMessage msg = new ExecuteMessage();
msg.SetMessage("Workspace item updated");
var payload = JsonConvert.SerializeObject(msg);
mockConn.Setup(c => c.ExecuteCommand(It.IsAny<StringBuilder>(), It.IsAny<Guid>())).Returns(new StringBuilder(payload)).Verifiable();
var model = CreateModel(ResourceType.Service, mockConn, out resourceName, out workspaceID, out serverID);
#region Setup ImportService - GRRR!
#endregion
var repository = new WorkspaceItemRepository(GetUniqueRepositoryPath());
repository.AddWorkspaceItem(model.Object);
var result = repository.UpdateWorkspaceItem(model.Object, true);
mockConn.Verify(c => c.ExecuteCommand(It.IsAny<StringBuilder>(), It.IsAny<Guid>()), Times.Once());
Assert.AreEqual(ExpectedResult, result.Message.ToString());
}
public void WorkspaceItemRepositoryUpdateWorkspaceItemWithNonExistingModelExpectedDoesNothing()
{
string resourceName;
Guid workspaceID;
Guid serverID;
var mockConn = new Mock<IEnvironmentConnection>();
mockConn.Setup(c => c.IsConnected).Returns(true);
ExecuteMessage msg = new ExecuteMessage();
msg.SetMessage("");
var payload = JsonConvert.SerializeObject(msg);
mockConn.Setup(c => c.ExecuteCommand(It.IsAny<StringBuilder>(), It.IsAny<Guid>())).Returns(new StringBuilder(payload)).Verifiable();
var model = CreateModel(ResourceType.Service, mockConn, out resourceName, out workspaceID, out serverID);
var repository = new WorkspaceItemRepository(GetUniqueRepositoryPath());
var result = repository.UpdateWorkspaceItem(model.Object, true);
Assert.IsTrue(string.IsNullOrEmpty(result.Message.ToString()));
}
public void WorkspaceItemRepositoryAddWorkspaceItemWithNewModelWithSameNameExpectedInvokesWrite()
{
Guid workspaceID = Guid.NewGuid();
Guid serverID = Guid.NewGuid();
Guid envID = Guid.NewGuid();
var mockConn = new Mock<IEnvironmentConnection>();
mockConn.Setup(c => c.IsConnected).Returns(true);
ExecuteMessage msg = new ExecuteMessage();
msg.SetMessage("Workspace item updated");
var payload = JsonConvert.SerializeObject(msg);
mockConn.Setup(c => c.ExecuteCommand(It.IsAny<StringBuilder>(), It.IsAny<Guid>())).Returns(new StringBuilder(payload)).Verifiable();
var model1 = CreateModel(ResourceType.Service, mockConn, workspaceID, serverID, envID);
workspaceID = Guid.NewGuid();
serverID = Guid.NewGuid();
envID = Guid.NewGuid();
var model2 = CreateModel(ResourceType.Service, mockConn, workspaceID, serverID, envID);
var repositoryPath = GetUniqueRepositoryPath();
Assert.IsFalse(File.Exists(repositoryPath));
var repository = new WorkspaceItemRepository(repositoryPath);
repository.AddWorkspaceItem(model1.Object);
repository.AddWorkspaceItem(model2.Object);
Assert.IsTrue(repository.WorkspaceItems.Count == 2);
Assert.IsTrue(File.Exists(repositoryPath));
}
public StringBuilder ProcessRequest(EsbExecuteRequest request, Guid workspaceID, Guid dataListID, string connectionId)
{
var channel = new EsbServicesEndpoint();
var xmlData = string.Empty;
if(request.Args != null && request.Args.ContainsKey("DebugPayload"))
{
xmlData = request.Args["DebugPayload"].ToString();
xmlData = xmlData.Replace("<DataList>", "<XmlData>").Replace("</DataList>", "</XmlData>");
}
// we need to adjust for the silly xml structure this system was init built on ;(
if(string.IsNullOrEmpty(xmlData))
{
xmlData = "<DataList></DataList>";
}
IDSFDataObject dataObject = new DsfDataObject(xmlData, dataListID);
dataObject.StartTime = DateTime.Now;
dataObject.EsbChannel = channel;
dataObject.ServiceName = request.ServiceName;
var resource = ResourceCatalog.Instance.GetResource(workspaceID, request.ServiceName);
if(resource != null)
{
dataObject.ResourceID = resource.ResourceID;
}
dataObject.ClientID = Guid.Parse(connectionId);
dataObject.ExecutingUser = ExecutingUser;
// we need to assign new ThreadID to request coming from here, because it is a fixed connection and will not change ID on its own ;)
if(!dataObject.Environment.HasErrors())
{
ErrorResultTO errors;
if(ExecutingUser == null)
{
throw new Exception("Null Executing User");
}
try
{
// Execute in its own thread to give proper context ;)
var t = new Thread(() =>
{
Thread.CurrentPrincipal = ExecutingUser;
channel.ExecuteRequest(dataObject, request, workspaceID, out errors);
});
t.Start();
t.Join();
}
catch(Exception e)
{
Dev2Logger.Log.Error(e.Message,e);
}
if(request.ExecuteResult.Length > 0)
{
return request.ExecuteResult;
}
return new StringBuilder();
}
ExecuteMessage msg = new ExecuteMessage { HasError = true };
msg.SetMessage(String.Join(Environment.NewLine, dataObject.Environment.Errors));
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(msg);
}
public ExecuteMessage UpdateWorkspaceItem(IContextualResourceModel resource, bool isLocalSave)
{
// BUG 9492 - 2013.06.08 - TWR : added null check
if(resource == null)
{
throw new ArgumentNullException("resource");
}
var workspaceItem = WorkspaceItems.FirstOrDefault(wi => wi.ID == resource.ID && wi.EnvironmentID == resource.Environment.ID);
if(workspaceItem == null)
{
var msg = new ExecuteMessage { HasError = false };
msg.SetMessage(string.Empty);
return msg;
}
workspaceItem.Action = WorkspaceItemAction.Commit;
var comsController = new CommunicationController { ServiceName = "UpdateWorkspaceItemService" };
comsController.AddPayloadArgument("Roles", String.Join(",", "Test"));
var xml = workspaceItem.ToXml();
comsController.AddPayloadArgument("ItemXml", xml.ToString(SaveOptions.DisableFormatting));
comsController.AddPayloadArgument("IsLocalSave", isLocalSave.ToString());
var con = resource.Environment.Connection;
var result = comsController.ExecuteCommand<ExecuteMessage>(con, con.WorkspaceID);
return result;
}
/// <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();
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();
}
if(string.IsNullOrEmpty(serializedSource))
{
ExecuteMessage message = new ExecuteMessage();
message.HasError = true;
message.SetMessage("No sharepoint server set.");
Dev2Logger.Log.Debug("No sharepoint server set.");
return serializer.SerializeToBuilder(message);
}
SharepointSource source;
SharepointSource runtimeSource = null;
try
{
source = serializer.Deserialize<SharepointSource>(serializedSource);
if(source.ResourceID != Guid.Empty)
{
runtimeSource = ResourceCatalog.Instance.GetResource<SharepointSource>(theWorkspace.ID, source.ResourceID);
if(runtimeSource == null)
{
var contents = ResourceCatalog.Instance.GetResourceContents(theWorkspace.ID, source.ResourceID);
runtimeSource = new SharepointSource(contents.ToXElement());
}
}
}
catch(Exception e)
{
Dev2Logger.Log.Error(e);
var res = new DbTableList("Invalid JSON data for sharepoint server parameter. Exception: {0}", e.Message);
return serializer.SerializeToBuilder(res);
}
if(runtimeSource == null)
{
var res = new DbTableList("Invalid sharepoint server source");
Dev2Logger.Log.Debug("Invalid sharepoint server source");
return serializer.SerializeToBuilder(res);
}
if(string.IsNullOrEmpty(runtimeSource.Server))
{
var res = new DbTableList("Invalid sharepoint server sent {0}.", serializedSource);
Dev2Logger.Log.Debug(String.Format("Invalid sharepoint server sent {0}.", serializedSource));
return serializer.SerializeToBuilder(res);
}
try
{
Dev2Logger.Log.Info("Get Sharepoint Server Lists. " + source.Server);
List<SharepointListTo> lists = runtimeSource.LoadLists();
return serializer.SerializeToBuilder(lists);
}
catch(Exception ex)
{
var tables = new DbTableList(ex);
return serializer.SerializeToBuilder(tables);
}
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
try
{
var res = new ExecuteMessage {HasError = false};
string resourceId = null;
string newName = null;
if(values == null)
{
throw new InvalidDataContractException("No parameter values provided.");
}
StringBuilder tmp;
values.TryGetValue("ResourceID", out tmp);
if (tmp != null)
{
resourceId = tmp.ToString();
}
values.TryGetValue("NewName", out tmp);
if(tmp != null)
{
newName = tmp.ToString();
}
if(resourceId == null)
{
throw new InvalidDataContractException("No value provided for ResourceID parameter.");
}
if(String.IsNullOrEmpty(newName))
{
throw new InvalidDataContractException("No value provided for NewName parameter.");
}
Guid id;
Guid.TryParse(resourceId, out id);
Dev2Logger.Log.Info(String.Format( "Rename Resource. ResourceId:{0} NewName:{1}",resourceId,newName));
var saveToWorkSpaceResult = ResourceCatalog.Instance.RenameResource(theWorkspace.ID, id, newName);
if (saveToWorkSpaceResult.Status == ExecStatus.Success)
{
var saveToLocalServerResult = ResourceCatalog.Instance.RenameResource(Guid.Empty, id, newName);
if (saveToLocalServerResult.Status == ExecStatus.Success)
{
res.SetMessage(saveToLocalServerResult.Message);
}
}
else
{
res.HasError = true;
}
res.SetMessage(saveToWorkSpaceResult.Message);
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(res);
}
catch (Exception err)
{
Dev2Logger.Log.Error(err);
throw;
}
}
protected void SetupForDelete()
{
PopupController.Setup(c => c.Show()).Verifiable();
PopupController.Setup(s => s.Show()).Returns(MessageBoxResult.Yes);
ResourceRepo.Setup(c => c.HasDependencies(FirstResource.Object)).Returns(false).Verifiable();
var succesResponse = new ExecuteMessage();
succesResponse.SetMessage(@"<DataList>Success</DataList>");
ResourceRepo.Setup(s => s.DeleteResource(FirstResource.Object)).Returns(succesResponse);
}
