/// <summary>
/// CheckFactsAndDimensionsMatch
/// </summary>
/// <param name="totalCells"></param>
/// <param name="spec"></param>
/// <param name="language"></param>
/// <param name="messageFormatter"></param>
/// <returns></returns>
private bool CheckFactsAndDimensionsMatch(int totalCells, Matrix.Specification spec, string language, MessageFormatter messageFormatter)
{
try
{
var cubeSize = 0;
var statisticCount = spec.Statistic.Count;
var periodCount = spec.Frequency.Period.Count;
var variableCombinations = 1;
foreach (var classification in spec.Classification)
{
variableCombinations = variableCombinations * classification.Variable.Count;
}
cubeSize = variableCombinations * periodCount * statisticCount;
if (cubeSize != totalCells)
{
//TODO: do we need translation here?
messageFormatter.AppendArgument("Language", language);
messageFormatter.AppendArgument("Expected", cubeSize);
messageFormatter.AppendArgument("Found", totalCells);
return(false);
}
return(true);
}
catch (Exception e)
{
Log.Instance.ErrorFormat("Error @ CheckFactsAndDimensionsMatch for language = {0}", language);
Log.Instance.Error(e);
return(false);
}
}
/// <summary>
/// Execute
/// </summary>
/// <returns></returns>
protected override bool Execute()
{
var signature = Utility.GetMD5(Utility.GetCustomConfig("APP_SALSA") + Utility.JsonSerialize_IgnoreLoopingReference(DTO.GetSignatureDTO()));
dynamic validationResult = new ExpandoObject();
List <string> FrqValues = new List <string>();
PxStat.RequestLanguage.LngIsoCode = DTO.LngIsoCode;
bool isValid = false;
isValid = Validate();
// }
if (isValid)
{
validationResult.Signature = signature;
validationResult.FrqValueCandidate = FrqValues;
Response.data = validationResult;
return(true);
}
if (!isValid)
{
if (MatrixData != null)
{
if (MatrixData.MainSpec.requiresResponse)
{
//cancel any validation errors and return an object to enable the user to choose which should be the time dimension
Matrix.Specification langSpec = MatrixData.GetSpecFromLanguage(DTO.LngIsoCode);
if (langSpec == null)
{
langSpec = MatrixData.MainSpec;
}
foreach (var v in langSpec.MainValues)
{
FrqValues.Add(v.Key);
}
validationResult.Signature = null;
validationResult.FrqValueCandidate = FrqValues;
Response.data = validationResult;
return(true);
}
}
Response.data = validationResult;
return(false);
}
//Response.error = Label.Get("error.validation");
return(false);
}
/// <summary>
/// Check that there are no duplicate dimension codes or names in the Specification
/// </summary>
/// <param name="spec"></param>
/// <returns></returns>
private bool ValidateSpec(Matrix.Specification spec)
{
List <string> comparisons = new List <string>();
comparisons.Add(spec.ContentVariable.ToUpper());
comparisons.Add(spec.Frequency.Code.ToUpper());
foreach (var cls in spec.Classification)
{
comparisons.Add(cls.Code.ToUpper());
}
if (hasDupes(comparisons))
{
return(false);
}
comparisons = new List <string>();
comparisons.Add(spec.ContentVariable.ToUpper());
comparisons.Add(spec.Frequency.Value.ToUpper());
foreach (var cls in spec.Classification)
{
comparisons.Add(cls.Value.ToUpper());
}
//Frequency code must be one of the ones defined in STATIC
List <string> validCodes = new List <string>();
foreach (string str in Utility.GetCustomConfig("APP_PX_FREQUENCY_CODES").Split(',').ToList <string>())
{
if (str != null)
{
if (str.Contains('/'))
{
validCodes.Add(str.Split('/')[0]);
}
}
}
if (spec.Frequency.Code == null)
{
return(false);
}
if (!validCodes.Contains(spec.Frequency.Code))
{
return(false);
}
return(!hasDupes(comparisons));
}
public PxIntegrityValidator(Matrix.Specification spec, string lngIsoCode = null)
{
long threshold = Configuration_BSO.GetCustomConfig("dataset.threshold");;
RuleFor(x => x).Must(PxStat.Build.CustomValidations.BelowLimitDatapoints).WithMessage(lngIsoCode == null ? String.Format(Label.Get("integrity.cell-count"), spec.GetRequiredDatapointCount(), threshold.ToString()) : String.Format(Label.Get("integrity.cell-count", lngIsoCode), spec.GetRequiredDatapointCount(), threshold.ToString()));
RuleFor(x => x.MainSpec).HaveFactsAndDimensionsMatching().WithMessage(Label.Get("integrity.size"));
RuleFor(x => x.OtherLanguageSpec).HaveFactsAndDimensionsMatching().When(x => x.OtherLanguageSpec != null && x.OtherLanguageSpec.Count > 0).WithMessage(Label.Get("integrity.size"));
RuleFor(x => x.Cells).DataIsGood().When(x => x.Cells != null && x.Cells.Count > 0).WithMessage(FormatDataIsGood);
RuleFor(x => x).Must(NoDuplicateDomains).WithMessage(Label.Get("integrity.codes"));
RuleFor(x => x).Must(NoDuplicateNames).When(x => spec.Values != null && spec.MainValues != null).WithMessage(Label.Get("integrity.values"));
RuleFor(x => x).Must(NoDuplicateDomainsLanguageSpec).WithMessage(Label.Get("integrity.codes"));
RuleFor(x => x).Must(NoDuplicateNamesLanguageSpec).When(x => spec.Values != null && spec.MainValues != null).WithMessage(Label.Get("integrity.values"));
}
private void UpdateExistingSpec(Matrix.Specification theSpec, BuildUpdate_DTO dto)
{
if (dto.Map != null)
{
foreach (var map in dto.Map)
{
ClassificationRecordDTO_Create cls = theSpec.Classification.Where(x => x.Code == map.Key).FirstOrDefault();
if (cls != null)
{
cls.GeoFlag = map.Value != null;
cls.GeoUrl = map.Value;
}
}
}
}
/// <summary>
/// Gets a Matrix_DTO object from a Matrix and Specification
/// </summary>
/// <param name="theMatrix"></param>
/// <param name="spec"></param>
/// <param name="DTO"></param>
/// <returns></returns>
private Matrix_DTO GetMatrixDto(Matrix theMatrix, Matrix.Specification spec, dynamic DTO)
{
return(new Matrix_DTO()
{
MtrCode = theMatrix.Code,
FrmType = theMatrix.FormatType,
FrmVersion = theMatrix.FormatVersion,
MtrOfficialFlag = theMatrix.IsOfficialStatistic,
LngIsoCode = spec.Language,
MtrNote = spec.NotesAsString,
CprValue = spec.Source,
MtrTitle = spec.Contents,
MtrInput = DTO.MtrInput
});
}
/// <summary>
/// Creates the metadata for a specific language (px files may contain metadata in more than one language)
/// </summary>
/// <param name="releaseId"></param>
/// <param name="theMatrix"></param>
/// <param name="languageSpec"></param>
/// <param name="username"></param>
/// <param name="DTO"></param>
private void CreateMatrixForLanguage(int releaseId, Matrix theMatrix, Matrix.Specification languageSpec, string username, dynamic DTO)
{
Matrix_ADO matrixAdo = new Data.Matrix_ADO(Ado);
var matrixRecordDTO = GetMatrixDto(theMatrix, languageSpec, DTO);
languageSpec.MatrixId = matrixAdo.CreateMatrixRecord(matrixRecordDTO, releaseId, username);
languageSpec.Frequency.FrequencyId = CreateFrequency(languageSpec.Frequency, languageSpec.MatrixId);
// if I have contvariable I use the content of contvariable to access the values with that value to obtain the names of stat products
// and I use codes with same name to get the correspondent codes!
// otherwise
// if there is only one statistical product we use contents for the title and we set the code at zero 0
CreateStatisticalProducts(languageSpec.Statistic, languageSpec.MatrixId);
CreateClassifications(languageSpec.Classification, languageSpec.MatrixId);
}
/// <summary>
/// Execute
/// </summary>
/// <returns></returns>
protected override bool Execute()
{
// Init
List <string> FrqValues = new List <string>();
dynamic validationResult = new ExpandoObject();
validationResult.Signature = Utility.GetMD5(Utility.GetCustomConfig("APP_SALSA") + Utility.JsonSerialize_IgnoreLoopingReference(DTO.GetSignatureDTO()));// null;
validationResult.FrqValueCandidate = FrqValues;
if (!Validate(validationResult.Signature) && !RequiresResponse)
{
return(false);
}
if (RequiresResponse)
{
//cancel any validation errors and return an object to enable the user to choose which should be the time dimension
Matrix.Specification langSpec = MatrixData.GetSpecFromLanguage(Configuration_BSO.GetCustomConfig(ConfigType.global, "language.iso.code"));
if (langSpec == null)
{
langSpec = MatrixData.MainSpec;
}
foreach (var v in langSpec.MainValues)
{
FrqValues.Add(v.Key);
}
// Set Frequency candidates
validationResult.FrqValueCandidate = FrqValues;
validationResult.Signature = null;
Response.data = validationResult;
return(true);
}
// Set the Signature
Response.data = validationResult;
return(true);
}
private IList <KeyValuePair <string, IList <IPxSingleElement> > > sortMainValuesSpc(Matrix.Specification spec)
{
var newValues = new List <object>();
if (spec.MainValues.Where(x => x.Key == spec.ContentVariable).Count() > 0)
{
var val = spec.MainValues.Where(x => x.Key == spec.ContentVariable).FirstOrDefault();
newValues.Add(val);
}
if (spec.MainValues.Where(x => x.Key == spec.Frequency.Value).Count() > 0)
{
var val = spec.MainValues.Where(x => x.Key == spec.Frequency.Value).FirstOrDefault();
newValues.Add(val);
}
foreach (var cls in spec.Classification)
{
if (spec.MainValues.Where(x => x.Key == cls.Value).Count() > 0)
{
var val = spec.MainValues.Where(x => x.Key == cls.Value).FirstOrDefault();
newValues.Add(val);
}
}
spec.MainValues.Clear();
foreach (var v in newValues)
{
spec.MainValues.Add((KeyValuePair <string, IList <PxParser.Resources.Parser.IPxSingleElement> >)v);
}
return(spec.MainValues);
}