/// <summary>
/// Send request to create a single resource
/// </summary>
/// <param name="resourceType"></param>
/// <param name="fieldAlias"></param>
/// <param name="fieldValue"></param>
/// <param name="expectedCode"></param>
/// <param name="cleaner"></param>
/// <param name="referenceRecords"></param>
/// <param name="idRelatedFieldCreatedAutomatically"></param>
/// <param name="index"></param>
public static void CreateSingleItem(Enums.ResourceType resourceType, string fieldAlias, Func <int, object> getFieldValue, int expectedCode,
HrbcRecordDelete cleaner, HrbcRecordCreator referenceRecords, bool idRelatedFieldCreatedAutomatically = false, int index = 0)
{
XmlResource resource = ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias, getFieldValue(index), referenceRecords,
idRelatedFieldCreatedAutomatically, index, referenceRecords);
var error = ResourceHelper.WriteResourceFail(resource, cleaner);
Assert.That(error, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
/// <summary>
/// Send request to create a single resource
/// </summary>
/// <param name="resourceType"></param>
/// <param name="fieldAlias"></param>
/// <param name="fieldValue"></param>
/// <param name="expectedCode"></param>
/// <param name="cleaner"></param>
/// <param name="referenceRecords"></param>
public static void CreateSingleItem(Enums.ResourceType resourceType, string fieldAlias, Func <int, object> getFieldValue,
HrbcRecordDelete cleaner, HrbcRecordCreator referenceRecords, Action <object> verifyActualValue, bool idRelatedFieldCreatedAutomatically = false, int index = 0)
{
XmlResource resource = ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias, getFieldValue(index), referenceRecords,
idRelatedFieldCreatedAutomatically, index, referenceRecords);
string id = ResourceHelper.WriteResource(resource, cleaner);
//Verify result
Assert.That(id, MustBe.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
ReadAndVerify(resourceType, fieldAlias, id, verifyActualValue);
}
/// <summary>
/// Send a request to create a list of resources
/// </summary>
/// <param name="resourceType"></param>
/// <param name="fieldAlias"></param>
/// <param name="fieldValue"></param>
/// <param name="expectedCode"></param>
/// <param name="cleaner"></param>
/// <param name="records"></param>
/// <param name="idRelatedFieldCreatedAutomatically"></param>
public static void CreateListItem(Enums.ResourceType resourceType, string fieldAlias, Func <int, object> getFieldValue, int expectedCode,
HrbcRecordDelete cleaner, HrbcRecordCreator records, bool idRelatedFieldCreatedAutomatically = false)
{
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
return(ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias, getFieldValue(depKey), records,
idRelatedFieldCreatedAutomatically, depKey, records));
}).ToList();
ErrorCode result = ResourceHelper.WriteResourcesFail(resourceList, cleaner);
Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
/// <summary>
/// Send a request to create a list of resources
/// </summary>
/// <param name="resourceType"></param>
/// <param name="fieldAlias"></param>
/// <param name="fieldValue"></param>
/// <param name="cleaner"></param>
/// <param name="records"></param>
/// <param name="verifyActualValue"></param>
/// <param name="idRelatedFieldCreatedAutomatically"></param>
public static void CreateListItem(Enums.ResourceType resourceType, string fieldAlias, Func <int, object> getFieldValue,
HrbcRecordDelete cleaner, HrbcRecordCreator records, Action <object> verifyActualValue = null, bool idRelatedFieldCreatedAutomatically = false)
{
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
return(ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias, getFieldValue(depKey), records,
idRelatedFieldCreatedAutomatically, depKey, records));
}).ToList();
List <WriteResultItem> result = ResourceHelper.WriteResources(resourceType, resourceList, cleaner);
Assert.That(result, MustBe.SuccessfullyWritten(resourceList.Count), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
foreach (var item in result)
{
ReadAndVerify(resourceType, fieldAlias, item.Id, verifyActualValue);
}
}
/// <summary>
/// Send a request to create a list of resources
/// </summary>
/// <param name="resourceType"></param>
/// <param name="fieldAlias"></param>
/// <param name="fieldValue"></param>
/// <param name="expectedCode"></param>
/// <param name="cleaner"></param>
/// <param name="records"></param>
public static void CreateListItem(Enums.ResourceType resourceType, string fieldAlias, object fieldValue, int expectedCode,
HrbcRecordDelete cleaner, HrbcRecordCreator records, bool idRelatedFieldCreatedAutomatically = false)
{
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
return(ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias, fieldValue, records,
idRelatedFieldCreatedAutomatically, depKey, records));
}).ToList();
if (fieldValue == null)
{
foreach (XmlResource item in resourceList)
{
item.DictionaryValues.Remove(fieldAlias);
}
}
ErrorCode result = ResourceHelper.WriteResourcesFail(resourceList, cleaner);
Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
private static void WriteAndVerify(Enums.ResourceType resourceType, List <XmlResource> resourceList, BulkWriteInputType firstItemType, BulkWriteInputType secondItemType, HrbcRecordDelete cleaner)
{
//Write data
List <WriteResultItem> result = ResourceHelper.WriteResources(resourceType, resourceList, null);
//In case a new resource is created, We add it to the cleaner
if (result != null && result.Count > 0)
{
if (firstItemType != BulkWriteInputType.UpdatedItem)
{
cleaner.Delete(resourceType, result[0].Id);
}
if (secondItemType != BulkWriteInputType.UpdatedItem)
{
cleaner.Delete(resourceType, result[1].Id);
}
}
//Verify result
Assert.That(result, Is.Not.Null, "Create records operation failed. Response is null or cannot be parsed.");
Assert.That(result.Count, Is.EqualTo(resourceList.Count), "Create records operation failed. Number of successfully inserted resources is not same as the number of records we intended to insert");
VerifyBulkWriteResultItem(firstItemType, result[0]);
VerifyBulkWriteResultItem(secondItemType, result[1]);
}
/// <summary>
/// Execute all steps of Singe Item Bulk Write test
/// </summary>
/// <param name="resourceType"></param>
/// <param name="fieldAlias1"></param>
/// <param name="fieldAlias2"></param>
/// <param name="fieldValue"></param>
/// <param name="records"></param>
/// <param name="isPhase"></param>
/// <param name="cleaner"></param>
public static void ExecuteTestSingleItem(Enums.ResourceType resourceType, string fieldAlias1, string fieldAlias2,
Func <string, int, object> getFieldValue, HrbcRecordCreator records, bool isPhase, HrbcRecordDelete cleaner, int index = 0, HrbcRecordCreator referenceRecords = null)
{
//Preparation
XmlResource resource = ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias1, getFieldValue(fieldAlias1, index), records, isPhase, index, referenceRecords);
resource.DictionaryValues[fieldAlias2] = getFieldValue(fieldAlias2, index);
//Write data
string id = ResourceHelper.WriteResource(resource, cleaner);
//Verify result
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
}
/// <summary>
/// Execute all steps of List Item Bulk Write test
/// </summary>
/// <param name="resourceType"></param>
/// <param name="firstItemType"></param>
/// <param name="secondItemType"></param>
/// <param name="records"></param>
/// <param name="referenceRecords"></param>
/// <param name="fieldAlias"></param>
/// <param name="cleaner"></param>
/// <param name="getFieldValue"></param>
/// <param name="isPhase"></param>
public static void ExecuteTestListItem(Enums.ResourceType resourceType, BulkWriteInputType firstItemType, BulkWriteInputType secondItemType,
HrbcRecordCreator records, HrbcRecordCreator referenceRecords, string fieldAlias, HrbcRecordDelete cleaner,
Func <int, object> getFieldValue, bool isPhase = false, int startIndex = 0)
{
//Preparation
var resourceList = new List <XmlResource>()
{
BulkWriteHelper.CreateBulkWriteTestResourceInstance(resourceType, firstItemType, records, referenceRecords, fieldAlias, getFieldValue(0), isPhase, startIndex),
BulkWriteHelper.CreateBulkWriteTestResourceInstance(resourceType, secondItemType, records, referenceRecords, fieldAlias, getFieldValue(1), isPhase, startIndex + 1),
};
WriteAndVerify(resourceType, resourceList, firstItemType, secondItemType, cleaner);
}
public static void UpdateListItem(Enums.ResourceType resourceType, string fieldAlias, ZeroScaleValidInput valueType, HrbcRecordCreator records, HrbcRecordDelete cleaner)
{
var fieldValue = WriteZeroScaleValidInput.GetDataInput(valueType).Input;
var expectedValue = WriteZeroScaleValidInput.GetDataInput(valueType).Expected;
IEnumerable <XmlResource> resourceList = new List <XmlResource>
{
ResourceHelper.CreateResourceInstance(records, resourceType, 0),
ResourceHelper.CreateResourceInstance(records, resourceType, 1)
};
List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList, cleaner);
Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assume.That(ids.Select(t => t.Code), Is.All.EqualTo(0), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
resourceList = ids.Select(item =>
{
return(ResourceHelper.CreateUpdatedResource(resourceType, item.Id, fieldAlias, fieldValue));
});
List <WriteResultItem> result = ResourceHelper.WriteResources(Enums.ResourceType.Activity, resourceList, cleaner);
Assert.That(result, Is.Not.Null, "The response data is incorrect!");
Assert.That(result.Count, Is.EqualTo(resourceList.Count()), "The response data is incorrect!");
foreach (var item in result)
{
Assert.That(item.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), Enums.Message.WRONG_ERROR_CODE);
Assert.That(item.Id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
ReadAndVerifyData(resourceType, item.Id, fieldAlias, expectedValue.ToString());
}
}
public static void CreateSingleItem(Enums.ResourceType resourceType, string fieldAlias, ZeroScaleValidInput valueType, HrbcRecordCreator records, HrbcRecordDelete cleaner)
{
var fieldValue = WriteZeroScaleValidInput.GetDataInput(valueType).Input;
var expectedValue = WriteZeroScaleValidInput.GetDataInput(valueType).Expected;
XmlResource resource = ResourceHelper.CreateResourceInstance(records, resourceType);
resource.DictionaryValues[fieldAlias] = fieldValue;
string id = ResourceHelper.WriteResource(resource, cleaner);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
ReadAndVerifyData(resourceType, id, fieldAlias, expectedValue.ToString());
}
public static void CreateListItem(Enums.ResourceType resourceType, string fieldAlias, ZeroScaleValidInput valueType, HrbcRecordCreator records, HrbcRecordDelete cleaner)
{
var fieldValue = WriteZeroScaleValidInput.GetDataInput(valueType).Input;
var expectedValue = WriteZeroScaleValidInput.GetDataInput(valueType).Expected;
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
var resource = ResourceHelper.CreateResourceInstance(records, resourceType, depKey);
resource.DictionaryValues[fieldAlias] = fieldValue;
return(resource);
}).ToList();
List <WriteResultItem> result = ResourceHelper.WriteResources(resourceType, resourceList, cleaner);
Assert.That(result, Is.Not.Null, "The response data is incorrect!");
Assert.That(result.Count, Is.EqualTo(resourceList.Count()), "The response data is incorrect!");
foreach (var item in result)
{
Assert.That(item.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), Enums.Message.WRONG_ERROR_CODE);
Assert.That(item.Id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
ReadAndVerifyData(resourceType, item.Id, fieldAlias, expectedValue.ToString());
}
}
public static void UpdateSingleItem(Enums.ResourceType resourceType, string fieldAlias, ScaleInvalidInput valueType, HrbcRecordCreator records, HrbcRecordDelete cleaner)
{
XmlResource resource = ResourceHelper.CreateResourceInstance(records, resourceType, 1);
string id = ResourceHelper.WriteResource(resource, cleaner);
Assume.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
var fieldValue = WriteScaleInvalidInput.GetDataInput(valueType);
resource = ResourceHelper.CreateUpdatedResource(resourceType, id, fieldAlias, fieldValue);
var error = ResourceHelper.WriteResourceFail(resource, cleaner);
Assert.That(error, Is.Not.Null, string.Format(Enums.Message.UPDATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(error.Code, Is.EqualTo(Enums.PublicAPIResultCode.InvalidParameterValue), Enums.Message.WRONG_ERROR_CODE);
}
public static void UpdateListItem(Enums.ResourceType resourceType, string fieldAlias, ScaleInvalidInput valueType, HrbcRecordCreator records, HrbcRecordDelete cleaner)
{
var fieldValue = WriteScaleInvalidInput.GetDataInput(valueType);
IEnumerable <XmlResource> resourceList = new List <XmlResource>
{
ResourceHelper.CreateResourceInstance(records, resourceType, 0),
ResourceHelper.CreateResourceInstance(records, resourceType, 1)
};
List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList, cleaner);
Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assume.That(ids.Select(t => t.Code), Is.All.EqualTo(0), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
resourceList = ids.Select(item =>
{
return(ResourceHelper.CreateUpdatedResource(resourceType, item.Id, fieldAlias, fieldValue));
});
ErrorCode result = ResourceHelper.WriteResourcesFail(resourceList);
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.UPDATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.InvalidParameterValue), Enums.Message.WRONG_ERROR_CODE);
}
//Invalid
public static void CreateListItem(Enums.ResourceType resourceType, string fieldAlias, ScaleInvalidInput valueType, HrbcRecordCreator records, HrbcRecordDelete cleaner)
{
var fieldValue = WriteScaleInvalidInput.GetDataInput(valueType);
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
var resource = ResourceHelper.CreateResourceInstance(records, resourceType, depKey);
resource.DictionaryValues[fieldAlias] = fieldValue;
return(resource);
}).ToList();
ErrorCode result = ResourceHelper.WriteResourcesFail(resourceList, cleaner);
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.InvalidParameterValue), Enums.Message.WRONG_ERROR_CODE);
}
public static void TestCreateListItem(Enums.ResourceType resourceType, Dictionary <string, ResourceFields.InputType> dictionaryAliasValue, bool isPhaseIncluded, HrbcRecordCreator referenceRecords, HrbcFieldReader fieldReader, HrbcRecordDelete cleaner)
{
string resourceName = resourceType.ToResourceName();
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
var resource = ResourceHelper.CreateResourceInstance(referenceRecords, resourceType, depKey);
resource = AddValueForAllField(resource, dictionaryAliasValue, depKey, referenceRecords, fieldReader);
if (isPhaseIncluded)
{
resource = AddPhaseToResource(resource, resourceName);
}
return(resource);
}).ToList();
List <WriteResultItem> result = ResourceHelper.WriteResources(resourceType, resourceList, cleaner);
Assert.That(result, MustBe.SuccessfullyWritten(resourceList.Count), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
for (int i = 0; i < result.Count; i++)
{
ReadAndVerify(resourceType, dictionaryAliasValue, result[i].Id, i, referenceRecords, fieldReader);
}
}
/// <summary>
/// Create Field Search Instance
/// </summary>
/// <param name="records">Hrbc Record Creator</param>
/// <param name="cleaner">Hrbc Record Delete</param>
/// <param name="resourceType">Resource Type</param>
/// <param name="fieldAlias">Field Alias</param>
/// <param name="fieldValues">List of field values</param>
/// <param name="condition1">The First Condition</param>
/// <param name="condition2">The Second Condition</param>
/// <returns>Parameters</returns>
public static Dictionary <string, string> CreateSearchInstance(HrbcRecordCreator records, HrbcRecordDelete cleaner, Enums.ResourceType resourceType, string fieldAlias, List <string> fieldValues, string condition)
{
string resourceName = resourceType.ToResourceName();
var fieldValuesToDict = fieldValues.Select((s, i) => new { s, i }).ToDictionary(x => x.i, x => x.s);
var resourceList = fieldValuesToDict.Select(item =>
{
var resource = ResourceHelper.CreateResourceInstance(records, resourceType, item.Key);
resource.DictionaryValues[fieldAlias] = item.Value;
return(resource);
});
List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList.ToList(), cleaner);
Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName));
Assume.That(ids.Select(t => t.Code), Is.All.EqualTo(0), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName));
return(new Dictionary <string, string>()
{
{ DateTimeValidator.FieldAlias1, fieldAlias },
{ DateTimeValidator.Condition1, condition },
{ DateTimeValidator.ConditionValue1, fieldValuesToDict[2] },
{ DateTimeValidator.ConditionValue2, fieldValuesToDict[4] },
});
}
/// <summary>
/// Create Multiple Field Search Instance
/// </summary>
/// <param name="records">Hrbc Record Creator</param>
/// <param name="cleaner">Hrbc Record Delete</param>
/// <param name="resourceType">Resource Type</param>
/// <param name="fieldAlias1">The First Field Alias</param>
/// <param name="fieldAlias2">The Second Field Alias</param>
/// <param name="fieldValues">List of field values</param>
/// <param name="condition1">The First Condition</param>
/// <param name="condition2">The Second Condition</param>
/// <returns>Parameters</returns>
public static Dictionary <string, string> CreateMultipleFieldSearchInstance(HrbcRecordCreator records, HrbcRecordDelete cleaner, Enums.ResourceType resourceType, string fieldAlias1, string fieldAlias2, List <string> fieldValues, string condition1, string condition2)
{
string resourceName = resourceType.ToResourceName();
var resourceList = new Dictionary <int, string> {
{ 0, fieldValues[0] }, { 1, fieldValues[1] }, { 2, fieldValues[2] }, { 3, fieldValues[3] }, { 4, fieldValues[4] },
{ 5, fieldValues[5] }
}.Select(item =>
{
var resource = ResourceHelper.CreateResourceInstance(records, resourceType, item.Key);
if (fieldAlias1.Contains(DateTimeSystemField.PhaseDate) || fieldAlias2.Contains(DateTimeSystemField.PhaseDate))
{
List <string> phaseList = GetPhaseList(resourceType);
resource.DictionaryValues[$"{resourceName}.P_Phase"] = new Option()
{
ActualXMLTag = phaseList.First()
};
}
if (fieldAlias1.Contains(DateTimeSystemField.ActivityFromDate) && !fieldAlias2.Contains(DateTimeSystemField.ActivityToDate))
{
resource.DictionaryValues[$"{resourceName}.{DateTimeSystemField.ActivityToDate}"] = item.Value;
}
else
if (fieldAlias1.Contains(DateTimeSystemField.ActivityToDate) && !fieldAlias2.Contains(DateTimeSystemField.ActivityFromDate))
{
resource.DictionaryValues[$"{resourceName}.{DateTimeSystemField.ActivityFromDate}"] = item.Value;
}
resource.DictionaryValues[fieldAlias1] = item.Value;
resource.DictionaryValues[fieldAlias2] = item.Value;
return(resource);
});
List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList.ToList(), cleaner);
Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName));
Assume.That(ids.Select(t => t.Code), Is.All.EqualTo(0), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName));
return(new Dictionary <string, string>()
{
{ DateTimeValidator.FieldAlias1, fieldAlias1 },
{ DateTimeValidator.FieldAlias2, fieldAlias2 },
{ DateTimeValidator.Condition1, condition1 },
{ DateTimeValidator.Condition2, condition2 },
{ DateTimeValidator.ConditionValue1, fieldValues[2] },
{ DateTimeValidator.ConditionValue2, fieldValues[4] },
});
}
/// <summary>
/// Create Multiple Field Search Instance
/// </summary>
/// <param name="records">Hrbc Record Creator</param>
/// <param name="cleaner">Hrbc Record Delete</param>
/// <param name="resourceType">Resource Type</param>
/// <param name="fieldAlias">Field Alias</param>
/// <param name="fieldValues">List of field values</param>
/// <param name="condition1">The First Condition</param>
/// <param name="condition2">The Second Condition</param>
/// <returns>Parameters</returns>
public static Dictionary <string, string> CreateOneFieldSearchInstance(HrbcRecordCreator records, HrbcRecordDelete cleaner, Enums.ResourceType resourceType, string fieldAlias, List <string> fieldValues, string condition1, string condition2)
{
string resourceName = resourceType.ToResourceName();
var resourceList = new Dictionary <int, string> {
{ 0, fieldValues[0] }, { 1, fieldValues[1] }, { 2, fieldValues[2] }, { 3, fieldValues[3] }, { 4, fieldValues[4] },
{ 5, fieldValues[5] }
}.Select(item =>
{
var resource = ResourceHelper.CreateResourceInstance(records, resourceType, item.Key);
resource.DictionaryValues[fieldAlias] = item.Value;
return(resource);
});
List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList.ToList(), cleaner);
Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName));
Assume.That(ids.Select(t => t.Code), Is.All.EqualTo(0), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName));
return(new Dictionary <string, string>()
{
{ DateTimeValidator.FieldAlias1, fieldAlias },
{ DateTimeValidator.FieldAlias2, fieldAlias },
{ DateTimeValidator.Condition1, condition1 },
{ DateTimeValidator.Condition2, condition2 },
{ DateTimeValidator.ConditionValue1, fieldValues[2] },
{ DateTimeValidator.ConditionValue2, fieldValues[4] },
});
}
/// <summary>
/// Create Order Instance
/// </summary>
/// <param name="records">HrbcRecordCreator</param>
/// <param name="cleaner">HrbcRecordDelete</param>
/// <param name="resourceType">Resource Type</param>
/// <param name="fieldsName">List Of Field Name</param>
/// <param name="fieldValues">List Of Field Values</param>
/// <returns>List of WriteResultItem</returns>
public static List <WriteResultItem> CreateOrderInstance(HrbcRecordCreator records, HrbcRecordDelete cleaner, Enums.ResourceType resourceType, List <string> fieldsName, List <string> fieldValues)
{
string resourceName = resourceType.ToResourceName();
var resourceList = fieldValues.Select((s, i) => new { s, i }).ToDictionary(x => x.i, x => x.s).Select(item =>
{
var resource = ResourceHelper.CreateResourceInstance(records, resourceType, item.Key);
if (fieldsName.Count() == 1) // Single order
{
string fieldName = fieldsName.First();
if (fieldName == DateTimeSystemField.PhaseDate)
{
List <string> phaseList = GetPhaseList(resourceType);
resource.DictionaryValues[$"{resourceName}.P_Phase"] = new Option()
{
ActualXMLTag = phaseList.First()
};
}
resource.DictionaryValues[$"{resourceName}.{fieldName}"] = item.Value;
}
else
if (fieldsName.Count() == 2) // Multiple orders
{
string fieldName1 = fieldsName.First();
string fieldName2 = fieldsName.Last();
if ((fieldName1 == DateTimeSystemField.PhaseDate) || (fieldName2 == DateTimeSystemField.PhaseDate))
{
List <string> phaseList = GetPhaseList(resourceType);
resource.DictionaryValues[$"{resourceName}.P_Phase"] = new Option()
{
ActualXMLTag = phaseList.First()
};
}
if ((fieldName1 == DateTimeSystemField.ActivityFromDate) && !(fieldName2 == DateTimeSystemField.ActivityToDate))
{
resource.DictionaryValues[$"{resourceName}.{DateTimeSystemField.ActivityToDate}"] = item.Value;
}
else
if ((fieldName1 == DateTimeSystemField.ActivityToDate) && !(fieldName2 == DateTimeSystemField.ActivityFromDate))
{
resource.DictionaryValues[$"{resourceName}.{DateTimeSystemField.ActivityToDate}"] = item.Value;
resource.DictionaryValues[$"{resourceName}.{DateTimeSystemField.ActivityFromDate}"] = item.Value;
}
resource.DictionaryValues[$"{resourceName}.{fieldName1}"] = item.Value;
resource.DictionaryValues[$"{resourceName}.{fieldName2}"] = item.Value;
}
return(resource);
});
List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList.ToList(), cleaner);
Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName));
Assume.That(ids.Select(t => t.Code), Is.All.EqualTo(0), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName));
return(ids);
}
public static void TestCreateSingleItem(Enums.ResourceType resourceType, Dictionary <string, ResourceFields.InputType> dictionaryAliasValue, bool isPhaseIncluded, HrbcRecordCreator referenceRecords, HrbcFieldReader fieldReader, HrbcRecordDelete cleaner)
{
string resourceName = resourceType.ToResourceName();
XmlResource resource = ResourceHelper.CreateResourceInstance(referenceRecords, resourceType, 0);
resource = AddValueForAllField(resource, dictionaryAliasValue, 0, referenceRecords, fieldReader);
if (isPhaseIncluded)
{
resource = AddPhaseToResource(resource, resourceName);
}
string id = ResourceHelper.WriteResource(resource, cleaner);
Assert.That(id, MustBe.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
ReadAndVerify(resourceType, dictionaryAliasValue, id, 0, referenceRecords, fieldReader);
}
