private void AssociatedObject_Sorting(object sender, GridViewSortingEventArgs e)
{
e.Cancel = true;
var sortByPropertyName = (( GridViewDataColumn )e.Column).DataMemberBinding.Path.Path;
switch (e.OldSortingState)
{
case SortingState.None:
e.NewSortingState = SortingState.Ascending;
SortDirection = ListSortDirection.Ascending;
SortBy = sortByPropertyName;
break;
case SortingState.Ascending:
e.NewSortingState = SortingState.Descending;
SortDirection = ListSortDirection.Descending;
SortBy = sortByPropertyName;
break;
case SortingState.Descending:
SortDirection = ListSortDirection.Ascending;
SortBy = sortByPropertyName;
break;
default:
break;
}
// Sort executed server-side.
SortCommand.Execute(null);
}
public IList <Book> FindAll(SortCommand sortCommand = null, IList <FilterCommand> filterCommands = null, PageCommand pageCommand = null)
{
IQuery query = null;
if (!string.IsNullOrWhiteSpace(sortCommand?.SortKey))
{
query = ApplySortCommand(sortCommand, query);
}
if (!ListUtils.IsListNullOrEmpty(filterCommands))
{
query = ApplyFilterCommands(filterCommands, query);
}
if (pageCommand?.Limit > 0 || pageCommand?.Offset > 0)
{
query = ApplyPageCommand(pageCommand, query);
}
if (query != null)
{
return(query.Execute <Book>());
}
return(FindAll());
}
public void CorrectInstancesAreUsedForSortCommand()
{
this.BuildTournamentSelector();
// Send a simple sort command and wait for completion.
var originalCommand = new SortCommand <TestInstance>(
this.CreateGenomesAdheringToParameterTree(GenomeSorterTest.TotalNumberEvaluationActors),
this._singleTestInstance);
this._genomeSorter.Tell(originalCommand);
this.ExpectMsg <SortResult>();
// Build a new sort command with several new instances.
var instances = new List <TestInstance>
{
new TestInstance("1"),
new TestInstance("2"),
};
var genomes = this.CreateGenomesAdheringToParameterTree(GenomeSorterTest.TotalNumberEvaluationActors);
var selectCommand = new SortCommand <TestInstance>(genomes, instances.ToImmutableList());
// Send it & wait for completion.
this._genomeSorter.Tell(selectCommand);
this.ExpectMsg <SortResult>();
// Check that storage actor has knowledge about both new instances for both genomes.
foreach (var genome in genomes)
{
foreach (var instance in instances)
{
this._resultStorageActor.Tell(new ResultRequest <TestInstance>(genome, instance));
this.ExpectMsg <ResultMessage <TestInstance, IntegerResult> >();
}
}
}
public void SetUp()
{
new ArbiterMSBuildLocator().RegisterDefaults();
var container = ContainerHelper.ConfigureContainer().WithRealFileSystem().Build();
_command = container.Resolve <SortCommand>();
_console = container.Resolve <IConsole>();
}
public ChildCommands(DiffCommand diff, SetupComCommand setupCom, CleanCommand cleanCom, SortCommand sort, GraphCommand graph, AnalyzeCommand analyze)
{
Diff = diff;
SetupCom = setupCom;
CleanCom = cleanCom;
Sort = sort;
Graph = graph;
Analyze = analyze;
}
public ArrayVisualizerViewModel(Canvas canvas)
{
Sort = new SortCommand(this);
ValueModels = new ValueModel[amount];
for (int i = 0; i < amount; i++)
{
ValueModels[i] = new ValueModel(canvas, i);
}
}
private void ItemPropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (FindUnusedAndMissingCommand != null)
{
FindUnusedAndMissingCommand.RaiseCanExecuteChanged();
SortCommand.RaiseCanExecuteChanged();
}
ViewComplexObjectsCommand?.RaiseCanExecuteChanged();
DeleteCommand?.RaiseCanExecuteChanged();
}
/// <summary>
/// Actor is ready to process <see cref="SortCommand{TInstance}"/>s.
/// </summary>
protected override void Ready()
{
// Switch to working state if a genome sorting command was sent.
this.Receive <SortCommand <TInstance> >(
command =>
{
this._sortCommand = command;
this.CommandIssuer = this.Sender;
this.BecomeWorking();
});
}
private void OnSorting(object sender, DataGridSortingEventArgs eventArgs)
{
eventArgs.Handled = true;
if (SortCommand != null)
{
var column = eventArgs.Column;
var sortDirection = GetNextSortDirection(column.SortDirection);
column.SortDirection = sortDirection;
SortCommand.Execute(new SortData(column.Header.ToString(), sortDirection));
}
}
static void SortObj(Dictionary <int, Car> Cars)
{
string SortCommand;
Console.WriteLine("Izberite atribut po katerem želite sortirati avtomobile");
Console.WriteLine();
Console.WriteLine("1. Moč");
Console.WriteLine("2. Hitrost");
Console.WriteLine("3. Teža");
Console.WriteLine("4. Znamka");
SortCommand = Console.ReadLine();
if (SortCommand.Equals("1"))
{
var CarsSorted = Cars.Values.OrderBy(v => v.Power);
foreach (Car car in CarsSorted)
{
Console.WriteLine(car.PrintWithUnit());
}
}
if (SortCommand.Equals("2"))
{
var CarsSorted = Cars.Values.OrderBy(v => v.TopSpeed);
foreach (Car car in CarsSorted)
{
Console.WriteLine(car.PrintWithUnit());
}
}
if (SortCommand.Equals("3"))
{
var CarsSorted = Cars.Values.OrderBy(v => v.Weight);
foreach (Car car in CarsSorted)
{
Console.WriteLine(car.PrintWithUnit());
}
}
if (SortCommand.Equals("4"))
{
var CarsSorted = Cars.Values.OrderBy(v => v.Brand);
foreach (Car car in CarsSorted)
{
Console.WriteLine(car.PrintWithUnit());
}
}
}
static void Main(string[] args)
{
// setup description of this application
var app = new CommandLineApplication();
app.Name = "name-sorter";
app.Description = "This command tool help to sort names by last name then given name.";
app.HelpOption("-? | -h | --help");
// configure sort command
SortCommand.Configure(app);
app.Execute(args);
}
public void ParseArgumentsSetsIndexAndDescendingWhenDescendingProvided()
{
SortCommand cmd = new SortCommand();
cmd.ArgumentsString = @"""col 3"" DESC";
Document doc = new Document();
var slide = new SlideElement(doc);
ShapeElementBase element = (ShapeElementBase)(ShapeElementBaseTest.Create());
cmd.TargetElement = element;
cmd.ParseArguments();
Assert.AreEqual("col 3", cmd.Index.Name);
Assert.AreEqual(SortOrder.Descending, cmd.SortOrder);
}
private void HeaderCell_OnHeaderTapped(object sender, DataGridColumn dataGridColumn)
{
if (_currentSortingColumn != dataGridColumn && dataGridColumn.SortingEnabled)
{
_currentSortingColumn?.ResetOrderType();
_currentSortingColumn = dataGridColumn;
}
if (_autoSort && _currentSortingColumn != null && _currentSortingColumn.SortingEnabled)
{
var orderQuery = ItemsSource.AsQueryable().SortBy(_currentSortingColumn.PropertyName, _currentSortingColumn.SortOrderType);
SortCommand?.Execute(orderQuery);
}
HeaderTappedCommand?.Execute(dataGridColumn);
}
public Stream GetExcel(string filter, SortCommand sortCommand, bool isSortedDesc)
{
List <ContactDto> table;
using (var database = new PhoneBookDatabaseEntities())
{
table = GetFullData(filter, database.Contact, sortCommand, isSortedDesc).ToList();
}
using (var workbook = new XLWorkbook())
{
var worksheet = workbook.Worksheets.Add("Контакты");
worksheet.ColumnWidth = 20;
worksheet.Cell("A1").Value = "Фамилия";
worksheet.Cell("B1").Value = "Имя";
worksheet.Cell("C1").Value = "Телефон";
var i = 2;
foreach (var contact in table)
{
worksheet.Cell("A" + i).Value = contact.Surname;
worksheet.Cell("B" + i).Value = contact.Name;
worksheet.Cell("C" + i).Value = contact.Phone;
++i;
}
var range = worksheet.Range("A1", "C" + (i - 1));
worksheet.Range("C2", "C" + (i - 1)).DataType = XLCellValues.Text;
range.CreateTable();
var memoryStream = new MemoryStream();
workbook.SaveAs(memoryStream);
HttpContext.Current.Response.Headers["Content-Disposition"] = "attachment; filename=contacts.xlsx";
HttpContext.Current.Response.ContentType = "application/octet-stream";
memoryStream.Position = 0;
return(memoryStream);
}
}
public MainWindowVM()
{
using (FileStream fs = new FileStream("Words.dat", FileMode.OpenOrCreate))
{
BinaryFormatter formater = new BinaryFormatter();
if (fs.Length > 0)
{
_wordsList = (ObservableCollection <Words>)formater.Deserialize(fs);
}
else
{
_wordsList = new ObservableCollection <Words>();
}
}
deleteCommand = new DeleteCommand(this);
newWordCommand = new AddWordCommand(this);
sortCommand = new SortCommand(this);
ViewList = new CollectionViewSource();
ViewList.Source = _wordsList;
}
public void ApplyToDataSortsData()
{
SortCommand cmd = new SortCommand()
{
Index = new Index("column 1"), SortOrder = SortOrder.Descending
};
DataElement da = Helpers.CreateTestDataElement();
cmd.ApplyToData(da);
Assert.AreEqual(5.05, da.Columns[0].Data[0]);
Assert.AreEqual(1.0, da.Columns[0].Data[1]);
Assert.AreEqual("client 2", da.Columns[1].Data[0]);
Assert.AreEqual("client 1", da.Columns[1].Data[1]);
Assert.AreEqual(true, da.Columns[2].Data[0]);
Assert.AreEqual(false, da.Columns[2].Data[1]);
Assert.AreEqual(da.Columns[0].Data[0], da.Rows[0].Data[0]);
Assert.AreEqual(da.Columns[0].Data[1], da.Rows[1].Data[0]);
Assert.AreEqual(da.Columns[1].Data[0], da.Rows[0].Data[1]);
Assert.AreEqual(da.Columns[1].Data[1], da.Rows[1].Data[1]);
Assert.AreEqual(da.Columns[2].Data[0], da.Rows[0].Data[2]);
Assert.AreEqual(da.Columns[2].Data[1], da.Rows[1].Data[2]);
}
private void MouseDownOnHeaderCell(object sender, MouseEventArgs args)
{
var cellClicked = (( FrameworkElement )args.OriginalSource).ParentOfType <GridViewHeaderCell> ();
if (cellClicked == null)
{
return;
}
var column = ( GridViewDataColumn )cellClicked.Column;
var sortByPropertyName = (column).DataMemberBinding.Path.Path;
var oldSortDirection = SortDirection;
if (sortByPropertyName != SortBy)
{
oldSortDirection = ListSortDirection.Descending;
}
switch (oldSortDirection)
{
case ListSortDirection.Ascending:
column.SortingState = SortingState.Descending;
SortDirection = ListSortDirection.Descending;
SortBy = sortByPropertyName;
break;
case ListSortDirection.Descending:
column.SortingState = SortingState.Ascending;
SortDirection = ListSortDirection.Ascending;
SortBy = sortByPropertyName;
break;
default:
break;
}
// Sort executed server-side.
SortCommand.Execute(null);
}
public IEnumerable <Book> Get(SortCommand sortCommand, BookFilterCommand filterCommand, PageCommand pageCommand)
{
return(bookService.FindAll(sortCommand, bookService.GetFilterCommands(filterCommand), pageCommand));
}
/// <summary>
/// Creates a sorting query.
/// </summary>
/// <param name="sortCommand">The sort command to use.</param>
/// <param name="query">Optional query to append to.</param>
/// <returns>A query with the sorting command applied.</returns>
private IQuery ApplySortCommand(SortCommand sortCommand, IQuery query = null)
{
return((query == null) ? firestoreService.OrderBy(CollectionId, sortCommand.SortKey, sortCommand.SortBy)
: query.OrderBy(sortCommand.SortKey, sortCommand.SortBy));
}
/// <summary>
/// Resets all fields that change between two different commands.
/// </summary>
protected override void ResetCommandSpecificFields()
{
this._sortCommand = null;
base.ResetCommandSpecificFields();
}
private static IQueryable <ContactDto> GetFullData(string filter, IQueryable <Contact> contact, SortCommand sortCommand,
bool isSortedDesc)
{
var data = contact.Select(c => new ContactDto
{
Id = c.Id,
Name = c.Name,
Surname = c.Surname,
Phone = c.Phone
}).Where(c => c.Surname.Contains(filter) || c.Name.Contains(filter) || c.Phone.Contains(filter));
if (!isSortedDesc)
{
if (sortCommand == SortCommand.Name)
{
return(data.OrderBy(c => c.Name));
}
if (sortCommand == SortCommand.Surname)
{
return(data.OrderBy(c => c.Surname));
}
return(data.OrderBy(c => c.Phone));
}
if (sortCommand == SortCommand.Name)
{
return(data.OrderByDescending(c => c.Name));
}
if (sortCommand == SortCommand.Surname)
{
return(data.OrderByDescending(c => c.Surname));
}
return(data.OrderByDescending(c => c.Phone));
}
public Command ParseCommand(string commandInput)
{
var commandArguments = commandInput.Split(new [] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
// first check if it's a valid command
var length = commandArguments.Length;
Command command = null;
var action = commandArguments[0];
var parameters = commandArguments.Skip(1).ToList();
// make it with reflection, if you hate your life
switch (action)
{
case "append":
ValidateCommandLength(length, Constants.AppendCommandLength);
command = new AppendCommand(parameters);
break;
case "prepend":
ValidateCommandLength(length, Constants.PrependCommandLength);
command = new PrependCommand(parameters);
break;
case "reverse":
ValidateCommandLength(length, Constants.ReverseCommandLength);
command = new ReverseCommand(parameters);
break;
case "insert":
ValidateCommandLength(length, Constants.InsertCommandLength);
command = new InsertCommand(parameters);
break;
case "delete":
ValidateCommandLength(length, Constants.DeleteCommandLength);
command = new DeleteCommand(parameters);
break;
case "roll":
ValidateCommandLength(length, Constants.RollCommandLength);
command = new RollCommand(parameters);
break;
case "sort":
ValidateCommandLength(length, Constants.SortCommandLength);
command = new SortCommand(parameters);
break;
case "count":
ValidateCommandLength(length, Constants.CountCommandLength);
command = new CountCommand(parameters);
break;
case "end":
this.logger.Write(Constants.FinishedMessage);
command = new EndCommand(parameters);
break;
default:
throw new ArgumentException(Constants.InvalidCommand);
}
return(command);
}
public void RefreshSorting()
{
SortCommand.Refresh(LastSortDescr);
}
public void InstancesAreSetCorrectly()
{
var result = new SortCommand <TestInstance>(this._items, this._instances);
TestUtils.SetsAreEquivalent(this._instances, result.Instances);
}