public Task HandleDb(HttpContext httpContext, ITransactor transactor)
{
string result = null;
int wantedId = GetRandomWantedId();
transactor.Transact(db =>
{
IWorld w = GetRandomWorld(db, wantedId);
if (w != null)
{
result = JsonConvert.SerializeObject(w, _jsonSerializerSettings);
}
});
if (result == null)
{
result = "410 Gone\r\n";
httpContext.Response.StatusCode = StatusCodes.Status410Gone;
httpContext.Response.ContentType = "text/plain";
}
else
{
httpContext.Response.StatusCode = StatusCodes.Status200OK;
httpContext.Response.ContentType = "application/json";
}
httpContext.Response.ContentLength = result.Length;
return(httpContext.Response.WriteAsync(result));
}
public static void Populate(ITransactor transactor)
{
transactor.Transact(db =>
{
int found = 0;
foreach (Fortune f in db.Sql <Fortune>("SELECT f FROM Starcounter.Techempower.Fortune f"))
{
Debug.Assert(f.Id >= 1);
Debug.Assert(f.Id <= Count);
Debug.Assert(db.GetOid(f) != 0);
found++;
}
for (int id = found + 1; id <= Count; id++)
{
Fortune f = db.Insert <Fortune>();
f.Id = id;
f.Message = _initial[id - 1];
Debug.Assert(f.Id >= 1);
Debug.Assert(f.Id <= Count);
Debug.Assert(db.GetOid(f) != 0);
}
});
}
/// <inheritdoc/>
public override void ProcessInteraction(DiagramInteractionEventArguments interaction)
{
var selectedNodes = interaction.Diagram.Nodes.Where(n => n.IsSelected).ToList();
selectedNodes.ForEach(n => n.IsSelected = false);
if (interaction.Key == Key.C)
{
_copiedNodes = selectedNodes.Select(s => s.Model.Copy()).OfType <NodeModel>().ToList();
}
else
{
if (_copiedNodes == null)
{
return;
}
var firstCopiedNodeX = _copiedNodes.FirstOrDefault()?.X ?? 0;
var firstCopiedNodeY = _copiedNodes.FirstOrDefault()?.Y ?? 0;
var nodesToInsertToDiagram = new List <Node>();
foreach (var copiedNode in _copiedNodes)
{
var node = _nodeProvider.CreateNodeFromModel((NodeModel)copiedNode.Copy());
node.IsSelected = true;
var diagramMousePoint = interaction.Diagram.GetDiagramPointFromViewPoint(interaction.MousePosition);
node.X -= firstCopiedNodeX - diagramMousePoint.X;
node.Y -= firstCopiedNodeY - diagramMousePoint.Y;
node.IsSelected = true;
nodesToInsertToDiagram.Add(node);
interaction.Diagram.AddNode(node);
}
_transactor.Transact(new UndoCommand(new MapCommand(new UnwireAndDeleteNodeCommand(interaction.Diagram))), nodesToInsertToDiagram);
}
}
/// <inheritdoc/>
protected override void Execute(ITransactor transactor, object parameter)
{
foreach (var composedCommand in _composedCommands)
{
transactor.Transact(composedCommand, parameter);
}
}
public static void Populate(ITransactor transactor)
{
Random rnd = new Random();
transactor.Transact(db =>
{
int found = 0;
foreach (World w in db.Sql <World>("SELECT w FROM Starcounter.Techempower.World w"))
{
Debug.Assert(w.Id >= 1);
Debug.Assert(w.Id <= Count);
Debug.Assert(db.GetOid(w) != 0);
found++;
}
for (int id = found + 1; id <= Count; id++)
{
var w = db.Insert <World>();
w.Id = id;
w.RandomNumber = rnd.Next(1, Count + 1);
Debug.Assert(w.Id >= 1);
Debug.Assert(w.Id <= Count);
Debug.Assert(db.GetOid(w) != 0);
}
});
}
/// <inheritdoc/>
protected override void Execute(ITransactor transactor, object parameter)
{
foreach (var node in _nodes)
{
transactor.Transact(new MoveNodeCommand(_nodeToPositionMap[node]), node);
}
}
/// <inheritdoc/>
public override void ProcessInteraction(DiagramInteractionEventArguments interaction)
{
if (interaction.ViewModelUnderMouse is Wire wire)
{
var deleteWireCommand = new DeleteWireCommand(interaction.Diagram);
_transactor.Transact(deleteWireCommand, wire.WireModel);
}
}
/// <inheritdoc/>
protected override void Execute(ITransactor transactor, object parameter)
{
if (parameter is IEnumerable enumerable)
{
foreach (var item in enumerable)
{
transactor.Transact(_commandToMap, item);
}
}
}
/// <inheritdoc/>
protected override void Execute(ITransactor transactor, object parameter)
{
foreach (var node in _nodes)
{
if (_nodeToSizeMap.ContainsKey(node))
{
transactor.Transact(new ResizeNodeCommand(_nodeToSizeMap[node]), node);
}
}
}
/// <inheritdoc/>
protected override void Execute(ITransactor transactor, object parameter)
{
if (parameter is Node node)
{
foreach (var wire in node.Terminals.SelectMany(t => t.Model.ConnectedWires).ToArray())
{
transactor.Transact(_removeWireCommand, wire);
}
}
}
/// <inheritdoc/>
public override void StopInteraction(DiagramInteractionEventArguments interaction)
{
if (!interaction.IsCtrlKeyPressed)
{
foreach (var node in _resizingNodes)
{
node.X = interaction.Diagram.SnapToGrid(node.X);
node.Y = interaction.Diagram.SnapToGrid(node.Y);
node.Width = interaction.Diagram.SnapToGrid(node.Width);
node.Height = interaction.Diagram.SnapToGrid(node.Height);
}
}
interaction.Diagram.ShowSnapGrid = false;
Mouse.SetCursor(Cursors.Arrow);
var resizeCommand = new ResizeNodesToCurrentSizeCommand(_resizingNodes);
var positionAdjustmentCommand = new MoveNodesToCurrentPositionCommand(_resizingNodes);
_transactor.Transact(resizeCommand, _undoResizeCommand);
_transactor.Transact(positionAdjustmentCommand, _undoPositionAdjustmentCommand);
}
/// <inheritdoc/>
public override void ProcessInteraction(DiagramInteractionEventArguments interaction)
{
var diagram = interaction.Diagram;
var selectedNodes = diagram.Nodes.Where(n => n.IsSelected).ToArray();
var unwireAndRemoveAllNodesCommand = new MapCommand(new UnwireAndDeleteNodeCommand(diagram));
_transactor.Transact(unwireAndRemoveAllNodesCommand, selectedNodes);
if (!diagram.Nodes.Any())
{
diagram.ResetPanAndZoom();
}
}
/// <inheritdoc/>
public override void StopInteraction(DiagramInteractionEventArguments interaction)
{
if (interaction.Type == InteractionType.RightMouseDown)
{
var removeNodeCommand = new UnwireAndDeleteNodeCommand(interaction.Diagram);
removeNodeCommand.Execute(InsertingNodeViewModel);
}
else
{
InsertingNodeViewModel.X = interaction.Diagram.SnapToGrid(InsertingNodeViewModel.X);
InsertingNodeViewModel.Y = interaction.Diagram.SnapToGrid(InsertingNodeViewModel.Y);
}
_transactor.Transact(new UndoCommand(new UnwireAndDeleteNodeCommand(interaction.Diagram)), InsertingNodeViewModel);
InsertingNodeViewModel = null;
interaction.Diagram.ShowSnapGrid = false;
}
/// <inheritdoc/>
public override void StopInteraction(DiagramInteractionEventArguments interaction)
{
Mode = RiftMode.None;
_lastRiftDeltaX = 0;
_lastRiftDeltaY = 0;
if (_nodesBeingRifted == null)
{
return;
}
if (!interaction.IsCtrlKeyPressed)
{
foreach (var node in _nodesBeingRifted)
{
node.X = interaction.Diagram.SnapToGrid(node.X);
node.Y = interaction.Diagram.SnapToGrid(node.Y);
}
}
var doRiftCommand = new MoveNodesToCurrentPositionCommand(_nodesBeingRifted);
_transactor.Transact(doRiftCommand, _undoRiftCommand, null);
_nodesBeingRifted = null;
}
/// <summary>
/// Executes a command without providing a parameter.
/// </summary>
/// <param name="transactor">The transactor to execute the command with.</param>
/// <param name="command">The command to execute with a null parameter.</param>
public static void Transact(this ITransactor transactor, IReversableCommand command)
{
transactor.Transact(command, parameter: null);
}
private static void WireTwoTerminalsOnDiagram(Diagram diagram, Terminal startTerminal, Terminal endTerminal, ITransactor transactor, bool animateWire)
{
var wireToTerminalCommand = new WireToTerminalCommand(diagram, startTerminal.Model, animateWire);
transactor.Transact(wireToTerminalCommand, endTerminal.Model);
}
/// <summary>
/// Execute a command with a custom undo command. Useful for complex undo scenarios.
/// </summary>
/// <param name="transactor">The transactor to execute the command with.</param>
/// <param name="command">The command to execute.</param>
/// <param name="undoCommand">The command that will undo the <paramref name="command"/>.</param>
/// <param name="parameter">The parameter to pass into the command.</param>
public static void Transact(this ITransactor transactor, IReversableCommand command, IReversableCommand undoCommand, object parameter)
{
var commandWithCustomUndo = new CustomUndoCommand(command, undoCommand);
transactor.Transact(commandWithCustomUndo, parameter);
}