async Task <IEnumerable <ParameterResponse> > getParametersForProduct(int productId)
{
//fetch all parameters for product
var fetchedParameters = await _context.Parameter.Where(p => p.ProductId == productId).ToListAsync();
var parameters = new ParameterResponse[fetchedParameters.Count];
for (int j = 0; j < fetchedParameters.Count; j++)
{
var parameter = fetchedParameters[j];
//fetch all values for parameter
var fetchedParametersValues = await _context.ParameterValue.Where(p => p.ParameterId == parameter.ObjectId).ToListAsync();
//add all values to parameter
var values = new ParameterValueResponse[fetchedParametersValues.Count];
for (int i = 0; i < fetchedParametersValues.Count; i++)
{
var value = fetchedParametersValues[i];
values[i] = (new ParameterValueResponse {
id = value.ObjectId,
parameterId = parameter.ObjectId,
name = value.Name,
});
}
//populate parameter with value
parameters[j] = (new ParameterResponse {
id = parameter.ObjectId,
name = parameter.Name,
parameterValues = values,
});
}
return(parameters);
}
async Task <IEnumerable <RuleResponse> > getRulesForParameters(int[] parameterIds)
{
var rules = new List <RuleResponse>();
var ruleIds = new List <int>();
//get all parameters
var allDisallowedParameters = new List <DisallowedParameter>();
foreach (var parameterId in parameterIds)
{
var fetchedParameters = await _context.DisallowedParameter
.Where(rule => rule.ParameterId == parameterId)
.ToListAsync();
allDisallowedParameters.AddRange(fetchedParameters);
}
//get all rule names
var allDisallowedRuleNames = new List <DisallowedRule>();
foreach (var disallowedParameter in allDisallowedParameters)
{
var fetchedRuleNames = await _context.DisallowedRule
.Where(rule => rule.ObjectId == disallowedParameter.DisallowedRuleId)
.ToListAsync();
allDisallowedRuleNames.AddRange(fetchedRuleNames);
}
//get all rule values
var allDisallowedRuleValues = new List <DisallowedValue>();
foreach (var disallowedParameter in allDisallowedParameters)
{
var fetchedRuleValues = await _context.DisallowedValue
.Where(value => value.DisallowedParameterId == disallowedParameter.ParameterId)
.ToListAsync();
allDisallowedRuleValues.AddRange(fetchedRuleValues);
}
//remove duplicates
var disallowedRuleNames = allDisallowedRuleNames.Distinct().ToList();
//add rules
foreach (var disallowedRule in disallowedRuleNames)
{
//create value list
var incompatableValues = new List <ParameterValueResponse>();
//get all parameter with rule id
var ruleParameters = allDisallowedParameters.FindAll(p => p.DisallowedRuleId == disallowedRule.ObjectId);
foreach (var param in ruleParameters)
{
//get all values with param ids
var ruleValues = allDisallowedRuleValues.FindAll(v => v.DisallowedParameterId == param.ParameterId);
System.Console.WriteLine("{0}, param {1}, have {2} conflicting values", disallowedRule.Name, param.ParameterId, ruleValues.Count);
foreach (var value in ruleValues)
{
if (!incompatableValues.Exists(v => v.id == value.ParameterValueId))
{
//add values
var valueResponse = new ParameterValueResponse {
id = value.ParameterValueId,
parameterId = value.DisallowedParameterId,
name = null
};
incompatableValues.Add(valueResponse);
}
}
}
//map rules
var rule = new RuleResponse {
id = disallowedRule.ObjectId,
name = disallowedRule.Name,
incompatableValues = incompatableValues.ToArray(),
};
rules.Add(rule);
System.Console.WriteLine("");
}
return(rules);
}
