private void AddZAxisRowToChartDataTable(int xAxisColumnIndex, SPField xAxisField)
        {
            if ((String.IsNullOrEmpty(PropChartZaxisField.Trim()) || PropChartZaxisField.Contains("None Selected")) &&
                PropChartAggregationType.ToUpper() == "COUNT")
            {
                if (xAxisField.InternalName.ToUpper() == "LIST")
                {
                    if (!SeriesExistsInChartDataTable(xAxisField.Title))
                    {
                        AddNewRowToChartDataTable(xAxisField.Title);
                    }
                }
                else
                {
                    AddNewRowToChartDataTable(dtSPSiteDataQueryData.Columns[xAxisColumnIndex].ColumnName);
                }

                _numberOfRowsInChartDataTable++;
            }
        }
        public void DataBindChart()
        {
            LoadChartDataUsingSPSiteDataQuery();

            TraceHeader();

            try
            {
                if (_numberOfColumnsInChartDataTable > 0 && _numberOfRowsInChartDataTable > 0) // has data points
                {
                    if (IsBubbleChart())
                    {
                        Series.AddRange(BuildSeriesArrayForBubbleChart());
                    }
                    else
                    {
                        int iCol = 0;
                        var x    = new String[_numberOfColumnsInChartDataTable];
                        foreach (DataColumn col in ChartDataTable.Columns)
                        {
                            if (col.ColumnName != "SeriesName")
                            {
                                x[iCol] = col.ColumnName;
                                iCol++;
                            }
                        }

                        DataView v = ChartDataTable.DefaultView;
                        v.Sort         = "[" + ChartDataTable.Columns[0].ColumnName + "] desc";
                        ChartDataTable = v.ToTable();

                        switch (PropChartAggregationType.ToUpper())
                        {
                        case "COUNT":
                            if ((PropChartZaxisField.Trim() == "" || PropChartZaxisField.Contains("None Selected")) &&
                                _numberOfRowsInChartDataTable > 1)
                            {
                                foreach (DataRow dr in ChartDataTable.Rows)
                                {
                                    AddChartSeries(dr["SeriesName"].ToString(), PropChartAggregationType, ChartDataTable.Rows.Count, 0, false, false);
                                }
                            }
                            else
                            {
                                foreach (DataRow dr in ChartDataTable.Rows)
                                {
                                    AddChartSeries(dr["SeriesName"].ToString(), PropChartAggregationType, ChartDataTable.Rows.Count, 0, false, false);
                                }
                            }
                            break;

                        case "SUM":
                        case "AVG":
                            if ((String.IsNullOrEmpty(PropChartZaxisField.Trim()) ||
                                 PropChartZaxisField.Contains("None Selected")) && _numberOfRowsInChartDataTable > 1)
                            {
                                foreach (DataRow dr in ChartDataTable.Rows)
                                {
                                    AddChartSeries(dr["SeriesName"].ToString(), PropChartAggregationType, ChartDataTable.Rows.Count, 0, false, true);
                                }
                            }
                            else
                            {
                                foreach (DataRow dr in ChartDataTable.Rows)
                                {
                                    AddChartSeries(dr["SeriesName"].ToString(), PropChartAggregationType, ChartDataTable.Rows.Count, 0, false, true);
                                }
                            }
                            break;

                        default:
                            break;
                        }
                    }
                }
                else // no data points - show msg
                {
                    PropChartTitle = "There are no results to show in this chart.";
                }
            }
            catch (Exception ex)
            {
                HandleException(ex);
            }
        }
        private void ProcessSiteQueryData(string sListName)
        {
            const int xAxisColumnIndex = 3;
            const int zAxisFieldIndex  = 4;

            try
            {
                var     xAxisField = oTopList.Fields.GetFieldByInternalName(PropChartXaxisField);
                SPField zAxisField = null;

                if (!PropChartZaxisField.Contains("None Selected"))
                {
                    zAxisField = oTopList.Fields.GetFieldByInternalName(PropChartZaxisField);
                }

                AddZAxisRowToChartDataTable(xAxisColumnIndex, xAxisField);

                foreach (DataRow dr in dtSPSiteDataQueryData.Rows)
                {
                    var xAxisFieldValue = GetXaxisFieldValue(sListName, xAxisField, xAxisColumnIndex, dr);
                    var zAxisFieldValue = GetZaxisFieldValue(sListName, zAxisField, zAxisFieldIndex, dr);

                    var sYaxisFldVal = "";

                    AddXAxisColumnToChartDataTableIfDoesntExist(xAxisFieldValue);

                    switch (PropChartAggregationType.ToUpper())
                    {
                    case "COUNT":
                        if (PropChartZaxisField.Trim().Length != 0 && !PropChartZaxisField.Contains("None Selected"))
                        {
                            if (zAxisFieldValue.Trim() == "")
                            {
                                zAxisFieldValue = "No Value";
                            }

                            if (SeriesExistsInChartDataTable(zAxisFieldValue))
                            {
                                UpdateCellValue(zAxisFieldValue, xAxisFieldValue, zAxisFieldValue, PropChartAggregationType);
                                _numberOfRowsInChartDataTable++;
                            }
                            else
                            {
                                AddNewRowToChartDataTable(zAxisFieldValue);
                                _numberOfRowsInChartDataTable++;
                                UpdateCellValue(zAxisFieldValue, xAxisFieldValue, zAxisFieldValue, PropChartAggregationType);
                            }
                        }
                        else
                        {
                            if (xAxisField.InternalName.ToUpper() == "LIST")
                            {
                                UpdateCellValue(xAxisField.Title, xAxisFieldValue, "1", "COUNT");
                            }
                            else
                            {
                                UpdateCellValue(dtSPSiteDataQueryData.Columns[xAxisColumnIndex].ColumnName, xAxisFieldValue, "1", "COUNT");
                            }
                            _numberOfRowsInChartDataTable++;
                        }
                        break;

                    case "SUM":
                    case "AVG":
                        if (PropChartAggregationType.ToUpper() != "SUM" && (PropChartZaxisField.Trim() != "" && !PropChartZaxisField.Contains("None Selected")))
                        {
                            if (zAxisFieldValue.Trim().Length == 0)
                            {
                                zAxisFieldValue = "No Value";
                            }

                            if (GetYFields().Length > 0)
                            {
                                if (SeriesExistsInChartDataTable(zAxisFieldValue))
                                {
                                    UpdateCellValue(zAxisFieldValue, xAxisFieldValue, sYaxisFldVal,
                                                    PropChartAggregationType);
                                    _numberOfRowsInChartDataTable++;
                                }
                                else
                                {
                                    AddNewRowToChartDataTable(zAxisFieldValue);
                                    _numberOfRowsInChartDataTable++;
                                    UpdateCellValue(zAxisFieldValue, xAxisFieldValue, sYaxisFldVal,
                                                    PropChartAggregationType);
                                }
                            }
                            else
                            {
                                if (dtSPSiteDataQueryData.Columns.Count > 5)
                                {
                                    if (
                                        SeriesExistsInChartDataTable(zAxisField.GetFieldValueAsText(dtSPSiteDataQueryData.Columns[5].ColumnName)))
                                    {
                                        UpdateCellValue(dtSPSiteDataQueryData.Columns[5].ColumnName, xAxisFieldValue,
                                                        zAxisFieldValue, PropChartAggregationType);
                                        _numberOfRowsInChartDataTable++;
                                    }
                                    else
                                    {
                                        AddNewRowToChartDataTable(dtSPSiteDataQueryData.Columns[5].ColumnName);
                                        _numberOfRowsInChartDataTable++;
                                        UpdateCellValue(dtSPSiteDataQueryData.Columns[5].ColumnName, xAxisFieldValue,
                                                        zAxisFieldValue, PropChartAggregationType);
                                    }
                                }
                                else
                                {
                                    if (dtSPSiteDataQueryData.Columns[zAxisFieldIndex].ColumnName.ToUpper() == "LIST")
                                    {
                                        if (zAxisField != null)
                                        {
                                            if (SeriesExistsInChartDataTable(zAxisField.Title))
                                            {
                                                UpdateCellValue(zAxisField.Title, xAxisFieldValue, zAxisFieldValue,
                                                                PropChartAggregationType);
                                                _numberOfRowsInChartDataTable++;
                                            }
                                            else
                                            {
                                                AddNewRowToChartDataTable(zAxisField.Title);
                                                _numberOfRowsInChartDataTable++;
                                                UpdateCellValue(zAxisField.Title, xAxisFieldValue, zAxisFieldValue,
                                                                PropChartAggregationType);
                                            }
                                        }
                                        else
                                        {
                                            if (SeriesExistsInChartDataTable("Work Type"))
                                            {
                                                UpdateCellValue("Work Type", xAxisFieldValue, zAxisFieldValue,
                                                                PropChartAggregationType);
                                                _numberOfRowsInChartDataTable++;
                                            }
                                            else
                                            {
                                                AddNewRowToChartDataTable("Work Type");
                                                _numberOfRowsInChartDataTable++;
                                                UpdateCellValue("Work Type", xAxisFieldValue, zAxisFieldValue,
                                                                PropChartAggregationType);
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        if (GetYFields().Length > 0)
                        {
                            string sSeriesName;
                            int    iStartCol;
                            if (!PropChartZaxisField.Contains("None Selected") && !IsBubbleChart())
                            {
                                iStartCol = 5;
                            }
                            else
                            {
                                iStartCol = 4;
                            }

                            SPField fldYaxis;

                            if (!IsBubbleChart())
                            {
                                for (int iSeries = iStartCol; iSeries < dtSPSiteDataQueryData.Columns.Count; iSeries++)
                                {
                                    SetGraphData(iSeries, dr, zAxisFieldValue, xAxisFieldValue);
                                }
                            }
                            else
                            {
                                SetGraphData(iStartCol, dr, zAxisFieldValue, xAxisFieldValue);
                            }
                        }
                        break;

                    default:
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                HandleException(ex);
            }
        }