public void IsSingeRecordSetRule_Check_TwoIndexes_ExpectErrorNoComma()
{
//------------Setup for test--------------------------
var isSingeRecordSetRule = new IsSingleRecordSetRule(() => "[[rec().a]][[rec().a]]");
GetValue(isSingeRecordSetRule);
}
// ReSharper disable InconsistentNaming
public void IsSingeRecordSetRule_Check_TwoIndexes_ExpectError()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingeRecordSetRule = new IsSingleRecordSetRule(() => "[[rec().a]],[[rec().a]]");
Assert.AreEqual("sort field is invalid. You may only sort on a single RecordSet columns", isSingeRecordSetRule.ErrorText);
}
// ReSharper disable InconsistentNaming
public void IsSingeRecordSetRule_Check_NoColumSpecifiedStar_ExpectError()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingeRecordSetRule = new IsSingleRecordSetRule(() => "[[rec(*)]]");
Assert.AreEqual("sort field is invalid. You may only sort on a single RecordSet columns", isSingeRecordSetRule.ErrorText);
}
// ReSharper disable InconsistentNaming
public void IsSingeRecordSetRule_Check_NoColumSpecifiedStar_ExpectError()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingeRecordSetRule = new IsSingleRecordSetRule(() => "[[rec(*)]]");
Assert.AreEqual(Warewolf.Resource.Errors.ErrorResource.IsSingeRecordSortFieldInvalidErrorTest, isSingeRecordSetRule.ErrorText);
}
public void IsSingeRecordSetRule_Check_NoColumSpecified_ExpectError()
{
//------------Setup for test--------------------------
var isSingeRecordSetRule = new IsSingleRecordSetRule(() => "[[rec()]]");
Assert.AreEqual(Warewolf.Resource.Errors.ErrorResource.IsSingeRecordSortFieldInvalidErrorTest, isSingeRecordSetRule.ErrorText);
}
// ReSharper disable InconsistentNaming
public void IsSingeRecordSetRule_Check_TwoIndexes_ExpectErrorNoComma()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingeRecordSetRule = new IsSingleRecordSetRule(() => "[[rec().a]][[rec().a]]");
GetValue(isSingeRecordSetRule);
}
static void GetValue(IsSingleRecordSetRule isSingeRecordSetRule)
{
//------------Execute Test---------------------------
var err = isSingeRecordSetRule.Check();
//------------Assert Results-------------------------
Assert.IsNotNull(err);
Assert.AreEqual("The sort field is invalid. You may only sort on a single RecordSet columns", err.Message);
}
static void GetValue(IsSingleRecordSetRule isSingeRecordSetRule)
{
//------------Execute Test---------------------------
var err = isSingeRecordSetRule.Check();
//------------Assert Results-------------------------
Assert.IsNotNull(err);
Assert.AreEqual(Warewolf.Resource.Errors.ErrorResource.IsSingeRecordSortFieldInvalidErrorTest, err.Message);
}
public void IsSingeRecordSetRule_Check_Single_ExpectNull()
{
//------------Setup for test--------------------------
var isSingeRecordSetRule = new IsSingleRecordSetRule(() => "[[rec().a]]");
//------------Execute Test---------------------------
Assert.IsNull(isSingeRecordSetRule.Check());
//------------Assert Results-------------------------
}
// ReSharper disable InconsistentNaming
public void IsSingeRecordSetRule_Check_SingleNested_ExpectNull()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingeRecordSetRule = new IsSingleRecordSetRule(() => "[[rec([[rec().b]]).a]]");
//------------Execute Test---------------------------
Assert.IsNull(isSingeRecordSetRule.Check());
//------------Assert Results-------------------------
}
// ReSharper disable InconsistentNaming
public void IsSingeRecordSetRule_Ctor_Single_Expectmessage_Has_Default()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingeRecordSetRule = new IsSingleRecordSetRule(() => "[[rec().a]]");
//------------Execute Test---------------------------
Assert.IsNull(isSingeRecordSetRule.Check());
//------------Assert Results-------------------------
}
// ReSharper disable InconsistentNaming
public void IsSingeRecordSetRule_Ctor_Single_Expectmessage_Has_Default()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingeRecordSetRule = new IsSingleRecordSetRule(() => "[[rec().a]]");
//------------Execute Test---------------------------
Assert.IsNull(isSingeRecordSetRule.Check());
//------------Assert Results-------------------------
}
// ReSharper disable InconsistentNaming
public void IsSingeRecordSetRule_Check_SingleNested_ExpectNull()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingeRecordSetRule = new IsSingleRecordSetRule(() => "[[rec([[rec().b]]).a]]");
//------------Execute Test---------------------------
Assert.IsNull(isSingeRecordSetRule.Check());
//------------Assert Results-------------------------
}
public override void Validate()
{
IsSingleRecordSetRule rule = new IsSingleRecordSetRule(() => GetProperty<string>("SortField"));
var single = rule.Check();
if (single != null)
{
if (Errors == null )
Errors = new List<IActionableErrorInfo>();
Errors.Add(single);
}
}
public override void Validate()
{
IsSingleRecordSetRule rule = new IsSingleRecordSetRule(() => GetProperty <string>("SortField"));
var single = rule.Check();
if (single != null)
{
if (Errors == null)
{
Errors = new List <IActionableErrorInfo>();
}
Errors.Add(single);
}
}
public override void Validate()
{
// ReSharper disable once ExplicitCallerInfoArgument
IsSingleRecordSetRule rule = new IsSingleRecordSetRule(() => GetProperty<string>("SortField"));
var single = rule.Check();
if (single != null)
{
if (Errors == null )
Errors = new List<IActionableErrorInfo>();
Errors.Add(single);
}
}
public override void Validate()
{
// ReSharper disable once ExplicitCallerInfoArgument
IsSingleRecordSetRule rule = new IsSingleRecordSetRule(() => GetProperty <string>("SortField"));
var single = rule.Check();
if (single != null)
{
if (Errors == null)
{
Errors = new List <IActionableErrorInfo>();
}
Errors.Add(single);
}
}
// ReSharper disable InconsistentNaming
public void IsSingeRecordSetRule_Check_TwoIndexes_ExpectErrorNoComma()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var isSingeRecordSetRule = new IsSingleRecordSetRule(() => "[[rec().a]][[rec().a]]");
GetValue(isSingeRecordSetRule);
}
static void GetValue(IsSingleRecordSetRule isSingeRecordSetRule)
{
//------------Execute Test---------------------------
var err = isSingeRecordSetRule.Check();
//------------Assert Results-------------------------
Assert.IsNotNull(err);
Assert.AreEqual("The sort field is invalid. You may only sort on a single RecordSet columns", err.Message);
}
// ReSharper restore RedundantOverridenMember
protected override void OnExecute(NativeActivityContext context)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
ErrorResultTO errors;
ErrorResultTO allErrors = new ErrorResultTO();
Guid executionId = DataListExecutionID.Get(context);
InitializeDebug(dataObject);
try
{
string rawRecsetName = RetrieveItemForEvaluation(enIntellisensePartType.RecordsetsOnly, SortField);
string sortField = RetrieveItemForEvaluation(enIntellisensePartType.RecordsetFields, SortField);
bool descOrder = String.IsNullOrEmpty(SelectedSort) || SelectedSort.Equals("Backwards");
// Travis.Frisinger : New Stuff....
if (!string.IsNullOrEmpty(rawRecsetName))
{
IBinaryDataList bdl = compiler.FetchBinaryDataList(executionId, out errors);
IBinaryDataListEntry rsData;
string error;
bdl.TryGetEntry(rawRecsetName, out rsData, out error);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(SortField, "Sort Field", rsData, executionId);
}
allErrors.AddError(error);
IsSingleRecordSetRule rule = new IsSingleRecordSetRule(() => SortField);
var single = rule.Check();
if (single != null)
{
allErrors.AddError(single.Message);
}
// Check for fields
if (rsData != null && rsData.HasField(sortField))
{
rsData.Sort(sortField, descOrder, out error);
errors.AddError(error);
// Push back against the datalist
compiler.PushBinaryDataList(executionId, bdl, out errors);
allErrors.MergeErrors(errors);
if (dataObject.IsDebugMode())
{
bdl.TryGetEntry(rawRecsetName, out rsData, out error);
//Added for Bug 9479
string tmpExpression = SortField;
if (tmpExpression.Contains("()."))
{
tmpExpression = tmpExpression.Replace("().", "(*).");
}
AddDebugOutputItem(new DebugItemVariableParams(tmpExpression, "", rsData, executionId));
}
}
}
else
{
allErrors.AddError("No recordset given");
}
}
finally
{
if (allErrors.HasErrors())
{
DisplayAndWriteError("DsfSortRecordsActivity", allErrors);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
// End Travis.Frisinger New Stuff
}
