/// <summary>
/// Executes the service
/// </summary>
/// <param name="values">The values.</param>
/// <param name="theWorkspace">The workspace.</param>
/// <returns></returns>
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
var execMessage = new ExecuteMessage { HasError = false };
if(!values.ContainsKey("resourceId"))
{
Dev2Logger.Log.Info("Delete Version. Invalid Resource Id");
execMessage.HasError = true;
execMessage.Message = new StringBuilder( "No resourceId sent to server");
}
else if(!values.ContainsKey("versionNumber") )
{
Dev2Logger.Log.Info("Delete Version. Invalid Version number");
execMessage.HasError = true;
execMessage.Message = new StringBuilder("No versionNumber sent to server");
}
else
{
try
{
var guid = Guid.Parse(values["resourceId"].ToString());
var version = values["versionNumber"].ToString();
Dev2Logger.Log.Info(String.Format("Delete Version. ResourceId:{0} VersionNumber{1}",guid,version));
var res = ServerVersionRepo.DeleteVersion(guid,version);
execMessage.Message = serializer.SerializeToBuilder(res);
}
catch (Exception e)
{
Dev2Logger.Log.Error(String.Format("Delete Version Error."),e);
execMessage.HasError = true;
execMessage.Message = new StringBuilder( e.Message);
}
}
return serializer.SerializeToBuilder(execMessage);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
var result = new ExecuteMessage { HasError = false };
Dev2Logger.Log.Info("Find Log Directory");
try
{
var logdir = WorkflowLoggger.GetDirectoryPath(SettingsProvider.Instance.Configuration.Logging);
var cleanedDir = CleanUp(logdir);
result.Message.Append("<JSON>");
result.Message.Append(@"{""PathToSerialize"":""");
result.Message.Append(cleanedDir);
result.Message.Append(@"""}");
result.Message.Append("</JSON>");
}
catch (Exception ex)
{
Dev2Logger.Log.Error(ex);
result.Message.Append(ex.Message);
result.HasError = true;
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(result);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
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)
{
try
{
Dev2Logger.Log.Info("Fetch Server Log Started");
var result = new ExecuteMessage { HasError = false };
if (File.Exists(_serverLogPath))
{
var fileStream = File.Open(_serverLogPath, FileMode.Open, FileAccess.Read,FileShare.Read);
using (var streamReader = new StreamReader(fileStream))
{
while(!streamReader.EndOfStream)
{
result.Message.Append(streamReader.ReadLine());
}
}
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(result);
}
catch (Exception err)
{
Dev2Logger.Log.Error("Fetch Server Log Error", err);
throw;
}
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
string 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 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);
}
/// <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 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 static ExecuteMessage MakeMessage(string msg)
{
var result = new ExecuteMessage { HasError = false };
result.SetMessage(msg);
return 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)
{
string domain = null;
string username = null;
string password = null;
StringBuilder tmp;
values.TryGetValue("Domain", out tmp);
if(tmp != null)
{
domain = tmp.ToString();
}
values.TryGetValue("Username", out tmp);
if(tmp != null)
{
username = tmp.ToString();
}
values.TryGetValue("Password", out tmp);
if(tmp != null)
{
password = tmp.ToString();
}
if(string.IsNullOrEmpty(domain) || string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
{
throw new InvalidDataContractException("Domain or Username or Password is missing");
}
var result = new ExecuteMessage { HasError = false };
try
{
if(domain.Equals("."))
{
domain = Environment.UserDomainName;
}
bool isValid;
using(var context = new PrincipalContext(ContextType.Domain, domain))
{
isValid = context.ValidateCredentials(username, password);
context.Dispose();
}
result.SetMessage(isValid ? "<result>Connection successful!</result>" : "<result>Connection failed. Ensure your username and password are valid</result>");
}
catch
{
result.SetMessage("<result>Connection failed. Ensure your username and password are valid</result>");
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(result);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
try
{
Dev2Logger.Log.Info("Find Dependencies");
var result = new ExecuteMessage { HasError = false };
string resourceId = null;
string dependsOnMeString = null;
bool dependsOnMe = false;
StringBuilder tmp;
values.TryGetValue("ResourceId", out tmp);
if(tmp != null)
{
resourceId = tmp.ToString();
}
values.TryGetValue("GetDependsOnMe", out tmp);
if(tmp != null)
{
dependsOnMeString = tmp.ToString();
}
if (string.IsNullOrEmpty(resourceId))
{
throw new InvalidDataContractException("ResourceName is empty or null");
}
var resource= ResourceCatalog.Instance.GetResource(theWorkspace.ID, Guid.Parse(resourceId));
var resourceName = resource.ResourcePath;
if(!string.IsNullOrEmpty(dependsOnMeString))
{
if(!bool.TryParse(dependsOnMeString, out dependsOnMe))
{
dependsOnMe = false;
}
}
if(dependsOnMe)
{
result.Message.Append(string.Format("<graph title=\"Local Dependants Graph: {0}\">", resourceName));
result.Message.Append(FindWhatDependsOnMe(resource, theWorkspace.ID));
result.Message.Append("</graph>");
}
else
{
result.Message.Append(string.Format("<graph title=\"Dependency Graph Of {0}\">", resourceName));
result.Message.Append(FindDependenciesRecursive(resource.ResourceID, theWorkspace.ID));
result.Message.Append("</graph>");
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(result);
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
throw;
}
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
string serviceId = null;
string workspaceId = null;
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
var result = new ExecuteMessage { HasError = false };
StringBuilder tmp;
values.TryGetValue("ServiceID", out tmp);
if(tmp != null)
{
serviceId = tmp.ToString();
}
values.TryGetValue("WorkspaceID", out tmp);
if(tmp != null)
{
workspaceId = tmp.ToString();
}
values.TryGetValue("FilterList", out tmp);
if(tmp != null)
{
}
if(string.IsNullOrEmpty(serviceId) || string.IsNullOrEmpty(workspaceId))
{
throw new InvalidDataContractException("Null or empty ServiceID or WorkspaceID");
}
Guid wGuid;
Guid sGuid;
Guid.TryParse(workspaceId, out wGuid);
Guid.TryParse(serviceId, out sGuid);
var thisService = ResourceCatalog.Instance.GetResource(wGuid, sGuid);
if(thisService != null)
{
var deps = thisService.Dependencies;
CompileMessageType[] filters = null; // TODO : Convert string list to enum array ;)
// ReSharper disable ExpressionIsAlwaysNull
CompileMessageList msgs = CompileMessageRepo.Instance.FetchMessages(wGuid, sGuid, deps, filters);
// ReSharper restore ExpressionIsAlwaysNull
result.Message.Append(serializer.SerializeToBuilder(msgs));
}
else
{
result.Message.Append("Could not locate service with ID [ " + sGuid + " ]");
result.HasError = true;
}
return serializer.SerializeToBuilder(result);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage msg = new ExecuteMessage { HasError = false };
msg.SetMessage(values["payload"].ToString());
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(msg);
}
public void 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 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 StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage msg = new ExecuteMessage {HasError = false};
msg.SetMessage("Pong @ " + Now.Invoke().ToString("yyyy-MM-dd hh:mm:ss.fff"));
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(msg);
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
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 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 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)
{
Dev2Logger.Log.Info("Fetch Debug Item File Started");
try
{
var result = new ExecuteMessage { HasError = false };
if(values == null)
{
Dev2Logger.Log.Debug("values are missing");
throw new InvalidDataContractException("values are missing");
}
StringBuilder tmp;
values.TryGetValue("DebugItemFilePath", out tmp);
if(tmp == null || tmp.Length == 0)
{
Dev2Logger.Log.Debug("DebugItemFilePath is missing");
throw new InvalidDataContractException("DebugItemFilePath is missing");
}
string debugItemFilePath = tmp.ToString();
if(File.Exists(debugItemFilePath))
{
Dev2Logger.Log.Debug("DebugItemFilePath found");
var lines = File.ReadLines(debugItemFilePath);
foreach(var line in lines)
{
result.Message.AppendLine(line);
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(result);
}
Dev2Logger.Log.Debug("DebugItemFilePath not found, throwing an exception");
throw new InvalidDataContractException(string.Format("DebugItemFilePath {0} not found", debugItemFilePath));
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
throw;
}
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage result = new ExecuteMessage { HasError = false };
StringBuilder msg = new StringBuilder();
string directory = null;
StringBuilder tmp;
values.TryGetValue("Directory", out tmp);
if(tmp != null)
{
directory = tmp.ToString();
}
if(String.IsNullOrWhiteSpace(directory))
{
AppendError(msg, directory, "Cant delete a file if no directory is passed.");
}
else if(!Directory.Exists(directory))
{
AppendError(msg, directory, "No such directory exists on the server.");
}
else
{
try
{
var files = Directory.GetFiles(directory);
foreach(var file in files)
{
File.Delete(file);
}
msg.Append("Success");
}
catch(Exception ex)
{
AppendError(msg, directory, ex.Message);
Dev2Logger.Log.Info(ex.StackTrace);
}
}
result.Message.Append(msg);
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(result);
}
static void WriteSecuritySettings(IWorkspace theWorkspace, Settings settings, ExecuteMessage result)
{
try
{
if(settings.Security != null)
{
var executionResult = ExecuteService(theWorkspace, new SecurityWrite(), "SecuritySettings", settings.Security);
result.Message.AppendLine(executionResult);
}
}
catch(Exception ex)
{
Dev2Logger.Log.Error("Error writing settings configuration.", ex);
result.HasError = true;
result.Message.AppendLine("Error writing settings configuration.");
}
}
/// <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, 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)
{
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);
}
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);
}
