/// <inheritdoc/>
public override (bool, string) ValidateArguments()
{
if (Arguments.Count != 2)
{
string message = $"Invoked {Name} and expected 2 arguments, but {Arguments.Count} arguments were provided";
return(false, message);
}
// Read in the individual arguments
MachineField extraMachineField = Arguments[0].AsMachineField();
DatItemField extraDatItemField = Arguments[0].AsDatItemField();
string extraFile = Arguments[1];
// If we had an invalid input, log and continue
if (extraMachineField == MachineField.NULL &&
extraDatItemField == DatItemField.NULL)
{
string message = $"{Arguments[0]} was an invalid field name";
return(false, message);
}
if (!File.Exists(extraFile))
{
string message = $"{Arguments[1]} was an invalid file name";
return(false, message);
}
return(true, null);
}
/// <summary>
/// Set remover from a value
/// </summary>
/// <param name="field">Key for the remover to be set</param>
public bool SetRemover(string field)
{
// If the key is null or empty, return false
if (string.IsNullOrWhiteSpace(field))
{
return(false);
}
// If we have a Machine field
MachineField machineField = field.AsMachineField();
if (machineField != MachineField.NULL)
{
MachineFields.Add(machineField);
return(true);
}
// If we have a DatItem field
DatItemField datItemField = field.AsDatItemField();
if (datItemField != DatItemField.NULL)
{
DatItemFields.Add(datItemField);
return(true);
}
return(false);
}
/// <summary>
/// Populate the filters objects using a set of key:value filters
/// </summary>
/// <param name="filters">List of key:value where ~key/!key is negated</param>
public void PopulateFiltersFromList(List <string> filters)
{
// Instantiate the filters, if necessary
MachineFilter ??= new MachineFilter();
DatItemFilter ??= new DatItemFilter();
// If the list is null or empty, just return
if (filters == null || filters.Count == 0)
{
return;
}
InternalStopwatch watch = new InternalStopwatch("Populating filters from list");
foreach (string filterPair in filters)
{
(string field, string value, bool negate) = ProcessFilterPair(filterPair);
// If we don't even have a possible filter pair
if (field == null && value == null)
{
continue;
}
// Machine fields
MachineField machineField = field.AsMachineField();
if (machineField != MachineField.NULL)
{
MachineFilter.SetFilter(machineField, value, negate);
MachineFilter.HasFilters = true;
continue;
}
// DatItem fields
DatItemField datItemField = field.AsDatItemField();
if (datItemField != DatItemField.NULL)
{
DatItemFilter.SetFilter(datItemField, value, negate);
DatItemFilter.HasFilters = true;
continue;
}
// If we didn't match anything, log an error
logger.Warning($"The value {field} did not match any filterable field names. Please check the wiki for more details on supported field names.");
}
watch.Stop();
}
/// <inheritdoc/>
public override (bool, string) ValidateArguments()
{
if (Arguments.Count < 2 || Arguments.Count > 4)
{
string message = $"Invoked {Name} and expected between 2-4 arguments, but {Arguments.Count} arguments were provided";
return(false, message);
}
// Read in the individual arguments
DatHeaderField filterDatHeaderField = Arguments[0].AsDatHeaderField();
MachineField filterMachineField = Arguments[0].AsMachineField();
DatItemField filterDatItemField = Arguments[0].AsDatItemField();
bool? filterRemove = false;
if (Arguments.Count >= 3)
{
filterRemove = Arguments[2].AsYesNo();
}
bool?filterPerMachine = false;
if (Arguments.Count >= 4)
{
filterPerMachine = Arguments[3].AsYesNo();
}
// If we had an invalid input, log and continue
if (filterDatHeaderField == DatHeaderField.NULL &&
filterMachineField == MachineField.NULL &&
filterDatItemField == DatItemField.NULL)
{
string message = $"{Arguments[0]} was an invalid field name";
return(false, message);
}
if (filterRemove == null)
{
string message = $"{Arguments[2]} was an invalid true/false value";
return(false, message);
}
if (filterPerMachine == null)
{
string message = $"{Arguments[3]} was an invalid true/false value";
return(false, message);
}
return(true, null);
}
/// <inheritdoc/>
public override void Process(BatchState batchState)
{
// Read in the individual arguments
MachineField filterMachineField = Arguments[0].AsMachineField();
DatItemField filterDatItemField = Arguments[0].AsDatItemField();
string filterValue = Arguments[1];
bool? filterRemove = false;
if (Arguments.Count >= 3)
{
filterRemove = Arguments[2].AsYesNo();
}
bool?filterPerMachine = false;
if (Arguments.Count >= 4)
{
filterPerMachine = Arguments[3].AsYesNo();
}
// Create filter to run filters from
Filter filter = new Filter
{
MachineFilter = new MachineFilter {
HasFilters = true
},
DatItemFilter = new DatItemFilter {
HasFilters = true
},
};
// Set the possible filters
filter.MachineFilter.SetFilter(filterMachineField, filterValue, filterRemove.Value);
filter.DatItemFilter.SetFilter(filterDatItemField, filterValue, filterRemove.Value);
// Apply the filters blindly
filter.ApplyFilters(batchState.DatFile, filterPerMachine.Value);
// Cleanup after the filter
// TODO: We might not want to remove immediately
batchState.DatFile.Items.ClearMarked();
batchState.DatFile.Items.ClearEmpty();
}
/// <inheritdoc/>
public override void Process(BatchState batchState)
{
// Read in the individual arguments
MachineField extraMachineField = Arguments[0].AsMachineField();
DatItemField extraDatItemField = Arguments[0].AsDatItemField();
string extraFile = Arguments[1];
// Create the extra INI
ExtraIni extraIni = new ExtraIni();
ExtraIniItem extraIniItem = new ExtraIniItem
{
MachineField = extraMachineField,
DatItemField = extraDatItemField,
};
extraIniItem.PopulateFromFile(extraFile);
extraIni.Items.Add(extraIniItem);
// Apply the extra INI blindly
extraIni.ApplyExtras(batchState.DatFile);
}
public void AsDatItemFieldTest(string field, DatItemField expected)
{
DatItemField actual = field.AsDatItemField();
Assert.Equal(expected, actual);
}
