/// <summary>
/// Read a condition with special characters in midle multiple conidion
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="fieldAlias">Field alias</param>
/// <param name="condition">Condition</param>
/// <param name="inputType">Special character</param>
/// <param name="isSpecialCharInMidleSearch">Special character in midle search (True/False)</param>
/// <param name="isSpecialCharInValueOption">Special character in option value (True/False)</param>
public static void ReadFailSpecialCharacters(Enums.ResourceType resourceType, string fieldAlias, string condition, SpecialCharacters inputType, bool isSpecialCharInMidleSearch = false, bool isSpecialCharInValueOption = false)
{
const string defaultInvalidNumericValue = "100";
GenerateConditionAndSearchFailed(resourceType, fieldAlias, defaultInvalidNumericValue, condition, inputType, isSpecialCharInMidleSearch, isSpecialCharInValueOption);
}
private XmlResource CreateResourceInstance(Enums.ResourceType resourceType, int depSet = 1)
{
string testUser = "******";
switch (resourceType)
{
case Enums.ResourceType.Client:
return(new Client
{
Id = "-1",
Name = "Test target client",
Owner = testUser
});
case Enums.ResourceType.Activity:
return(new Activity()
{
Id = "-1",
Title = "Test Target Activity",
Owner = "1",
FromDate = Util.ToString(DateTime.Now),
});
case Enums.ResourceType.Sales:
return(new Sales
{
Id = "-1",
Client = records.Data["client1"].Id
});
case Enums.ResourceType.Contract:
return(new Contract
{
Id = "-1",
Name = "This is contract with client",
Client = records.Data["client1"].Id
});
case Enums.ResourceType.Process:
return(new Process
{
Id = "-1",
Client = records.Data["client1"].Id,
Recruiter = records.Data["recruiter1"].Id,
Resume = records.Data[$"resume{depSet}"].Id,
Job = records.Data[$"job{depSet}"].Id,
Candidate = records.Data["person1"].Id,
Owner = testUser
});
case Enums.ResourceType.Job:
return(new Job
{
Id = "-1",
Client = records.Data["client1"].Id,
Recruiter = records.Data["recruiter1"].Id,
Position = "Job Name",
Owner = testUser
});
case Enums.ResourceType.Recruiter:
return(new Recruiter
{
Id = "-1",
Client = records.Data["client1"].Id,
Name = "Recruiter Name",
Owner = testUser
});
case Enums.ResourceType.Resume:
return(new Resume
{
Id = "-1",
Candidate = records.Data["person1"].Id,
Owner = testUser
});
case Enums.ResourceType.Candidate:
return(new Candidate()
{
Id = "-1",
Name = "Client with Number Field",
Owner = testUser,
});
default:
throw new InconclusiveException("Broken test case: invalid resource type");
}
}
private List <string> WriteResources(Enums.ResourceType resourceType, IEnumerable <XmlResource> resources)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resources.ToList(), cleaner.DeleteMany));
}
public void TestSearchMultipleSearchConditionUsing1Field(Enums.ResourceType resourceType, string condition1, string condition2, string conditionValue1, string conditionValue2)
{
string resourceName = resourceType == Enums.ResourceType.Candidate ? "Person" : resourceType.ToString();
string fieldAlias = customFields.Data[$"{resourceType}"].Field.ToAlias();
var resourceList = new Dictionary <int, string> {
{ 1, "Porters Japan Keyword" }, { 2, "Porters VietNam Keyword" }, { 3, "Porters" }
}.Select(item =>
{
var resource = CreateResourceInstance(resourceType, item.Key);
resource.DictionaryValues[fieldAlias] = item.Value;
return(resource);
});
List <string> ids = WriteResources(resourceType, resourceList);
Assert.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
string formatCond = string.Format("{0}:{1}={3},{0}:{2}={4}", fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
Dictionary <string, object> urlParameter = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", formatCond },
{ "field", fieldAlias }
};
switch (resourceType)
{
case Enums.ResourceType.Activity:
ReadResourceAndVerify <Activity>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Client:
ReadResourceAndVerify <Client>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Candidate:
ReadResourceAndVerify <Candidate>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Contract:
ReadResourceAndVerify <Contract>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Job:
ReadResourceAndVerify <Job>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Process:
ReadResourceAndVerify <Process>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Recruiter:
ReadResourceAndVerify <Recruiter>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Resume:
ReadResourceAndVerify <Resume>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Sales:
ReadResourceAndVerify <Sales>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
}
}
private XmlResource CreateUpdatedResource(Enums.ResourceType resourceType, string id,
string AppField, string fieldValue)
{
XmlResource result = null;
switch (resourceType)
{
case Enums.ResourceType.Client:
result = new Client()
{
Id = id
};
result.DictionaryValues[AppField] = fieldValue;
break;
case Enums.ResourceType.Activity:
result = new Activity()
{
Id = id
};
result.DictionaryValues[AppField] = fieldValue;
break;
case Enums.ResourceType.Sales:
result = new Sales()
{
Id = id
};
result.DictionaryValues[AppField] = fieldValue;
break;
case Enums.ResourceType.Contract:
result = new Contract()
{
Id = id
};
result.DictionaryValues[AppField] = fieldValue;
break;
case Enums.ResourceType.Process:
result = new Process()
{
Id = id
};
result.DictionaryValues[AppField] = fieldValue;
break;
case Enums.ResourceType.Job:
result = new Job()
{
Id = id
};
result.DictionaryValues[AppField] = fieldValue;
break;
case Enums.ResourceType.Recruiter:
result = new Recruiter()
{
Id = id
};
result.DictionaryValues[AppField] = fieldValue;
break;
case Enums.ResourceType.Resume:
result = new Resume()
{
Id = id
};
result.DictionaryValues[AppField] = fieldValue;
break;
case Enums.ResourceType.Candidate:
result = new Candidate()
{
Id = id
};
result.DictionaryValues[AppField] = fieldValue;
break;
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="resourceType"></param>
/// <param name="max"></param>
/// <returns></returns>
public static string GetResourceId(Enums.ResourceType resourceType, HrbcRecordCreator records, int index)
{
return(records.Data[$"{resourceType.ToPrivateEnum()}{index}"].Id.ToString());
}
public void ItemStateReadFieldInputTests(ItemState state, Enums.ResourceType resource, string field, PropertyType propType, int expectedCode)
{
var request = RequestParams(state, resource, field, propType);
PerformTest(resource.ToString(), request, propType == PropertyType.Field ? true : false, expectedCode);
}
private ErrorCode WriteResourcesFail(Enums.ResourceType resourceType, IEnumerable <XmlResource> resources)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteFail(resources.ToList(), cleaner.DeleteMany));
}
public Entities.CacheSetting GetByType(Enums.ResourceType resourceType)
{
return(EntityModelFactory.Create(base.DbSet.Where(x => x.ResourceType == resourceType).FirstOrDefault()));
}
public void TestUpdateSingleItem(Enums.ResourceType resourceType, string fieldName, string fieldValue, int expectedCode)
{
string fieldAlias = resourceType.ToResourceName() + "." + fieldName;
WriteInvalidHelper.UpdateSingleItem(resourceType, fieldAlias, fieldValue, expectedCode, updateRecords);
}
/// <summary>
/// Creates quantity of the requared resource.
/// </summary>
/// <param name="resourceType"></param>
/// <param name="resourceQuantity"></param>
/// <returns></returns>
public IResource CreateResource(Enums.ResourceType resourceType, int resourceQuantity)
{
return(new Resource(resourceType, resourceQuantity));
}
public void TestCreateListItem(Enums.ResourceType resourceType, string fieldName, string fieldValue, int expectedCode)
{
string fieldAlias = resourceType.ToResourceName() + "." + fieldName;
WriteInvalidHelper.CreateListItem(resourceType, fieldAlias, fieldValue, expectedCode, cleaner, records);
}
public void TestReadValidInput(Enums.ResourceType resourceType, string lengthType, Enums.TextType textType)
{
string resourceName = resourceType == Enums.ResourceType.Candidate ? "Person" : resourceType.ToString();
string fieldAlias = string.Format("{0}.{1}", resourceName, AppField);
//Check registered application field
CheckRegisteredField(resourceType, AppField);
uint characterNumber = GetStringLength(lengthType, fieldAlias);
string fieldValue = Util.GetRandomText(textType, characterNumber);
XmlResource resource = CreateResourceInstance(resourceType);
resource.DictionaryValues[fieldAlias] = fieldValue;
string id = WriteResource(resourceType, resource);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
//Read & verify the field's value
Dictionary <string, object> urlParameter = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", string.Format("{0}.P_Id:eq={1}", resourceName, id) },
{ "field", fieldAlias }
};
switch (resourceType)
{
case Enums.ResourceType.Activity:
ReadData <Activity>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Client:
ReadData <Client>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Candidate:
ReadData <Candidate>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Contract:
ReadData <Contract>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Job:
ReadData <Job>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Process:
ReadData <Process>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Recruiter:
ReadData <Recruiter>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Resume:
ReadData <Resume>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Sales:
ReadData <Sales>(urlParameter, fieldAlias, fieldValue);
break;
}
}
/// <summary>
/// Read a condition with special characters in conidion and value option
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="fieldAlias">Field alias</param>
/// <param name="condition">Condition</param>
/// <param name="inputType">Special character</param>
/// <param name="isSpecialCharInMidleSearch">Special character in midle search (True/False)</param>
/// <param name="isSpecialCharInValueOption">Special character in option value (True/False)</param>
public static void ReadFailSpecialCharactersForOptionType(List <string> optionList, Enums.ResourceType resourceType, string fieldAlias, string condition, SpecialCharacters inputType, bool isSpecialCharInMidleSearch = false, bool isSpecialCharInValueOption = false)
{
GenerateConditionAndSearchFailed(resourceType, fieldAlias, optionList.FirstOrDefault(), condition, inputType, isSpecialCharInMidleSearch, isSpecialCharInValueOption);
}
/// <summary>
///
/// </summary>
/// <param name="resourceType"></param>
/// <param name="max"></param>
/// <returns></returns>
public static string GetRandomResourceId(Enums.ResourceType resourceType, HrbcRecordCreator records, int max)
{
return(records.Data[$"{resourceType.ToPrivateEnum()}{Util.GetRandomNumber(max)}"].Id.ToString());
}
public void TestSearchMultipleSearchConditionUsing1Field(Enums.ResourceType resourceType, string condition1, string condition2, string conditionValue1, string conditionValue2)
{
string resourceName = resourceType == Enums.ResourceType.Candidate ? "Person" : resourceType.ToString();
string fieldAlias = string.Empty;
switch (resourceType)
{
case Enums.ResourceType.Client:
fieldAlias = string.Format("{0}.{1}", resourceName, ClientField);
break;
case Enums.ResourceType.Resume:
fieldAlias = string.Format("{0}.{1}", resourceName, ResumeField);
break;
case Enums.ResourceType.Process:
fieldAlias = string.Format("{0}.{1}", resourceName, ProcessField);
break;
case Enums.ResourceType.Job:
fieldAlias = string.Format("{0}.{1}", resourceName, JobField);
break;
case Enums.ResourceType.Activity:
fieldAlias = string.Format("{0}.{1}", resourceName, ActivityField);
break;
case Enums.ResourceType.Recruiter:
fieldAlias = string.Format("{0}.{1}", resourceName, RecruiterField);
break;
case Enums.ResourceType.Contract:
fieldAlias = string.Format("{0}.{1}", resourceName, ContractField);
break;
case Enums.ResourceType.Candidate:
fieldAlias = string.Format("{0}.{1}", resourceName, CandidateField);
break;
case Enums.ResourceType.Sales:
fieldAlias = string.Format("{0}.{1}", resourceName, SalesField);
break;
}
var resourceList = new Dictionary <int, string> {
{ 1, "Porters Japan Keyword" }, { 2, "Porters VietNam Keyword" }, { 3, "Porters" }
}.Select(item =>
{
var resource = CreateResourceInstance(resourceType, item.Key);
resource.DictionaryValues[fieldAlias] = item.Value;
if (fieldAlias.Contains("P_PhaseMemo"))
{
List <string> phaseList = GetPhaseListResources(resourceType);
resource.DictionaryValues[$"{resourceName}.P_Phase"] = new Option()
{
ActualXMLTag = phaseList.First()
};
resource.DictionaryValues[$"{resourceName}.P_PhaseDate"] = Util.ToString(DateTime.Now);
}
return(resource);
});
List <string> ids = WriteResources(resourceType, resourceList);
Assert.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
string formatCond = string.Format("{0}:{1}={3},{0}:{2}={4}", fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
Dictionary <string, object> urlParameter = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", formatCond },
{ "field", fieldAlias }
};
switch (resourceType)
{
case Enums.ResourceType.Activity:
ReadResourceAndVerify <Activity>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Client:
ReadResourceAndVerify <Client>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Candidate:
ReadResourceAndVerify <Candidate>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Contract:
ReadResourceAndVerify <Contract>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Job:
ReadResourceAndVerify <Job>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Process:
ReadResourceAndVerify <Process>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Recruiter:
ReadResourceAndVerify <Recruiter>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Resume:
ReadResourceAndVerify <Resume>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
case Enums.ResourceType.Sales:
ReadResourceAndVerify <Sales>(urlParameter, fieldAlias, condition1, condition2, conditionValue1, conditionValue2);
break;
}
}
public static ReadResponseData <XmlResource> GetMultipleSearchMultipleFieldResult(Enums.ResourceType resourceType, string fieldAlias1, string fieldAlias2, string condition1, string condition2, string conditionValue1, string conditionValue2, string conditionValue3, string conditionValue4)
{
string formatCond = GetFormatCondition(fieldAlias1, fieldAlias2, condition1, condition2, conditionValue1, conditionValue2, conditionValue3, conditionValue4);
Dictionary <string, object> urlParameters = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", formatCond },
{ "field", fieldAlias1 == fieldAlias2 ? fieldAlias1 : string.Format("{0},{1}", fieldAlias1, fieldAlias2) },
};
return(PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceType.ToString(), urlParameters));
}
public void TestCreateGeneralFieldSettingValidation(Enums.ResourceType resourceType, string fieldName, FieldProperty fieldProperty, object val)
{
string fieldAlias = resourceType.ToResourceName() + "." + fieldName;
WriteValidHelper.CreateSingleItem(resourceType, fieldAlias, 1, cleaner, records, null);
}
public void TestReadValidInputWithScale(Enums.ResourceType resourceType, string fieldScale, string precision, string scale)
{
string fieldAlias = string.Empty;
switch (fieldScale)
{
case "ZeroScale":
fieldAlias = AppFieldScale0;
break;
case "OneScale":
fieldAlias = AppFieldScale1;
break;
case "TwoScale":
fieldAlias = AppFieldScale2;
break;
}
//Check registered application field
CheckRegisteredField(resourceType, fieldAlias);
string resourceName = resourceType == Enums.ResourceType.Candidate ? "Person" : resourceType.ToString();
fieldAlias = string.Format("{0}.{1}", resourceName, fieldAlias);
decimal valueInput = decimal.Parse(precision + scale);
decimal valueOuput = GetPrecisionAfterScale(precision, scale, fieldScale);
XmlResource resource = CreateResourceInstance(resourceType);
resource.DictionaryValues[fieldAlias] = valueInput;
string id = WriteResource(resourceType, resource);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
//Read & verify the field's value
Dictionary <string, object> urlParameter = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", string.Format("{0}.P_Id:eq={1}", resourceName, id) },
{ "field", fieldAlias }
};
switch (resourceType)
{
case Enums.ResourceType.Activity:
ReadData <Activity>(urlParameter, fieldAlias, valueOuput);
break;
case Enums.ResourceType.Client:
ReadData <Client>(urlParameter, fieldAlias, valueOuput);
break;
case Enums.ResourceType.Candidate:
ReadData <Candidate>(urlParameter, fieldAlias, valueOuput);
break;
case Enums.ResourceType.Contract:
ReadData <Contract>(urlParameter, fieldAlias, valueOuput);
break;
case Enums.ResourceType.Job:
ReadData <Job>(urlParameter, fieldAlias, valueOuput);
break;
case Enums.ResourceType.Process:
ReadData <Process>(urlParameter, fieldAlias, valueOuput);
break;
case Enums.ResourceType.Recruiter:
ReadData <Recruiter>(urlParameter, fieldAlias, valueOuput);
break;
case Enums.ResourceType.Resume:
ReadData <Resume>(urlParameter, fieldAlias, valueOuput);
break;
case Enums.ResourceType.Sales:
ReadData <Sales>(urlParameter, fieldAlias, valueOuput);
break;
}
}
public void TestSearchKeyword(Enums.ResourceType resourceType, string lengthType)
{
string resourceName = resourceType == Enums.ResourceType.Candidate ? "Person" : resourceType.ToString();
string fieldAlias = customFields.Data[$"{resourceType}"].Field.ToAlias();
int characterNumber = GetStringLength(lengthType);
string fieldValue = Util.GetUniqueString(characterNumber, false);
XmlResource resource = CreateResourceInstance(resourceType);
resource.DictionaryValues[fieldAlias] = fieldValue;
string id = WriteResource(resourceType, resource);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Dictionary <string, object> urlParameter = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "keywords", fieldValue.Substring(0, Util.GetRandomNumber(10, 100)) },
{ "field", fieldAlias }
};
switch (resourceType)
{
case Enums.ResourceType.Activity:
ReadResourceAndVerify <Activity>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Client:
ReadResourceAndVerify <Client>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Candidate:
ReadResourceAndVerify <Candidate>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Contract:
ReadResourceAndVerify <Contract>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Job:
ReadResourceAndVerify <Job>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Process:
ReadResourceAndVerify <Process>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Recruiter:
ReadResourceAndVerify <Recruiter>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Resume:
ReadResourceAndVerify <Resume>(urlParameter, fieldAlias, fieldValue);
break;
case Enums.ResourceType.Sales:
ReadResourceAndVerify <Sales>(urlParameter, fieldAlias, fieldValue);
break;
}
}
public void ItemStateReadInvalidCustomFieldTests(ItemState state, Enums.ResourceType resource, FieldTypes type, int expectedCode)
{
var request = RequestCustomParams(state, resource, type);
PerformTest(resource.ToString(), request, false, expectedCode);
}
public void TestUpdateSingleItem(Enums.ResourceType resourceType, ScaleInvalidInput valueType)
{
var fieldAlias = customFields.Data[$"{resourceType}-{ZeroScale}"].Field.ToAlias();
Common.UpdateSingleItem(resourceType, fieldAlias, valueType, records, cleaner);
}
public void TestReadMultiOrder(Enums.ResourceType resourceType, string fieldName1, string fieldName2)
{
string resourceName = resourceType == Enums.ResourceType.Candidate ? "Person" : resourceType.ToString();
List <string> fieldList = new List <string>()
{
resourceName + "." + fieldName1, resourceName + "." + fieldName2
};
string fieldAlias1 = fieldList.First();
string fieldAlias2 = fieldList.Last();
string optionMaster1 = GetOptionMaster(fieldAlias1);
Assume.That(optionMaster1, Is.Not.Null.And.Not.Empty, "Cannot get the master option!");
List <string> optionList1 = OptionFieldHelper.GetOptionList(optionMaster1);
Assume.That(optionList1, Is.Not.Null.And.Not.Empty, "Cannot get the option list!");
string fieldValue1 = optionList1.First();
string fieldValue2 = optionList1.Last();
string fieldValue3 = optionList1.Random();
string optionMaster2 = GetOptionMaster(fieldAlias2);
Assume.That(optionMaster2, Is.Not.Null.And.Not.Empty, "Cannot get the master option!");
List <string> optionList2 = OptionFieldHelper.GetOptionList(optionMaster2);
Assume.That(optionList2, Is.Not.Null.And.Not.Empty, "Cannot get the option list!");
string fieldValue4 = optionList1.First();
string fieldValue5 = optionList1.Last();
string fieldValue6 = optionList1.Random();
List <XmlResource> resourceList = new Dictionary <int, string[]>
{
[1] = new string[] { fieldValue1, fieldValue2 },
[2] = new string[] { fieldValue3, fieldValue4 },
[3] = new string[] { fieldValue5, fieldValue6 }
}
.Select(item =>
{
var resource = CreateResourceInstance(resourceType, item.Key);
resource.DictionaryValues[fieldAlias1] = new Option()
{
ActualXMLTag = item.Value[0]
};
resource.DictionaryValues[fieldAlias2] = new Option()
{
ActualXMLTag = item.Value[1]
};
return(resource);
}).ToList();
List <string> idList = WriteResources(resourceType, resourceList);
Assume.That(idList, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Dictionary <string, object> urlParameter = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "order", string.Format("{0}:desc,{1}:asc", fieldAlias1, fieldAlias2) },
};
Handler handler = PublicApiAdapter.CreateAdapterForDefaultConnection().Read(resourceType.ToString(), urlParameter);
Assert.That(handler, Is.Not.Null, "Cannot read resource!");
ErrorCode result = XmlHelper.ParseXMLString <ErrorCode>(handler.RawContent);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.InvalidParameterValue), "Error code is not matched!");
}
private static HrbcFieldUpdater.FieldSpec CreateFieldUpdateSpecForSingleProperty(Enums.ResourceType resource, string fieldName, Dictionary <FieldProperty, object> fieldProperties)
{
return(new HrbcFieldUpdater.FieldSpec {
Field = new HrbcField((ResourceId)(int)resource, fieldName), Properties = fieldProperties
});
}
private ErrorCode WriteResourceFail(Enums.ResourceType resourceType, XmlResource resource)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteFail(resource, cleaner.DeleteMany));
}
/// <summary>
/// Verify single search/single field result by system field reference resource
/// </summary>
/// <param name="resourceType">Resource Type</param>
/// <param name="resourceType">Reference Resource Type</param>
/// <param name="fieldAlias">Field Alias</param>
/// <param name="condition">Condition</param>
/// <param name="conditionValue1">Condition Value 1</param>
/// <param name="conditionValue2">Condition Value 2</param>
/// <returns>empty</returns>
public static void VerifySingleSearchSystemFieldReferenceResource(Enums.ResourceType resourceType, Enums.ResourceType referenceResourceType, Dictionary <string, string> parameters)
{
string fieldAlias = parameters[DateTimeValidator.FieldAlias1];
string condition = parameters[DateTimeValidator.Condition1];
int conditionValue1 = int.Parse(parameters[DateTimeValidator.ConditionValue1]);
int conditionValue2 = int.Parse(parameters[DateTimeValidator.ConditionValue2]);
ReadResponseData <XmlResource> result = GetSingleSearchResult(resourceType.ToString(), fieldAlias, condition, conditionValue1, conditionValue2);
int realValue = 0;
foreach (var item in result.Items)
{
XmlResource referenceResource = result.Items[0].DictionaryValues[fieldAlias] as XmlResource;
realValue = int.Parse((referenceResource.DictionaryValues[referenceResourceType.ToString()] as XmlResource).DictionaryValues[$"{referenceResourceType.ToResourceName()}.P_Id"].ToString());
DateTimeValidator.ConditionalAssertions[condition](realValue, conditionValue1, conditionValue2);
}
}
private string WriteResource(Enums.ResourceType resourceType, XmlResource resource)
{
return(PublicApiAdapter.CreateAdapterForDefaultConnection().WriteSuccess(resource, cleaner.Delete));
}
/// <summary>
/// Verify multi search/multi field result by resource of system field
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="resourceType">Reference resource type</param>
/// <param name="parameters">Parameters of condition search</param>
public static void VerifyMultiSearchMultiFieldReferenceResource(Enums.ResourceType resourceType, Enums.ResourceType referenceResourceType1, Enums.ResourceType referenceResourceType2, Dictionary <string, string> parameters)
{
string fieldAlias1 = parameters[DateTimeValidator.FieldAlias1];
string fieldAlias2 = parameters[DateTimeValidator.FieldAlias2];
string condition1 = parameters[DateTimeValidator.Condition1];
string condition2 = parameters[DateTimeValidator.Condition2];
int conditionValue1 = int.Parse(parameters[DateTimeValidator.ConditionValue1].ToString());
int conditionValue2 = int.Parse(parameters[DateTimeValidator.ConditionValue2].ToString());
int conditionValue3 = int.Parse(parameters[DateTimeValidator.ConditionValue3].ToString());
int conditionValue4 = int.Parse(parameters[DateTimeValidator.ConditionValue4].ToString());
ReadResponseData <XmlResource> result = GetMultipleSearchMultipleFieldResult(resourceType, fieldAlias1, fieldAlias2, condition1, condition2, conditionValue1.ToString(), conditionValue2.ToString(), conditionValue3.ToString(), conditionValue4.ToString());
switch (condition1 + condition2)
{
case DateTimeValidator.Eq + DateTimeValidator.Gt:
//case DateTimeValidator.Eq + DateTimeValidator.Ge:
//case DateTimeValidator.Eq + DateTimeValidator.Eq:
case DateTimeValidator.Le + DateTimeValidator.Gt:
//case DateTimeValidator.Le + DateTimeValidator.Ge:
//case DateTimeValidator.Le + DateTimeValidator.Eq:
case DateTimeValidator.Lt + DateTimeValidator.Gt:
case DateTimeValidator.Lt + DateTimeValidator.Ge:
case DateTimeValidator.Lt + DateTimeValidator.Eq:
Assert.That(result, MustBe.ReadSuccess(0), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceType.ToString()));
break;
default:
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), Enums.Message.WRONG_ERROR_CODE);
Assert.Greater(result.Count, 0, Enums.Message.COUNT_ERROR);
Assert.Greater(result.Items.Count, 0, Enums.Message.COUNT_ERROR);
int realValue1 = 0;
int realValue2 = 0;
foreach (var item in result.Items)
{
realValue1 = GetValueField(referenceResourceType1, item, fieldAlias1, "resource");
realValue2 = GetValueField(referenceResourceType2, item, fieldAlias2, "resource");
DateTimeValidator.ConditionalAssertions[condition1](realValue1, conditionValue1, conditionValue2);
DateTimeValidator.ConditionalAssertions[condition2](realValue2, conditionValue3, conditionValue4);
}
break;
}
}
public void TestCreateSingleItem(Enums.ResourceType resourceType, bool isPhaseIncluded)
{
var dictionaryAliasValue = ResourceFields.FieldsDictionary[resourceType];
CombineCaseHelper.TestCreateSingleItem(resourceType, dictionaryAliasValue, isPhaseIncluded, referenceRecords, fieldReader, cleaner);
}
/// <summary>
/// Create Info for mapping
/// </summary>
/// <param name="fileName">Uploaded file name</param>
/// <param name="filePath">Uploaded file path</param>
/// <param name="resourceType">Resource type of import data</param>
/// <returns>Info for mapping</returns>
public static Info GetImportFileInfo(string fileName, string filePath, Enums.ResourceType resourceType)
{
string resourceName = resourceType.ToResourceName();
var result = new Info
{
MappingNameLabel = $"My{resourceName}Import",
MappingSettings = new Settings
{
ResourceGroup = $"{resourceType}",
ResourceType = $"{resourceType}",
Keys = new List <string> {
$"{resourceName}.P_Id"
},
},
Labels = new Dictionary <string, string>
{
["source.1"] = $"{resourceName} ID",
["source.3"] = "Date Updated",
["source.5"] = "Updated by"
},
Groups = new Dictionary <string, string>
{
[$"{resourceName}.P_Id"] = "container.0",
[$"{resourceName}.P_UpdateDate"] = "container.2",
[$"{resourceName}.P_UpdatedBy"] = "container.4"
},
Items = new Dictionary <string, ItemsContent>
{
["container.0"] = new ItemsContent
{
Type = "container",
Items = new List <string> {
"source.1"
},
Converters = new List <string> {
"template.container.0.3", "defaultJoin"
},
},
["source.1"] = new ItemsContent
{
Type = "source",
Source = 1,
Converters = new List <string>(),
},
["container.2"] = new ItemsContent
{
Type = "container",
Items = new List <string> {
"source.3"
},
Converters = new List <string> {
"template.container.2.3", "defaultJoin",
"defaultDatetime"
},
},
["source.3"] = new ItemsContent
{
Type = "source",
Source = 2,
Converters = new List <string>(),
},
["container.4"] = new ItemsContent
{
Type = "container",
Items = new List <string> {
"source.5"
},
Converters = new List <string> {
"template.container.4.3", "defaultJoin", "defaultUser"
},
},
["source.5"] = new ItemsContent
{
Type = "source",
Source = 3,
Converters = new List <string>()
},
},
Converters = new Dictionary <string, object>
{
["template.container.0.3"] = new TemplateAdditional
{
Rule = new RuleTemplate {
Template = @"<Template Version=""1.0""><PlaceHolder Name=""Item.source.1"">1</PlaceHolder></Template>"
}
},
["template.container.2.3"] = new TemplateAdditional
{
Rule = new RuleTemplate {
Template = @"<Template Version=""1.0""><PlaceHolder Name=""Item.source.3"">2</PlaceHolder></Template>"
}
},
["template.container.4.3"] = new TemplateAdditional
{
Rule = new RuleTemplate {
Template = @"<Template Version=""1.0""><PlaceHolder Name=""Item.source.5"">3</PlaceHolder></Template>"
}
},
}
};
result.FileName = fileName;
result.FilePath = filePath;
result.ControlName = "_0__frm_if";
result.FileType = "application/vnd.ms-excel";
return(result);
}
