private void createFilteredList(string search)
{
//generate objects to be layed out in the panel
List <GameObject> knownSkills = SkillLibrary.Instance.getByListID(PlayerMotivator.Instance.getSkillBook());
skillList = new List <GameObject>();
OrderEnum pri = PlayerMotivator.Instance.GetPrimaryOrderEnum();
OrderEnum sec = PlayerMotivator.Instance.GetSecondaryOrderEnum();
foreach (GameObject skill in knownSkills)
{
BaseSkill component = skill.GetComponent <BaseSkill>();
// make sure that it has a baseSkill component, just in case
if (component != null)
{
OrderEnum skillOrder = component.getOrder();
// and check if the object is of the right order, then add it to the list
if (skillOrder == pri || skillOrder == sec || skillOrder == OrderEnum.none)
{
// Gets the name and searches it for any instances of the search string
if (component.getName().ToLower().Contains(search.ToLower()))
{
skillList.Add(skill);
}
}
}
}
}
private IQueryable <UserGroup> ApplyOrder(IQueryable <UserGroup> queryUserGroups,
GroupFieldEnum orderField, OrderEnum order)
{
switch (orderField)
{
case GroupFieldEnum.name:
if (order == OrderEnum.Ascending)
{
queryUserGroups = queryUserGroups.OrderBy(x => x.name);
}
else
{
queryUserGroups = queryUserGroups.OrderByDescending(x => x.name);
}
break;
case GroupFieldEnum.description:
if (order == OrderEnum.Ascending)
{
queryUserGroups = queryUserGroups.OrderBy(x => x.description);
}
else
{
queryUserGroups = queryUserGroups.OrderByDescending(x => x.description);
}
break;
default:
queryUserGroups = queryUserGroups.OrderBy(x => x.name);
break;
}
return(queryUserGroups);
}
public bool BinaryContains(Document document, OrderEnum listOrder)
{
bool returnValue = false;
switch (listOrder)
{
case OrderEnum.IDOrder:
if (BinarySearch(document, OrderEnum.IDOrder) > 0)
{
returnValue = true;
}
break;
case OrderEnum.TitleOrder:
if (BinarySearch(document, OrderEnum.TitleOrder) > 0)
{
returnValue = true;
}
break;
case OrderEnum.MatchOrder:
if (BinarySearch(document, OrderEnum.MatchOrder) > 0)
{
returnValue = true;
}
break;
}
return(returnValue);
}
public static bool MenuAction(OrderEnum option, bool exit)
{
var list = new List<Employee>();
switch (option)
{
case OrderEnum.A:
list = service.TakeListAndOrder(x => x.LastName).Result;
PrintList(list);
break;
case OrderEnum.N:
list = service.TakeListAndOrder(x => x.FirstName).Result;
PrintList(list);
break;
case OrderEnum.P:
list = service.TakeListAndOrder(x => x.Position).Result;
PrintList(list);
break;
case OrderEnum.F:
list = service.TakeListAndOrder(x => x.SeparationDate).Result;
PrintList(list);
break;
case OrderEnum.S:
exit = true;
break;
default:
break;
}
return exit;
}
public bool Equals(OrderEnum obj)
{
if ((object)obj == null)
{
return(false);
}
return(StringComparer.OrdinalIgnoreCase.Equals(this.Value, obj.Value));
}
public OrderProcessor(OrderEnum order, IRuleCommandFacotry ruleCommandFacotry, bool isContinueOnFail)
{
RuleCommandFacotry = ruleCommandFacotry
?? throw new NullReferenceException("Rule command facotry should not be null");
Order = order;
IsContinueOnFail = isContinueOnFail;
Console.WriteLine($"Order processor created for {Order.ToString()}");
}
public static string ToExplain(this OrderEnum that)
{
switch (that)
{
case OrderEnum.Asc: return("ASC");
case OrderEnum.Desc: return("DESC");
}
return("");
}
private IQueryable <Product> ApplyOrder(IQueryable <Product> queryProducts,
ProductFields orderField, OrderEnum order)
{
switch (orderField)
{
case ProductFields.productCode:
if (order == OrderEnum.Ascending)
{
queryProducts = queryProducts.OrderBy(x => x.productCode);
}
else
{
queryProducts = queryProducts.OrderByDescending(x => x.productCode);
}
break;
case ProductFields.productDescription:
if (order == OrderEnum.Ascending)
{
queryProducts = queryProducts.OrderBy(x => x.productDescription);
}
else
{
queryProducts = queryProducts.OrderByDescending(x => x.productDescription);
}
break;
case ProductFields.productGTIN:
if (order == OrderEnum.Ascending)
{
queryProducts = queryProducts.OrderBy(x => x.productGTIN);
}
else
{
queryProducts = queryProducts.OrderByDescending(x => x.productGTIN);
}
break;
case ProductFields.productName:
if (order == OrderEnum.Ascending)
{
queryProducts = queryProducts.OrderBy(x => x.productName);
}
else
{
queryProducts = queryProducts.OrderByDescending(x => x.productName);
}
break;
default:
queryProducts = queryProducts.OrderBy(x => x.productId);
break;
}
return(queryProducts);
}
public void MergeSort(OrderEnum listOrder)
{
switch (listOrder)
{
case OrderEnum.IDOrder: this.MergeSort(); break;
case OrderEnum.TitleOrder: this.MergeSort(Document.CompareTitles); break;
case OrderEnum.MatchOrder: this.MergeSort(Document.CompareMatches); break;
}
}
public void TestWhere5()
{
var repository = new Repository <DictInfo>(Conn);
OrderEnum orderEnum = OrderEnum.optionA;
var rst = repository.Where(x => x.OrderNum == orderEnum);
Assert.NotEmpty(rst);
foreach (var item in rst)
{
Assert.Equal(OrderEnum.optionA, item.OrderNum);
}
}
public void TestWhere7()
{
var repository = new Repository <DictInfo2>(Conn);
OrderEnum orderEnum = OrderEnum.optionA;
var rst = repository.Where(x => x.OrderNum == orderEnum);
Assert.AreNotEqual(0, rst.Count);
foreach (var item in rst)
{
Assert.AreEqual(OrderEnum.optionA, item.OrderNum);
}
}
public SortHolder CreateSortQuery(string sort, OrderEnum order)
{
return(new SortHolder(
new List <ISort>
{
new SortStandard(sort)
{
Order = order
}
}
));
}
/// <summary>
/// 生成单号
/// </summary>
/// <param name="orderEnum">单号类型</param>
/// <param name="CompanyID">企业ID</param>
/// <returns></returns>
public static string Generator(OrderEnum orderEnum, int CompanyID)
{
switch (orderEnum)
{
case OrderEnum.OWR:
return(OWRGenerator.CreateNo(CompanyID));
case OrderEnum.OWS:
return(OWSGenerator.CreateNo(CompanyID));
case OrderEnum.IC:
return(ICGenerator.CreateNo(CompanyID));
case OrderEnum.IS:
return(ISGenerator.CreateNo(CompanyID));
case OrderEnum.IR:
return(IRGenerator.CreateNo(CompanyID));
case OrderEnum.SOWR:
return(SOWRGenerator.CreateNo(CompanyID));
case OrderEnum.SO:
return(SOGenerator.CreateNo(CompanyID));
case OrderEnum.PO:
return(POGenerator.CreateNo(CompanyID));
case OrderEnum.WO:
return(WOGenerator.CreateNo(CompanyID));
case OrderEnum.MO:
return(MOGenerator.CreateNo(CompanyID));
case OrderEnum.PMR:
return(PMRGenerator.CreateNo(CompanyID));
case OrderEnum.PDR:
return(PDRGenerator.CreateNo(CompanyID));
case OrderEnum.PR:
return(PRGenerator.CreateNo(CompanyID));
case OrderEnum.MR:
return(MRGenerator.CreateNo(CompanyID));
case OrderEnum.PDC:
return(PDCGenerator.CreateNo(CompanyID));
default:
return("");
}
}
public async Task <(List <Recipe>, int)> getRecipes(int startat, int quantity, List <string> fields,
RecipeFields orderField, OrderEnum order)
{
var recipesQuery = _context.Recipes.AsQueryable();
recipesQuery = ApplyMultifilter(recipesQuery, fields);
recipesQuery = ApplyOrder(recipesQuery, orderField, order);
var recipesId = await recipesQuery
.Skip(startat).Take(quantity)
.Select(x => x.recipeId)
.ToListAsync();
var queryCount = _context.Recipes.AsQueryable();
queryCount = ApplyMultifilter(recipesQuery, fields);
queryCount = ApplyOrder(queryCount, orderField, order);
var totalCount = queryCount.Count();
List <Recipe> recipes = new List <Recipe> ();
foreach (var item in recipesId)
{
var recipe = await getRecipe(item);
if (recipe != null)
{
if (recipe.recipeTypeId != null)
{
var recipeType = await _recipeTypeService.getRecipeType(recipe.recipeTypeId.Value);
if (recipeType != null)
{
recipe.typeDescription = recipeType.typeDescription;
}
}
recipe.phases = new List <Phase> ();
foreach (var phaseId in recipe.phasesId)
{
var phase = await _phaseService.getPhase(phaseId);
if (phase != null)
{
recipe.phases.Add(phase);
}
}
recipes.Add(recipe);
}
}
return(recipes, totalCount);
}
public int BinarySearch(Document document, OrderEnum listOrder)
{
int listIndex = 0;
switch (listOrder)
{
case OrderEnum.IDOrder: listIndex = this.BinarySearch(document); break;
case OrderEnum.TitleOrder: listIndex = this.BinarySearch(document, OrderEnum.TitleOrder); break;
case OrderEnum.MatchOrder: listIndex = this.BinarySearch(document, OrderEnum.MatchOrder); break;
}
return(listIndex);
}
/// <summary>
/// Converts a OrderEnum value to a corresponding string value
/// </summary>
/// <param name="enumValue">The OrderEnum value to convert</param>
/// <returns>The representative string value</returns>
public static string ToValue(OrderEnum enumValue)
{
switch (enumValue)
{
//only valid enum elements can be used
//this is necessary to avoid errors
case OrderEnum.ENUM_USERFIRSTNAME:
case OrderEnum.ENUM_USERLASTNAME:
case OrderEnum.ENUM_CLIENTREGISTRATIONDATE:
case OrderEnum.ENUM_CLIENTID:
return(stringValues[(int)enumValue]);
//an invalid enum value was requested
default:
return(null);
}
}
private IQueryable <Tag> ApplyOrder(IQueryable <Tag> queryTags,
TagFieldEnum orderField, OrderEnum order)
{
switch (orderField)
{
case TagFieldEnum.physicalTag:
if (order == OrderEnum.Ascending)
{
queryTags = queryTags.OrderBy(x => x.physicalTag);
}
else
{
queryTags = queryTags.OrderByDescending(x => x.physicalTag);
}
break;
case TagFieldEnum.tagDescription:
if (order == OrderEnum.Ascending)
{
queryTags = queryTags.OrderBy(x => x.tagDescription);
}
else
{
queryTags = queryTags.OrderByDescending(x => x.tagDescription);
}
break;
case TagFieldEnum.tagName:
if (order == OrderEnum.Ascending)
{
queryTags = queryTags.OrderBy(x => x.tagName);
}
else
{
queryTags = queryTags.OrderByDescending(x => x.tagName);
}
break;
default:
queryTags = queryTags.OrderBy(x => x.tagId);
break;
}
return(queryTags);
}
private IQueryable <Recipe> ApplyOrder(IQueryable <Recipe> query,
RecipeFields orderField, OrderEnum order)
{
switch (orderField)
{
case RecipeFields.recipeCode:
if (order == OrderEnum.Ascending)
{
query = query.OrderBy(x => x.recipeCode);
}
else
{
query = query.OrderByDescending(x => x.recipeCode);
}
break;
case RecipeFields.recipeName:
if (order == OrderEnum.Ascending)
{
query = query.OrderBy(x => x.recipeName);
}
else
{
query = query.OrderByDescending(x => x.recipeName);
}
break;
case RecipeFields.recipeTypeId:
if (order == OrderEnum.Ascending)
{
query = query.OrderBy(x => x.recipeTypeId);
}
else
{
query = query.OrderByDescending(x => x.recipeTypeId);
}
break;
default:
query = query.OrderBy(x => x.recipeId);
break;
}
return(query);
}
public virtual void MDXOrderTuple(ref string OrderTuple, ref OrderEnum Order)
{
OrderTuple = null;
if (this.Ordinal == 2)
{
return;
}
for (int i = 0; i < this.Hierarchies.Count; i++)
{
Hierarchy hier = this.Hierarchies[i];
if (hier.OrderTupleMember != null)
{
if (_order == OrderEnum.NONE)
{
hier._orderTupleMember = null;
}
else
{
OrderTuple = OrderTuple + hier.OrderTupleMember + ",";
}
}
else if (hier.OrderTupleMember == null)
{
if (_order != OrderEnum.NONE)
{
_order = OrderEnum.NONE;
i = -1; //restart for
}
OrderTuple = null;
}
}
//remove last comma
if (OrderTuple != null && OrderTuple.EndsWith(","))
{
OrderTuple = OrderTuple.Remove(OrderTuple.Length - 1, 1);
}
Order = _order;
}
private static VKParams parseParamsForGet(
IEnumerable<FieldsEnum> fields,
Int64? userId,
OrderEnum? order,
Int64? listId,
Int32? count,
Int32? offset,
NameCaseEnum? nameCase
)
{
VKParams param = new VKParams();
if (fields != null)
{
param.Add("fields", String.Join(",", fields));
}
if (userId.HasValue)
{
param.Add("user_id", userId.Value);
}
if (order.HasValue)
{
param.Add("order", order.Value);
}
if (listId.HasValue)
{
param.Add("list_id", listId.Value);
}
if (count.HasValue)
{
param.Add("count", count.Value);
}
if (offset.HasValue)
{
param.Add("offset", offset.Value);
}
if (nameCase.HasValue)
{
param.Add("name_case", nameCase.Value);
}
return param;
}
public void Test_Orders_Should_Return_True(OrderEnum orderEnum)
{
// Prepare
var op = new OrderProcessor(orderEnum, new RuleCommandFacotry(), true);
// Run
var result = op.RunCommands();
// Assert
Assert.AreEqual(orderEnum, op.Order);
Assert.IsTrue(op.IsContinueOnFail);
Assert.AreEqual(0, result);
if (orderEnum == OrderEnum.LearningToSki)
{
Assert.AreEqual(1, op.RuleCommands.Count());
}
else
{
Assert.AreEqual(2, op.RuleCommands.Count());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="InputCollectionSort" /> class.
/// </summary>
/// <param name="input">Collection of strings to sort (required).</param>
/// <param name="order">Sort order (required) (default to OrderEnum.Ascending).</param>
public InputCollectionSort(List <string> input = default(List <string>), OrderEnum order = OrderEnum.Ascending)
{
// to ensure "input" is required (not null)
if (input == null)
{
throw new InvalidDataException("input is a required property for InputCollectionSort and cannot be null");
}
else
{
this.Input = input;
}
// to ensure "order" is required (not null)
if (order == null)
{
throw new InvalidDataException("order is a required property for InputCollectionSort and cannot be null");
}
else
{
this.Order = order;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AccessLists" /> class.
/// </summary>
/// <param name="cidrs">Classless Inter-Domain Routing IP notation for use on the access lists (required).</param>
/// <param name="order">Allow-Deny or Deny-Allow? (required).</param>
/// <param name="userAgent">Regexp to match valid user agent strings.</param>
public AccessLists(List <string> cidrs = default(List <string>), OrderEnum order = default(OrderEnum), string userAgent = default(string))
{
// to ensure "cidrs" is required (not null)
if (cidrs == null)
{
throw new InvalidDataException("cidrs is a required property for AccessLists and cannot be null");
}
else
{
this.Cidrs = cidrs;
}
// to ensure "order" is required (not null)
if (order == null)
{
throw new InvalidDataException("order is a required property for AccessLists and cannot be null");
}
else
{
this.Order = order;
}
this.UserAgent = userAgent;
}
internal void LoadFromXml(XmlElement xmlEl)
{
if (this.Ordinal != 2)
{
this._order = (OrderEnum)System.Enum.Parse(typeof(OrderEnum), xmlEl.GetAttribute("SO"), true);
this._emptyTupleOption = (EmptyTupleOptionEnum)System.Enum.Parse(typeof(EmptyTupleOptionEnum), xmlEl.GetAttribute("ETO"), true);
}
foreach (XmlElement hierEl in xmlEl.ChildNodes) //hierarchies
{
string uniqueName = hierEl.GetAttribute("UN");
Olap.Hierarchy hier = Schema.Hierarchies[uniqueName];
if (hier == null)
{
continue;
}
//move to specified axis
hier.Axis = this;
hier.LoadFromXml(hierEl);
}
}
public ScraperInfoDto GetScraperInfo(OrderEnum order)
{
var result = _scraperInfoRepository.GetScraperInfo(Enum.GetName(typeof(OrderEnum), order));
if (result != null)
{
return(new ScraperInfoDto
{
Order = (OrderEnum)Enum.Parse(typeof(OrderEnum), result.Order),
LastPage = result.LastPage,
LastRun = result.LastRun
});
}
else
{
return(new ScraperInfoDto
{
Order = order,
LastPage = 0,
LastRun = DateTime.Now
});
}
}
static void Main(string[] args)
{
OrderEnum order1 = OrderEnum.done;
if (order1 == OrderEnum.done)
{
Console.WriteLine("La commande est terminé");
}
OrderEnum orderChoosen = OrderEnum.undefined;
Console.WriteLine("Choisissez le statut");
int choice = Int32.Parse(Console.ReadLine());
switch (choice)
{
case 0:
orderChoosen = OrderEnum.pending;
break;
case 1:
orderChoosen = OrderEnum.done;
break;
case 2:
orderChoosen = OrderEnum.canceled;
break;
default:
break;
}
Console.WriteLine("Votre commande est maintenant " + orderChoosen);
Console.ReadLine();
}
public OrderAgg(string field, OrderEnum order)
{
_field = field;
_order = order;
}
public static List <User> GetUsers(string userType, string userName, ActiveStatusEnum active, UserOrderEnum order, OrderEnum orderDirection)
{
try
{
List <User> retVal = new List <User>();
using (SqlConnection connection = new SqlConnection(DBFunctions.ConnectionString))
{
SqlCommand command = connection.CreateCommand();
command.CommandText = String.Format(@"
SELECT
{0}
FROM
[user].[User]
JOIN [user].[UserType] ON [User].[UserTypeId] = [UserType].[Id]
WHERE
(@UserType IS NULL OR [user].[UserType].Name LIKE @UserType) AND
(@UserName IS NULL OR [user].[User].Name LIKE @UserName) AND
(@Active IS NULL OR [user].[User].Active = @Active)
", AllColumnSelect);
command.Parameters.Add("@UserType", SqlDbType.NVarChar);
command.Parameters.Add("@UserName", SqlDbType.NVarChar);
command.Parameters.Add("@Active", SqlDbType.Bit);
command.Parameters["@UserType"].Value = CreateLikeQueryString(userType);
command.Parameters["@UserName"].Value = CreateLikeQueryString(userName);
switch (active)
{
case ActiveStatusEnum.Active:
command.Parameters["@Active"].Value = true;
break;
case ActiveStatusEnum.Inactive:
command.Parameters["@Active"].Value = false;
break;
case ActiveStatusEnum.All:
command.Parameters["@Active"].Value = DBNull.Value;
break;
}
System.Diagnostics.Debug.WriteLine(command.CommandText);
connection.Open();
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
retVal.Add(ReadRow(reader));
}
}
}
return(retVal);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
throw ErrorResponse.ErrorMessage(HttpStatusCode.BadRequest, ex);
}
}
/// <summary>
/// 设置 排序方式 默认asc
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
public FluentGridColumn Order(OrderEnum order)
{
Column.Order = order;
return this;
}
private IQueryable <Tool> ApplyOrder(IQueryable <Tool> queryTags,
ToolFieldEnum orderField, OrderEnum order)
{
switch (orderField)
{
case ToolFieldEnum.Code:
if (order == OrderEnum.Ascending)
{
queryTags = queryTags.OrderBy(x => x.code);
}
else
{
queryTags = queryTags.OrderByDescending(x => x.code);
}
break;
case ToolFieldEnum.Description:
if (order == OrderEnum.Ascending)
{
queryTags = queryTags.OrderBy(x => x.description);
}
else
{
queryTags = queryTags.OrderByDescending(x => x.description);
}
break;
case ToolFieldEnum.Name:
if (order == OrderEnum.Ascending)
{
queryTags = queryTags.OrderBy(x => x.name);
}
else
{
queryTags = queryTags.OrderByDescending(x => x.name);
}
break;
case ToolFieldEnum.SerialNumber:
if (order == OrderEnum.Ascending)
{
queryTags = queryTags.OrderBy(x => x.serialNumber);
}
else
{
queryTags = queryTags.OrderByDescending(x => x.serialNumber);
}
break;
case ToolFieldEnum.Status:
if (order == OrderEnum.Ascending)
{
queryTags = queryTags.OrderBy(x => x.status);
}
else
{
queryTags = queryTags.OrderByDescending(x => x.status);
}
break;
case ToolFieldEnum.TypeName:
if (order == OrderEnum.Ascending)
{
queryTags = queryTags.OrderBy(x => x.typeName);
}
else
{
queryTags = queryTags.OrderByDescending(x => x.typeName);
}
break;
default:
queryTags = queryTags.OrderBy(x => x.toolId);
break;
}
return(queryTags);
}
public async Task <(List <Tool>, int)> getTools(int startat, int quantity, ToolFieldEnum fieldFilter,
string fieldValue, ToolFieldEnum orderField, OrderEnum order)
{
var queryTool = _context.Tools.Where(x => x.toolId > 0).Include(x => x.toolType).AsQueryable();
queryTool = ApplyFilter(queryTool, fieldFilter, fieldValue);
queryTool = ApplyOrder(queryTool, orderField, order);
var toolId = await queryTool
.Skip(startat).Take(quantity)
.Select(x => x.toolId)
.ToListAsync();
var queryToolCount = _context.Tools.Where(x => x.toolId > 0);
queryToolCount = ApplyFilter(queryToolCount, fieldFilter, fieldValue);
queryToolCount = ApplyOrder(queryToolCount, orderField, order);
var totalCount = await queryToolCount.CountAsync();
List <Tool> tools = new List <Tool> ();
foreach (var item in toolId)
{
var tool = await getTool(item);
if (tool != null)
{
tools.Add(tool);
}
}
return(tools, totalCount);
}
public async Task <(List <User>, int)> getUsers(int startat, int quantity, UserFieldEnum fieldFilter, string fieldValue, UserFieldEnum orderField, OrderEnum order)
{
var queryUser = _context.Users.Where(x => x.enabled == true);
queryUser = ApplyFilter(queryUser, fieldFilter, fieldValue);
queryUser = ApplyOrder(queryUser, orderField, order);
var users = await queryUser.Include(x => x.userGroup)
.Skip(startat).Take(quantity).ToListAsync();
var queryUserCount = _context.Users.Where(x => x.enabled == true);
queryUserCount = ApplyFilter(queryUserCount, fieldFilter, fieldValue);
queryUserCount = ApplyOrder(queryUserCount, orderField, order);
var totalCount = await queryUserCount.CountAsync();
return(users, totalCount);
}
public OrderAgg(string field, OrderEnum order)
{
_field = field;
_order = order;
}
// Locate and return the index of data
public int BinarySearch(Employee employee, OrderEnum listOrder)
{
// in the list. The list must be ordered
int listIndex = 0; // by the value of the listOrder parameter.
switch (listOrder)
{
case OrderEnum.IDOrder: listIndex = this.BinarySearch(employee); break;
case OrderEnum.NameOrder: listIndex = this.BinarySearch(employee, Employee.CompareNames); break;
case OrderEnum.HireDateOrder: listIndex = this.BinarySearch(employee, Employee.CompareHireDates); break;
case OrderEnum.TypeOrder: listIndex = this.BinarySearch(employee, Employee.CompareTypes); break;
case OrderEnum.EarningsOrder: listIndex = this.BinarySearch(employee, Employee.CompareEarnings); break;
case OrderEnum.FICAOrder: listIndex = this.BinarySearch(employee, Employee.CompareFICAs); break;
case OrderEnum.FedTaxOrder: listIndex = this.BinarySearch(employee, Employee.CompareFedTaxes); break;
case OrderEnum.StateTaxOrder: listIndex = this.BinarySearch(employee, Employee.CompareStateTaxes); break;
case OrderEnum.NetPayOrder: listIndex = this.BinarySearch(employee, Employee.CompareNetPays); break;
}
return listIndex;
}
// The value of the listOrder parameter
public void SelectionSort(OrderEnum listOrder)
{
// determines the sort order.
switch (listOrder)
{
case OrderEnum.IDOrder: this.SelectionSort(); break;
case OrderEnum.NameOrder: this.SelectionSort(Employee.CompareNames); break;
case OrderEnum.HireDateOrder: this.SelectionSort(Employee.CompareHireDates); break;
case OrderEnum.TypeOrder: this.SelectionSort(Employee.CompareTypes); break;
case OrderEnum.EarningsOrder: this.SelectionSort(Employee.CompareEarnings); break;
case OrderEnum.FICAOrder: this.SelectionSort(Employee.CompareFICAs); break;
case OrderEnum.FedTaxOrder: this.SelectionSort(Employee.CompareFedTaxes); break;
case OrderEnum.StateTaxOrder: this.SelectionSort(Employee.CompareStateTaxes); break;
case OrderEnum.NetPayOrder: this.SelectionSort(Employee.CompareNetPays); break;
}
}
public OrderBy(string name, OrderEnum order, CharacterCasingEnum casing = CharacterCasingEnum.Unchanged)
{
this.Name = name;
this.Order = order;
this.Casing = casing;
}
/// <summary>
/// Возвращает расширенную информацию о друзьях пользователя
/// </summary>
/// <param name="fields">Cписок дополнительных полей, которые необходимо вернуть</param>
/// <param name="userId">
/// Идентификатор пользователя, для которого необходимо получить список друзей. Если параметр не
/// задан, то считается, что он равен идентификатору текущего пользователя
/// </param>
/// <param name="order">Порядок, в котором нужно вернуть список друзей</param>
/// <param name="listId">Идентификатор списка друзей, друзей из которого необходимо получить</param>
/// <param name="count">Количество друзей, которое нужно вернуть</param>
/// <param name="offset">Смещение, необходимое для выборки определенного подмножества друзей</param>
/// <param name="nameCase">Падеж для склонения имени и фамилии пользователя</param>
/// <returns>Список друзей</returns>
public static VKList<VKFriend> GetExtended(
IEnumerable<FieldsEnum> fields,
Int64? userId = null,
OrderEnum? order = null,
Int64? listId = null,
Int32? count = null,
Int32? offset = null,
NameCaseEnum? nameCase = null
)
{
VKParams param = parseParamsForGet(fields, userId, order, listId, count, offset, nameCase);
string response = VKSession.Instance.DoRequest("friends.get", param);
JObject obj = JObject.Parse(response);
if (obj["response"] == null) return null;
var objArr = JsonConvert.DeserializeObject<VKList<VKFriend>>(obj["response"].ToString());
return objArr;
}
/// <summary>
/// Возвращает расширенную информацию о друзьях пользователя
/// </summary>
/// <param name="fields">Cписок дополнительных полей, которые необходимо вернуть</param>
/// <param name="userId">
/// Идентификатор пользователя, для которого необходимо получить список друзей. Если параметр не
/// задан, то считается, что он равен идентификатору текущего пользователя
/// </param>
/// <param name="order">Порядок, в котором нужно вернуть список друзей</param>
/// <param name="listId">Идентификатор списка друзей, друзей из которого необходимо получить</param>
/// <param name="count">Количество друзей, которое нужно вернуть</param>
/// <param name="offset">Смещение, необходимое для выборки определенного подмножества друзей</param>
/// <param name="nameCase">Падеж для склонения имени и фамилии пользователя</param>
/// <param name="token">Токен для отмены выполнения запроса</param>
/// <returns>Список друзей</returns>
public static async Task<VKList<VKFriend>> GetExtendedAsync(
IEnumerable<FieldsEnum> fields,
Int64? userId = null,
OrderEnum? order = null,
Int64? listId = null,
Int32? count = null,
Int32? offset = null,
NameCaseEnum? nameCase = null,
CancellationToken? token = null
)
{
VKParams param = parseParamsForGet(fields, userId, order, listId, count, offset, nameCase);
string response = await VKSession.Instance.DoRequestAsync("friends.get", param);
JObject obj = JObject.Parse(response);
if (obj["response"] == null) return null;
var objArr = await JsonConvert.DeserializeObjectAsync<VKList<VKFriend>>(obj["response"].ToString());
if (token.HasValue) token.Value.ThrowIfCancellationRequested();
return objArr;
}
// Locate and return the listIndex
public int BinarySearch(Student student, OrderEnum listOrder)
{
// position of element in the list.
int listIndex = 1; // Assumes the list is ordered in listOrder.
switch (listOrder)
{
case OrderEnum.IDOrder : listIndex = this.BinarySearch(student); break;
case OrderEnum.NameOrder : listIndex = this.BinarySearch(student, Student.CompareNames); break;
case OrderEnum.BirthDateOrder : listIndex = this.BinarySearch(student, Student.CompareBirthDates); break;
case OrderEnum.MajorOrder : listIndex = this.BinarySearch(student, Student.CompareMajors); break;
case OrderEnum.HoursOrder : listIndex = this.BinarySearch(student, Student.CompareHours); break;
case OrderEnum.GPAOrder : listIndex = this.BinarySearch(student, Student.CompareGPAs); break;
}
return listIndex;
}
public void SelectionSort(OrderEnum listOrder)
{
switch (listOrder)
{
case OrderEnum.IDOrder : this.SelectionSort(); break;
case OrderEnum.NameOrder : this.SelectionSort(Student.CompareNames); break;
case OrderEnum.BirthDateOrder : this.SelectionSort(Student.CompareBirthDates); break;
case OrderEnum.MajorOrder : this.SelectionSort(Student.CompareMajors); break;
case OrderEnum.HoursOrder : this.SelectionSort(Student.CompareHours); break;
case OrderEnum.GPAOrder : this.SelectionSort(Student.CompareGPAs); break;
}
}
