public void PushResponseIntoEnvironment(string input, int update, IDSFDataObject dataObj, bool formatResult)
{
if (dataObj == null)
{
throw new ArgumentNullException(nameof(dataObj));
}
try
{
if (!IsObject && (Outputs == null || Outputs.Count == 0))
{
return;
}
if (!IsObject && OutputDescription != null && OutputDescription.DataSourceShapes.Count == 1 && OutputDescription.DataSourceShapes[0].Paths.All(a => a is StringPath))
{
var serviceOutputMapping = Outputs.First();
if (serviceOutputMapping != null)
{
dataObj.Environment.Assign(serviceOutputMapping.MappedTo, input, update);
}
return;
}
if (IsObject)
{
AssignObject(input, update, dataObj);
}
else
{
TryFormatOutput(input, update, dataObj, formatResult);
}
}
catch (Exception e)
{
dataObj.Environment.AddError(e.Message);
Dev2Logger.Error(e.Message, e, GlobalConstants.WarewolfError);
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Auditing Settings Service", GlobalConstants.WarewolfInfo);
values.TryGetValue(Warewolf.Service.SaveAuditingSettings.AuditingSettings, out StringBuilder settings);
values.TryGetValue(Warewolf.Service.SaveAuditingSettings.SinkType, out StringBuilder sinkType);
if (sinkType.ToString() == "AuditingSettingsData")
{
var updatedAuditingSettings = serializer.Deserialize <AuditingSettingsData>(settings);
Config.Auditing.LoggingDataSource = updatedAuditingSettings.LoggingDataSource;
Config.Auditing.EncryptDataSource = updatedAuditingSettings.EncryptDataSource;
Config.Server.Sink = nameof(AuditingSettingsData);
}
else
{
var updatedLegacySettings = serializer.Deserialize <LegacySettingsData>(settings);
var auditsFilePath = updatedLegacySettings.AuditFilePath;
Config.Legacy.SaveLoggingPath(auditsFilePath);
Config.Server.Sink = nameof(LegacySettingsData);
}
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)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Email Service Source", GlobalConstants.WarewolfInfo);
values.TryGetValue("EmailServiceSource", out StringBuilder resourceDefinition);
var src = serializer.Deserialize <IEmailServiceSource>(resourceDefinition);
var con = new EmailSource
{
Host = src.HostName,
UserName = src.UserName,
Password = src.Password,
Port = src.Port,
EnableSsl = src.EnableSsl,
Timeout = src.Timeout,
ResourceName = src.ResourceName,
ResourceID = src.Id
};
ResourceCatalog.Instance.SaveResource(GlobalConstants.ServerWorkspaceID, con, src.Path);
ServerExplorerRepo.UpdateItem(con);
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 IOutputDescription Test(PluginInvokeArgs setupInfo, out string serializedResult)
{
try
{
serializedResult = null;
_assemblyLocation = setupInfo.AssemblyLocation;
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
if (!_assemblyLoader.TryLoadAssembly(setupInfo.AssemblyLocation, setupInfo.AssemblyName, out Assembly loadedAssembly))
{
return(null);
}
var methodToRun = TryExecutePlugin(setupInfo, loadedAssembly, out object pluginResult);
AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomain_AssemblyResolve;
// do formating here to avoid object serialization issues ;)
var dataBrowser = DataBrowserFactory.CreateDataBrowser();
var dataSourceShape = DataSourceShapeFactory.CreateDataSourceShape();
if (pluginResult != null)
{
serializedResult = JsonConvert.SerializeObject(pluginResult);
pluginResult = AdjustPluginResult(pluginResult, methodToRun);
var tmpData = dataBrowser.Map(pluginResult);
dataSourceShape.Paths.AddRange(tmpData);
}
var result = OutputDescriptionFactory.CreateOutputDescription(OutputFormats.ShapedXML);
result.DataSourceShapes.Add(dataSourceShape);
return(result);
}
catch (Exception e)
{
Dev2Logger.Error("IOutputDescription Test(PluginInvokeArgs setupInfo)", e, GlobalConstants.WarewolfError);
serializedResult = null;
return(null);
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
_indexCounter = 1;
var allErrors = new ErrorResultTO();
try
{
var sharepointReadListTos = SharepointUtils.GetValidReadListItems(ReadListItems).ToList();
if (sharepointReadListTos.Any())
{
TryExecute(dataObject, update, sharepointReadListTos);
}
}
catch (Exception e)
{
Dev2Logger.Error("SharepointCreateListItemActivity", e, GlobalConstants.WarewolfError);
allErrors.AddError(e.Message);
}
finally
{
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
dataObject.Environment.Assign(Result, "Failed", update);
DisplayAndWriteError("SharepointCreateListItemActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage msg = new ExecuteMessage();
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Test connection Service");
StringBuilder resourceDefinition;
var workspaceIdString = string.Empty;
values.TryGetValue("ServerSource", out resourceDefinition);
IServerSource src = serializer.Deserialize <ServerSource>(resourceDefinition);
Connections tester = new Connections();
var result = tester.CanConnectToServer(new Connection
{
Address = src.Address,
AuthenticationType = src.AuthenticationType,
UserName = src.UserName,
Password = src.Password
});
msg.HasError = false;
msg.Message = new StringBuilder(result.IsValid ? "" : result.ErrorMessage);
msg.HasError = !result.IsValid;
}
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 serializer = new Dev2JsonSerializer();
try
{
string serviceId = null;
var prepairForDeployment = false;
values.TryGetValue(@"ResourceID", out StringBuilder tmp);
if (tmp != null)
{
serviceId = tmp.ToString();
}
values.TryGetValue(@"PrepairForDeployment", out tmp);
if (tmp != null)
{
prepairForDeployment = bool.Parse(tmp.ToString());
}
Guid.TryParse(serviceId, out Guid resourceId);
Dev2Logger.Info($"Fetch Resource definition. ResourceId: {resourceId}", GlobalConstants.WarewolfInfo);
var result = ResourceCat.GetResourceContents(theWorkspace.ID, resourceId);
var resourceDefinition = Cleaner.GetResourceDefinition(prepairForDeployment, resourceId, result);
return(resourceDefinition);
}
catch (Exception err)
{
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
throw;
}
}
public Stream Get(IActivityIOPath path, List <string> filesToCleanup)
{
Stream result = null;
try
{
if (_implementation.IsStandardFtp(path))
{
_implementation.ReadFromFtp(path, ref result);
}
else
{
Dev2Logger.Debug($"SFTP_GET:{path.Path}", GlobalConstants.WarewolfDebug);
_implementation.ReadFromSftp(path, ref result, filesToCleanup);
}
}
catch (Exception ex)
{
Dev2Logger.Error(this, ex, GlobalConstants.WarewolfError);
var message = $"{ex.Message} , [{path.Path}]";
throw new Exception(message, ex);
}
return(result);
}
protected override void Save(IServer server, dynamic jsonArgs)
{
try
{
string resName = jsonArgs.resourceName;
bool loadingFromServer = jsonArgs.resourceLoadingFromServer;
string originalPath = jsonArgs.OriginalPath;
var resCat = HelperUtils.SanitizePath((string)jsonArgs.resourcePath, resName);
if (_resourceModel != null)
{
EventPublisher.Publish(new SaveUnsavedWorkflowMessage(_resourceModel, resName, resCat, AddToTabManager, loadingFromServer, originalPath));
}
Close();
}
catch (Exception e)
{
var e1 = new Exception("There was a problem saving. Please try again.", e);
Dev2Logger.Info(e.Message + Environment.NewLine + " Stacktrace : " + e.StackTrace + Environment.NewLine + " jsonObj: " + jsonArgs.ToString(), "Warewolf Info");
throw e1;
}
}
void CreateSourceFileWithSomeDummyData(int numberOfGuids = 1)
{
try
{
Dev2Logger.Debug(string.Format("Source File: {0}", _scenarioContext.Get <string>(ActualSourceHolder)), "Warewolf Debug");
var broker = ActivityIOFactory.CreateOperationsBroker();
var source = ActivityIOFactory.CreatePathFromString(_scenarioContext.Get <string>(ActualSourceHolder),
_scenarioContext.Get <string>(SourceUsernameHolder),
_scenarioContext.Get <string>(SourcePasswordHolder),
true, "");
var sb = new StringBuilder();
Enumerable.Range(1, numberOfGuids).ToList().ForEach(x => sb.Append(Guid.NewGuid().ToString()));
var ops = ActivityIOFactory.CreatePutRawOperationTO(WriteType.Overwrite, sb.ToString());
var sourceEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(source);
if (sourceEndPoint.PathIs(sourceEndPoint.IOPath) == enPathType.File)
{
var result = broker.PutRaw(sourceEndPoint, ops);
if (result != "Success")
{
result = broker.PutRaw(sourceEndPoint, ops);
if (result != "Success")
{
Dev2Logger.Debug("Create Source File for file op test error", "Warewolf Debug");
}
}
}
else if (sourceEndPoint.PathIs(sourceEndPoint.IOPath) == enPathType.Directory && source.Path.Contains("emptydir"))
{
broker.Create(sourceEndPoint, new Dev2CRUDOperationTO(true, false), false);
}
}
catch (Exception e)
{
Dev2Logger.Debug("Create Source File for file op test error", e, "Warewolf Debug");
}
}
public QueueWorkerMonitor(IProcessFactory processFactory, IQueueConfigLoader queueConfigLoader, ITriggersCatalog triggersCatalog, IChildProcessTracker childProcessTracker)
{
_childProcessTracker = childProcessTracker;
_processFactory = processFactory;
_queueConfigLoader = queueConfigLoader;
triggersCatalog.OnChanged += (triggerId) =>
{
try
{
var configs = _queueConfigLoader.Configs;
var config = configs.First(o => o.Id == triggerId);
WorkerDeleted(config.Id);
WorkerCreated(config.Id);
}
catch (Exception e)
{
Dev2Logger.Warn(e.Message, "");
}
};
triggersCatalog.OnDeleted += WorkerDeleted;
triggersCatalog.OnCreated += WorkerCreated;
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Test WebserviceSource", GlobalConstants.WarewolfInfo);
values.TryGetValue("WebserviceSource", out StringBuilder resourceDefinition);
var src = serializer.Deserialize <WebServiceSourceDefinition>(resourceDefinition);
var con = new WebSources();
var result = con.Test(new WebSource
{
Address = src.HostName,
DefaultQuery = src.DefaultQuery,
AuthenticationType = src.AuthenticationType,
UserName = src.UserName,
Password = src.Password
});
msg.HasError = false;
msg.Message = new StringBuilder(result.IsValid ? serializer.Serialize(result.Result) : result.ErrorMessage);
msg.HasError = !result.IsValid;
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
}
return(serializer.SerializeToBuilder(msg));
}
public SecuritySettingsTO ReadSettingsFile(IResourceNameProvider resourceNameProvider)
{
var serverSecuritySettingsFile = EnvironmentVariables.ServerSecuritySettingsFile;
if (!File.Exists(serverSecuritySettingsFile))
{
return(new SecuritySettingsTO(DefaultPermissions, DefaultOverrideResource, DefaultSecretKey)
{
CacheTimeout = CacheTimeout
});
}
string encryptedData;
using (var inStream = new FileStream(serverSecuritySettingsFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (var reader = new StreamReader(inStream))
{
encryptedData = reader.ReadToEnd();
}
}
Dev2Logger.Debug("Security Data Read", GlobalConstants.WarewolfDebug);
try
{
return(ProcessSettingsFile(resourceNameProvider, encryptedData));
}
catch (Exception e)
{
Dev2Logger.Error("SecurityRead", e, GlobalConstants.WarewolfError);
return(new SecuritySettingsTO(DefaultPermissions, DefaultOverrideResource, DefaultSecretKey)
{
CacheTimeout = CacheTimeout
});
}
}
public bool EnsureSsl(IFile fileWrapper, string certPath, IPEndPoint endPoint)
{
var result = false;
if (!fileWrapper.Exists(certPath))
{
try
{
var certificateBuilder = new SslCertificateBuilder();
certificateBuilder.EnsureSslCertificate(certPath, endPoint);
result = fileWrapper.Exists(certPath);
}
catch (Exception e)
{
Dev2Logger.Error(e, GlobalConstants.WarewolfError);
}
}
else
{
result = SslCertificateBuilder.BindSslCertToPorts(endPoint, certPath);
}
return(result);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage msg = new ExecuteMessage();
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Wcf Service Source");
StringBuilder resourceDefinition;
values.TryGetValue("WcfSource", out resourceDefinition);
var src = serializer.Deserialize <WcfServiceSourceDefinition>(resourceDefinition);
var con = new WcfSource
{
EndpointUrl = src.EndpointUrl,
ResourceName = src.Name,
Name = src.Name,
ResourceID = src.Id,
Type = enSourceType.WcfSource,
ResourceType = "WcfSource"
};
ResourceCatalog.Instance.SaveResource(GlobalConstants.ServerWorkspaceID, con, src.Path);
ServerExplorerRepo.UpdateItem(con);
msg.HasError = false;
}
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 serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Fetch All Tests Service", GlobalConstants.WarewolfInfo);
var tests = TestCatalog.FetchAllTests();
var message = new CompressedExecuteMessage();
message.SetMessage(serializer.Serialize(tests));
message.HasError = false;
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
var res = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
IExplorerRepositoryResult item;
var serializer = new Dev2JsonSerializer();
try
{
if (values == null)
{
throw new ArgumentNullException("values");
}
if (!values.TryGetValue("itemToMove", out StringBuilder itemToBeRenamed))
{
throw new ArgumentException(string.Format(ErrorResource.ValueNotSupplied, "itemToMove"));
}
if (!values.TryGetValue("newPath", out StringBuilder newPath))
{
throw new ArgumentException(string.Format(ErrorResource.ValueNotSupplied, "newName"));
}
if (!values.TryGetValue("itemToBeRenamedPath", out StringBuilder itemToBeRenamedPath))
{
throw new ArgumentException(string.Format(ErrorResource.ValueNotSupplied, "newName"));
}
var itemToMove = ServerExplorerRepo.Find(Guid.Parse(itemToBeRenamed.ToString())) ?? ServerExplorerRepo.Find(a => a.ResourcePath == itemToBeRenamedPath.ToString());
Dev2Logger.Info($"Move Item. Path:{itemToBeRenamed} NewPath:{newPath}", GlobalConstants.WarewolfInfo);
item = ServerExplorerRepo.MoveItem(itemToMove, newPath.ToString(), GlobalConstants.ServerWorkspaceID);
}
catch (Exception e)
{
Dev2Logger.Error(e, GlobalConstants.WarewolfError);
item = new ExplorerRepositoryResult(ExecStatus.Fail, e.Message);
}
return(serializer.SerializeToBuilder(item));
}
public ResourceCatalogResult DeleteResource(Guid workspaceID, Guid resourceID, string type, bool deleteVersions)
{
try
{
if (workspaceID != GlobalConstants.ServerWorkspaceID)
{
return(DeleteFromWorkspace(workspaceID, resourceID, type, deleteVersions));
}
foreach (var wid in _resourceCatalog.WorkspaceResources.Keys)
{
var result = DeleteFromWorkspace(wid, resourceID, type, deleteVersions);
if (wid == GlobalConstants.ServerWorkspaceID && result.Status != ExecStatus.Success)
{
return(result);
}
}
return(ResourceCatalogResultBuilder.CreateSuccessResult("Success"));
}
catch (Exception err)
{
Dev2Logger.Error("Delete Error", err, GlobalConstants.WarewolfError);
throw;
}
}
void Debug(IDSFDataObject dataObject, string firstOrDefault, Dev2Switch ds)
{
try
{
if (dataObject.IsDebugMode())
{
var result = new List <DebugItem>();
var itemToAdd = new DebugItem();
var debugResult = new DebugItemWarewolfAtomResult(firstOrDefault, "", ds.SwitchVariable, "", "Switch on", "", "=");
itemToAdd.AddRange(debugResult.GetDebugItemResult());
result.Add(itemToAdd);
_debugInputs = result;
if (Inner != null)
{
Inner.SetDebugInputs(_debugInputs);
}
}
}
catch (Exception e)
{
Dev2Logger.Warn(e.Message, GlobalConstants.WarewolfWarn);
}
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
try
{
Dev2Logger.Info("Get Scheduled Resources", GlobalConstants.WarewolfInfo);
ObservableCollection <IScheduledResource> resources;
using (var model = SchedulerFactory.CreateModel(GlobalConstants.SchedulerFolderId, SecurityWrapper))
{
resources = model.GetScheduledResources();
}
var sb = new StringBuilder(JsonConvert.SerializeObject(resources, Formatting.Indented, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Objects,
TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple
}));
return(sb);
}
catch (Exception err)
{
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
throw;
}
}
bool TransferDirectoryContents(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, IDev2CRUDOperationTO args)
{
ValidateSourceAndDestinationContents(src, dst, args);
if (args.DoRecursiveCopy)
{
RecursiveCopy(src, dst, args);
}
var srcContents = src.ListFilesInDirectory(src.IOPath);
var result = true;
var origDstPath = Dev2ActivityIOPathUtils.ExtractFullDirectoryPath(dst.IOPath.Path);
if (!dst.PathExist(dst.IOPath))
{
CreateDirectory(dst, args);
}
foreach (var p in srcContents)
{
result = PerformTransfer(src, dst, args, origDstPath, p, result);
}
Dev2Logger.Debug($"Transfered: {src.IOPath.Path}", GlobalConstants.WarewolfDebug);
return(result);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Test Redis Source", GlobalConstants.WarewolfInfo);
msg.HasError = false;
values.TryGetValue(Warewolf.Service.TestRedisSource.RedisSource, out StringBuilder resourceDefinition);
var redisServiceSourceDefinition = serializer.Deserialize <RedisSourceDefinition>(resourceDefinition);
var con = new RedisSources();
using (var redisSource = new RedisSource
{
HostName = redisServiceSourceDefinition.HostName,
Port = redisServiceSourceDefinition.Port,
AuthenticationType = redisServiceSourceDefinition.AuthenticationType,
Password = redisServiceSourceDefinition.Password
})
{
var result = con.Test(redisSource);
msg.HasError = false;
msg.Message = new StringBuilder(result.IsValid ? serializer.Serialize(result.Result) : result.ErrorMessage);
msg.HasError = !result.IsValid;
}
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
}
return(serializer.SerializeToBuilder(msg));
}
internal void CleanupServer()
{
try
{
_queueProcessMonitor.Shutdown();
if (_startWebServer != null)
{
_startWebServer.Dispose();
_startWebServer = null;
}
if (_ipcClient != null)
{
_ipcClient.Dispose();
_ipcClient = null;
}
DebugDispatcher.Instance.Shutdown();
}
catch (Exception ex)
{
Dev2Logger.Error("Dev2.ServerLifecycleManager", ex, GlobalConstants.WarewolfError);
}
}
public void Disconnect()
{
// It can take some time to shutdown when permissions have changed ;(
// Give 5 seconds, then force a dispose ;)
try
{
IsShuttingDown = true;
IsConnected = false;
IsConnecting = false;
HubConnection.Stop(new TimeSpan(0, 0, 0, 5));
}
catch (AggregateException aex)
{
aex.Flatten();
aex.Handle(ex =>
{
Dev2Logger.Error(this, aex);
var hex = ex as HttpClientException;
if (hex != null)
{
switch (hex.Response.StatusCode)
{
case HttpStatusCode.Unauthorized:
case HttpStatusCode.Forbidden:
UpdateIsAuthorized(false);
throw new NotConnectedException();
}
}
throw new NotConnectedException();
});
}
catch (Exception e)
{
Dev2Logger.Error(this, e);
}
}
string ExtendedDirListSftp(string path, string user, string pass, string privateKeyFile)
{
var result = new StringBuilder();
var pathFromString = ActivityIOFactory.CreatePathFromString(path, user, pass, privateKeyFile);
var sftp = BuildSftpClient(pathFromString);
try
{
var fromPath = ExtractFileNameFromPath(pathFromString.Path);
AddResults(sftp, fromPath, result);
}
catch (Exception ex)
{
sftp.Dispose();
Dev2Logger.Error(this, ex, GlobalConstants.WarewolfError);
throw new Exception(string.Format(ErrorResource.DirectoryNotFound, path));
}
finally
{
sftp.Disconnect();
sftp.Dispose();
}
return(result.ToString());
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage msg = new ExecuteMessage();
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Test DB Connection Service");
StringBuilder resourceDefinition;
values.TryGetValue("DbSource", out resourceDefinition);
IDbSource src = serializer.Deserialize <DbSourceDefinition>(resourceDefinition);
var con = new DbSources();
DatabaseValidationResult result = con.DoDatabaseValidation(new DbSource
{
AuthenticationType = src.AuthenticationType,
Server = src.ServerName,
Password = src.Password,
ServerType = src.Type,
UserID = src.UserName
});
msg.HasError = false;
msg.Message = new StringBuilder(result.IsValid ? serializer.Serialize(result.DatabaseList) : result.ErrorMessage);
msg.HasError = !result.IsValid;
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err);
}
return(serializer.SerializeToBuilder(msg));
}
/// <summary>
/// Adds the resource.
/// </summary>
/// <param name="res">The res.</param>
/// <param name="filePath">The file path.</param>
private void AddResource(IResource res, string filePath)
{
if (!filePath.Contains("VersionControl"))
{
if (!_addedResources.Contains(res.ResourceID))
{
_resources.Add(res);
_addedResources.Add(res.ResourceID);
}
else
{
var dupRes = _resources.Find(c => c.ResourceID == res.ResourceID);
if (dupRes != null)
{
CreateDupResource(dupRes, filePath);
Dev2Logger.Debug(string.Format(ErrorResource.ResourceAlreadyLoaded, res.ResourceName, filePath, dupRes.FilePath), GlobalConstants.WarewolfDebug);
}
else
{
Dev2Logger.Debug(string.Format("Resource '{0}' from file '{1}' wasn't loaded because a resource with the same name has already been loaded but cannot find its location.", res.ResourceName, filePath), GlobalConstants.WarewolfDebug);
}
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
var allErrors = new ErrorResultTO();
InitializeDebug(dataObject);
// Process if no errors
try
{
TryExecute(dataObject, update, allErrors);
}
catch (Exception e)
{
Dev2Logger.Error("DSFDateTime", e, GlobalConstants.WarewolfError);
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfDateTimeActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
IEnumerable <IExplorerItem> DuplicateAndSaveFolders(string sourceLocation, string destination, string newName, bool fixRefences)
{
var resourcesToMove = GetResourcesToMoveFrom(sourceLocation);
string destFolderPath = CalculateDestinationFolderPath(destination, newName, out List <IExplorerItem> items);
try
{
var duplicatedResourcesMap = DuplicateAndSaveResources(sourceLocation, destFolderPath, resourcesToMove);
DuplicateAndSaveTests(duplicatedResourcesMap);
if (fixRefences)
{
try
{
using (var tx = new TransactionScope(TransactionScopeOption.RequiresNew))
{
FixReferences(duplicatedResourcesMap);
tx.Complete();
}
}
catch (TransactionAbortedException e)
{
Dev2Logger.Error("Failure Fixing references", e, GlobalConstants.WarewolfError);
throw new WarewolfThreadAbortException(string.Format(ErrorResource.ErrorDuringDuplicateFolderCallback, e.Message));
}
}
}
catch (TransactionAbortedException ex)
{
Dev2Logger.Error(ErrorResource.ErrorDuringDuplicateFolderCallback, ex, GlobalConstants.WarewolfError);
throw new WarewolfThreadAbortException(string.Format(ErrorResource.ErrorDuringDuplicateFolderCallback, ex.Message));
}
return(items);
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
var allErrors = new ErrorResultTO();
var errors = new ErrorResultTO();
_executionResult = new List <string>();
allErrors.MergeErrors(errors);
InitializeDebug(dataObject);
// Process if no errors
try
{
TryExecute(dataObject, update, allErrors, errors);
}
catch (Exception ex)
{
Dev2Logger.Error(string.Format("{0} Exception", DisplayName), ex, GlobalConstants.WarewolfError);
allErrors.AddError(ex.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError(DisplayName, allErrors);
var errorList = allErrors.MakeDataListReady();
dataObject.Environment.AddError(errorList);
dataObject.Environment.Assign(Result, DisplayName.ToUpper().Contains("Dropbox".ToUpper()) ? GlobalConstants.DropBoxFailure : null, update);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
