public void WarewolfListIterator_Object_GetValues()
{
//------------Setup for test--------------------------
_expr3 = new WarewolfIterator(_environment.Eval("[[RecSet()]]", 0));
var privateObj = new PrivateObject(_warewolfListIterator);
var variablesToIterateOn = privateObj.GetField("_variablesToIterateOn") as List <IWarewolfIterator>;
_warewolfListIterator.AddVariableToIterateOn(_expr3);
var listIterator = _warewolfListIterator as WarewolfListIterator;
listIterator.Types = variablesToIterateOn.Select(iterator => iterator.GetType()).ToList();
int integerPrimitive = 2;
float floatPrimitive = 1.23f;
Object[] objects = new Object[] {
integerPrimitive,
floatPrimitive
};
//------------Execute Test---------------------------
var val = listIterator.GetValues(objects);
//------------Assert Results-------------------------
Assert.AreEqual(2, val);
}
public string FetchNextValue(IWarewolfIterator expression)
{
var warewolfEvalResult = _variablesToIterateOn[_variablesToIterateOn.IndexOf(expression)];
if (warewolfEvalResult!=null)
{
return warewolfEvalResult.GetNextValue();
}
return null;
}
public string FetchNextValue(IWarewolfIterator expression)
{
var warewolfEvalResult = _variablesToIterateOn[_variablesToIterateOn.IndexOf(expression)];
if (warewolfEvalResult != null)
{
return(warewolfEvalResult.GetNextValue());
}
return(null);
}
protected override void AddItemsToIterator(IExecutionEnvironment environment, int update)
{
_compresItr = new WarewolfIterator(environment.Eval(CompressionRatio, update));
ColItr.AddVariableToIterateOn(_compresItr);
_archNameItr = new WarewolfIterator(environment.Eval(ArchiveName, update));
ColItr.AddVariableToIterateOn(_archNameItr);
_archPassItr = new WarewolfIterator(environment.Eval(DecryptedArchivePassword, update));
ColItr.AddVariableToIterateOn(_archPassItr);
}
protected override void AddItemsToIterator(IExecutionEnvironment environment)
{
_compresItr = new WarewolfIterator(environment.Eval(CompressionRatio));
ColItr.AddVariableToIterateOn(_compresItr);
_archNameItr = new WarewolfIterator(environment.Eval(ArchiveName));
ColItr.AddVariableToIterateOn(_archNameItr);
_archPassItr = new WarewolfIterator(environment.Eval(ArchivePassword));
ColItr.AddVariableToIterateOn(_archPassItr);
}
private bool AssignExpression(out WarewolfListIterator listIterator)
{
_expr3 = new WarewolfIterator(_environment.Eval("[[RecSet().a]]", 0));
_warewolfListIterator.AddVariableToIterateOn(_expr3);
listIterator = _warewolfListIterator as WarewolfListIterator;
if (listIterator == null)
{
return(true);
}
Assert.AreEqual(0, listIterator.RecordsAffected);
return(false);
}
public void TestInitialize()
{
_environment = new ExecutionEnvironment();
_warewolfListIterator = new WarewolfListIterator();
_environment.Assign(Result, "Success", 0);
_expr1 = new WarewolfIterator(_environment.Eval(Result, 0));
_expr2 = new WarewolfIterator(_environment.Eval("[[@Parent()]]", 0));
_warewolfListIterator.AddVariableToIterateOn(_expr1);
_warewolfListIterator.AddVariableToIterateOn(_expr2);
}
public void WarewolfListIterator_AddVariableToIterateOn_Should()
{
_expr3 = new WarewolfIterator(_environment.Eval("[[RecSet()]]", 0));
Assert.IsNotNull(_warewolfListIterator);
var privateObj = new PrivateObject(_warewolfListIterator);
var variablesToIterateOn = privateObj.GetField("_variablesToIterateOn") as List <IWarewolfIterator>;
Assert.IsNotNull(variablesToIterateOn);
Assert.AreEqual(2, variablesToIterateOn.Count);
_warewolfListIterator.AddVariableToIterateOn(_expr3);
Assert.AreEqual(3, variablesToIterateOn.Count);
}
public MySqlBulkLoader SetupMySqlBulkCopy(IWarewolfIterator batchItr, IWarewolfListIterator parametersIteratorCollection, IWarewolfIterator timeoutItr, DbSource runtimeDatabase, SqlBulkCopyOptions copyOptions)
{
var batchSize = -1;
var timeout = -1;
GetParameterValuesForBatchSizeAndTimeOut(batchItr, parametersIteratorCollection, timeoutItr, ref batchSize, ref timeout);
var sqlBulkCopy = new MySqlBulkLoader(new MySqlConnection(runtimeDatabase.ConnectionString))
{
TableName = TableName, FieldTerminator = ",", LineTerminator = "\n"
};
return(sqlBulkCopy);
}
void GetTimeOut(IWarewolfListIterator parametersIteratorCollection, IWarewolfIterator timeoutItr, ref int timeout)
{
if (timeoutItr != null)
{
var timeoutString = parametersIteratorCollection.FetchNextValue(timeoutItr);
if (!string.IsNullOrEmpty(timeoutString) && int.TryParse(timeoutString, out int parsedValue))
{
timeout = parsedValue;
}
}
else
{
int.TryParse(Timeout, out timeout);
}
}
void GetBatchSize(IWarewolfIterator batchItr, IWarewolfListIterator parametersIteratorCollection, ref int batchSize)
{
if (batchItr != null)
{
var batchSizeString = parametersIteratorCollection.FetchNextValue(batchItr);
if (!string.IsNullOrEmpty(batchSizeString) && int.TryParse(batchSizeString, out int parsedValue))
{
batchSize = parsedValue;
}
}
else
{
int.TryParse(BatchSize, out batchSize);
}
}
public void WarewolfListIterator_GetGuid_ShouldReturn0()
{
ValidateInstance(out PrivateObject privateObj, out List <IWarewolfIterator> variablesToIterateOn);
_environment.Assign("[[RecSet().a]]", "00d1c07e-7fa7-4127-a85f-3ae9aaa7c6de", 0);
_expr3 = new WarewolfIterator(_environment.Eval("[[RecSet().a]]", 0));
_warewolfListIterator.AddVariableToIterateOn(_expr3);
var listIterator = _warewolfListIterator as WarewolfListIterator;
if (listIterator == null)
{
return;
}
var guid = listIterator.GetGuid(2);
Assert.IsNotNull(guid);
}
public void WarewolfListIterator_Object_GetValue_String()
{
//------------Setup for test--------------------------
_expr3 = new WarewolfIterator(_environment.Eval("[[RecSet()]]", 0));
var privateObj = new PrivateObject(_warewolfListIterator);
var variablesToIterateOn = privateObj.GetField("_variablesToIterateOn") as List <IWarewolfIterator>;
_warewolfListIterator.AddVariableToIterateOn(_expr3);
var listIterator = _warewolfListIterator as WarewolfListIterator;
listIterator.Types = variablesToIterateOn.Select(iterator => iterator.GetType()).ToList();
//------------Execute Test---------------------------
var val = listIterator.GetValue(0);
listIterator.Close();
//------------Assert Results-------------------------
Assert.AreEqual("Success", val);
}
public SqlBulkCopy SetupSqlBulkCopy(IWarewolfIterator batchItr, IWarewolfListIterator parametersIteratorCollection, IWarewolfIterator timeoutItr, DbSource runtimeDatabase, SqlBulkCopyOptions copyOptions)
{
var batchSize = -1;
var timeout = -1;
GetParameterValuesForBatchSizeAndTimeOut(batchItr, parametersIteratorCollection, timeoutItr, ref batchSize, ref timeout);
var sqlBulkCopy = new SqlBulkCopy(runtimeDatabase.ConnectionString, copyOptions)
{
DestinationTableName = TableName
};
if (batchSize != -1)
{
sqlBulkCopy.BatchSize = batchSize;
}
if (timeout != -1)
{
sqlBulkCopy.BulkCopyTimeout = timeout;
}
return(sqlBulkCopy);
}
IWarewolfListIterator BuildParametersIteratorCollection(IExecutionEnvironment executionEnvironment, out IWarewolfIterator batchIterator, out IWarewolfIterator timeOutIterator)
{
var parametersIteratorCollection = new WarewolfListIterator();
batchIterator = null;
timeOutIterator = null;
if (!String.IsNullOrEmpty(BatchSize))
{
var batchItr = new WarewolfIterator(executionEnvironment.Eval(BatchSize));
parametersIteratorCollection.AddVariableToIterateOn(batchItr);
batchIterator = batchItr;
}
if (!String.IsNullOrEmpty(Timeout))
{
var timeoutItr = new WarewolfIterator(executionEnvironment.Eval(Timeout));
parametersIteratorCollection.AddVariableToIterateOn(timeoutItr);
timeOutIterator = timeoutItr;
}
return(parametersIteratorCollection);
}
void GetParameterValuesForBatchSizeAndTimeOut(IWarewolfIterator batchItr, IWarewolfListIterator parametersIteratorCollection, IWarewolfIterator timeoutItr, ref int batchSize, ref int timeout)
{
GetBatchSize(batchItr, parametersIteratorCollection, ref batchSize);
GetTimeOut(parametersIteratorCollection, timeoutItr, ref timeout);
}
void DoInsertForMySql(DbSource runtimeDatabase, SqlBulkCopyOptions currentOptions, IWarewolfListIterator parametersIteratorCollection, IWarewolfIterator batchItr, IWarewolfIterator timeoutItr, IDSFDataObject dataObject, ErrorResultTO errorResultTo, ErrorResultTO allErrors, ref bool addExceptionToErrorList)
{
MySqlBulkLoader sqlBulkCopy = new MySqlBulkLoader(new MySqlConnection(runtimeDatabase.ConnectionString));
TableName = TableName.Replace("[", "").Replace("]", "");
if (TableName.Contains("."))
{
TableName = TableName.Substring(TableName.IndexOf(".", StringComparison.Ordinal) + 1);
}
if (String.IsNullOrEmpty(BatchSize) && String.IsNullOrEmpty(Timeout))
{
sqlBulkCopy = new MySqlBulkLoader(new MySqlConnection(runtimeDatabase.ConnectionString))
{
TableName = TableName, FieldTerminator = ",", LineTerminator = "\n"
};
}
else
{
while (parametersIteratorCollection.HasMoreData())
{
sqlBulkCopy = SetupMySqlBulkCopy(batchItr, parametersIteratorCollection, timeoutItr, runtimeDatabase, currentOptions);
}
}
if (sqlBulkCopy != null)
{
var dataTableToInsert = BuildDataTableToInsertMySql();
if (InputMappings != null && InputMappings.Count > 0)
{
var iteratorCollection = new WarewolfListIterator();
var listOfIterators = GetIteratorsFromInputMappings(dataObject, iteratorCollection, out errorResultTo);
allErrors.MergeErrors(errorResultTo);
// oh no, we have an issue, bubble it out ;)
if (allErrors.HasErrors())
{
addExceptionToErrorList = false;
throw new Exception("Problems with Iterators for SQLBulkInsert");
}
// emit options to debug as per acceptance test ;)
if (dataObject.IsDebugMode())
{
AddBatchSizeAndTimeOutToDebug(dataObject.Environment);
AddOptionsDebugItems();
}
FillDataTableWithDataFromDataList(iteratorCollection, dataTableToInsert, listOfIterators);
foreach (var dataColumnMapping in InputMappings)
{
if (!String.IsNullOrEmpty(dataColumnMapping.InputColumn))
{
sqlBulkCopy.Columns.Add(dataColumnMapping.OutputColumn.ColumnName);
}
}
}
// Pass in wrapper now ;)
var wrapper = new MySqlBulkCopyWrapper(sqlBulkCopy);
var inserted = SqlBulkInserter.Insert(wrapper, dataTableToInsert);
var resultString = inserted ? "Success" : "Failure";
dataObject.Environment.Assign(Result, resultString);
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemWarewolfAtomResult(resultString, Result, ""));
}
allErrors.MergeErrors(errorResultTo);
if (dataTableToInsert != null)
{
dataTableToInsert.Dispose();
}
}
}
protected override void ExecuteTool(IDSFDataObject dataObject)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
allErrors.MergeErrors(errors);
var env = dataObject.Environment;
InitializeDebug(dataObject);
try
{
if (!errors.HasErrors())
{
if (dataObject.IsDebugMode())
{
AddDebugInputItem(Length, From, To, dataObject.Environment, RandomType);
}
IWarewolfIterator lengthItr = !String.IsNullOrEmpty(Length) ? new WarewolfIterator(env.EvalStrict(Length)) as IWarewolfIterator : new WarewolfAtomIterator(new[] { DataASTMutable.WarewolfAtom.Nothing, });
var fromItr = !String.IsNullOrEmpty(From) ? new WarewolfIterator(env.EvalStrict(From)) as IWarewolfIterator : new WarewolfAtomIterator(new[] { DataASTMutable.WarewolfAtom.Nothing, });
var toItr = !String.IsNullOrEmpty(To) ? new WarewolfIterator(env.EvalStrict(To)) as IWarewolfIterator : new WarewolfAtomIterator(new[] { DataASTMutable.WarewolfAtom.Nothing, });
WarewolfListIterator colItr = new WarewolfListIterator();
colItr.AddVariableToIterateOn(lengthItr);
colItr.AddVariableToIterateOn(fromItr);
colItr.AddVariableToIterateOn(toItr);
Dev2Random dev2Random = new Dev2Random();
while (colItr.HasMoreData())
{
int lengthNum = -1;
int fromNum = -1;
int toNum = -1;
string fromValue = colItr.FetchNextValue(fromItr);
string toValue = colItr.FetchNextValue(toItr);
string lengthValue = colItr.FetchNextValue(lengthItr);
if (RandomType != enRandomType.Guid)
{
if (RandomType == enRandomType.Numbers)
{
#region Getting the From
fromNum = GetFromValue(fromValue, out errors);
if (errors.HasErrors())
{
allErrors.MergeErrors(errors);
continue;
}
#endregion
#region Getting the To
toNum = GetToValue(toValue, out errors);
if (errors.HasErrors())
{
allErrors.MergeErrors(errors);
continue;
}
#endregion
}
else
{
#region Getting the Length
lengthNum = GetLengthValue(lengthValue, out errors);
if (errors.HasErrors())
{
allErrors.MergeErrors(errors);
continue;
}
#endregion
}
}
string value = dev2Random.GetRandom(RandomType, lengthNum, fromNum, toNum);
var rule = new IsSingleValueRule(() => Result);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
else
{
env.Assign(Result, value);
}
}
}
allErrors.MergeErrors(errors);
if (!allErrors.HasErrors())
{
AddDebugOutputItem(new DebugEvalResult(Result, "", dataObject.Environment));
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("DSFRandomActivity", e);
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfRandomActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
AddDebugOutputItem(new DebugItemStaticDataParams("", Result, ""));
}
DispatchDebugState(dataObject, StateType.Before);
DispatchDebugState(dataObject, StateType.After);
}
}
}
public string SendEmail(IExchange runtimeSource, IWarewolfListIterator colItr, IWarewolfIterator toItr, IWarewolfIterator ccItr, IWarewolfIterator bccItr, IWarewolfIterator subjectItr, IWarewolfIterator bodyItr, IWarewolfIterator attachmentsItr, out ErrorResultTO errors) => SendEmail(runtimeSource, colItr, toItr, ccItr, bccItr, subjectItr, bodyItr, attachmentsItr, out errors, true);
public void AddVariableToIterateOn(IWarewolfIterator iterator)
{
_variablesToIterateOn.Add(iterator);
}
public string FetchNextValue(IWarewolfIterator iterator)
{
var warewolfEvalResult = _variablesToIterateOn[_variablesToIterateOn.IndexOf(iterator)];
return(warewolfEvalResult?.GetNextValue());
}
public void AddVariableToIterateOn(IWarewolfIterator iterator)
{
_variablesToIterateOn.Add(iterator);
}
void DoInsertForSqlServer(DbSource runtimeDatabase, SqlBulkCopyOptions currentOptions, IDSFDataObject dataObject, ErrorResultTO allErrors, IWarewolfIterator batchItr, IWarewolfListIterator parametersIteratorCollection, IWarewolfIterator timeoutItr, ref ErrorResultTO errorResultTo, ref bool addExceptionToErrorList)
{
SqlBulkCopy sqlBulkCopy;
if (String.IsNullOrEmpty(BatchSize) && String.IsNullOrEmpty(Timeout))
{
sqlBulkCopy = new SqlBulkCopy(runtimeDatabase.ConnectionString, currentOptions)
{
DestinationTableName = TableName
};
}
else
{
sqlBulkCopy = SetupSqlBulkCopy(batchItr, parametersIteratorCollection, timeoutItr, runtimeDatabase, currentOptions);
}
if (sqlBulkCopy != null)
{
var dataTableToInsert = BuildDataTableToInsert();
var types = GETTypesFromMappingTypes();
var columns = GetNamesFromMappings();
if (InputMappings != null && InputMappings.Count > 0)
{
var iteratorCollection = new WarewolfListIterator();
var listOfIterators = GetIteratorsFromInputMappings(dataObject, iteratorCollection, out errorResultTo);
iteratorCollection.Types = types;
iteratorCollection.Names = columns;
allErrors.MergeErrors(errorResultTo);
FillDataTableWithDataFromDataList(iteratorCollection, dataTableToInsert, listOfIterators);
// oh no, we have an issue, bubble it out ;)
if (allErrors.HasErrors())
{
addExceptionToErrorList = false;
throw new Exception("Problems with Iterators for SQLBulkInsert");
}
// emit options to debug as per acceptance test ;)
if (dataObject.IsDebugMode())
{
AddBatchSizeAndTimeOutToDebug(dataObject.Environment);
AddOptionsDebugItems();
}
if (InputMappings != null)
{
foreach (var dataColumnMapping in InputMappings)
{
if (!String.IsNullOrEmpty(dataColumnMapping.InputColumn))
{
sqlBulkCopy.ColumnMappings.Add(new SqlBulkCopyColumnMapping(dataColumnMapping.OutputColumn.ColumnName, dataColumnMapping.OutputColumn.ColumnName));
}
}
}
var wrapper = new SqlBulkCopyWrapper(sqlBulkCopy);
SqlBulkInserter.Insert(wrapper, dataTableToInsert);
dataObject.Environment.Assign(Result, "Success");
if (dataObject.IsDebugMode())
{
AddDebugOutputItem(new DebugItemWarewolfAtomResult("Success", Result, ""));
}
}
if (dataTableToInsert != null)
{
dataTableToInsert.Dispose();
}
}
}
public string SendEmail(IExchange runtimeSource, IWarewolfListIterator colItr, IWarewolfIterator toItr, IWarewolfIterator ccItr, IWarewolfIterator bccItr, IWarewolfIterator subjectItr, IWarewolfIterator bodyItr, IWarewolfIterator attachmentsItr, out ErrorResultTO errors, bool isHtml)
{
InitializeService();
errors = new ErrorResultTO();
var toValue = colItr.FetchNextValue(toItr);
var ccValue = colItr.FetchNextValue(ccItr);
var bccValue = colItr.FetchNextValue(bccItr);
var subjectValue = colItr.FetchNextValue(subjectItr);
var bodyValue = colItr.FetchNextValue(bodyItr);
var attachmentsValue = colItr.FetchNextValue(attachmentsItr);
var mailMessage = new EmailMessage(ExchangeService)
{
Subject = subjectValue
};
AddToAddresses(toValue, mailMessage);
mailMessage.Body = bodyValue;
if (isHtml)
{
mailMessage.Body.BodyType = BodyType.HTML;
}
else
{
mailMessage.Body.BodyType = BodyType.Text;
}
if (!string.IsNullOrEmpty(ccValue))
{
AddCcAddresses(ccValue, mailMessage);
}
if (!string.IsNullOrEmpty(bccValue))
{
AddBccAddresses(bccValue, mailMessage);
}
if (!string.IsNullOrEmpty(attachmentsValue))
{
AddAttachmentsValue(attachmentsValue, mailMessage);
}
string result;
try
{
EmailSender = new ExchangeEmailSender(runtimeSource);
EmailSender.Send(ExchangeService, mailMessage);
result = "Success";
}
catch (Exception e)
{
result = "Failure";
errors.AddError(e.Message);
}
return(result);
}
// ReSharper disable TooManyArguments
string SendEmail(EmailSource runtimeSource, IWarewolfListIterator colItr, IWarewolfIterator fromAccountItr, IWarewolfIterator passwordItr, IWarewolfIterator toItr, IWarewolfIterator ccItr, IWarewolfIterator bccItr, IWarewolfIterator subjectItr, IWarewolfIterator bodyItr, IWarewolfIterator attachmentsItr, out ErrorResultTO errors)
// ReSharper restore TooManyArguments
{
errors = new ErrorResultTO();
var fromAccountValue = colItr.FetchNextValue(fromAccountItr);
var passwordValue = colItr.FetchNextValue(passwordItr);
var toValue = colItr.FetchNextValue(toItr);
var ccValue = colItr.FetchNextValue(ccItr);
var bccValue = colItr.FetchNextValue(bccItr);
var subjectValue = colItr.FetchNextValue(subjectItr);
var bodyValue = colItr.FetchNextValue(bodyItr);
var attachmentsValue = colItr.FetchNextValue(attachmentsItr);
MailMessage mailMessage = new MailMessage();
MailPriority priority;
if (Enum.TryParse(Priority.ToString(), true, out priority))
{
mailMessage.Priority = priority;
}
mailMessage.Subject = subjectValue;
AddToAddresses(toValue, mailMessage);
try
{
// Always use source account unless specifically overridden by From Account
if (!string.IsNullOrEmpty(fromAccountValue))
{
runtimeSource.UserName = fromAccountValue;
runtimeSource.Password = passwordValue;
}
mailMessage.From = new MailAddress(runtimeSource.UserName);
}
catch (Exception)
{
errors.AddError(string.Format("From address is not in the valid format: {0}", fromAccountValue));
return("Failure");
}
mailMessage.Body = bodyValue;
if (!String.IsNullOrEmpty(ccValue))
{
AddCcAddresses(ccValue, mailMessage);
}
if (!String.IsNullOrEmpty(bccValue))
{
AddBccAddresses(bccValue, mailMessage);
}
if (!String.IsNullOrEmpty(attachmentsValue))
{
AddAttachmentsValue(attachmentsValue, mailMessage);
}
string result;
try
{
EmailSender.Send(runtimeSource, mailMessage);
result = "Success";
}
catch (Exception e)
{
result = "Failure";
errors.AddError(e.Message);
}
return(result);
}
