public LayoutValidateResult LoadPivotFromDB(AvrPivotGridData model, IList <IAvrPivotGridField> avrFields, bool isNewObject)
{
if ((PivotGridXmlVersion)LayoutRow.intPivotGridXmlVersion == PivotGridXmlVersion.Version5)
{
throw new AvrDbException("Layout has version 5 format. It's not supported.");
}
if (!isNewObject)
{
AvrPivotGridHelper.LoadSearchFieldsVersionSixFromDB(avrFields, LayoutSearchFieldTable, LayoutRow.idfsDefaultGroupDate);
LoadPivotFilterVersionSixFromDB();
}
AvrPivotGridHelper.LoadExstraSearchFieldsProperties(avrFields, LayoutSearchFieldTable);
AvrPivotGridHelper.SwapOriginalAndCopiedFieldsIfReversed(avrFields);
var result = new LayoutValidateResult();
LayoutBaseValidator validator = LayoutPivotGridHelper.CreateLayoutComplexityValidator();
if (LayoutRow.blnShowMissedValuesInPivotGrid)
{
result = AvrPivotGridHelper.AddMissedValuesAndValidateComplexity(model, avrFields, validator);
}
if (!result.IsCancelOrUserDialogCancel())
{
result = AvrPivotGridHelper.FillEmptyValuesAndValidateComplexity(model, avrFields, validator);
}
return(result);
}
public static void AddMissedValues(AvrPivotGridModel model, bool forceRefill)
{
if (forceRefill)
{
bool isNewObject;
string errorMessage;
model.PivotData = GetPivotData(model.PivotSettings, out isNewObject, out errorMessage);
if (!string.IsNullOrEmpty(errorMessage))
{
//todo:[mike] return ErrorMessage to user
}
}
List <IAvrPivotGridField> fields = model.PivotSettings.Fields.Cast <IAvrPivotGridField>().ToList();
var result = new LayoutValidateResult();
if (model.PivotSettings.ShowMissedValues)
{
LayoutBaseValidator validator = CreateLayoutComplexityValidator();
result = AvrPivotGridHelper.AddMissedValuesAndValidateComplexity(model, fields, validator);
}
if (result.IsCancelOrUserDialogCancel())
{
model.HideDataForComplexLayout();
}
else
{
FillEmptyValuesInDataArea(model, fields);
}
}
public static LayoutValidateResult FillEmptyValuesInDataArea(AvrPivotGridModel model, List <IAvrPivotGridField> fields = null)
{
if (fields == null)
{
fields = model.PivotSettings.Fields.ToList <IAvrPivotGridField>();
}
var avrDataSource = new AvrPivotGridData(model.PivotData);
var result = new LayoutValidateResult();
LayoutBaseValidator validator = CreateLayoutComplexityValidator();
if (model.PivotSettings.ShowMissedValues)
{
result = AvrPivotGridHelper.AddMissedValuesAndValidateComplexity(avrDataSource, fields, validator);
}
if (!result.IsCancelOrUserDialogCancel())
{
result = AvrPivotGridHelper.FillEmptyValuesAndValidateComplexity(avrDataSource, fields, validator);
}
//LayoutValidateResult result = AvrPivotGridHelper.FillEmptyValuesAndValidateComplexity(avrDataSource, fields, validator);
if (result.IsCancelOrUserDialogCancel())
{
model.HideDataForComplexLayout();
}
return(result);
}
public void PivotGridDeleteFieldMissedValuesDuplicateTest()
{
IAvrPivotGridField date1 = GetIAvrPivotGridField("Date");
date1.SearchFieldDataType = typeof(DateTime);
date1.AddMissedValues = true;
IAvrPivotGridField region1 = GetIAvrPivotGridField("Region");
IAvrPivotGridField region2 = GetIAvrPivotGridField("Region");
region2.AddMissedValues = true;
IAvrPivotGridField region3 = GetIAvrPivotGridField("Region");
region3.AddMissedValues = true;
IAvrPivotGridField date2 = GetIAvrPivotGridField("Date");
date2.SearchFieldDataType = typeof(DateTime);
date2.AddMissedValues = true;
var fields = new List <IAvrPivotGridField> {
date1, region1, region2, region3, date2
};
foreach (IAvrPivotGridField field in fields)
{
field.AllPivotFields = fields;
}
List <IAvrPivotGridField> result = AvrPivotGridHelper.AddRelatedFields(fields).ToList();
Assert.AreEqual(2, result.Count);
Assert.AreEqual(date1, result[0]);
Assert.AreEqual(region2, result[1]);
}
public void GetPivotSummaryTypeTest()
{
using (var pivot = new PivotDetailPanel())
{
AvrDataTable dataTable = new AvrDataTable(DataHelper.GenerateTestTable());
List <WinPivotGridField> list = AvrPivotGridHelper.CreateFields <WinPivotGridField>(dataTable);
pivot.PivotGrid.Fields.AddRange(list.ToArray());
pivot.PivotGrid.SetDataSourceAndCreateFields(dataTable);
Assert.IsTrue(Configuration.SummaryTypeDictionary.ContainsKey(typeof(string)));
CustomSummaryType type = Configuration.SummaryTypeDictionary[typeof(string)];
Assert.AreEqual(CustomSummaryType.Count, type);
Assert.IsTrue(Configuration.SummaryTypeDictionary.ContainsKey(typeof(DateTime)));
type = Configuration.SummaryTypeDictionary[typeof(DateTime)];
Assert.AreEqual(CustomSummaryType.Max, type);
Assert.IsFalse(Configuration.SummaryTypeDictionary.ContainsKey(typeof(bool)));
type = Configuration.DefaltSummaryType;
Assert.AreEqual(CustomSummaryType.Count, type);
Assert.IsTrue(Configuration.SummaryTypeDictionary.ContainsKey(typeof(int)));
type = Configuration.SummaryTypeDictionary[typeof(int)];
Assert.AreEqual(CustomSummaryType.Sum, type);
Assert.IsTrue(Configuration.SummaryTypeDictionary.ContainsKey(typeof(long)));
type = Configuration.SummaryTypeDictionary[typeof(long)];
Assert.AreEqual(CustomSummaryType.Sum, type);
}
}
public ActionResult OnCopyField(string fieldId)
{
AvrPivotGridModel model = GetModelFromSession();
if (model == null)
{
return(View("AvrServiceError", (object)m_ErrorMessage));
}
if (string.IsNullOrEmpty(fieldId))
{
return(new JsonResult {
Data = false, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
WebPivotGridField sourceField = model.PivotSettings.Fields.Find(f => f.FieldName == fieldId);
var copy = AvrPivotGridHelper.CreateFieldCopy <WebPivotGridField>(sourceField,
model.PivotSettings.LayoutDataset,
model,
model.PivotSettings.QueryId,
model.PivotSettings.LayoutId);
model.PivotSettings.AddField(copy);
model.PivotSettings.SelectedField = copy;
copy.Action = WebFieldAction.Add;
model.PivotSettings.UpdatedField = copy;
model.IsFirstLoad = true;
return(new JsonResult {
Data = true, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
private void RestorePivotSettings(LayoutDetailDataSet layoutDataSet)
{
try
{
LayoutDetailDataSet.LayoutRow layoutRow = GetLayoutRow(layoutDataSet);
List <IAvrPivotGridField> avrFields = m_AvrPivot.AvrFields.ToList();
AvrPivotGridHelper.LoadSearchFieldsVersionSixFromDB(avrFields, layoutDataSet.LayoutSearchField,
layoutRow.idfsDefaultGroupDate);
using (m_AvrPivot.BeginTransaction())
{
AvrPivotGridHelper.LoadExstraSearchFieldsProperties(avrFields, layoutDataSet.LayoutSearchField);
AvrPivotGridHelper.SwapOriginalAndCopiedFieldsIfReversed(avrFields);
m_AvrPivot.PivotGridPresenter.UpdatePivotCaptions();
RestoreTotals(layoutRow);
}
}
catch (XmlException ex)
{
Trace.WriteLine(ex);
ErrorForm.ShowError("errCantParseLayout", "Cannot parse Layout retrived from Database", ex);
}
}
//[HttpPost]
// public ActionResult OnSaveFieldChanges()
public ActionResult AggregateFunctionChanged(string aggregateFunctionId)
{
AvrPivotGridModel model = GetModelFromSession();
if (model == null)
{
return(View("AvrServiceError", (object)m_ErrorMessage));
}
int intPrecision = -1;
if (model.PivotSettings.SelectedField != null)
{
long aggrId = bv.common.Core.Utils.ToLong(aggregateFunctionId);
CustomSummaryType summaryTypeType = AvrPivotGridHelper.ParseSummaryType(aggrId);
if (model.PivotSettings.SelectedField.PrecisionDictionary.ContainsKey(summaryTypeType))
{
intPrecision = model.PivotSettings.SelectedField.PrecisionDictionary[summaryTypeType];
}
else
{
string strPrecision = LookupCache.GetLookupValue((long)summaryTypeType, LookupTables.AggregateFunction,
"intDefaultPrecision");
intPrecision = int.TryParse(strPrecision, out intPrecision)
? intPrecision
: -1;
}
}
return(new JsonResult {
Data = new { precision = (decimal)intPrecision }, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
public static AvrDataTable GetPivotData(LayoutDetailDataSet ds, long queryId, long layoutId, bool useArchiveData, string filter, out bool isNewObject, out string errorMessage)
{
CachedQueryResult queryResult = ServiceClientHelper.ExecQuery(queryId, useArchiveData, filter);
isNewObject = ds.LayoutSearchField.Count == 0;
errorMessage = queryResult.ErrorMessage;
return(AvrPivotGridHelper.GetPreparedDataSource(ds.LayoutSearchField, queryId, layoutId, queryResult.QueryTable, isNewObject));
}
private AvrPivotViewModel CreateAvrPivotViewModelInternal(long layoutId, string lang)
{
LayoutDetailDataSet layoutDataSet = GetLayoutDataSet(layoutId);
LayoutDetailDataSet.LayoutRow layoutRow = GetLayoutRow(layoutDataSet);
m_SharedPresenter.SharedModel.SelectedQueryId = layoutRow.idflQuery;
m_SharedPresenter.SharedModel.SelectedLayoutId = layoutId;
m_Trace.Trace(TraceTitle, string.Format("Layout {0} structure read from DB", layoutId));
var validatorWaiter = new LayoutSilentValidatorWaiter();
var filter = layoutRow.blnApplyPivotGridFilter ? layoutRow.strPivotGridSettings : string.Empty;
var queryResult = AvrMainFormPresenter.ExecQueryInternal(layoutRow.idflQuery, lang,
layoutRow.blnUseArchivedData, filter, validatorWaiter, false, QueryExecutor);
//var queryResult = AvrMainFormPresenter.ExecQueryInternal(layoutRow.idflQuery, lang,
// layoutRow.blnUseArchivedData, layoutRow.strPivotGridSettings, validatorWaiter, false, QueryExecutor);
m_Trace.Trace(TraceTitle, string.Format("Data for layout {0} received from AVR Cashe ", layoutId));
AvrDataTable preparedQueryTable = AvrPivotGridHelper.GetPreparedDataSource(layoutDataSet.LayoutSearchField,
layoutRow.idflQuery, layoutId, queryResult.QueryTable, false);
m_AvrPivot.SetDataSourceAndCreateFields(preparedQueryTable);
RestorePivotSettings(layoutDataSet);
using (m_AvrPivot.BeginTransaction())
{
List <IAvrPivotGridField> fields = m_AvrPivot.AvrFields.ToList();
var result = new LayoutValidateResult();
if (layoutRow.blnShowMissedValuesInPivotGrid)
{
result = AvrPivotGridHelper.AddMissedValuesAndValidateComplexity(m_AvrPivot.DataSource, fields,
validatorWaiter.Validator);
}
if (!result.IsCancelOrUserDialogCancel())
{
result = AvrPivotGridHelper.FillEmptyValuesAndValidateComplexity(m_AvrPivot.DataSource, fields,
validatorWaiter.Validator);
}
if (result.IsCancelOrUserDialogCancel())
{
m_AvrPivot.HideData = true;
}
m_AvrPivot.RefreshData();
}
m_Trace.Trace(TraceTitle, string.Format("Layout {0} builded", layoutId));
PivotGridDataLoadedCommand command = m_AvrPivot.CreatePivotDataLoadedCommand(layoutRow.strLayoutName);
m_Trace.Trace(TraceTitle, string.Format("View model for layout {0}, language {1} created", layoutId, lang));
return(command.Model);
}
public void QueryFieldImageTest()
{
DataTable table = CreateLookupWithFieldType();
Dictionary <string, Type> types = AvrPivotGridHelper.GetSearchFieldDataTypes(table);
Assert.AreEqual(table.Rows.Count * 4, types.Count);
Assert.AreEqual(typeof(bool), types["fBit"]);
Assert.AreEqual(typeof(DateTime), types["fDate"]);
Assert.AreEqual(typeof(float), types["fFloat"]);
Assert.AreEqual(typeof(long), types["fID"]);
Assert.AreEqual(typeof(long), types["fInteger"]);
Assert.AreEqual(typeof(string), types["fString"]);
}
public void QueryParamImageTest()
{
DataTable table = CreateLookupWithFF();
Dictionary <string, Type> types = AvrPivotGridHelper.GetSearchFieldDataTypes(table);
Assert.AreEqual(typeof(long), types["fNumeric"]);
Assert.AreEqual(typeof(bool), types["fBoolean"]);
Assert.AreEqual(typeof(string), types["fCaption"]);
Assert.AreEqual(typeof(DateTime), types["fDate"]);
Assert.AreEqual(typeof(DateTime), types["fDateTime"]);
Assert.AreEqual(typeof(long), types["fMonths"]);
Assert.AreEqual(typeof(string), types["fString"]);
Assert.AreEqual(typeof(long), types["fNumericNatural"]);
Assert.AreEqual(typeof(long), types["fNumericPositive"]);
Assert.AreEqual(typeof(long), types["fNumericInteger"]);
}
public void PivotGridLinkedFieldRayonRegionSettlementTest()
{
WinPivotGridField region = GetIAvrPivotGridField("Region");
WinPivotGridField rayon = GetIAvrPivotGridField("Rayon");
rayon.RelatedFields = new List <IAvrPivotGridField> {
region
};
WinPivotGridField settlement = GetIAvrPivotGridField("Settlement");
settlement.RelatedFields = new List <IAvrPivotGridField> {
rayon, region
};
WinPivotGridField diagnosis = GetIAvrPivotGridField("Diagnosis");
WinPivotGridField zoonotic = GetIAvrPivotGridField("Zoonotic");
zoonotic.RelatedFields = new List <IAvrPivotGridField> {
diagnosis
};
var allFields = new List <IAvrPivotGridField> {
region, rayon, settlement, diagnosis, zoonotic
};
foreach (IAvrPivotGridField field in allFields)
{
field.AllPivotFields = allFields;
}
Assert.AreEqual(2, settlement.GetRelatedFieldChain().Count);
Assert.AreEqual(1, zoonotic.GetRelatedFieldChain().Count);
var fields = new List <IAvrPivotGridField> {
rayon, region, settlement, zoonotic
};
List <IAvrPivotGridField> result = AvrPivotGridHelper.AddRelatedFields(fields).ToList();
Assert.AreEqual(5, result.Count);
Assert.AreEqual(region, result[0]);
Assert.AreEqual(rayon, result[1]);
Assert.AreEqual(settlement, result[2]);
Assert.AreEqual(diagnosis, result[3]);
Assert.AreEqual(zoonotic, result[4]);
}
public AvrPivotGridHelperWeb(ASPxPivotGrid pivotGrid)
{
DisplayTextHandler = new DisplayTextHandler();
m_BaseFields = pivotGrid.Fields;
m_DataAreaFields = new List <IAvrPivotGridField>();
foreach (PivotGridField field in pivotGrid.GetFieldsByArea(PivotArea.DataArea))
{
//todo: change this initialization
if (field is IAvrPivotGridField)
{
m_DataAreaFields.Add((IAvrPivotGridField)field);
}
}
m_ColumnAreaFields = new List <IAvrPivotGridField>();
foreach (PivotGridField field in pivotGrid.GetFieldsByArea(PivotArea.ColumnArea))
{
//todo: change this initialization
if (field is IAvrPivotGridField)
{
m_ColumnAreaFields.Add((IAvrPivotGridField)field);
}
}
m_RowAreaFields = new List <IAvrPivotGridField>();
foreach (PivotGridField field in pivotGrid.GetFieldsByArea(PivotArea.RowArea))
{
//todo: change this initialization
if (field is IAvrPivotGridField)
{
m_RowAreaFields.Add((IAvrPivotGridField)field);
}
}
var fields = RowAreaFields;
fields.AddRange(ColumnAreaFields);
GenderField = AvrPivotGridHelper.GetGenderField(fields);
AgeGroupField = AvrPivotGridHelper.GetAgeGroupField(fields);
PivotWebData = pivotGrid.Data;
WebPivotGrid = pivotGrid;
}
public static AvrPivotGridModel FillData(ref long queryId, long layoutId)
{
var service = new WebLayoutDB();
var sessionDataSet = (LayoutDetailDataSet)service.GetDetail(layoutId);
if (queryId <= 0)
{
queryId = ((LayoutDetailDataSet.LayoutRow)sessionDataSet.Layout.Rows[0]).idflQuery;
}
var helper = new LayoutHelper(sessionDataSet);
var settings = new AvrPivotSettings(queryId, layoutId);
helper.InitAvrPivotSettings(settings);
bool isNewObject;
string errorMessage;
AvrDataTable data = LayoutPivotGridHelper.GetPivotData(
helper.LayoutDataSet,
queryId,
layoutId,
settings.UseArchiveData,
settings.ApplyFilter ? settings.FilterCriteriaString :string.Empty,
out isNewObject, out errorMessage);
if (!string.IsNullOrEmpty(errorMessage))
{
throw new AvrException(errorMessage);
}
settings.Fields = AvrPivotGridHelper.CreateFields <WebPivotGridField>(data);
helper.PrepareWebFields(settings);
List <IAvrPivotGridField> fields = settings.Fields.Cast <IAvrPivotGridField>().ToList();
LayoutValidateResult result = helper.LoadPivotFromDB(new AvrPivotGridData(data), fields, isNewObject);
var model = new AvrPivotGridModel(settings, data);
if (result.IsCancelOrUserDialogCancel())
{
model.HideDataForComplexLayout();
}
return(model);
}
public void PivotGridDeleteFieldMissedValuesSingleTest()
{
IAvrPivotGridField region1 = GetIAvrPivotGridField("Region");
IAvrPivotGridField region2 = GetIAvrPivotGridField("Region");
IAvrPivotGridField region3 = GetIAvrPivotGridField("Region");
region3.AddMissedValues = true;
var fields = new List <IAvrPivotGridField> {
region1, region2, region3
};
foreach (IAvrPivotGridField field in fields)
{
field.AllPivotFields = fields;
}
List <IAvrPivotGridField> result = AvrPivotGridHelper.AddRelatedFields(fields).ToList();
Assert.AreEqual(1, result.Count);
Assert.AreEqual(region3, result[0]);
}
public void PivotGridLinkedFieldSimpleTest()
{
IAvrPivotGridField region = GetIAvrPivotGridField("Region");
IAvrPivotGridField rayon = GetIAvrPivotGridField("Rayon");
IAvrPivotGridField settlement = GetIAvrPivotGridField("Settlement");
var fields = new List <IAvrPivotGridField> {
region, rayon, settlement
};
foreach (IAvrPivotGridField field in fields)
{
field.AllPivotFields = fields;
}
List <IAvrPivotGridField> result = AvrPivotGridHelper.AddRelatedFields(fields).ToList();
Assert.AreEqual(3, result.Count);
Assert.AreEqual(region, result[0]);
Assert.AreEqual(rayon, result[1]);
Assert.AreEqual(settlement, result[2]);
}
public ActionResult DeleteFieldCopy()
{
AvrPivotGridModel model = GetModelFromSession();
if (model == null)
{
return(View("AvrServiceError", (object)m_ErrorMessage));
}
if (model.PivotSettings.SelectedField != null)
{
WebPivotGridField field = model.PivotSettings.SelectedField;
field.Action = WebFieldAction.Delete;
AvrPivotGridHelper.DeleteFieldCopy(field, model.PivotSettings.LayoutDataset, model);
model.PivotSettings.DeleteField(field);
model.PivotSettings.UpdatedField = field;
model.PivotSettings.SelectedField = null;
model.IsFirstLoad = true;
}
return(new JsonResult {
Data = true, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
public bool SaveData(AvrPivotSettings settings)
{
List <IAvrPivotGridField> fields = settings.Fields.Cast <IAvrPivotGridField>().ToList();
AvrPivotGridHelper.PrepareLayoutSearchFieldsBeforePost(fields,
LayoutDataSet.LayoutSearchField, settings.QueryId, settings.LayoutId);
var db = new WebLayoutDB();
db.SetQueryID(settings.QueryId);
LayoutRow.idfsDefaultGroupDate = settings.DefaultGroupInterval;
LayoutRow.blnShowColsTotals = settings.ShowColumnTotals;
LayoutRow.blnShowRowsTotals = settings.ShowRowTotals;
LayoutRow.blnShowColGrandTotals = settings.ShowColumnGrandTotals;
LayoutRow.blnShowRowGrandTotals = settings.ShowRowGrandTotals;
LayoutRow.blnShowForSingleTotals = settings.ShowTotalsForSingleValues;
LayoutRow.blnShowMissedValuesInPivotGrid = settings.ShowMissedValues;
LayoutRow.blnApplyPivotGridFilter = settings.ApplyFilter;
LayoutRow.blnCompactPivotGrid = settings.CompactLayout;
LayoutRow.blnFreezeRowHeaders = settings.FreezeRowHeaders;
LayoutRow.blnUseArchivedData = settings.UseArchiveData;
LayoutRow.strPivotGridSettings = settings.FilterCriteriaString;
LayoutRow.blnShowDataInPivotGrid = settings.ShowDataInPivot;
return(db.PostDetail(m_DataSet, (int)PostType.FinalPosting));
}
public void PivotGridMissedValuesFilterDateTest()
{
IAvrPivotGridField date1 = GetIAvrPivotGridField("Date");
date1.SearchFieldDataType = typeof(DateTime);
date1.GroupInterval = PivotGroupInterval.DateYear;
date1.AddMissedValues = true;
IAvrPivotGridField date2 = GetIAvrPivotGridField("Date");
date2.SearchFieldDataType = typeof(DateTime);
date2.GroupInterval = PivotGroupInterval.DateMonth;
date2.AddMissedValues = true;
IAvrPivotGridField date3 = GetIAvrPivotGridField("Date");
date3.SearchFieldDataType = typeof(DateTime);
date3.IsHiddenFilterField = true;
var fields = new List <IAvrPivotGridField> {
date1, date2, date3
};
foreach (IAvrPivotGridField field in fields)
{
field.AllPivotFields = fields;
}
List <IAvrPivotGridField> result = AvrPivotGridHelper.AddRelatedFields(new List <IAvrPivotGridField> {
date1, date2
}).ToList();
Assert.AreEqual(1, result.Count);
Assert.AreEqual(date1, result[0]);
}
public ActionResult OnSaveFieldChanges
(string caption, string captionEn, string aggregateFunctionId, string precision, string basicCountFunctionId, string adminUnitField, string dateField,
string groupInterval, string addMissedValue, string startDate, string endDate)
{
AvrPivotGridModel model = GetModelFromSession();
if (model == null)
{
return(new JsonResult
{
JsonRequestBehavior = JsonRequestBehavior.AllowGet,
Data = new { result = "error", error = m_ErrorMessage }
});
}
if (model.PivotSettings.SelectedField != null)
{
WebPivotGridFieldClone clonedField =
model.PivotSettings.SelectedField.GetClonedField(model.PivotSettings.LayoutDataset, false);
if (ModelUserContext.CurrentLanguage != Localizer.lngEn)
{
clonedField.Caption = caption;
}
clonedField.CaptionEn = captionEn;
clonedField.AggregateFunctionId = bv.common.Core.Utils.ToLong(aggregateFunctionId);
clonedField.BasicCountFunctionId = bv.common.Core.Utils.ToLong(basicCountFunctionId);
clonedField.Precision = bv.common.Core.Utils.ToNullableInt(precision);
clonedField.UnitLayoutSearchFieldId = bv.common.Core.Utils.ToNullableLong(adminUnitField);
clonedField.DateLayoutSearchFieldId = bv.common.Core.Utils.ToNullableLong(dateField);
bool updateMissedValues = (!clonedField.AddMissedValues.Equals(bool.Parse(addMissedValue)) ||
!clonedField.DiapasonStartDate.Equals(bv.common.Core.Utils.ToDateNullable(startDate)) ||
!clonedField.DiapasonEndDate.Equals(bv.common.Core.Utils.ToDateNullable(endDate)) ||
!clonedField.PrivateGroupInterval.Equals(bv.common.Core.Utils.ToNullableLong(groupInterval)));
clonedField.PrivateGroupInterval = bv.common.Core.Utils.ToNullableLong(groupInterval);
bool fillEmptyValues =
LayoutPivotGridHelper.IsFieldGroupIntervalChanged(model.PivotSettings.SelectedField,
clonedField.PrivateGroupInterval.HasValue ? (PivotGroupInterval)clonedField.PrivateGroupInterval : model.PivotSettings.SelectedField.GroupInterval);
clonedField.AddMissedValues = bool.Parse(addMissedValue);
clonedField.DiapasonStartDate = bv.common.Core.Utils.ToDateNullable(startDate);
clonedField.DiapasonEndDate = bv.common.Core.Utils.ToDateNullable(endDate);
string error = ValidateFieldClone(clonedField, model.PivotSettings.SelectedField.IsDateTimeField);
if (!string.IsNullOrEmpty(error))
{
return(new JsonResult
{
JsonRequestBehavior = JsonRequestBehavior.AllowGet,
Data = new { result = "error", error = error }
});
}
bool aggregateChanged =
!model.PivotSettings.SelectedField.AggregateFunctionId.Equals(clonedField.AggregateFunctionId);
model.PivotSettings.SelectedField.FlashChanges(model.PivotSettings.LayoutDataset);
if (aggregateChanged)
{
WebPivotGridField field = model.PivotSettings.SelectedField;
CustomSummaryType summaryTypeType =
AvrPivotGridHelper.ParseSummaryType(model.PivotSettings.SelectedField.AggregateFunctionId);
field.SummaryDisplayType = PivotSummaryDisplayType.Default;
PivotSummaryType summaryType = summaryTypeType == CustomSummaryType.Count
? PivotSummaryType.Count
: PivotSummaryType.Custom;
field.CustomSummaryType = summaryTypeType;
field.SummaryType = summaryType;
}
if (model.PivotSettings.SelectedField.Action != WebFieldAction.Add)
{
model.PivotSettings.SelectedField.Action = WebFieldAction.Edit;
}
model.PivotSettings.UpdatedField = model.PivotSettings.SelectedField;
if (model.PivotSettings.SelectedField.HasChanges)
{
model.PivotSettings.HasChanges = true;
}
if (updateMissedValues)
{
LayoutPivotGridHelper.CopyMissedValuesFromField(model.PivotSettings.SelectedField, model.PivotSettings.Fields);
LayoutPivotGridHelper.AddMissedValues(model, true);
}
else if (fillEmptyValues)
{
LayoutPivotGridHelper.FillEmptyValuesInDataArea(model);
}
if (model.PivotSettings.SelectedField.Action != WebFieldAction.Add)
{
return(new JsonResult {
Data = String.Empty, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
}
return(new JsonResult
{
JsonRequestBehavior = JsonRequestBehavior.AllowGet,
Data = new { result = "refresh", function = "RefeshData2" }
});
}
private LayoutDetailDataSet.LayoutSearchFieldRow GetLayoutSearchFieldRowByField(LayoutDetailDataSet ds, WebPivotGridField webField)
{
return(AvrPivotGridHelper.GetLayoutSearchFieldRowByField(webField, ds));
}
private static void PivotGridOnFieldAreaChanged(object sender, PivotFieldEventArgs pivotFieldEventArgs)
{
var pivotGrid = (MVCxPivotGrid)sender;
AvrPivotGridModel model = GetModelFromSession(pivotGrid.Request);
PivotGridField field = pivotFieldEventArgs.Field;
WebPivotGridField webField = GetWebPivotGridFieldByName(model.PivotSettings.Fields, field.ID);
if (field.Area == webField.Area && field.AreaIndex == webField.AreaIndex && field.Visible == webField.Visible)
{
return;
}
bool copyAddMissedValues = field.Visible &&
(field.Area == PivotArea.ColumnArea || field.Area == PivotArea.RowArea) &&
(!webField.Visible || !(webField.Area == PivotArea.ColumnArea ||
webField.Area == PivotArea.RowArea));
bool clearMissedValues = !field.Visible ||
!(field.Area == PivotArea.ColumnArea || field.Area == PivotArea.RowArea);
webField.Area = field.Area;
webField.AreaIndex = field.AreaIndex;
webField.Visible = field.Visible;
if (copyAddMissedValues)
{
CopyMissedValuesToField(webField, model.PivotSettings.Fields);
}
else if (clearMissedValues)
{
ClearMissedValues(webField);
}
var adminUnitsList = AvrPivotGridHelper.GetAdministrativeUnitView(model.PivotSettings.QueryId,
model.PivotSettings.Fields.ToList <IAvrPivotGridField>());
foreach (PivotGridField f in pivotGrid.Fields)
{
WebPivotGridField webF = GetWebPivotGridFieldByName(model.PivotSettings.Fields, f.ID);
if (f.Visible && f.Area == field.Area && f.ID != field.ID)
{
webF.AreaIndex = f.AreaIndex;
}
if (webF.UnitLayoutSearchFieldId != -1 && webF.UnitLayoutSearchFieldId != 0)
{
if (adminUnitsList == null || adminUnitsList.Count == 0 || webF.Area != PivotArea.RowArea)
{
webF.UnitLayoutSearchFieldId = -1L;
}
else if (!webF.UnitLayoutSearchFieldId.Equals(adminUnitsList[0]["Id"]))
{
webF.UnitLayoutSearchFieldId = DBNull.Value.Equals(adminUnitsList[0]["Id"])
? -1L
: (long)adminUnitsList[0]["Id"];
}
}
}
if (model.PivotSettings.ShowMissedValues)
{
AddMissedValues(model, true);
pivotGrid.JSProperties["cpNeedCallback"] = true;
//pivotGrid.ReloadData();
}
else
{
LayoutValidateResult validateResult = FillEmptyValuesInDataArea(model);
pivotGrid.JSProperties["cpNeedCallback"] = validateResult.IsCancelOrUserDialogCancel();
}
// because AvrPivotGridHelperWeb which used inside m_CustomSummaryHandler should be re-initialized
m_CustomSummaryHandler = null;
}
private static PivotGridSettings CreateLayoutPivotGridSettings(AvrPivotGridModel model)
{
var settings = new PivotGridSettings();
bool readOnly = model.PivotSettings.IsPublished | !AvrPermissions.UpdatePermission;
settings.Name = "pivotGrid";
settings.CallbackRouteValues =
new
{
Controller = "Layout",
Action = "PivotGridPartial",
//queryId = model.PivotSettings.QueryId,
layoutId = model.PivotSettings.LayoutId
};
settings.CustomActionRouteValues =
new
{
Controller = "Layout",
Action = "PivotGridPartial",
//queryId = model.PivotSettings.QueryId,
layoutId = model.PivotSettings.LayoutId
};
settings.OptionsView.HorizontalScrollBarMode = model.PivotSettings.FreezeRowHeaders ? ScrollBarMode.Auto : ScrollBarMode.Hidden;
if (model.PivotSettings.FreezeRowHeaders)
{
settings.Width = Unit.Percentage(99);
}
settings.OptionsView.ShowFilterHeaders = false;
settings.OptionsView.ShowColumnHeaders = true;
settings.OptionsView.ShowRowHeaders = true;
settings.OptionsView.DataHeadersDisplayMode = PivotDataHeadersDisplayMode.Popup;
settings.OptionsView.DataHeadersPopupMaxColumnCount = 3;
//settings.OptionsDataField.RowHeaderWidth = 100;
settings.OptionsPager.Position = PagerPosition.Bottom;
settings.OptionsPager.RowsPerPage = BaseSettings.AvrRowsPerPage;
// note: this option disables paging. commented by Ivan because of out of memory
// settings.OptionsPager.Visible = false;
settings.OptionsBehavior.BestFitMode = PivotGridBestFitMode.FieldValue; // PivotGridBestFitMode.Cell;
settings.CustomLoadCallbackState = CustomLoadCallbackState;
settings.OptionsCustomization.AllowDrag = !readOnly;
settings.OptionsCustomization.AllowExpand = !readOnly;
settings.OptionsCustomization.AllowDragInCustomizationForm = true;
settings.OptionsCustomization.AllowHideFields = AllowHideFieldsType.Always;
settings.OptionsCustomization.CustomizationFormStyle = CustomizationFormStyle.Simple;
settings.OptionsCustomization.AllowCustomizationForm = !readOnly;
SetTotalSettings(settings.OptionsView, model.PivotSettings);
if (!readOnly)
{
settings.PivotCustomizationExtensionSettings.Name = "pivotCustomization";
settings.PivotCustomizationExtensionSettings.Enabled = true;
settings.PivotCustomizationExtensionSettings.Visible = true;
settings.PivotCustomizationExtensionSettings.AllowedLayouts =
CustomizationFormAllowedLayouts.TopPanelOnly;
settings.PivotCustomizationExtensionSettings.Layout = CustomizationFormLayout.TopPanelOnly;
settings.PivotCustomizationExtensionSettings.AllowSort = true;
settings.PivotCustomizationExtensionSettings.AllowFilter = false;
settings.PivotCustomizationExtensionSettings.Height = Unit.Percentage(100);
settings.PivotCustomizationExtensionSettings.Width = Unit.Percentage(100);
}
settings.OptionsCustomization.AllowPrefilter = false;
settings.Prefilter.Enabled = false;
settings.OptionsView.EnableFilterControlPopupMenuScrolling = true;
settings.Prefilter.Criteria = CriteriaOperator.TryParse(model.PivotSettings.FilterCriteriaString);
settings.Styles.PrefilterBuilderCloseButtonStyle.CssClass = "invisible";
settings.Styles.PrefilterBuilderHeaderStyle.CssClass = "roundbox";
settings.PopupMenuCreated += PopupMenuCreated;
settings.Styles.PrefilterBuilderMainAreaStyle.CssClass = "filterwindow";
settings.FilterControlOperationVisibility = (sender, args) =>
{
WebPivotGridField webField = GetWebPivotGridFieldByName(model.PivotSettings.Fields, args.PropertyInfo.PropertyName);
if (webField == null)
{
args.Visible = false;
return;
}
switch (webField.SearchFieldType)
{
case SearchFieldType.ID: //lookup
args.Visible = IsValidLookupClause(args.Operation);
break;
case SearchFieldType.String:
args.Visible = IsValidStringClause(args.Operation);
break;
case SearchFieldType.Date:
args.Visible = IsValidDateClause(args.Operation);
break;
default:
args.Visible = IsValidDefaultClause(args.Operation);
break;
}
};
settings.FilterControlCustomValueDisplayText = (sender, args) =>
{
if (args.Value == null)
{
args.DisplayText = Translator.GetMessageString("FilterConrol_EmptyEnter");
}
else if (args.PropertyInfo.PropertyType == typeof(DateTime))
{
args.DisplayText = string.Format("{0:d}", args.Value);
}
};
settings.OptionsCustomization.AllowFilterInCustomizationForm = true;
settings.Theme = GeneralSettings.Theme;
settings.Fields.Clear();
foreach (WebPivotGridField webField in
model.PivotSettings.Fields.Where(f => f.Visible && f.Area != PivotArea.FilterArea).OrderBy(f => (long)f.Area * 100000 + f.AreaIndex))
{
settings.Fields.Add(webField);
}
foreach (WebPivotGridField webField in
model.PivotSettings.Fields.Where(f => !f.Visible || f.Area == PivotArea.FilterArea).OrderBy(f => f.Caption))
{
settings.Fields.Add(webField);
}
settings.Init = (sender, args) =>
{
var pivotGrid = (MVCxPivotGrid)sender;
if (model.ShowingPrefilter)
{
pivotGrid.PrefilterCriteriaChanged += PrefilterCriteriaChanged;
}
pivotGrid.FieldAreaChanged += PivotGridOnFieldAreaChanged;
pivotGrid.HeaderTemplate = new HeaderTemplate(model);
};
settings.PreRender = (sender, e) =>
{
var pivotGrid = (MVCxPivotGrid)sender;
pivotGrid.BeginUpdate();
pivotGrid.HeaderTemplate = new HeaderTemplate(model);
pivotGrid.EndUpdate();
};
settings.BeforeGetCallbackResult = (sender, e) =>
{
var pivotGrid = (MVCxPivotGrid)sender;
if (model.ShowPrefilter)
{
pivotGrid.IsPrefilterPopupVisible = true;
CriteriaOperator criteria = CriteriaOperator.TryParse(model.PivotSettings.FilterCriteriaString);
criteria = ValidatePrefilterCriteria(criteria);
pivotGrid.Prefilter.Criteria = criteria;
model.ShowPrefilter = false;
model.ShowingPrefilter = true;
return;
}
model.ShowingPrefilter = false;
pivotGrid.BeginUpdate();
try
{
pivotGrid.Prefilter.Enabled = false;
UpdatePivotGridField(pivotGrid, model);
model.PivotSettings.UpdatedField = null;
if (model.PivotSettings.UpdateGroupInterval)
{
PivotGroupInterval interval = GroupIntervalHelper.GetGroupInterval(model.PivotSettings.DefaultGroupInterval);
SetInterval(pivotGrid, interval);
model.PivotSettings.UpdateGroupInterval = false;
}
SetTotalSettings(pivotGrid.OptionsView, model.PivotSettings);
pivotGrid.OptionsView.HorizontalScrollBarMode = model.PivotSettings.FreezeRowHeaders ? ScrollBarMode.Auto : ScrollBarMode.Hidden;
if (model.PivotSettings.FreezeRowHeaders)
{
pivotGrid.Width = Unit.Percentage(99);
}
else
{
pivotGrid.Width = Unit.Empty;
}
pivotGrid.ReloadData();
}
finally
{
pivotGrid.EndUpdate();
}
};
//settings.ClientSideEvents.EndCallback = "layoutPivotGrid.resizePivotGridEvent";
settings.AfterPerformCallback = (sender, e) =>
{
var pivotGrid = (MVCxPivotGrid)sender;
if (pivotGrid.HeaderTemplate == null)
{
pivotGrid.HeaderTemplate = new HeaderTemplate(model);
}
//pivotGrid.BeginUpdate();
//pivotGrid.ReloadData();
//pivotGrid.EndUpdate();
};
settings.ClientSideEvents.CallbackError = "layoutPivotGrid.onCallbackError";
settings.ClientSideEvents.EndCallback = "layoutPivotGrid.onEndCallback";
settings.CustomCellDisplayText = (sender, e) =>
{
InitDisplayTexthandler();
m_DisplayTextHandler.DisplayAsterisk(new WebPivotCellDisplayTextEventArgs(e));
if (e.DataField == null)
{
return;
}
if (model.PivotSettings.FieldsDictionary.ContainsKey(e.DataField.FieldName))
{
WebPivotGridField field = model.PivotSettings.FieldsDictionary[e.DataField.FieldName];
m_DisplayTextHandler.DisplayCellText(new WebPivotCellDisplayTextEventArgs(e), field.CustomSummaryType, field.Precision);
}
};
settings.FieldValueDisplayText = (sender, e) =>
{
InitDisplayTexthandler();
var eventArgs = new WebPivotFieldDisplayTextEventArgs(e);
m_DisplayTextHandler.DisplayAsterisk(eventArgs);
m_DisplayTextHandler.DisplayBool(eventArgs);
if (m_CustomSummaryHandler == null)
{
var helper = new AvrPivotGridHelperWeb((ASPxPivotGrid)sender)
{
SingleSearchObject = model.PivotSettings.IsSingleSearchObject
};
m_CustomSummaryHandler = new CustomSummaryHandler(helper);
}
var summaryTypes = new List <CustomSummaryType>();
List <IAvrPivotGridField> dataFields = AvrPivotGridHelper.GetFieldCollectionFromArea(model.PivotSettings.Fields,
PivotArea.DataArea);
foreach (IAvrPivotGridField field in dataFields)
{
summaryTypes.Add(field.CustomSummaryType);
m_DisplayTextHandler.DisplayStatisticsTotalCaption(eventArgs, summaryTypes);
}
};
settings.CustomSummary = (sender, e) =>
{
if (m_CustomSummaryHandler == null)
{
var helper = new AvrPivotGridHelperWeb((ASPxPivotGrid)sender);
m_CustomSummaryHandler = new CustomSummaryHandler(helper);
}
WebPivotGridField settingsField = model.PivotSettings.Fields.Find(f => f.FieldName == e.DataField.FieldName);
var field = e.DataField as IAvrPivotGridField;
if (settingsField != null && field != null && ((int)field.CustomSummaryType <= 0))
{
field.CustomSummaryType = settingsField.CustomSummaryType;
field.BasicCountFunctionId = settingsField.BasicCountFunctionId;
field.AggregateFunctionId = settingsField.AggregateFunctionId;
field.UnitLayoutSearchFieldId = settingsField.UnitLayoutSearchFieldId;
field.UnitSearchFieldAlias = settingsField.UnitSearchFieldAlias;
field.SearchFieldDataType = settingsField.SearchFieldDataType;
field.DefaultGroupInterval = settingsField.DefaultGroupInterval;
field.Ordinal = settingsField.Ordinal;
field.AddMissedValues = settingsField.AddMissedValues;
field.DiapasonStartDate = settingsField.DiapasonStartDate;
field.DiapasonEndDate = settingsField.DiapasonEndDate;
field.Precision = settingsField.Precision;
field.AggregateFunctionId = settingsField.AggregateFunctionId;
field.BasicCountFunctionId = settingsField.BasicCountFunctionId;
field.UnitLayoutSearchFieldId = settingsField.UnitLayoutSearchFieldId;
field.UnitSearchFieldAlias = settingsField.UnitSearchFieldAlias;
field.DateLayoutSearchFieldId = settingsField.DateLayoutSearchFieldId;
field.DateSearchFieldAlias = settingsField.DateSearchFieldAlias;
if (settingsField.IsDateTimeField)
{
field.GroupInterval = settingsField.DefaultGroupInterval;
}
field.AllowMissedReferenceValues = settingsField.AllowMissedReferenceValues;
field.LookupTableName = settingsField.LookupTableName;
field.GisReferenceTypeId = settingsField.GisReferenceTypeId;
field.ReferenceTypeId = settingsField.ReferenceTypeId;
field.LookupAttributeName = settingsField.LookupAttributeName;
field.HaCode = settingsField.HaCode;
field.AllPivotFields = settingsField.AllPivotFields;
field.FieldNamesDictionary = settingsField.FieldNamesDictionary;
}
m_CustomSummaryHandler.OnCustomSummary(sender, new WebPivotGridCustomSummaryEventArgs(e));
};
settings.CustomCellStyle = (sender, args) =>
{
var pivotGrid = (MVCxPivotGrid)sender;
};
settings.HtmlCellPrepared = (sender, args) =>
{
var pivotGrid = (MVCxPivotGrid)sender;
};
settings.HtmlFieldValuePrepared = (sender, args) =>
{
var pivotGrid = (MVCxPivotGrid)sender;
};
settings.GridLayout = (sender, args) =>
{
var pivotGrid = (MVCxPivotGrid)sender;
model.PivotSettings.HasChanges = true;
var fieldsToDelete = new List <PivotGridFieldBase>();
foreach (PivotGridField field in pivotGrid.Fields)
{
WebPivotGridField webField = GetWebPivotGridFieldByFieldName(model.PivotSettings.Fields, field.FieldName);
if (webField != null)
{
PivotFieldItemBase visualField =
pivotGrid.Fields.Data.VisualItems.Data.FieldItems.SingleOrDefault(
s => s.FieldName == field.FieldName);
Dbg.Assert(visualField != null, "field {0} is not found in pivot fields list",
field.FieldName);
if (!visualField.Visible && visualField.Area != PivotArea.FilterArea)
{
webField.Area = PivotArea.FilterArea;
webField.AreaIndex = -1;
webField.FilterValues.Clear();
webField.SortOrder = field.SortOrder;
webField.Width = field.Width;
ClearMissedValues(webField);
}
else
{
webField.Area = field.Area;
webField.AreaIndex = field.AreaIndex;
webField.Visible = field.Visible;
webField.SortOrder = field.SortOrder;
webField.Width = field.Width;
webField.FilterValues.Assign(field.FilterValues);
//if (webField.IsDateTimeField && webField.GroupInterval == PivotGroupInterval.Default)
//{
// webField.DefaultGroupInterval = GroupIntervalHelper.GetGroupInterval(model.PivotSettings.DefaultGroupInterval);
// field.GroupInterval = webField.GroupInterval;
//}
}
}
else
{
fieldsToDelete.Add(field);
}
}
foreach (PivotGridFieldBase field in fieldsToDelete)
{
field.Visible = false;
field.Area = PivotArea.FilterArea;
field.AreaIndex = -1;
pivotGrid.Fields.Remove(field);
}
//if (model.PivotSettings.ShowMissedValues)
//{
// List<IAvrPivotGridField> fields = model.PivotSettings.Fields.Cast<IAvrPivotGridField>().ToList();
// AvrPivotGridHelper.AddMissedValuesInRowColumnArea(model, fields);
//}
if (fieldsToDelete.Count > 0)
{
pivotGrid.ReloadData();
}
};
return(settings);
}
public void PivotSummaryTypeParserBadValueTest()
{
CustomSummaryType type = AvrPivotGridHelper.ParseSummaryType(0);
Assert.AreEqual(CustomSummaryType.Max, type);
}
public void PivotSummaryTypeParserTest()
{
CustomSummaryType type = AvrPivotGridHelper.ParseSummaryType(10004002);
Assert.AreEqual(CustomSummaryType.Count, type);
}
public bool CanDeleteSelectedField()
{
return(AvrPivotGridHelper.EnableDeleteField(SelectedField, Fields));
}
