public void TestValidSingleSearch1OptionField(string fieldName, string condition)
{
condition = condition.ToLowerString();
string conditionValue1 = PhaseHelper.GetValueField(defaultResource, records.Data[$"{defaultResource.ToPrivateEnum()}{num}"].Records.Id.ToString(), new List <string> {
fieldName
}).Select(item => (item.PhaseObject as Option).ActualXMLTag).ToList().Random();
string conditionValue2 = PhaseHelper.GetValueField(defaultResource, records.Data[$"{defaultResource.ToPrivateEnum()}{num}"].Records.Id.ToString(), new List <string> {
fieldName
}).Select(item => (item.PhaseObject as Option).ActualXMLTag).ToList().Random();
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ PhaseApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ PhaseApiFields.Resource, (int)defaultResource },
{ PhaseApiFields.Condition, $"{fieldName}:{condition}={conditionValue1}:{conditionValue2}" },
{ PhaseApiFields.Field, fieldName },
};
ReadResponseData <Phase> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Phase>(parameters);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
foreach (var item in result.Items)
{
Assert.That((item.DictionaryValues[fieldName] as Option).ActualXMLTag, PhaseHelper.OptionConditionsMap[condition](conditionValue1, conditionValue2), DateTimeValidator.ErrorMessage);
}
}
public TestDeleteRecordContainsPhase()
{
foreach (var resourceId in Enum.GetValues(typeof(Enums.ResourceType)).Cast <Enums.ResourceType>().Where(r => r != Enums.ResourceType.Contract))
{
optionIds.Add(resourceId, PhaseHelper.GetLastPhaseOptionId(resourceId));
}
}
public static void Postfix(Vehicle __instance)
{
int initPhase = PhaseHelper.TonnageToPhase((int)Math.Ceiling(__instance.tonnage));
Mod.Log.Debug?.Write($"Setting baseInit for vehicle: {CombatantUtils.Label(__instance)} to {initPhase}");
__instance.StatCollection.Set <int>(ModStats.BaseInitiative, initPhase);
}
public DungeonBuilder(string world, string meshDir)
{
Dungeon = world;
_meshDir = meshDir;
Config = RecastConfig.Dungeon;
MapId = PhaseHelper.GetMapIdByName(Dungeon);
}
public void TestSearchMultipleOrderField(string fieldName1, string condition1, string fieldName2, string condition2, string orderType)
{
Dictionary <string, Type> sortOrders = new Dictionary <string, Type>();
string idField = "Id";
Dictionary <string, object> urlParameters = new Dictionary <string, object>()
{
{ PhaseApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ PhaseApiFields.Resource, (int)defaultResource },
};
//List of sort order class { <field, sortType, Type>, <field, sortType, Type>,... }
List <SortOrders> sortOrderFieldList = new List <SortOrders>()
{
{ new SortOrders(fieldName1, condition1, SearchTestData.phaseFieldList[fieldName1]) },
{ new SortOrders(fieldName2, condition2, SearchTestData.phaseFieldList[fieldName2]) },
};
SortOrders parameterSortOrder = PhaseHelper.GetParameterSortOrders(sortOrderFieldList, idField, orderType);
urlParameters[PhaseApiFields.Order] = parameterSortOrder.Condition;
urlParameters[PhaseApiFields.Field] = parameterSortOrder.Field;
sortOrders = parameterSortOrder.SortOrderTypes;
//Sort
List <XmlResource> result = ReadPhaseResource(urlParameters);
List <XmlResource> sortedItems = ResourceHelper.SortList(result, sortOrders);
Assert.IsTrue(ResourceHelper.CompareList(result, sortedItems, idField), Enums.Message.SORT_INCORRECT);
}
private Phase CreateBulkWritePhaseInstance(Enums.ResourceType resourceType, BulkWriteInputType itemType, int index = 0)
{
Phase result = null;
switch (itemType)
{
case BulkWriteInputType.ValidItem:
result = PhaseHelper.CreatePhaseInstance(creatingRequestRecords, resourceType, index);
break;
case BulkWriteInputType.InvalidItem:
result = PhaseHelper.CreatePhaseInstance(creatingRequestRecords, resourceType, index);
result.DictionaryValues["Datexxx"] = "Abc";
break;
case BulkWriteInputType.UpdatedItem:
result = new Phase()
{
Id = phaseReader.Data[$"{resourceType.ToPrivateEnum()}{index}"].FirstOrDefault().Id,
Date = Util.ToString(DateTime.Now, false),
};
break;
case BulkWriteInputType.CreatedItem:
result = PhaseHelper.CreatePhaseInstance(creatingRequestRecords, resourceType, index);
break;
}
return(result);
}
public void TestReadPhaseWithDuplicateParameters(string param, bool isDuplicatedValue)
{
Enums.ResourceType job = Enums.ResourceType.Job;
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ PhaseApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
};
List <object> duplicatedParameters = new List <object>();
var parameterValues = new Dictionary <string, object>
{
[PhaseApiFields.ResourceId + "1"] = (int)records.Data[$"{job.ToPrivateEnum()}0"].Id,
[PhaseApiFields.ResourceId + "2"] = (int)records.Data[$"{job.ToPrivateEnum()}1"].Id,
[PhaseApiFields.Id + "1"] = PhaseHelper.CreatePhase(job, records.Data[$"{job.ToPrivateEnum()}0"].Id.ToString()),
[PhaseApiFields.Id + "2"] = PhaseHelper.CreatePhase(job, records.Data[$"{job.ToPrivateEnum()}1"].Id.ToString()),
[PhaseApiFields.Resource + "1"] = (int)Enums.ResourceType.Client,
[PhaseApiFields.Resource + "2"] = (int)Enums.ResourceType.Activity,
[PhaseApiFields.Count + "1"] = 10,
[PhaseApiFields.Count + "2"] = 11,
[PhaseApiFields.Start + "1"] = 10,
[PhaseApiFields.Start + "2"] = 12,
[PhaseApiFields.Field + "1"] = PhaseApiFields.Memo,
[PhaseApiFields.Field + "2"] = PhaseApiFields.Phase,
[PhaseApiFields.Condition + "1"] = $"{nameof(PhaseApiFields.Id)}:eq={records.Data[$"{job.ToPrivateEnum()}0"].Id}",
[PhaseApiFields.Condition + "2"] = $"{nameof(PhaseApiFields.Id)}:eq={records.Data[$"{job.ToPrivateEnum()}1"].Id}",
[PhaseApiFields.Order + "1"] = $"{PhaseApiFields.Order}={nameof(PhaseApiFields.Id)}:{records.Data[$"{job.ToPrivateEnum()}0"].Id}",
[PhaseApiFields.Order + "2"] = $"{PhaseApiFields.Order}={nameof(PhaseApiFields.Id)}:{records.Data[$"{job.ToPrivateEnum()}1"].Id}",
};
if (isDuplicatedValue)
{
duplicatedParameters = new List <object>
{
parameterValues[$"{param}1"],
parameterValues[$"{param}1"],
parameterValues[$"{param}1"],
};
}
else
{
duplicatedParameters = new List <object>
{
parameterValues[$"{param}1"],
parameterValues[$"{param}2"],
parameterValues[$"{param}2"],
};
}
if (param != PhaseApiFields.Resource)
{
parameters.Add(PhaseApiFields.Resource, (int)job);
}
parameters.Add(param, duplicatedParameters);
ErrorCode result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadFail <Phase>(parameters);
Assert.That(result, MustBe.MatchingErrorCode(Enums.PublicAPIResultCode.ParameterIsInvalid), Enums.Message.WRONG_ERROR_CODE);
}
public TestMultipleSearchMultipleField()
{
//Create 16 phase entries
for (int i = 1; i <= 4; i++)
{
PhaseHelper.CreatePhaseWithGenerateSystemDateTimeField(); //Create 4 phase entries
}
}
public TileBuilder(string world, int x, int y)
{
World = world;
X = x;
Y = y;
Config = RecastConfig.Default;
MapId = PhaseHelper.GetMapIdByName(World);
}
public void TestCreateSingleItem(Enums.ResourceType resourceType)
{
Phase phase = PhaseHelper.CreatePhaseInstance(creatingRequestRecords, resourceType);
string result = PhaseHelper.WriteResource(phase);
Assert.That(result, Is.Not.Null.And.Not.Empty, string.Format("Cannot create phase for {0}", resourceType));
}
public void TestUpdateSingleItem(Enums.ResourceType resourceType, WriteInvalidMemoInput valueType, int expectedCode)
{
var phase = UpdateSinglePhaseInstance(resourceType, valueType);
var error = PhaseHelper.WritePhaseFail(phase);
Assert.That(error, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(error.Code, Is.EqualTo(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestUpdateListItem(string fieldName, WriteInvalidResourceInput valueType, int expectedCode)
{
var error = PhaseHelper.WritePhasesFail(new List <Phase> {
UpdateSinglePhaseInstance(fieldName, valueType, 0), UpdateSinglePhaseInstance(fieldName, valueType, 1)
});
Assert.That(error, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, defaultResource));
Assert.That(error.Code, Is.EqualTo(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public TestMultipleSearch1Field()
{
//Create 4 phase entries by public
PhaseHelper.CreatePhaseWithGenerateSystemDateTimeField();
//Create 5 phase entries more by private. Make sure that we have multiple phase entry to search correctly
recordUpdater1 = new HrbcRecordUpdater(() => PhaseHelper.InitRecordsUpdater(records, defaultResource, indexHrbcRecord, 1)); //Update phase in middle. Note: should choose resource type more than 3 option phases
recordUpdater2 = new HrbcRecordUpdater(() => PhaseHelper.InitRecordsUpdater(records, defaultResource, indexHrbcRecord, 2));
recordUpdater3 = new HrbcRecordUpdater(() => PhaseHelper.InitRecordsUpdater(records, defaultResource, indexHrbcRecord, 3));
}
public void TestCreateSingleItem(Enums.ResourceType resourceType, LengthType lengthType, Enums.TextType textType)
{
Phase phase = PhaseHelper.CreatePhaseInstance(creatingRequestRecords, resourceType);
phase.Memo = Util.GetRandomText(textType, stringLength[lengthType]);
string result = PhaseHelper.WriteResource(phase);
Assert.That(result, Is.Not.Null.And.Not.Empty, string.Format("Cannot create phase for {0}", resourceType));
}
public void TestCreateListItem(Enums.ResourceType resourceType)
{
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
return(PhaseHelper.CreatePhaseInstance(creatingRequestRecords, resourceType, depKey));
}).ToList();
List <WriteResultItem> result = PhaseHelper.WritePhases(resourceList);
Assert.That(result, MustBe.SuccessfullyWritten(2), string.Format("Cannot create phase for {0}", resourceType));
}
public static void Postfix(Mech __instance)
{
int initPhase = PhaseHelper.TonnageToPhase((int)Math.Ceiling(__instance.tonnage));
Mod.Log.Debug?.Write($"Setting baseInit for mech: {CombatantUtils.Label(__instance)} to {initPhase}");
// We have to remove the stat, then set it to the default value we want. We do this because when the history is reverted (from effect expiriation)
// it reverts to the value initally set on the statistic
__instance.StatCollection.RemoveStatistic(ModStats.BaseInitiative);
__instance.StatCollection.AddStatistic <int>(ModStats.BaseInitiative, initPhase);
}
public void TestCreateSingleItem(ResourceType resourceType, string fieldName, string fieldValue, int expectedCode)
{
Phase phase = PhaseHelper.CreatePhaseInstance(records, resourceType);
phase.DictionaryValues[fieldName] = fieldValue;
var error = PhaseHelper.WritePhaseFail(phase);
Assert.That(error, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(error.Code, Is.EqualTo(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestCreateSingleItem(Enums.ResourceType resourceType, string fieldName, WriteValidInput valueType)
{
string fieldValue = FieldValueMapper.ValidInputMapper[valueType];
Phase phase = PhaseHelper.CreatePhaseInstance(creatingRequestRecords, resourceType);
phase.DictionaryValues[fieldName] = fieldValue;
string result = PhaseHelper.WriteResource(phase);
Assert.That(result, Is.Not.Null.And.Not.Empty, string.Format("Cannot create phase for {0}", resourceType));
}
private string GetPhaseValueText(ModelRiskAlert alert)
{
StringBuilder returnText = new StringBuilder();
List <ModelRiskAlertPhase> modelRiskAlertPhases = ModelRiskAlertHelper.GetPhases(alert);
foreach (var modelRiskAlertPhase in modelRiskAlertPhases)
{
Phase phase = PhaseHelper.Get(modelRiskAlertPhase.IDPhase);
returnText.Append(phase.Title + "<br/>");
}
return(returnText.ToString());
}
public void TestUpdateSingleItem(ResourceType resourceType, string fieldName, string fieldValue, int expectedCode)
{
var phase = new Phase {
Id = phaseEntryReader.Data[$"{resourceType.ToPrivateEnum()}{0}"].First().Id
};
phase.DictionaryValues[fieldName] = fieldValue;
var error = PhaseHelper.WritePhaseFail(phase);
Assert.That(error, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestUpdateSingleItem(Enums.ResourceType resourceType, LengthType lengthType, Enums.TextType textType)
{
var phase = new Phase
{
Id = phaseReader.Data[$"{resourceType.ToPrivateEnum()}{0}"].FirstOrDefault().Id,
Memo = Util.GetRandomText(textType, stringLength[lengthType]),
};
string result = PhaseHelper.WriteResource(phase);
Assert.That(result, Is.Not.Null.And.Not.Empty, string.Format("Cannot update phase memo for {0}", resourceType));
}
public void TestCreateSingleItem(Enums.ResourceType resourceType, InvalidPhaseOption valueType, int expectedCode)
{
object fieldValue = GetOptionValue(valueType, resourceType);
Phase phase = PhaseHelper.CreatePhaseInstance(creatingRecords, resourceType);
phase.PhaseObject = fieldValue;
var error = PhaseHelper.WritePhaseFail(phase);
Assert.That(error, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(error.Code, Is.EqualTo(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestCreateListItem(Enums.ResourceType resourceType, LengthType lengthType, Enums.TextType textType)
{
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
Phase phase = PhaseHelper.CreatePhaseInstance(creatingRequestRecords, resourceType, depKey);
phase.Memo = Util.GetRandomText(textType, stringLength[lengthType]);
return(phase);
}).ToList();
List <WriteResultItem> result = PhaseHelper.WritePhases(resourceList);
Assert.That(result, MustBe.SuccessfullyWritten(2), string.Format("Cannot create phase for {0}", resourceType));
}
private Phase CreateSinglePhaseInstance(Enums.ResourceType resourceType, WriteInvalidMemoInput valueType, int index = 0)
{
string fieldValue = Util.GetRandomText(Enums.TextType.BasicLatin, overMaxLen);
Phase phase = PhaseHelper.CreatePhaseInstance(recordsWithPhase, resourceType, index);
if (valueType == WriteInvalidMemoInput.MemoWithoutPhase)
{
phase.DictionaryValues.Remove(PhaseApiFields.Phase);
fieldValue = Util.GetRandomText(Enums.TextType.BasicLatin, 1000);
}
phase.Memo = fieldValue;
return(phase);
}
public void TestUpdateSingleItem(Enums.ResourceType resourceType, string fieldName, WriteInvalidInput valueType, int expectedCode)
{
string fieldValue = FieldValueMapper.InvalidMapper[valueType];
var phase = new Phase {
Id = ReadPhaseBasedOnResource(resourceType, 0)
};
phase.DictionaryValues[fieldName] = fieldValue;
var error = PhaseHelper.WritePhaseFail(phase);
Assert.That(error, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestUpdateSingleItem(Enums.ResourceType resourceType, InvalidPhaseOption valueType, int expectedCode)
{
object fieldValue = GetOptionValue(valueType, resourceType);
var phase = new Phase {
Id = ReadPhaseBasedOnResource(resourceType, 0), Date = Util.ToString(DateTime.Now)
};
phase.PhaseObject = fieldValue;
var error = PhaseHelper.WritePhaseFail(phase);
Assert.That(error, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestUpdateListItem(ResourceType resourceType, string fieldName, string fieldValue, int expectedCode)
{
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
var phase = new Phase {
Id = phaseEntryReader.Data[$"{resourceType.ToPrivateEnum()}{depKey}"].First().Id
};
phase.DictionaryValues[fieldName] = fieldValue;
return(phase);
});
ErrorCode result = PhaseHelper.WritePhasesFail(resourceList);
Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestCreateListItem(ResourceType resourceType, string fieldName, string fieldValue, int expectedCode)
{
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
var phase = PhaseHelper.CreatePhaseInstance(records, resourceType, depKey);
phase.DictionaryValues[fieldName] = fieldValue;
return(phase);
}).ToList();
ErrorCode result = PhaseHelper.WritePhasesFail(resourceList);
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(result.Code, Is.EqualTo(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestUpdateSingleItem(Enums.ResourceType resourceType, string fieldName, WriteValidInput valueType)
{
string fieldValue = FieldValueMapper.ValidInputMapper[valueType];
var phase = new Phase
{
Id = phaseReader.Data[$"{resourceType.ToPrivateEnum()}{0}"].FirstOrDefault().Id,
};
phase.DictionaryValues[fieldName] = fieldValue;
string result = PhaseHelper.WriteResource(phase);
Assert.That(result, Is.Not.Null.And.Not.Empty, string.Format("Cannot create phase for {0}", resourceType));
}
public void TestUpdateSingleItem(Enums.ResourceType resourceType)
{
var resourcePhase = PhaseSearcher.Data.Options.Where(op => op.Alias == $"Option.P_{resourceType.ToResourceName()}Phase").SingleOrDefault();
var phase = new Phase
{
Id = phaseReader.Data[$"{resourceType.ToPrivateEnum()}{0}"].FirstOrDefault().Id,
PhaseObject = new Option()
{
ActualXMLTag = resourcePhase.Children.FirstOrDefault().Alias
},
};
string result = PhaseHelper.WriteResource(phase);
Assert.That(result, Is.Not.Null.And.Not.Empty, string.Format("Cannot create phase for {0}", resourceType));
}