public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
StringBuilder itemXml;
string isLocal = string.Empty;
StringBuilder tmp;
values.TryGetValue("ItemXml", out itemXml);
values.TryGetValue("IsLocalSave", out tmp);
if (tmp != null)
{
isLocal = tmp.ToString();
}
bool isLocalSave;
bool.TryParse(isLocal, out isLocalSave);
var res = new ExecuteMessage { HasError = false};
if(itemXml == null || itemXml.Length == 0)
{
res.SetMessage("Invalid workspace item definition " + DateTime.Now);
res.HasError = true;
}
else
{
try
{
XElement xe = itemXml.ToXElement();
var workspaceItem = new WorkspaceItem(xe);
if (workspaceItem.WorkspaceID != theWorkspace.ID)
{
res.SetMessage("Cannot update a workspace item from another workspace " + DateTime.Now);
res.HasError = true;
}
else
{
theWorkspace.Update(workspaceItem, isLocalSave);
res.SetMessage("Workspace item updated " + DateTime.Now);
}
}
catch(Exception ex)
{
res.SetMessage("Error updating workspace item " + DateTime.Now);
res.SetMessage(ex.Message);
res.SetMessage(ex.StackTrace);
res.HasError = true;
}
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(res);
}
public void ServiceCallbackHandler_CheckForServerMessages_OnlyDependantIsInWorkspaceItemRepo_DontShowDependancyViewer()
{
//------------------------------Setup-------------------------------------------------
Mock<IShowDependencyProvider> showDependencyProvider;
Mock<IResourceRepository> resourceRepo;
Guid resourceId = Guid.NewGuid();
SetupObjects(out showDependencyProvider, out resourceRepo, resourceId);
var compileMessageTos = new List<ICompileMessageTO> { new CompileMessageTO() };
var envConnection = SetupConnectionWithCompileMessageList(compileMessageTos, new List<string> { "Unsaved 1" });
var envModel = new Mock<IEnvironmentModel>();
envModel.Setup(e => e.ResourceRepository).Returns(resourceRepo.Object);
envModel.Setup(e => e.Connection).Returns(envConnection.Object);
var aggregator = new Mock<IEventAggregator>();
var envRepo = new Mock<IEnvironmentRepository>();
var handler = new ServiceCallbackHandlerMock(aggregator.Object, envRepo.Object, showDependencyProvider.Object);
var workspace = new Mock<IWorkspaceItemRepository>();
var workspaceItem = new WorkspaceItem(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>()) { ServiceName = "Unsaved 1" };
workspace.Setup(c => c.WorkspaceItems).Returns(new List<IWorkspaceItem> { workspaceItem });
//------------------------------Execute -------------------------------------------------
handler.TestCheckForServerMessages(envModel.Object, resourceId, workspace.Object);
//------------------------------Assert Result -------------------------------------------------
showDependencyProvider.Verify(provider => provider.ShowDependencyViewer(It.IsAny<IContextualResourceModel>(), new List<string> { "" }), Times.Never());
}
public void MainViewModelConstructorWithWorkspaceItemsInRepositoryExpectedNotLoadsWorkspaceItemsWithSameEnvID()
{
lock (syncroot)
{
var workspaceID = Guid.NewGuid();
var serverID = Guid.NewGuid();
var resourceName = "TestResource_" + Guid.NewGuid();
var resourceID = Guid.NewGuid();
Guid environmentID = Guid.NewGuid();
var wsi = new WorkspaceItem(workspaceID, serverID, environmentID, resourceID) { ServiceName = resourceName, ServiceType = WorkspaceItem.ServiceServiceType };
var wsiRepo = new Mock<IWorkspaceItemRepository>();
wsiRepo.Setup(r => r.WorkspaceItems).Returns(new List<IWorkspaceItem>(new[] { wsi }));
wsiRepo.Setup(r => r.AddWorkspaceItem(It.IsAny<IContextualResourceModel>())).Verifiable();
SetupImportServiceForPersistenceTests(wsiRepo);
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.ResourceName).Returns(resourceName);
resourceModel.Setup(m => m.ID).Returns(resourceID);
resourceModel.Setup(m => m.ResourceType).Returns(ResourceType.WorkflowService);
var resourceRepo = new Mock<IResourceRepository>();
resourceRepo.Setup(r => r.All()).Returns(new List<IResourceModel>(new[] { resourceModel.Object }));
resourceRepo.Setup(r => r.ReloadResource(It.IsAny<string>(), It.IsAny<ResourceType>(), It.IsAny<IEqualityComparer<IResourceModel>>())).Verifiable();
var dsfChannel = new Mock<IStudioClientContext>();
dsfChannel.Setup(c => c.WorkspaceID).Returns(workspaceID);
dsfChannel.Setup(c => c.ServerID).Returns(serverID);
var envConn = new Mock<IEnvironmentConnection>();
var env = new Mock<IEnvironmentModel>();
env.Setup(e => e.DsfChannel).Returns(dsfChannel.Object);
env.Setup(e => e.Connection).Returns(envConn.Object);
env.Setup(e => e.IsConnected).Returns(true);
env.Setup(e => e.ResourceRepository).Returns(resourceRepo.Object);
env.Setup(e => e.ID).Returns(environmentID);
resourceModel.Setup(m => m.Environment).Returns(env.Object);
var envRepo = new Mock<IEnvironmentRepository>();
envRepo.Setup(r => r.All()).Returns(new List<IEnvironmentModel>(new[] { env.Object }));
var viewModel = new MainViewModelPersistenceMock(envRepo.Object, false);
resourceRepo.Verify(r => r.ReloadResource(It.IsAny<string>(), It.IsAny<ResourceType>(), It.IsAny<IEqualityComparer<IResourceModel>>()), Times.AtLeastOnce());
wsiRepo.Verify(r => r.AddWorkspaceItem(It.IsAny<IContextualResourceModel>()), Times.AtLeastOnce());
Assert.AreEqual(2, viewModel.Items.Count); // 1 extra for the help tab!
var expected = viewModel.Items.FirstOrDefault(i => i.WorkSurfaceKey.ResourceID == resourceID);
Assert.IsNotNull(expected);
}
}
public void MainViewModelConstructorWithWorkspaceItemsInRepositoryExpectedNotLoadsWorkspaceItemsWithSameEnvID()
{
var workspaceID = Guid.NewGuid();
var serverID = Guid.NewGuid();
var resourceName = "TestResource_" + Guid.NewGuid();
var resourceID = Guid.NewGuid();
Guid environmentID = Guid.NewGuid();
var wsi = new WorkspaceItem(workspaceID, serverID, environmentID, resourceID) { ServiceName = resourceName, ServiceType = WorkspaceItem.ServiceServiceType };
var wsiRepo = new Mock<IWorkspaceItemRepository>();
wsiRepo.Setup(r => r.WorkspaceItems).Returns(new List<IWorkspaceItem>(new[] { wsi }));
wsiRepo.Setup(r => r.AddWorkspaceItem(It.IsAny<IContextualResourceModel>())).Verifiable();
SetupImportServiceForPersistenceTests(wsiRepo);
WorkspaceItemRepository.Instance.WorkspaceItems.Clear();
WorkspaceItemRepository.Instance.WorkspaceItems.Add(wsi);
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.ResourceName).Returns(resourceName);
resourceModel.Setup(m => m.ID).Returns(resourceID);
resourceModel.Setup(m => m.ResourceType).Returns(ResourceType.WorkflowService);
var resourceRepo = new Mock<IResourceRepository>();
resourceRepo.Setup(r => r.All()).Returns(new List<IResourceModel>(new[] { resourceModel.Object }));
resourceRepo.Setup(r => r.ReloadResource(It.IsAny<Guid>(), It.IsAny<ResourceType>(), It.IsAny<IEqualityComparer<IResourceModel>>(), true)).Verifiable();
resourceRepo.Setup(r => r.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage());
var envConn = new Mock<IEnvironmentConnection>();
envConn.Setup(conn => conn.WorkspaceID).Returns(workspaceID);
envConn.Setup(conn => conn.ServerID).Returns(serverID);
envConn.Setup(conn => conn.ServerEvents).Returns(new Mock<IEventPublisher>().Object);
var env = new Mock<IEnvironmentModel>();
env.Setup(e => e.Connection).Returns(envConn.Object);
env.Setup(e => e.IsConnected).Returns(true);
env.Setup(e => e.ResourceRepository).Returns(resourceRepo.Object);
env.Setup(e => e.ID).Returns(environmentID);
resourceModel.Setup(m => m.Environment).Returns(env.Object);
var envRepo = new Mock<IEnvironmentRepository>();
envRepo.Setup(r => r.All()).Returns(new List<IEnvironmentModel>(new[] { env.Object }));
envRepo.Setup(r => r.Source).Returns(env.Object);
Mock<IAsyncWorker> asyncWorker = AsyncWorkerTests.CreateSynchronousAsyncWorker();
var viewModel = new MainViewModelPersistenceMock(envRepo.Object, asyncWorker.Object, false);
wsiRepo.Verify(r => r.AddWorkspaceItem(It.IsAny<IContextualResourceModel>()), Times.AtLeastOnce());
Assert.AreEqual(2, viewModel.Items.Count); // 1 extra for the help tab!
var expected = viewModel.Items.FirstOrDefault(i => i.WorkSurfaceKey.ResourceID == resourceID);
Assert.IsNotNull(expected);
}
public void WorkspaceItem_UnitTest_ConstructorWhereParametersXML_ObjectHasProperties()
{
//------------Setup for test--------------------------
Guid workspaceID = Guid.NewGuid();
Guid resourceID = Guid.NewGuid();
Guid environmentID = Guid.NewGuid();
Guid serverID = Guid.NewGuid();
WorkspaceItem workspaceItem = new WorkspaceItem(workspaceID, serverID, environmentID, resourceID);
workspaceItem.IsWorkflowSaved = true;
XElement xElement = workspaceItem.ToXml();
//------------Execute Test---------------------------
WorkspaceItem newWorkspaceItem = new WorkspaceItem(xElement);
//------------Assert Results-------------------------
Assert.AreEqual(workspaceID, newWorkspaceItem.WorkspaceID);
Assert.AreEqual(serverID, newWorkspaceItem.ServerID);
Assert.AreEqual(environmentID, newWorkspaceItem.EnvironmentID);
Assert.IsTrue(newWorkspaceItem.IsWorkflowSaved);
}
public void WorkspaceItem_UnitTest_ConstructorWhereParametersPassed_ObjectHasProperties()
{
//------------Setup for test--------------------------
Guid workspaceID = Guid.NewGuid();
Guid resourceID = Guid.NewGuid();
Guid environmentID = Guid.NewGuid();
Guid serverID = Guid.NewGuid();
//------------Execute Test---------------------------
WorkspaceItem workspaceItem = new WorkspaceItem(workspaceID, serverID, environmentID, resourceID);
//------------Assert Results-------------------------
Assert.AreEqual(workspaceID, workspaceItem.WorkspaceID);
Assert.AreEqual(serverID, workspaceItem.ServerID);
Assert.AreEqual(environmentID, workspaceItem.EnvironmentID);
}
public void WorkspaceItem_UnitTest_ToXMLWhereParametersXML_HasElementWithAttributes()
{
//------------Setup for test--------------------------
Guid workspaceID = Guid.NewGuid();
Guid resourceID = Guid.NewGuid();
Guid environmentID = Guid.NewGuid();
Guid serverID = Guid.NewGuid();
WorkspaceItem workspaceItem = new WorkspaceItem(workspaceID, serverID, environmentID, resourceID);
workspaceItem.IsWorkflowSaved = true;
//------------Execute Test---------------------------
XElement xElement = workspaceItem.ToXml();
//------------Assert Results-------------------------
Assert.IsNotNull(xElement);
Assert.AreEqual(xElement.Name, "WorkspaceItem");
Assert.AreEqual(workspaceItem.ID.ToString(), xElement.Attribute("ID").Value);
Assert.AreEqual(workspaceID.ToString(), xElement.Attribute("WorkspaceID").Value);
Assert.AreEqual(serverID.ToString(), xElement.Attribute("ServerID").Value);
Assert.AreEqual(environmentID.ToString(), xElement.Attribute("EnvironmentID").Value);
Assert.AreEqual(workspaceItem.Action.ToString(), xElement.Attribute("Action").Value);
}
// 2012.10.18 - 5782: TWR
public string UpdateWorkspaceItem(string itemXml, string roles)
{
dynamic xmlResponse = new UnlimitedObject(Resources.DynamicService_ServiceResponseTag);
if(string.IsNullOrEmpty(itemXml))
{
xmlResponse.Error = "Invalid workspace item definition";
}
else
{
try
{
var workspaceItem = new WorkspaceItem(XElement.Parse(itemXml));
if(workspaceItem.WorkspaceID != _workspace.ID)
{
xmlResponse.Error = "Cannot update a workspace item from another workspace";
}
else
{
_workspace.Update(workspaceItem, roles);
xmlResponse.Response = "Workspace item updated";
}
}
catch(Exception ex)
{
xmlResponse.Error = "Error updating workspace item";
xmlResponse.ErrorDetail = ex.Message;
xmlResponse.ErrorStackTrace = ex.StackTrace;
}
}
return xmlResponse.XmlString;
}
private void AddWorkspaceItem(IContextualResourceModel model)
{
// TODO: Check model server uri
IWorkspaceItem workspaceItem = WorkspaceItems.FirstOrDefault(wi => wi.ServiceName == model.ResourceName);
if (workspaceItem != null) return;
var context = (IStudioClientContext)model.Environment.DsfChannel;
workspaceItem = new WorkspaceItem(context.AccountID, context.ServerID)
{
ServiceName = model.ResourceName,
ServiceType =
model.ResourceType == ResourceType.Source
? WorkspaceItem.SourceServiceType
: WorkspaceItem.ServiceServiceType,
};
WorkspaceItems.Add(workspaceItem);
SaveWorkspaceItems();
}
