public string GetVersion2Display(int?InputVersion, string BuildNumber)
{
if (InputVersion == null)
{
return("");
}
MinorVersionAssociation l_MinoVersionAssociation = null;
var major = ComparableFields.GetMajorFromNumericVersion((int)InputVersion);
int?middle = 0;
int?least = 0;
if (!string.IsNullOrEmpty(BuildNumber))
{
l_MinoVersionAssociation = DBRegister.MinorVersionAssociations.SingleOrDefault(m => m.Major == major && m.BuildVersion == BuildNumber);
}
if (l_MinoVersionAssociation == null)
{
l_MinoVersionAssociation = DBRegister.MinorVersionAssociations.SingleOrDefault(m => m.Major == major);
}
if (l_MinoVersionAssociation != null)
{
middle = l_MinoVersionAssociation.Minor;
least = l_MinoVersionAssociation.Patch; // Gibiino [RTC 10963] patch should be inserted with an input file
}
return(ComparableFields.BuildStringVersion(major, middle, least));
}
public static Boolean isContainedSlim(ComparableFields contained, ComparableFields container, Func <int?, int?, bool> IsValueContainedFunc)
{
if (!IsValueContainedFunc(contained.OptionId, container.OptionId))
{
return(false);
}
if (!IsValueContainedFunc(contained.ApplicationId, container.ApplicationId))
{
return(false);
}
if (!IsValueContainedFunc(contained.ProbeId, container.ProbeId))
{
return(false);
}
if (!IsValueContainedFunc((Int32?)contained.TransducerType, (Int32?)container.TransducerType))
{
return(false);
}
if (!IsValueContainedFunc(contained.KitId, container.KitId))
{
return(false);
}
return(true);
}
internal static List <NormalRule> SqueezeModel(LogicalModel Model, List <NormalRule> nrules)
{
var result = new List <NormalRule>();
var input = new InputParams
{
LogicalModelId = Model.Id
};
result.AddRange(nrules.Where(nr => ComparableFields.isModelContained(input, nr)).ToList());
return(result);
}
/// <summary>
/// checks if two rules have a generic override: if all parameters specified for both inputs are equal the rules override.
///
/// *THIS CODE SHOULD BE AUTOMATICALLY GENERATED BY THE TEXT TEMPLATE*
///
/// </summary>
public Boolean genericOverride(ComparableFields r2)
{
return(
(((this.LogicalModelId == r2.LogicalModelId) && (r2.LogicalModelId != null)) || (this.LogicalModelId == null) || (r2.LogicalModelId == null)) &&
(((this.ProbeId == r2.ProbeId) && (r2.ProbeId != null)) || (this.ProbeId == null) || (r2.ProbeId == null)) &&
(((this.TransducerType == r2.TransducerType) && (r2.TransducerType != null)) || (this.TransducerType == null) || (r2.TransducerType == null)) &&
(((this.ApplicationId == r2.ApplicationId) && (r2.ApplicationId != null)) || (this.ApplicationId == null) || (r2.ApplicationId == null)) &&
(((this.OptionId == r2.OptionId) && (r2.OptionId != null)) || (this.OptionId == null) || (r2.OptionId == null)) &&
(((this.UserLevel == r2.UserLevel) && (r2.UserLevel != null)) || (this.UserLevel == null) || (r2.UserLevel == null)) &&
(((this.KitId == r2.KitId) && (r2.KitId != null)) || (this.KitId == null) || (r2.KitId == null)) &&
(((this.CountryId == r2.CountryId) && (r2.CountryId != null)) || (this.CountryId == null) || (r2.CountryId == null)) &&
(((this.DistributorId == r2.DistributorId) && (r2.DistributorId != null)) || (this.DistributorId == null) || (r2.DistributorId == null)) &&
(((this.Version == r2.Version) && (r2.Version != null)) || (this.Version == null) || (r2.Version == null)));
}
// fore each input checks if there is any specific forbidding rule
//public bool IsAlwaysTrue(InputParams input)
//{
// var interestedRules = this.NormalRules.Where(nr => ComparableFields.isAlwaysContained(input, nr)).ToList();
// return !interestedRules.Any(r => r.Allow == Allower.AllowModes.No);
//}
public List <NormalRule> getInterestedRulesFast(InputParams input, List <NormalRule> NRlist)
{
var overallFilter = RuleIndexes;
if (input.LogicalModelId != null)
{
var ModelFilter = GetRuleIndexList(RuleIndexes, input.LogicalModelId, LogicalModelIndexes);
overallFilter = overallFilter.IntersectSorted(ModelFilter);
}
if (input.ApplicationId != null)
{
var ApplicationFilter = GetRuleIndexList(RuleIndexes, input.ApplicationId, ApplicationIndexes);
overallFilter = overallFilter.IntersectSorted(ApplicationFilter);
}
if (input.OptionId != null)
{
var OptionFilter = GetRuleIndexList(RuleIndexes, input.OptionId, OptionIndexes);
overallFilter = overallFilter.IntersectSorted(OptionFilter);
}
if (input.ProbeId != null)
{
var ProbeFilter = GetRuleIndexList(RuleIndexes, input.ProbeId, ProbeIndexes);
overallFilter = overallFilter.IntersectSorted(ProbeFilter);
}
if (input.KitId != null)
{
var KitFilter = GetRuleIndexList(RuleIndexes, input.KitId, KitIndexes);
overallFilter = overallFilter.IntersectSorted(KitFilter);
}
if (input.TransducerType != null)
{
var TransducerFilter = GetRuleIndexList(RuleIndexes, (int)input.TransducerType, TransducerIndexes);
overallFilter = overallFilter.IntersectSorted(TransducerFilter);
}
var InterestedRules = new List <NormalRule>();
for (int i = 0; i < overallFilter.Count; i++)
{
if (ComparableFields.isContainedFull(input, NRlist[overallFilter[i]]))
{
InterestedRules.Add(NRlist[overallFilter[i]]);
}
}
return(InterestedRules);
}
// // base conteined with inverted inputs
//public static Boolean isAlwaysContained(ComparableFields contained, ComparableFields container)
//{
// var c1 = contained;
// var c2 = container;
// return isContainedSlim(contained, container, isValueAlwaysContained) && isModelContained(contained, container, isValueAlwaysContained)
// && isBaseContained(c2, c1, isValueAlwaysContained, isRangeAlwaysContained);
//}
// compares only Model, option, probe and application
public static Boolean IsContainedReduced(ComparableFields contained, ComparableFields container)
{
if (!isValueContained(contained.LogicalModelId, container.LogicalModelId))
{
return(false);
}
if (!isValueContained(contained.OptionId, container.OptionId))
{
return(false);
}
if (!isValueContained(contained.ApplicationId, container.ApplicationId))
{
return(false);
}
if (!isValueContained(contained.ProbeId, container.ProbeId))
{
return(false);
}
if (!isValueContained((Int32?)contained.UserLevel, (Int32?)container.UserLevel))
{
return(false);
}
if (container.KitId != null)
{
return(false);
}
if (container.TransducerType != null)
{
return(false);
}
if (container.CountryId != null)
{
return(false);
}
if (container.DistributorId != null)
{
return(false);
}
if (container.Version != null)
{
return(false);
}
return(true);
}
public static int?GetVersion(IVersionAssociationInput VersionAssociation, FeatureRegister DBRegister)
{
bool isnull;
// filter country/certifier
var ValidCountryVersions = VersionAssociation.GetVersionList(DBRegister).Where(x => x.GeographyId == VersionAssociation.GeographyId).ToList();
// filter logical model
var CountryModelVersionList = MatchValuesOrNull(ValidCountryVersions, VersionAssociation, (y) => y.LogicalModelId, out isnull);
// filter distributor
var CountryDistrModelVersionList = MatchValuesOrNull(CountryModelVersionList, VersionAssociation, (y) => y.DistributorId, out isnull);
var ValidCV = CountryDistrModelVersionList.FirstOrDefault();
if (ValidCV != null)
{
return(ComparableFields.GetNumericVersionFromMajor(ValidCV.MajorVersion));
}
return(null);
}
public static Boolean isBaseContained(ComparableFields contained, ComparableFields container, Func <int?, int?, bool> IsValueContainedFunc, Func <int?, int?,
bool> IsRangeContainedFunc)
{
if (!IsValueContainedFunc(contained.CountryId, container.CountryId))
{
return(false);
}
if (!IsValueContainedFunc(contained.DistributorId, container.DistributorId))
{
return(false);
}
if (!IsValueContainedFunc((Int32?)contained.UserLevel, (Int32?)container.UserLevel))
{
return(false);
}
if (!IsRangeContainedFunc(contained.Version, container.Version))
{
return(false);
}
return(true);
}
// filter rules for model
private void PreFilterModel(InputParams input)
{
this.NormalRules = this.NormalRules.Where(nr => ComparableFields.isModelContained(input, nr)).ToList();
}
static List <NormalRule> getInterestedRulesSlim(InputParams input, List <NormalRule> NRlist) => NRlist.Where(nr => ComparableFields.isContainedSlim(input, nr)).ToList();
internal Boolean IsAllowedSlim(InputParams input, IAllower Allower)
{
return(!NormalRules.Where(nr => ComparableFields.isContainedSlim(input, nr)).Any(ir => Allower.getAllowance(ir.Allow) == false));
}
public void FillIndexes()
{
LogicalModelIndexes = new Dictionary <int, List <Int32> >();
ApplicationIndexes = new Dictionary <int, List <Int32> >();
OptionIndexes = new Dictionary <int, List <Int32> >();
ProbeIndexes = new Dictionary <int, List <Int32> >();
KitIndexes = new Dictionary <int, List <Int32> >();
TransducerIndexes = new Dictionary <int, List <Int32> >();
foreach (var modelLic in DBRegister.ModelLicenses)
{
var rulesIndexes = new List <int>();
for (int i = 0; i < NormalRules.Count; i++)
{
if (ComparableFields.isValueContained(modelLic.Model.Id, NormalRules[i].LogicalModelId))
{
rulesIndexes.Add(i);
}
}
LogicalModelIndexes.Add(modelLic.Model.Id, rulesIndexes);
}
foreach (var app in DBRegister.Applications)
{
var rulesIndexes = new List <int>();
for (int i = 0; i < NormalRules.Count; i++)
{
if (ComparableFields.isValueContained(app.Id, NormalRules[i].ApplicationId))
{
rulesIndexes.Add(i);
}
}
ApplicationIndexes.Add(app.Id, rulesIndexes);
}
foreach (var opt in DBRegister.Options)
{
var rulesIndexes = new List <int>();
for (int i = 0; i < NormalRules.Count; i++)
{
if (ComparableFields.isValueContained(opt.Id, NormalRules[i].OptionId))
{
rulesIndexes.Add(i);
}
}
OptionIndexes.Add(opt.Id, rulesIndexes);
}
foreach (var probe in DBRegister.Probes)
{
var rulesIndexes = new List <int>();
for (int i = 0; i < NormalRules.Count; i++)
{
if (ComparableFields.isValueContained(probe.Id, NormalRules[i].ProbeId))
{
rulesIndexes.Add(i);
}
}
ProbeIndexes.Add(probe.Id, rulesIndexes);
}
foreach (var kit in DBRegister.Kits)
{
var rulesIndexes = new List <int>();
for (int i = 0; i < NormalRules.Count; i++)
{
if (ComparableFields.isValueContained(kit.Id, NormalRules[i].KitId))
{
rulesIndexes.Add(i);
}
}
KitIndexes.Add(kit.Id, rulesIndexes);
}
foreach (int transd in Enum.GetValues(typeof(ProbeType)))
{
var rulesIndexes = new List <int>();
for (int i = 0; i < NormalRules.Count; i++)
{
if (ComparableFields.isValueContained(transd, (int? )NormalRules[i].TransducerType))
{
rulesIndexes.Add(i);
}
}
TransducerIndexes.Add(transd, rulesIndexes);
}
RuleIndexes = Enumerable.Range(0, NormalRules.Count).ToList();
}
public static bool isModelContained(ComparableFields contained, ComparableFields container, Func <int?, int?, bool> IsValueContainedFunc)
{
return(IsValueContainedFunc(contained.LogicalModelId, container.LogicalModelId));
}
// checks the Model only in order to filter the rules and group them by model in different files
public static bool isModelContained(ComparableFields contained, ComparableFields container)
{
return(isModelContained(contained, container, isValueContained));
}
// checks only the fields automatically filled by the License Manager (The model is filtered by file loading)
public static Boolean isBaseContained(ComparableFields contained, ComparableFields container)
{
return(isBaseContained(contained, container, isValueContained, isRangeContained));
}
// Checks all the interesting fields alfter being filtered with the base Containance (isBaseContained)
public static Boolean isContainedSlim(ComparableFields contained, ComparableFields container)
{
return(isContainedSlim(contained, container, isValueContained));
}
/// For override checks
public static Boolean isContainedFull(ComparableFields contained, ComparableFields container)
{
return(isContained(contained, container) && isModelContained(contained, container));
}
public static Boolean isContained(ComparableFields contained, ComparableFields container)
{
return(isContainedSlim(contained, container) && isBaseContained(contained, container));
}
