예제 #1
0
        protected void rgSearchResults_SortCommand(object sender, GridSortCommandEventArgs e)
        {
            OrgChartSearchResultCollection searchresults = GetSearchResults();

            enumSortDirection sortdirection = enumSortDirection.ASC;

            if (e.SortExpression == SortExpression)
            {
                if (SortDirection == enumSortDirection.undefined || SortDirection == enumSortDirection.DESC)
                {
                    sortdirection = enumSortDirection.ASC;
                    SortDirection = enumSortDirection.ASC;
                }
                else
                {
                    sortdirection = enumSortDirection.DESC;
                    SortDirection = enumSortDirection.DESC;
                }
            }
            else
            {
                SortDirection = enumSortDirection.ASC;
            }

            SortExpression = e.SortExpression;

            switch (e.SortExpression)
            {
            case "OrganizationChartID":
                searchresults.OrderBy(enumOrgChartResultSortField.OrganizationChartID, sortdirection);
                break;

            case "Region":
                // searchresults.Sort(delegate(OrgChartSearchResult result1, OrgChartSearchResult result2)
                // {
                //     return result1.ChartEntity.OrgCode.RegionID.CompareTo(result2.ChartEntity.OrgCode.RegionID);
                // }
                //);
                searchresults.OrderBy(enumOrgChartResultSortField.Region, sortdirection);
                break;

            case "OrganizationCode":
                searchresults.OrderBy(enumOrgChartResultSortField.OrganizationCode, sortdirection);
                break;

            case "CreatedByFNR":
                searchresults.OrderBy(enumOrgChartResultSortField.CreatedByFNR, sortdirection);
                break;

            case "CreateDate":
                searchresults.OrderBy(enumOrgChartResultSortField.CreateDate, sortdirection);
                break;

            case "UpdatedByFNR":
                searchresults.OrderBy(enumOrgChartResultSortField.UpdatedByFNR, sortdirection);
                break;

            case "UpdateDate":
                searchresults.OrderBy(enumOrgChartResultSortField.UpdateDate, sortdirection);
                break;

            case "StatusID":
                searchresults.OrderBy(enumOrgChartResultSortField.WorkflowStatus, sortdirection);
                break;

            case "ChartType":
                searchresults.OrderBy(enumOrgChartResultSortField.ChartType, sortdirection);
                break;

            default:
                break;
            }
            //SearchResults = searchresults;
            //e.Item.OwnerTableView.DataSource = searchresults;

            //e.Item.OwnerTableView.Rebind();
            rgSearchResults.DataSource = searchresults;
            rgSearchResults.DataBind();
            e.Canceled = true;
        }
예제 #2
0
        public void OrderBy(enumOrgChartResultSortField field, enumSortDirection sortdirection)
        {
            switch (field)
            {
            case enumOrgChartResultSortField.Undefined:
                break;

            case enumOrgChartResultSortField.OrganizationChartID:
                if (sortdirection == enumSortDirection.DESC)
                {
                    this.Sort(OrderByOrgChartIDDesc);
                }
                else
                {
                    this.Sort(OrderByOrgChartID);
                }
                break;

            case enumOrgChartResultSortField.Region:
                if (sortdirection == enumSortDirection.DESC)
                {
                    this.Sort(OrderByRegionDesc);
                }
                else
                {
                    this.Sort(OrderByRegion);
                }
                break;

            case enumOrgChartResultSortField.OrganizationCode:
                if (sortdirection == enumSortDirection.DESC)
                {
                    this.Sort(OrderByOrganizationCodeDesc);
                }
                else
                {
                    this.Sort(OrderByOrganizationCode);
                }
                break;

            case enumOrgChartResultSortField.CreatedByFNR:
                if (sortdirection == enumSortDirection.DESC)
                {
                    this.Sort(OrderByCreatedByFNRDesc);
                }
                else
                {
                    this.Sort(OrderByCreatedByFNR);
                }
                break;

            case enumOrgChartResultSortField.CreateDate:
                if (sortdirection == enumSortDirection.DESC)
                {
                    this.Sort(OrderByCreateDateDesc);
                }
                else
                {
                    this.Sort(OrderByCreateDate);
                }
                break;

            case enumOrgChartResultSortField.UpdatedByFNR:
                if (sortdirection == enumSortDirection.DESC)
                {
                    this.Sort(OrderByUpdatedByFNRDesc);
                }
                else
                {
                    this.Sort(OrderByUpdatedByFNR);
                }
                break;

            case enumOrgChartResultSortField.UpdateDate:
                if (sortdirection == enumSortDirection.DESC)
                {
                    this.Sort(OrderByUpdateDateDesc);
                }
                else
                {
                    this.Sort(OrderByUpdateDate);
                }
                break;

            case enumOrgChartResultSortField.WorkflowStatus:
                if (sortdirection == enumSortDirection.DESC)
                {
                    this.Sort(OrderByOrgChartStatusIDDesc);
                }
                else
                {
                    this.Sort(OrderByOrgChartStatusID);
                }
                break;

            case enumOrgChartResultSortField.ChartType:
                if (sortdirection == enumSortDirection.DESC)
                {
                    this.Sort(OrderByOrgChartTypeDESC);
                }
                else
                {
                    this.Sort(OrderByOrgChartType);
                }
                break;

            default:
                break;
            }
        }