private RuleVersionDto EnsureVersion(int versionNumber, bool createIfMissing)
{
var rules = _rules;
lock (rules)
{
var ruleVersion = rules.FirstOrDefault(r => r.Version == versionNumber);
if (ruleVersion == null)
{
var ruleList = _persister.GetAllRules(versionNumber);
if (ruleList == null)
{
if (createIfMissing)
{
ruleVersion = CreateRuleVersion(versionNumber);
}
}
else
{
var versionName = _persister.GetVersionName(versionNumber);
ruleVersion = new RuleVersionDto
{
Version = versionNumber,
Rules = ruleList.ToList(),
Name = versionName ?? "Version " + versionNumber
};
SetEvaluationOrder(ruleVersion);
rules.Add(ruleVersion);
}
}
return(ruleVersion);
}
}
private RuleVersionDto GetVersion(int version, bool createIfMissing)
{
RuleVersionDto ruleVersion = null;
if (createIfMissing)
{
if (_ruleVersions == null)
{
_ruleVersions = new List <RuleVersionDto>();
}
ruleVersion = _ruleVersions.FirstOrDefault(r => r.Version == version);
if (ruleVersion == null)
{
ruleVersion = new RuleVersionDto
{
Name = "Version " + version,
Version = version,
Rules = new List <RuleDto>()
};
_ruleVersions.Add(ruleVersion);
}
}
else
{
if (_ruleVersions != null)
{
ruleVersion = _ruleVersions.FirstOrDefault(r => r.Version == version);
}
}
return(ruleVersion);
}
private void DeleteRule(RuleVersionDto ruleVersion, string name)
{
_persister.DeleteRule(ruleVersion.Version, name);
var rules = ruleVersion.Rules;
lock (rules)
{
rules.RemoveAll(r => string.Compare(r.RuleName, name, StringComparison.InvariantCultureIgnoreCase) == 0);
}
}
private List <RuleDto> GetApplicableRules(
RuleVersionDto ruleVersion,
EnvironmentDto environment,
string datacenter,
string machine,
string application,
string instance)
{
if (ruleVersion == null || ruleVersion.Rules == null || ruleVersion.Rules.Count == 0)
{
return(new List <RuleDto>());
}
return(ruleVersion.Rules.Where(r => RuleApplies(r, environment, datacenter, machine, application, instance)).ToList());
}
private RuleVersionDto CreateRuleVersion(int versionNumber)
{
var ruleVersion = new RuleVersionDto
{
Version = versionNumber,
Name = "Version " + versionNumber,
Rules = new List <RuleDto>()
};
var rules = _rules ?? new List <RuleVersionDto>();
lock (rules) rules.Add(ruleVersion);
_rules = rules;
return(ruleVersion);
}
public RuleVersionDto GetRuleVersion(IClientCredentials clientCredentials, int?version = null)
{
if (!version.HasValue)
{
version = GetDraftVersion();
}
var ruleVersion = EnsureVersion(version.Value, false);
if (ruleVersion == null)
{
return(null);
}
var blockedEnvironments = GetBlockedEnvironments(clientCredentials) ?? new List <EnvironmentDto>();
var blockedMachineNemes = GetBlockedMachines(blockedEnvironments);
var blockedEnvironmentNames = blockedEnvironments.Select(e => e.EnvironmentName.ToLower()).ToList();
Func <RuleDto, int, bool> isAllowed = (r, i) =>
{
if (!string.IsNullOrEmpty(r.Environment))
{
if (blockedEnvironmentNames.Contains(r.Environment.ToLower()))
{
return(false);
}
}
if (!string.IsNullOrEmpty(r.Machine))
{
if (blockedMachineNemes.Contains(r.Machine.ToLower()))
{
return(false);
}
}
return(true);
};
var filteredVersion = new RuleVersionDto
{
Version = ruleVersion.Version,
Name = ruleVersion.Name,
Rules = _mapper.Map <IEnumerable <RuleDto>, List <RuleDto> >(ruleVersion.Rules.Where(isAllowed))
};
return(filteredVersion);
}
private void SetEvaluationOrder(RuleVersionDto ruleVersion)
{
SetEvaluationOrder(ruleVersion.Rules);
}
