public async Task <SearchResult <UserModel> > SearchCourier([FromQuery] ManagerSearchModel model)
{
var managers = await _userService.SearchCouriers(model.SearchString);
return(new SearchResult <UserModel>(
managers.Count(),
SortManager.SortManagers(managers, model.Field, model.Direction, model.Count, model.Offset)));
}
public SearchResult <ProductSearchInfoForCourier> SearchProduct([FromQuery] ProductSearchModel model)
{
var products = _productService.Search(model.SearchString, model.DateFilter, model.DeliveryTypeFilter, null, null);
return(new SearchResult <ProductSearchInfoForCourier>(
products.Count(),
SortManager.SortProductsForCourier(products, model.ProductSortField, model.Direction, model.Count, model.Offset)));
}
public IActionResult SortedByName(bool toggle)
{
var list = context.GetAllGamesFromDatabase();
var sortManager = new SortManager(context);
var sortedList = sortManager.AlphabeticallySortedGames(list, toggle);
return(Ok(sortedList));
}
public SearchResult <DeliveryPointModel> SearchManagers([FromQuery] DeliveryPointSearchModel model)
{
var points = _deliveryPointService.SearchDeliveryPoints(model.SearchString);
return(new SearchResult <DeliveryPointModel>(
points.Count(),
SortManager.SortDeliveryPoints(points.Select(p => new DeliveryPointModel(p)), model.Field, model.Direction, model.Count, model.Offset)));
}
public void Construct_ShouldReturnInstanceOfISortManager()
{
//-----Setup------------------------------------
//-----Execute----------------------------------
var manager = new SortManager(null);
//-----Assert-----------------------------------
Assert.IsInstanceOfType(manager, typeof(ISortManager));
}
public SearchResult <ProductSearchInfoForManager> GetDeliveryHistory([FromRoute] Guid courierGuid, [FromQuery] ProductSearchModel model)
{
var products = _productService.Search(model.SearchString, model.DateFilter, DeliveryType.Courier, DeliveryStatus.Delivered, courierGuid);
return(new SearchResult <ProductSearchInfoForManager>(
products.Count(),
SortManager.SortProductsForManager(products, model.ProductSortField, model.Direction, model.Count, model.Offset).Select(p => new ProductSearchInfoForManager(p))
));
}
public IActionResult SortedByYear(bool toggle)
{
var list = context.GetAllGamesFromDatabase();
var sortManager = new SortManager(context);
var sortedList = sortManager.GamesSortedByYear(list, toggle);
return(Ok(sortedList));
}
public void Sort_Given_NullCustomerRecords_ShouldThrowArgumentNullException()
{
//-----Setup------------------------------------
ISortManager manager = new SortManager(null);
//-----Execute----------------------------------
manager.Sort(null);
//-----Assert-----------------------------------
Assert.Fail("Expected Exception not thrown!");
}
public void Sorters_ShouldReturnRegisteredSorters()
{
//-----Setup------------------------------------
ISortManager manager = new SortManager(GetFileWriter());
//-----Execute----------------------------------
var sorters = manager.Sorters;
//-----Assert-----------------------------------
Assert.IsTrue(sorters.Any());
}
private void RemoveSortButton_Click(object sender, EventArgs e)
{
var selectedRows = GrapeSortTable.SelectedRows;
foreach (DataGridViewRow row in selectedRows)
{
int id = Convert.ToInt32(row.Cells[0].Value);
SortManager.DeleteData(id);
GrapeSort local = GrapeSortList.Find(x => x.Id == id);
GrapeSortList.Remove(local);
}
UpdateGrapeSortTable();
}
static void Main(string[] args)
{
var fileName = args[0];
if (!File.Exists(fileName))
{
throw new ArgumentException("Input file does not exist");
}
var manager = new SortManager(fileName);
manager.Sort();
}
private void InitSqlManagers()
{
SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder();
builder.DataSource = "ALEX-ПК\\SQLEXPRESS";
builder.InitialCatalog = "WineryDb";
builder.IntegratedSecurity = true;
WineManager = new WineManager(builder.ConnectionString);
SortManager = new SortManager(builder.ConnectionString);
CountryManager = new CountryManager(builder.ConnectionString);
SeedlessnessManager = new SeedlessnessManager(builder.ConnectionString);
SweetnessManager = new SweetnessManager(builder.ConnectionString);
WineSortManager = new WineSortManager(builder.ConnectionString);
DbSearch = new SearchManager(builder.ConnectionString);
}
public async Task <IActionResult> SortByEmail(bool toggle)
{
var sortManager = new SortManager(applicationDbContext);
var users = applicationDbContext.AllUsers();
var sortedList = sortManager.AlphabeticallySortedUsers(users, toggle);
foreach (var item in sortedList)
{
var user = await userManager.FindByEmailAsync(item.Email);
item.Role = await userManager.GetRolesAsync(user);
}
return(Ok(sortedList));
}
public void LoadAllData()
{
WineList = WineManager.GetData();
GrapeSortList = SortManager.GetData();
CountryList = CountryManager.GetData();
SweetnessList = SweetnessManager.GetData();
SeedlessnessList = SeedlessnessManager.GetData();
SortCategoryList = WineSortManager.GetData();
WineTable.DataSource = WineList;
GrapeSortTable.DataSource = GrapeSortList;
SweetnessTable.DataSource = SweetnessList;
SeedlessnessTable.DataSource = SeedlessnessList;
CountryTable.DataSource = CountryList;
WineSortTable.DataSource = SortCategoryList;
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel()
{
if (IsInDesignMode)
{
// Code runs in Blend --> create design time data.
}
else
{
// Code runs "for real"
}
IsEnabledSelecting1 = true;
IsEnabledSelecting2 = false;
IsEnabledSelecting3 = false;
SortManager = new SortManager();
}
// Use this for initialization
private void Awake()
{
instance = this;
}
//스크롤 정렬
private int[] getOrder()
{
int[] data_order;
int total_list_num = 0;
if (currentScrollType == scroll_type.SERVANT_INFO)
{
total_list_num = ServantList.Count;
}
else if (currentScrollType == scroll_type.MONSTER_INFO)
{
total_list_num = MonsterList.Count;
}
data_order = new int[total_list_num];
for (int i = 0; i < data_order.Length; i++)
{
data_order[i] = 0;
}
if (!SortManager.checkInst())
{
DebugLog.Log(false, "Invalid sort manager!");
return(data_order);
}
switch (sort_type)
{
case SORT_TYPE.POWER:
for (int i = 0; i < total_list_num - 1; i++)
{
for (int j = i + 1; j < total_list_num; j++)
{
if (currentScrollType == scroll_type.SERVANT_INFO)
{
if (Calculator.GetPower(ServantList[i].status, ServantList[i].level) < Calculator.GetPower(ServantList[j].status, ServantList[j].level)) //TODO: 임시로 STR
{
data_order[i]++;
}
else
{
data_order[j]++;
}
}
else if (currentScrollType == scroll_type.MONSTER_INFO)
{
if (Calculator.GetPower(MonsterList[i].status, MonsterList[i].level) < Calculator.GetPower(MonsterList[j].status, MonsterList[j].level)) //TODO: 임시로 STR
{
data_order[i]++;
}
else
{
data_order[j]++;
}
}
}
}
break;
case SORT_TYPE.GRADE:
for (int i = 0; i < total_list_num - 1; i++)
{
for (int j = i + 1; j < total_list_num; j++)
{
if (currentScrollType == scroll_type.SERVANT_INFO)
{
if (ServantList[i].grade > ServantList[j].grade)
{
data_order[i]++;
}
else
{
data_order[j]++;
}
}
else if (currentScrollType == scroll_type.MONSTER_INFO)
{
if (MonsterList[i].grade > MonsterList[j].grade)
{
data_order[i]++;
}
else
{
data_order[j]++;
}
}
}
}
break;
case SORT_TYPE.LEVEL_OR_TIER:
for (int i = 0; i < total_list_num - 1; i++)
{
for (int j = i + 1; j < total_list_num; j++)
{
if (currentScrollType == scroll_type.SERVANT_INFO)
{
if (ServantList[i].level * 100 + ServantList[i].exp < ServantList[j].level * 100 + ServantList[j].exp)
{
data_order[i]++;
}
else
{
data_order[j]++;
}
}
else if (currentScrollType == scroll_type.MONSTER_INFO)
{
if (MonsterList[i].level * 100 + MonsterList[i].exp < MonsterList[j].level * 100 + MonsterList[j].exp)
{
data_order[i]++;
}
else
{
data_order[j]++;
}
}
}
}
break;
case SORT_TYPE.GOT_TIME:
for (int i = 0; i < total_list_num; i++)
{
data_order[i] = i;
}
break;
case SORT_TYPE.JOB_OR_UPGRADE:
for (int i = 0; i < total_list_num - 1; i++)
{
for (int j = i + 1; j < total_list_num; j++)
{
if (currentScrollType == scroll_type.SERVANT_INFO) //Servant는 직업 정렬
{
if (ServantList[i].jobType > ServantList[j].jobType)
{
data_order[i]++;
}
else
{
data_order[j]++;
}
}
else if (currentScrollType == scroll_type.MONSTER_INFO) //Monster는 업그레이드 정렬
{
if (MonsterList[i].upgrade < MonsterList[j].upgrade)
{
data_order[i]++;
}
else
{
data_order[j]++;
}
}
}
}
break;
default:
break;
}
if (reverse_sort)
{
for (int i = 0; i < data_order.Length; i++)
{
data_order[i] = total_list_num - 1 - data_order[i];
}
}
return(data_order);
}
public MainWindow()
{
sm = SortManager.GetInstance();
InitializeComponent();
}
public FilterViewModel(FilterManager filterManager, SortManager sortManager)
{
FilterManager = filterManager;
SortManager = sortManager;
}
