Esempio n. 1
0
        public void Sort(String SortBy, SortOrderEnum SortOrder)
        {
            GenericComparer comparer = new GenericComparer();

            comparer.SortOrder    = SortOrder;
            comparer.SortProperty = SortBy;
            this.InnerList.Sort(comparer);
        }
Esempio n. 2
0
        /// <summary>
        /// Queries all structures contained in the Structures data table using a wildcard query.  The '?' and '*' wildcard characters can be used to
        /// query the structures in the function.  The '?' character will serve as a single character wildcard in the string, whereas the '*' character
        /// will serve as a wildcard for any number of characters proceeding the wildcard symbol.  If the MatchCase parameter is set to true, then
        /// the wildcard query will be case-sensitive.
        /// </summary>
        /// <param name="strExpression"></param>
        /// <param name="blMatchCase"></param>
        /// <returns></returns>
        public CHeaderDataSet.tblStructuresRow[] QueryStructsByWildcard(
            string strExpression, bool blMatchCase = false,
            SortOrderEnum sortOrder       = SortOrderEnum.Ascending,
            StructUnionEnum structOrUnion = StructUnionEnum.Both)
        {
            try
            {
                IEnumerable <CHeaderDataSet.tblStructuresRow> qryStructRows = null;
                CHeaderDataSet.tblStructuresRow[]             aryStructRows = null;

                strExpression = "^" + strExpression.Replace('?', '.').Replace("*", "\\w*") + "\\z";

                if (!blMatchCase)
                {
                    strExpression = "(?i)" + strExpression;

                    qryStructRows = StructuresTable.Where(s =>
                                                          Regex.IsMatch(s.StructName, strExpression));
                }
                else
                {
                    strExpression = "(?-i)" + strExpression;

                    qryStructRows = StructuresTable.Where(s =>
                                                          Regex.IsMatch(s.StructName, strExpression));
                }//end if

                if (structOrUnion != StructUnionEnum.Both)
                {
                    if (structOrUnion == StructUnionEnum.Structure)
                    {
                        qryStructRows = qryStructRows.Where(s => s.StructUnion == 1);
                    }
                    else
                    {
                        qryStructRows = qryStructRows.Where(s => s.StructUnion == 2);
                    }
                }//end if

                if (sortOrder == SortOrderEnum.Ascending)
                {
                    qryStructRows = qryStructRows.OrderBy(s => s.StructName);
                }
                else
                {
                    qryStructRows = qryStructRows.OrderByDescending(s => s.StructName);
                }

                aryStructRows = qryStructRows.ToArray();

                return(aryStructRows);
            }
            catch (Exception err)
            {
                ErrorHandler.ShowErrorMessage(err, "Error in QueryStructsByWildcard function of DataAccess class.");
                return(null);
            }
        }
Esempio n. 3
0
        private void Sort(SortOrderEnum sortOrder)
        {
            var control = FindParent <CodeViewUserControl>(this);

            control.CodeDocumentViewModel.SortOrder    = sortOrder;
            control.CodeDocumentViewModel.CodeDocument = SortHelper.Sort(control.CodeDocumentViewModel);
            Settings.Default.SortOrder = sortOrder;
            Settings.Default.Save();
        }
Esempio n. 4
0
 public override System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> ReadFields(System.IO.BinaryReader binaryReader)
 {
     System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> pointerQueue = new System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer>(base.ReadFields(binaryReader));
     this.RegionName    = binaryReader.ReadStringID();
     this.fieldpad      = binaryReader.ReadBytes(1);
     this.fieldpad0     = binaryReader.ReadBytes(1);
     this.ParentVariant = binaryReader.ReadShortBlockIndex1();
     pointerQueue.Enqueue(binaryReader.ReadBlamPointer(32));
     this.SortOrder = ((SortOrderEnum)(binaryReader.ReadInt16()));
     this.fieldpad1 = binaryReader.ReadBytes(2);
     return(pointerQueue);
 }
Esempio n. 5
0
        /// <summary>
        /// Sort by a property.
        /// </summary>
        /// <param name="propertyName">Name of the property.</param>
        /// <param name="sortDir">Direction of sorting.</param>
        /// <returns>Current instance</returns>
        public IQueryConstraints <T> SortBy(string propertyName, SortOrderEnum sortDir)
        {
            if (string.IsNullOrEmpty(propertyName))
            {
                return(this);
            }

            ValidatePropertyName(propertyName);

            sortOrder.Add(new SortOrderEntry(sortDir, propertyName));

            return(this);
        }
Esempio n. 6
0
        public FilteredCountries GetCountries(int first, int rows, string sortField,
                                              SortOrderEnum sortOrder, Dictionary <string, string> filters)
        {
            var countryList = _context.Countries.ToList();

            if (filters != null)
            {
                string value = string.Empty;
                if (filters.ContainsKey("Capital"))
                {
                    filters.TryGetValue("Capital", out value);
                    countryList = countryList.Where(n => n.Capital.Contains(value)).ToList();
                }
                if (filters.ContainsKey("Name"))
                {
                    filters.TryGetValue("Name", out value);
                    countryList = countryList.Where(n => n.Name.Contains(value)).ToList();
                }
                if (filters.ContainsKey("Region"))
                {
                    filters.TryGetValue("Region", out value);
                    countryList = countryList.Where(n => n.Region.Contains(value)).ToList();
                }
            }
            var totalRows = countryList.Count();

            switch (sortField)
            {
            case "Capital":
                countryList = sortOrder == SortOrderEnum.ASC ? countryList.OrderBy(n => n.Capital).Skip(first).Take(rows).ToList() :
                              countryList.OrderByDescending(n => n.Capital).Skip(first).Take(rows).ToList();
                break;

            case "Name":
                countryList = sortOrder == SortOrderEnum.ASC ? countryList.OrderBy(n => n.Name).Skip(first).Take(rows).ToList() :
                              countryList.OrderByDescending(n => n.Name).Skip(first).Take(rows).ToList();
                break;

            default:
                countryList = sortOrder == SortOrderEnum.ASC ? countryList.OrderBy(n => n.Id).Skip(first).Take(rows).ToList() :
                              countryList.OrderByDescending(n => n.Id).Skip(first).Take(rows).ToList();
                break;
            }

            var countries = new FilteredCountries()
            {
                Countries = countryList.ToList(), TotalCountries = totalRows
            };

            return(countries);
        }
Esempio n. 7
0
        public static List <CodeItem> Sort(List <CodeItem> document, SortOrderEnum sortOrder)
        {
            switch (sortOrder)
            {
            case SortOrderEnum.SortByFile:
                return(SortByFile(document));

            case SortOrderEnum.SortByName:
                return(SortByName(document));

            default:
                return(document);
            }
        }
Esempio n. 8
0
        public void SortList()
        {
            SortOrderEnum       sortOrder = SortOrder;
            List <BoundingRect> result    = new List <BoundingRect>();

            if (BrList == null)
            {
                return;
            }
            if (BrList.Count < 2)
            {
                return;
            }
            if (sortOrder == SortOrderEnum.UpperLeft)
            {
                var x = from b in BrList
                        orderby b.OriginalUpperLeftY, b.OriginalUpperLeftX
                select b;
                result = x.ToList <BoundingRect>();
            }
            if (sortOrder == SortOrderEnum.CentroidLocation)
            {
                var x = from b in BrList
                        orderby b.CentroidX, b.CentroidY
                select b;
                result = x.ToList <BoundingRect>();
            }
            if (sortOrder == SortOrderEnum.RelativeBrightness)
            {
                var x = from b in BrList
                        orderby b.RelativeBrightness descending
                        select b;
                result = x.ToList <BoundingRect>();
            }
            if (sortOrder == SortOrderEnum.AbsoluteBrightness)
            {
                var x = from b in BrList
                        orderby b.AbsoluteBrightness descending
                        select b;
                result = x.ToList <BoundingRect>();
            }
            if (sortOrder == SortOrderEnum.Volume)
            {
                var x = from b in BrList
                        orderby b.Volume descending
                        select b;
                result = x.ToList <BoundingRect>();
            }
            BrList = result;
        }
Esempio n. 9
0
        static public string _GetSortMethodName(SortOrderEnum order)
        {
            switch (order)
            {
            case SortOrderEnum.Asc:
                return("OrderBy");

            case SortOrderEnum.Desc:
                return("OrderByDescending");

            default:
                throw new InvalidOperationException("Uknown sorting order = {0}".Form(order));
            }
        }
Esempio n. 10
0
        /// <summary>
        /// Queries all structures from the Structure data table contained in the linked HeaderData data set that are within a specified range of data sizes.
        /// The structure rows will be queried and sorted in ascending or descending order.  This function can be used to query either sets of structures or unions.
        /// </summary>
        /// <param name="iMinSize"></param>
        /// <param name="iMaxSize"></param>
        /// <param name="sortOrder"></param>
        /// <param name="structOrUnion"></param>
        /// <returns></returns>
        public CHeaderDataSet.tblStructuresRow[] QueryStructsBySize(int iMinSize, int iMaxSize    = -1,
                                                                    SortOrderEnum sortOrder       = SortOrderEnum.Ascending,
                                                                    StructUnionEnum structOrUnion = StructUnionEnum.Structure)
        {
            try
            {
                if (iMaxSize == -1)
                {
                    iMaxSize = Int32.MaxValue;
                }

                IEnumerable <CHeaderDataSet.tblStructuresRow> qryStructRows = null;
                CHeaderDataSet.tblStructuresRow[]             aryStructRows = null;

                qryStructRows = StructuresTable.Where(s => s.DataSize >= iMinSize && s.DataSize <= iMaxSize);

                if (structOrUnion != StructUnionEnum.Both)
                {
                    if (structOrUnion == StructUnionEnum.Structure)
                    {
                        qryStructRows = qryStructRows.Where(s => s.StructUnion == 1);
                    }
                    else
                    {
                        qryStructRows = qryStructRows.Where(s => s.StructUnion == 2);
                    }
                }//end if

                if (sortOrder == SortOrderEnum.Ascending)
                {
                    qryStructRows = qryStructRows.OrderBy(s => s.DataSize);
                }
                else
                {
                    qryStructRows = qryStructRows.OrderByDescending(s => s.DataSize);
                }

                aryStructRows = qryStructRows.ToArray();

                return(aryStructRows);
            }
            catch (Exception err)
            {
                ErrorHandler.ShowErrorMessage(err, "Error in QueryStructsBySize function of DataAccess class.");

                return(null);
            }
        }
Esempio n. 11
0
        public void ItemsSorting(SortOrderEnum sortOrder, string[] methodNames)
        {
            var document  = SyntaxMapper.MapDocument(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\Files\\TestSorting.cs"));
            var viewModel = new CodeDocumentViewModel {
                CodeDocument = document, SortOrder = sortOrder
            };

            viewModel.CodeDocument = SortHelper.Sort(viewModel);

            var sortingClass = (document.First() as IMembers).Members.First() as CodeClassItem;

            Assert.AreEqual(methodNames[0], sortingClass.Members.First().Name);
            Assert.AreEqual(methodNames[1], sortingClass.Members[1].Name);
            Assert.AreEqual(methodNames[2], sortingClass.Members.Last().Name);

            Assert.AreEqual(sortOrder, viewModel.SortOrder);
        }
Esempio n. 12
0
        /// <summary>
        /// Queries all structures contained in the Structures data table using a regular expression query.  The results will match exactly to criteria
        /// specified in the regular expression and will be case and space sensitive.
        /// </summary>
        /// <param name="strRegex"></param>
        /// <returns></returns>
        public CHeaderDataSet.tblStructuresRow[] QueryStructsByRegex(string strRegex,
                                                                     SortOrderEnum sortOrder       = SortOrderEnum.Ascending,
                                                                     StructUnionEnum structOrUnion = StructUnionEnum.Both)
        {
            try
            {
                IEnumerable <CHeaderDataSet.tblStructuresRow> qryStructRows = null;
                CHeaderDataSet.tblStructuresRow[]             aryStructRows = null;

                qryStructRows = StructuresTable.Where(s => Regex.IsMatch(s.StructName, strRegex));

                if (structOrUnion != StructUnionEnum.Both)
                {
                    if (structOrUnion == StructUnionEnum.Structure)
                    {
                        qryStructRows = qryStructRows.Where(s => s.StructUnion == 1);
                    }
                    else
                    {
                        qryStructRows = qryStructRows.Where(s => s.StructUnion == 2);
                    }
                }//end if

                if (sortOrder == SortOrderEnum.Ascending)
                {
                    qryStructRows = qryStructRows.OrderBy(s => s.StructName);
                }
                else
                {
                    qryStructRows = qryStructRows.OrderByDescending(s => s.StructName);
                }

                aryStructRows = qryStructRows.ToArray();

                return(aryStructRows);
            }
            catch (Exception err)
            {
                ErrorHandler.ShowErrorMessage(err, "Error in QueryStructsByRegex function of DataAccess class.");
                return(null);
            }
        }
Esempio n. 13
0
        public WorkOrderButton(Guid id, List <string> workOrderAttribute, bool highlight, bool showCaption, int sortSequence, SortOrderEnum sortOrder, bool hideOnButton)
        {
            if (id == default(Guid))
            {
                throw Error.Argument(string.Format("{0} can't be default guid.", nameof(id)));
            }

            if (workOrderAttribute == null)
            {
                throw Error.ArgumentNull(string.Format("{0} can't be empty.", nameof(workOrderAttribute)));
            }

            Id = id;
            WorkOrderAttribute = workOrderAttribute;
            Highlight          = highlight;
            ShowCaption        = showCaption;
            SortSequence       = sortSequence;
            SortOrder          = sortOrder;
            HideOnButton       = hideOnButton;
        }
Esempio n. 14
0
        /// <summary>
        /// This is used to retrieve a page of product records.
        /// </summary>
        /// <returns></returns>
        public async Task <IEnumerable <ProductModel> > GetProductsWithPagingAsync(int firstRecordNumber, int pageSize,
                                                                                   string sortField,
                                                                                   SortOrderEnum sortOrder)
        {
            var response = await this._connectionFactory.GetConnection(async c =>
            {
                IEnumerable <ProductModel> productModels = null;

                var p = new DynamicParameters();

                p.Add("FirstRecordNumber", firstRecordNumber, DbType.Int32);
                p.Add("PageSize", pageSize, DbType.Int32);
                p.Add("SortField", sortField, DbType.String);
                p.Add("SortOrder", (int)sortOrder, DbType.Int32);

                productModels = await c.QueryAsync <ProductModel>(sql: "[CISPlus].[USP_CISBIS_ProdComp_GetALLProductsWithPaging]", param: p, commandType: CommandType.StoredProcedure);
                return(productModels);
            });

            return(response);
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="OrderBySpec" /> class.
        /// </summary>
        /// <param name="key">The key that uniquely identifies a queryable address in Lusid. (required).</param>
        /// <param name="sortOrder">The available values are: Ascending, Descending (required).</param>
        public OrderBySpec(string key = default(string), SortOrderEnum sortOrder = default(SortOrderEnum))
        {
            // to ensure "key" is required (not null)
            if (key == null)
            {
                throw new InvalidDataException("key is a required property for OrderBySpec and cannot be null");
            }
            else
            {
                this.Key = key;
            }

            // to ensure "sortOrder" is required (not null)
            if (sortOrder == null)
            {
                throw new InvalidDataException("sortOrder is a required property for OrderBySpec and cannot be null");
            }
            else
            {
                this.SortOrder = sortOrder;
            }
        }
Esempio n. 16
0
        /// <summary>
        /// This is used to retrieve a page of product records.
        /// </summary>
        /// <returns></returns>
        public async Task <IEnumerable <ProductModel> > GetProductsWithPagingAsync(int firstRecordNumber,
                                                                                   int pageSize,
                                                                                   string sortField,
                                                                                   SortOrderEnum sortOrder)
        {
            if (true == string.IsNullOrEmpty(sortField) ||
                true == string.Equals(sortField, "undefined", StringComparison.OrdinalIgnoreCase))
            {
                sortField = "description";
            }

            if (SortOrderEnum.Asc != sortOrder && SortOrderEnum.Desc != sortOrder)
            {
                sortOrder = SortOrderEnum.Asc;
            }

            var response = await this._productRepository
                           .GetProductsWithPagingAsync(firstRecordNumber,
                                                       pageSize,
                                                       sortField,
                                                       sortOrder);

            return(response);
        }
Esempio n. 17
0
        private void AlternatingSortByField(List <HRMISModel.Employee> employees, HRMISModel.Employee.EmployeeSortField employeeSortField,
                                            int columnNum, string columnTitle, SortOrderEnum defaultSortOrder)
        {
            SortOrderEnum sortOrder;

            if (ViewState[employeeSortField.ToString()] != null)
            {
                sortOrder = ViewState[employeeSortField.ToString()].ToString() == SortOrderEnum.Descending.ToString()
                                ? SortOrderEnum.Ascending
                                : SortOrderEnum.Descending;
            }
            else
            {
                sortOrder = defaultSortOrder.ToString() == SortOrderEnum.Descending.ToString()
                                ? SortOrderEnum.Descending
                                : SortOrderEnum.Ascending;
            }
            if (sortOrder == SortOrderEnum.Descending)
            {
                //倒序
                gvMonthAttendanceList.Columns[columnNum].HeaderText = columnTitle +
                                                                      "<img src='../../image/down.gif' border='0'/>";
                ViewState[employeeSortField.ToString()] = SortOrderEnum.Descending.ToString();
                SortBase.InsertionSort(employees,
                                       new EmployeeComparer(employeeSortField, SortOrderEnum.Descending).Compare);
            }
            else
            {
                //正序
                gvMonthAttendanceList.Columns[columnNum].HeaderText = columnTitle +
                                                                      "<img src='../../image/up.gif' border='0'/>";
                ViewState[employeeSortField.ToString()] = SortOrderEnum.Ascending.ToString();
                SortBase.InsertionSort(employees,
                                       new EmployeeComparer(employeeSortField, SortOrderEnum.Ascending).Compare);
            }
        }
Esempio n. 18
0
 private void Initialize()
 {
     this.fldHorizontallAlignment = StringAlignment.Center;
     this.fldVerticalAlignment = StringAlignment.Center;
     this.fldFormat = String.Empty;
     this._sortOrder = SortOrderEnum.Unsorted;
     this._displayZeroValue = true;
 }
Esempio n. 19
0
 public OrderListRequest SortByCreatedAt(SortOrderEnum order)
 {
     _params.AddOpt("sort_by[" + order.ToString().ToLower() + "]", "created_at");
     return(this);
 }
Esempio n. 20
0
 /// <summary>
 /// 员工排序构造函数
 /// </summary>
 /// <param name="field"></param>
 /// <param name="order"></param>
 public EmployeeComparer(Employee.EmployeeSortField field, SortOrderEnum order)
 {
     Field = field;
     Order = order;
 }
        private void Page_Load(object sender, System.EventArgs e)
        {
            string Language = "en-US";

            if (Request.UserLanguages.Length != 0)
            {
                Language = Request.UserLanguages[0];
            }

            CurrentUserCulture = System.Globalization.CultureInfo.CreateSpecificCulture(Language);

            if (ConfigurationSettings.AppSettings["OlymarsDemo ConnectionString"] != null)
            {
                ConnectionString = ConfigurationSettings.AppSettings["OlymarsDemo ConnectionString"];
            }
            else if (Application["ConnectionString"] != null)
            {
                ConnectionString = Application["ConnectionString"].ToString().Trim();
            }

            if (!Page.IsPostBack)
            {
                // Any sort preferences?
                CurrentSortEnum sortColumn = CurrentSortEnum.SortBy_Cat_StrName;
                if (Request.Params["SortBy"] != String.Empty)
                {
                    try {
                        sortColumn = (CurrentSortEnum)Enum.Parse(typeof(CurrentSortEnum), "SortBy_" + Request.Params["SortBy"]);
                    }

                    catch {
                        // Ignore the parameter and do nothing here
                    }
                }

                SortOrderEnum sortOrder = SortOrderEnum.Ascending;
                if (Request.Params["SortOrder"] != String.Empty)
                {
                    try {
                        sortOrder = (SortOrderEnum)Enum.Parse(typeof(SortOrderEnum), Request.Params["SortOrder"]);
                    }

                    catch {
                        // Ignore the parameter and do nothing here
                    }
                }

                if (ViewState["WebFormList_tblCategory_CurrentSort"] == null)
                {
                    ViewState.Add("WebFormList_tblCategory_CurrentSort", sortColumn);
                }
                else
                {
                    ViewState["WebFormList_tblCategory_CurrentSort"] = sortColumn;
                }

                if (ViewState["sortOrder"] == null)
                {
                    ViewState.Add("sortOrder", sortOrder);
                }
                else
                {
                    ViewState["sortOrder"] = sortOrder;
                }
            }

            repeater_tblCategory_SelectDisplay.EnableViewState = true;

            RefreshList();
        }
Esempio n. 22
0
 public BoundingRectList()
 {
     BrList    = new List <BoundingRect>();
     SortOrder = SortOrderEnum.UpperLeft;
 }
Esempio n. 23
0
        private void Page_Load(object sender, System.EventArgs e)
        {
            string Language = "en-US";

            if (Request.UserLanguages.Length != 0)
            {
                Language = Request.UserLanguages[0];
            }

            CurrentUserCulture = System.Globalization.CultureInfo.CreateSpecificCulture(Language);

            if (ConfigurationSettings.AppSettings["OlymarsDemo ConnectionString"] != null)
            {
                ConnectionString = ConfigurationSettings.AppSettings["OlymarsDemo ConnectionString"];
            }
            else if (Application["ConnectionString"] != null)
            {
                ConnectionString = Application["ConnectionString"].ToString().Trim();
            }

            if (!Page.IsPostBack)
            {
                // com_Pro_LngCategoryID
                System.Data.SqlTypes.SqlInt32 colPro_LngCategoryID = System.Data.SqlTypes.SqlInt32.Null;
                if (Request.Params["Pro_LngCategoryID"] != String.Empty)
                {
                    try {
                        colPro_LngCategoryID = System.Data.SqlTypes.SqlInt32.Parse(Request.Params["Pro_LngCategoryID"]);
                    }
                    catch {
                        // Ignore the parameter and do nothing here
                    }
                }
                com_Pro_LngCategoryID.Initialize(ConnectionString);
                try {
                    com_Pro_LngCategoryID.RefreshData(colPro_LngCategoryID);
                }
                catch (OlymarsDemo.DataClasses.CustomException customException) {
                    if (customException.Parameter.SqlException != null)
                    {
                        throw new Exception(String.Format("An exception has been thrown in the underlying DataClass that is used by the 'WebDropDownList_tblCategory' class. Exception message is: {0}", customException.Parameter.SqlException.Message), customException);
                    }
                    else if (customException.Parameter.OtherException != null)
                    {
                        throw new Exception(String.Format("An exception has been thrown in the underlying DataClass that is used by the 'WebDropDownList_tblCategory' class. Exception message is: {0}", customException.Parameter.OtherException.Message), customException);
                    }
                    else
                    {
                        throw;
                    }
                }
                com_Pro_LngCategoryID.Items.Insert(0, "Show all");

                // Any sort preferences?
                CurrentSortEnum sortColumn = CurrentSortEnum.SortBy_Pro_StrName;
                if (Request.Params["SortBy"] != String.Empty)
                {
                    try {
                        sortColumn = (CurrentSortEnum)Enum.Parse(typeof(CurrentSortEnum), "SortBy_" + Request.Params["SortBy"]);
                    }

                    catch {
                        // Ignore the parameter and do nothing here
                    }
                }

                SortOrderEnum sortOrder = SortOrderEnum.Ascending;
                if (Request.Params["SortOrder"] != String.Empty)
                {
                    try {
                        sortOrder = (SortOrderEnum)Enum.Parse(typeof(SortOrderEnum), Request.Params["SortOrder"]);
                    }

                    catch {
                        // Ignore the parameter and do nothing here
                    }
                }

                if (ViewState["WebFormList_tblProduct_CurrentSort"] == null)
                {
                    ViewState.Add("WebFormList_tblProduct_CurrentSort", sortColumn);
                }
                else
                {
                    ViewState["WebFormList_tblProduct_CurrentSort"] = sortColumn;
                }

                if (ViewState["sortOrder"] == null)
                {
                    ViewState.Add("sortOrder", sortOrder);
                }
                else
                {
                    ViewState["sortOrder"] = sortOrder;
                }
            }

            repeater_tblProduct_SelectDisplay.EnableViewState = true;

            RefreshList();
        }
Esempio n. 24
0
 /// <summary>
 /// Reset this column to its default values.
 /// </summary>
 public void Reset()
 {
     this._sortOrder = SortOrderEnum.Ascending;
 }
Esempio n. 25
0
 /// <summary>
 /// Initializes a new instance of the <see cref="OrderBySpec" /> class.
 /// </summary>
 /// <param name="key">The key that uniquely identifies a queryable address in Lusid. (required).</param>
 /// <param name="sortOrder">The available values are: Ascending, Descending (required).</param>
 public OrderBySpec(string key = default(string), SortOrderEnum sortOrder = default(SortOrderEnum))
 {
     // to ensure "key" is required (not null)
     this.Key       = key ?? throw new ArgumentNullException("key is a required property for OrderBySpec and cannot be null");
     this.SortOrder = sortOrder;
 }
Esempio n. 26
0
 /// <summary>
 /// Initializes new instance of <see cref="SortOrderEntry"/>.
 /// </summary>
 /// <param name="sortOrder">kind of sort order.</param>
 /// <param name="sortPropertyName">property to sort by.</param>
 public SortOrderEntry(SortOrderEnum sortOrder, string sortPropertyName)
 {
     this.SortOrder        = sortOrder;
     this.SortPropertyName = sortPropertyName;
 }
Esempio n. 27
0
 public TransactionListRequest SortByDate(SortOrderEnum order)
 {
     _params.AddOpt("sort_by[" + order.ToString().ToLower() + "]", "date");
     return(this);
 }
Esempio n. 28
0
 public CreditNoteListRequest SortByDate(SortOrderEnum order)
 {
     m_params.AddOpt("sort_by[" + order.ToString().ToLower() + "]", "date");
     return(this);
 }
Esempio n. 29
0
 /// <summary>
 /// Toggle the sort order of this column between ascending and descending.
 /// </summary>
 /// <returns>The new sort order for this column</returns>
 public SortOrderEnum SwitchSortOrder()
 {
     this._sortOrder = (this._sortOrder == SortOrderEnum.Ascending) ? SortOrderEnum.Descending : SortOrderEnum.Ascending;
     return this._sortOrder;
 }
Esempio n. 30
0
 public TransactionListRequest SortByUpdatedAt(SortOrderEnum order)
 {
     m_params.AddOpt("sort_by[" + order.ToString().ToLower() + "]", "updated_at");
     return(this);
 }
Esempio n. 31
0
 public ItemListRequest SortById(SortOrderEnum order)
 {
     m_params.AddOpt("sort_by[" + order.ToString().ToLower() + "]", "id");
     return(this);
 }
Esempio n. 32
0
 public EventListRequest SortByOccurredAt(SortOrderEnum order)
 {
     _params.AddOpt("sort_by[" + order.ToString().ToLower() + "]", "occurred_at");
     return(this);
 }
Esempio n. 33
0
 public ActiveGridItemComparer()
 {
     this._col = 0;
     this._sortOrder = SortOrderEnum.Ascending;
 }
Esempio n. 34
0
 public UsageListRequest SortByUsageDate(SortOrderEnum order)
 {
     m_params.AddOpt("sort_by[" + order.ToString().ToLower() + "]", "usage_date");
     return(this);
 }
Esempio n. 35
0
 public ActiveGridItemComparer(ActiveColumnHeader columnHeader)
 {
     this._columnHeader = columnHeader;
     this._sortOrder = columnHeader.SortOrder;
     this._col = columnHeader.Index;
 }