public async Task <IActionResult> UpdateShiftById([FromBody] UpdateShiftRequestModel shiftRequestModel)
{
var result = await CommandRouter.RouteAsync <UpdateShiftCommand, IdResponse>(
new UpdateShiftCommand(shiftRequestModel.ShiftId, shiftRequestModel.ShiftStart, shiftRequestModel.ShiftEnd, shiftRequestModel.EmployeeId));
return(new ObjectResult(result));
}
public async Task <IActionResult> DeleteShiftById(Guid id)
{
var result =
await CommandRouter.RouteAsync <DeleteShiftByIdCommand, IdResponse>(new DeleteShiftByIdCommand(id));
return(new ObjectResult(result));
}
public void SetUp()
{
_commandHandlerFactory = Substitute.For <ICommandHandlerFactory>();
var testCommandHandler1 = Substitute.For <ICommandHandler <TestCommand> >();
testCommandHandler1.CanHandle(Arg.Any <TestCommand>()).Returns(true);
var testCommandHandler2 = Substitute.For <ICommandHandler <TestCommand> >();
testCommandHandler2.CanHandle(Arg.Any <TestCommand>()).Returns(true);
_test2CommandHandler = Substitute.For <ICommandHandler <Test2Command> >();
_test2CommandHandler.CanHandle(Arg.Any <Test2Command>()).Returns(true);
_test2Command = new Test2Command
{
Id = Guid.NewGuid()
};
_events = new[] { new Test2Event() };
_test2CommandHandler.Handle(_test2Command).Returns(_events);
var commandHandlerProvider = new CommandHandlerProvider(_commandHandlerFactory);
commandHandlerProvider.RegisterCommandHandler(testCommandHandler1);
commandHandlerProvider.RegisterCommandHandler(testCommandHandler2);
commandHandlerProvider.RegisterCommandHandler(_test2CommandHandler);
_eventHandler = Substitute.For <IEventHandler>();
_commandRouter = new CommandRouter(_eventHandler, commandHandlerProvider);
}
public async Task Should_allow_dynamic_reconfiguration_down()
{
var router = new CommandRouter();
int count = 0;
IPipe <InputContext> pipe = Pipe.New <InputContext>(cfg =>
{
cfg.UseRateLimit(100, TimeSpan.FromSeconds(1), router);
cfg.UseExecute(cxt =>
{
Interlocked.Increment(ref count);
});
});
await router.SetRateLimit(10);
var context = new InputContext("Hello");
var timer = Stopwatch.StartNew();
Task[] tasks = Enumerable.Range(0, 101)
.Select(index => Task.Run(async() => await pipe.Send(context)))
.ToArray();
await Task.WhenAll(tasks);
timer.Stop();
Assert.That(timer.ElapsedMilliseconds, Is.GreaterThan(9500));
}
public void SetUp()
{
var commandHandlerFactory = Substitute.For <ICommandHandlerFactory>();
_commandHandlerProvider = new CommandHandlerProvider(commandHandlerFactory);
_openTabCommandHandler = new OpenTabCommandHandler();
_commandHandlerProvider.RegisterCommandHandler(_openTabCommandHandler);
CommandHandler = new TCommandHandler
{
Id = AggregateId
};
CommandHandler2 = new TCommandHandler
{
Id = _aggregateId2
};
if (!CanUsePreregisteredCommandHandlersToHandleCommand())
{
ConfigureCommandHandlerFactory(commandHandlerFactory);
}
_eventHandler = Substitute.For <IEventHandler>();
_commandRouter = new CommandRouter(_eventHandler, _commandHandlerProvider);
_eventApplier = new EventApplier(new TypeInspector());
}
void OnPopupMenu(object o, EventArgs args)
{
object commandChain = this;
CommandEntrySet opset = new CommandEntrySet();
VersionControlItemList items = GetSelectedItems();
foreach (object ob in AddinManager.GetExtensionNodes("/MonoDevelop/VersionControl/StatusViewCommands"))
{
if (ob is TypeExtensionNode)
{
TypeExtensionNode node = (TypeExtensionNode)ob;
opset.AddItem(ParseCommandId(node));
VersionControlCommandHandler handler = node.CreateInstance() as VersionControlCommandHandler;
if (handler == null)
{
LoggingService.LogError("Invalid type specified in extension point 'MonoDevelop/VersionControl/StatusViewCommands'. Subclass of 'VersionControlCommandHandler' expected.");
continue;
}
handler.Init(items);
CommandRouter rt = new CommandRouter(handler);
rt.Next = commandChain;
commandChain = rt;
}
else
{
opset.AddSeparator();
}
}
IdeApp.CommandService.ShowContextMenu(opset, commandChain);
}
public async Task <IActionResult> UpdateTransporter(Guid id, [FromBody] TransporterRequestModel transporterRequestModel)
{
//var loggedIn = User.Claims.FirstOrDefault(c => c.Type == "sub").Value;
var Transporter = await QueryRouter.QueryAsync <GetTransporterById, Transporter>(new GetTransporterById(id));
if (Transporter != null)
{
if (String.IsNullOrEmpty(transporterRequestModel.Name))
{
transporterRequestModel.Name = Transporter.Name;
}
if (String.IsNullOrEmpty(transporterRequestModel.Address))
{
transporterRequestModel.Address = Transporter.Address;
}
if (transporterRequestModel.Telephone == 0)
{
transporterRequestModel.Telephone = Transporter.Telephone;
}
if (String.IsNullOrEmpty(transporterRequestModel.Email))
{
transporterRequestModel.Email = Transporter.Email;
}
}
var result = await CommandRouter.RouteAsync <UpdateTransporterCommand, IdResponse>(
new UpdateTransporterCommand(transporterRequestModel.Email, transporterRequestModel.Telephone,
transporterRequestModel.Address, transporterRequestModel.Name, id)
);
return(!result.IsSuccessful ? Conflict(result) : new ObjectResult(result));
}
public void CreateParkLotTest()
{
ICommands commands = new CommandRouter();
commands.create_parking_lot("4");
Assert.IsTrue(Program.ParkingLot != null && Program.ParkingLot.Cars.Length == 4);
}
/// <summary>
/// Initialization of the package; this method is called right
/// after the package is sited, so this is the place where you
/// can put all the initialization code that rely on services
/// provided by VisualStudio.
/// </summary>
///
/// <param name="cancellationToken">
/// A cancellation token to monitor
/// for initialization cancellation,
/// which can occur when VS is
/// shutting down.
/// </param>
///
/// <param name="progress">
/// A provider for progress updates.
/// </param>
///
/// <returns>
/// A task representing the async work of package initialization,
/// or an already completed task if there is none. Do not return
/// null from this method.
/// </returns>
protected override async System.Threading.Tasks.Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
OleMenuCommandService oleMenuCommandService = await GetServiceAsync(typeof(IMenuCommandService)) as OleMenuCommandService;
IVsSolution vsSolution = await GetServiceAsync(typeof(IVsSolution)) as IVsSolution;
await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
IMessageHelper messageHelper = new MessageHelper(vsSolution, new ErrorListProvider(this));
IProjectHelper projectHelper = new ProjectHelper();
IPackageOption packageOption = (PackageOption)GetDialogPage(typeof(PackageOption));
((PackageOption)packageOption).Init(messageHelper);
AbstractSwitch projectSwtich = new ProjectSwitch(true, ReferenceType.ProjectReference, packageOption, projectHelper, messageHelper);
AbstractSwitch packageSwitch = new PackageSwitch(true, ReferenceType.PackageReference, packageOption, projectHelper, messageHelper);
AbstractSwitch librarySwitch = new LibrarySwitch(true, ReferenceType.Reference, packageOption, projectHelper, messageHelper);
ICommandRouter commandRouter = new CommandRouter(packageOption, projectSwtich, packageSwitch, librarySwitch);
new CommandProject(commandRouter, messageHelper).Initialize(oleMenuCommandService, new Guid("c6018e68-fcab-41d2-a34a-42f7df92b162"), 0x0100);
new CommandPackage(commandRouter, messageHelper).Initialize(oleMenuCommandService, new Guid("c6018e68-fcab-41d2-a34a-42f7df92b162"), 0x0200);
new CommandLibrary(commandRouter, messageHelper).Initialize(oleMenuCommandService, new Guid("c6018e68-fcab-41d2-a34a-42f7df92b162"), 0x0300);
}
public async Task <IActionResult> CreateNewBooking([FromBody] BookingRequestModel bookingRequestModel)
{
var loggedIn = User.Claims.FirstOrDefault(c => c.Type == "sub").Value;
Guid LoggedInID = new Guid(loggedIn);
List <Order> orders = new List <Order>();
foreach (var order in bookingRequestModel.Orders)
{
orders.Add(new Order
{
BookingId = order.bookingId,
CustomerNumber = order.customerNumber,
WareNumber = order.wareNumber,
OrderNumber = order.orderNumber,
InOut = order.InOut,
TotalPallets = order.TotalPallets,
ExternalId = order.ExternalId,
Comment = order.Comment,
BottomPallets = order.BottomPallets,
SupplierName = order.SupplierName
});
}
var result = await CommandRouter.RouteAsync <CreateBookingCommand, IdResponse>(
new CreateBookingCommand(bookingRequestModel.totalPallets, bookingRequestModel.bookingTime,
bookingRequestModel.transporterName, bookingRequestModel.port, bookingRequestModel.actualArrival,
bookingRequestModel.startLoading, bookingRequestModel.endLoading, bookingRequestModel.email, orders, LoggedInID, bookingRequestModel.ExternalId, LoggedInID ));
return(!result.IsSuccessful ? Conflict(result) : new ObjectResult(result));
}
public void slotNumberForRegNo_NegTest()
{
Car[] cars = new Car[3]
{
new Car
{
Color = "white",
RegistrationNumber = "KA-01-HH-1234",
SlotNumber = 1
},
new Car
{
Color = "red",
RegistrationNumber = "KA-01-HH-9876",
SlotNumber = 2
},
new Car
{
Color = "blue",
RegistrationNumber = "KA-01-KH-1762",
SlotNumber = 3
}
};
sampleLot = new Model.ParkingLot(4)
{
Cars = cars
};
ICommands commands = new CommandRouter();
Program.ParkingLot = sampleLot;
int slotNo = commands.slot_number_for_registration_number("KA-01-HH-0000");
Assert.IsTrue(slotNo == -1);
}
public static IRunner BuildRunner(Action<IConfigurationHelper> configurator)
{
var configPlan = new ConfigurationPlan();
if (configurator != null)
{
configurator(configPlan);
}
configPlan.Validate();
var routingInfo = GetRoutingInfo(configPlan);
routingInfo.Validate();
var router = new CommandRouter(routingInfo);
var argsHelper = new ArgsHelper(configPlan.SwitchDelimiter);
var argsHelpProvider = new ArgsParameterHelpProvider(argsHelper);
var argsParameterBinder = new ArgsParameterBinder(argsHelper);
var helpProvider = new HelpProvider(router, argsHelpProvider);
var cmdProcessor = new CommandProcessor(router, configPlan.TypeInstantiationStrategy, argsParameterBinder);
return new RunnerInternal(helpProvider, cmdProcessor);
}
public void Should_be_called_when_send_faulted()
{
ICommandRouter router = new CommandRouter();
router.ConnectPipe(Pipe.New <CommandContext <SetConcurrencyLimit> >(cfg =>
{
cfg.UseExecute(cxt =>
{
throw new IntentionalTestException("Wow!");
});
}));
var observer = new Observer <CommandContext <SetConcurrencyLimit> >();
router.ConnectObserver(observer);
var observer2 = new Observer();
router.ConnectObserver(observer2);
Assert.That(async() => await router.SetConcurrencyLimit(32), Throws.TypeOf <IntentionalTestException>());
Assert.That(async() => await observer.SendFaulted, Throws.TypeOf <IntentionalTestException>());
Assert.That(async() => await observer2.SendFaulted, Throws.TypeOf <IntentionalTestException>());
}
public async Task <IActionResult> AssignSupplementTo(Guid userID, Guid suppId)
{
var result = await CommandRouter.RouteAsync <AssignSupplementToUserCommand, IdResponse>(
new AssignSupplementToUserCommand(userID, suppId));
return(new ObjectResult(result));
}
public async Task <IActionResult> AssignToShift(Guid id, Guid shiftId)
{
var result = await CommandRouter.RouteAsync <AssignUserToShiftCommand, IdResponse>(
new AssignUserToShiftCommand(id, shiftId));
return(new ObjectResult(result));
}
/// <summary>
/// Create CommandHookContext from the WebHook of a comment.
/// If the command is not on the list of <see cref="CommandRouter">CommandRouter</see>,
/// or it is not a comment for pull request, return null
/// </summary>
/// <param name="req"></param>
/// <returns>CommandHookContext object or null</returns>
public async Task <CommandHookContext> ParseAsync(HttpRequest req)
{
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
var comment = JsonConvert.DeserializeObject <PRCommentCreated>(requestBody);
var rawComment = comment?.comment?.body;
var command = rawComment?.Trim();
if (CommandRouter.ContainsKey(command) && comment?.pull_request != null)
{
return(new CommandHookContext()
{
Id = comment.comment?.id.ToString(),
Command = command,
PullRequestUri = new Uri(comment.pull_request.html_url),
PullRequestId = comment.pull_request.number.ToString(),
ReplyToId = comment.comment?.in_reply_to_id.ToString(),
RepositoryName = comment.repository.name,
RepositoryFullName = comment.repository.full_name
});
}
else
{
return(null);
}
}
public async Task <IActionResult> DeleteTransporter(Guid id)
{
var result =
await CommandRouter.RouteAsync <DeleteTransporterCommand, IdResponse>(new DeleteTransporterCommand(id));
return(!result.IsSuccessful ? Conflict(result) : new ObjectResult(result));
}
public void StatusCheckTest()
{
Car[] cars = new Car[2]
{
new Car
{
Color = "white",
RegistrationNumber = "KA-01-HH-1234",
SlotNumber = 1
},
new Car
{
Color = "red",
RegistrationNumber = "KA-01-HH-9876",
SlotNumber = 2
}
};
sampleLot = new Model.ParkingLot(4)
{
Cars = cars
};
ICommands commands = new CommandRouter();
Program.ParkingLot = sampleLot;
commands.status();
Program.ParkingLot = null;
Assert.ThrowsException <BaseException>(() => commands.status());
}
static void Main(string[] args)
{
while (true)
{
Console.WriteLine(">>>");
var command = Console.ReadLine();
try
{
RoutingStatus routingStatus = CommandRouter.RouteCommand(command);
switch (routingStatus)
{
case RoutingStatus.Quit:
Console.WriteLine("Exiting...");
return;
case RoutingStatus.Invalid:
Console.WriteLine(ErrorMessage.InvalidCommand);
Console.WriteLine(ConstantsKey.CommandHelp);
break;
case RoutingStatus.Success:
break;
}
}
catch (BaseException e)
{
Console.WriteLine(e.Message);
}
catch (Exception e)
{
Console.WriteLine("Fatal Error: {0}", e.Message);
}
}
}
public Task CreateIssueTransitionReplyComment(
[ActivityTrigger] CreateIssueTransitionReplyCommentContext context)
{
var body = $"The issue marked as {CommandRouter.GetTransition(context.Command)}. For more [detail]({context.Issue.Url}).";
return(_repository.CreatePullRequestReplyComment(int.Parse(context.PullRequestId), body,
int.Parse(context.InReplyTo)));
}
public async Task <IActionResult> CreateNewSupplier([FromBody] SupplierRequestModel supplierRequestModel)
{
var result = await CommandRouter.RouteAsync <CreateSupplierCommand, IdResponse>(
new CreateSupplierCommand(supplierRequestModel.Email,
supplierRequestModel.Telephone, supplierRequestModel.Name));
return(!result.IsSuccessful ? Conflict(result) : new ObjectResult(result));
}
public async Task <IActionResult> CreateNewOrder([FromBody] OrderRequestModel orderRequestModel)
{
var result = await CommandRouter.RouteAsync <CreateOrderCommand, IdResponse>(
new CreateOrderCommand(orderRequestModel.bookingId, orderRequestModel.customerNumber,
orderRequestModel.orderNumber, orderRequestModel.wareNumber, orderRequestModel.InOut));
return(!result.IsSuccessful ? Conflict(result) : new ObjectResult(result));
}
public async Task <IActionResult> AddUserToShift([FromBody] AddUserToShiftRequestModel addUserToShiftRequestModel)
{
var result = await CommandRouter.RouteAsync <AssignUserToShiftCommand, IdResponse>(
new AssignUserToShiftCommand(addUserToShiftRequestModel.EmployeeOnShift,
addUserToShiftRequestModel.id));
return(new ObjectResult(result));
}
/// <summary>
/// Called when the Autoplay options have been updated and action specified
/// </summary>
/// <param name="selectedLibrary"></param>
private void OptionsSelected(Autoplay newAutoplay, bool playNow)
{
// If any Autoplay options have changed then update them
AutoplayModel.CurrentAutoplay.UpdateOptions(newAutoplay);
// Pass the request on to the StartAutoPlaylistCommandHandler
CommandRouter.HandleCommand(playNow ? Resource.Id.auto_play : Resource.Id.auto_queue, selectedObjects.SelectedObjects, commandCallback, commandButton);
}
public ParkingController(DbContext dbContext, AuthenticationService authenticationService, CommandStoreService commandStoreService, ParkingQueryHandler queryHandler, CommandRouter commandRouter)
{
_dbContext = dbContext;
_authenticationService = authenticationService;
_commandStoreService = commandStoreService;
_queryHandler = queryHandler;
_commandRouter = commandRouter;
}
public async Task <IActionResult> UpdateUserByIdObjectAsParam(Guid id, UpdateUserRequestModel userRequestModel)
{
//*****************Calls update controller on Identity API, so the db is synced***************************
//var identityBaseurl = _identityConfig.Value.IdentityServerUrl + "/identity/users/" + id;
var identityBaseurl = "https://localhost:5001/identity/users/" + id;
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders
.Accept
.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
var jsonUpdateStatement = JsonConvert.SerializeObject(new UpdateIdentityUser
{
Email = userRequestModel.Email,
Password = userRequestModel.Password,
AuthLevel = userRequestModel.AccessLevel,
}, Formatting.Indented);
var httpContent = new StringContent(jsonUpdateStatement, System.Text.Encoding.UTF8, "application/json");
var identityResult = await httpClient.PutAsync(identityBaseurl, httpContent);
if (!identityResult.IsSuccessStatusCode)
{
return(StatusCode(400, "Identity server could not be reached."));
}
//*********************Update API db (seperate from identity db)************************
//Gets user from database to handle null and empty variables in the request model
var user = await QueryRouter.QueryAsync <GetUserById, User>(new GetUserById(id));
//if the variables are empty or null, (or 0 for access level), they wont be updated
if (user != null)
{
if (string.IsNullOrWhiteSpace(userRequestModel.Name) && !string.IsNullOrWhiteSpace(user.Name))
{
userRequestModel.Name = user.Name;
}
if (string.IsNullOrWhiteSpace(userRequestModel.Email) && !string.IsNullOrWhiteSpace(user.Email))
{
userRequestModel.Email = user.Email;
}
if (userRequestModel.AccessLevel == 0)
{
userRequestModel.AccessLevel = user.AccessLevel;
}
if (userRequestModel.Wage == 0)
{
userRequestModel.Wage = user.BaseWage;
}
}
var result = await CommandRouter.RouteAsync <UpdateUserCommand, IdResponse>(
new UpdateUserCommand(userRequestModel.Name, userRequestModel.Email, userRequestModel.Password,
userRequestModel.AccessLevel, userRequestModel.Wage, userRequestModel.EmploymentDate, id));
return(new ObjectResult(result));
}
public async Task <IActionResult> AddManyShifts([FromBody] AddManyShifts addUserToShiftRequestModel)
{
var result = await CommandRouter.RouteAsync <AddManyShiftsCommand, IdResponse>(
new AddManyShiftsCommand(addUserToShiftRequestModel.listOfShifts));
return(new ObjectResult(result));
}
public async Task <IActionResult> UpdateShiftAndEmployee(
[FromBody] UpdateShiftAndEmployeeRequestModel updateShiftAndEmployeeRequestModel)
{
var result = await CommandRouter.RouteAsync <CreateShiftWithEmployeeCommand, IdResponse>(
new CreateShiftWithEmployeeCommand(updateShiftAndEmployeeRequestModel.ShiftStart,
updateShiftAndEmployeeRequestModel.ShiftEnd, updateShiftAndEmployeeRequestModel.EmployeeId));
return(new ObjectResult(result));
}
public async Task <IActionResult> CreateNewTransporter([FromBody] TransporterRequestModel transporterRequestModel)
{
var result = await CommandRouter.RouteAsync <CreateTransporterCommand, IdResponse>(
new CreateTransporterCommand(transporterRequestModel.Email,
transporterRequestModel.Telephone, transporterRequestModel.Address,
transporterRequestModel.Name));
return(!result.IsSuccessful ? Conflict(result) : new ObjectResult(result));
}
public async Task <IActionResult> CreateNewSchedule([FromBody] ScheduleRequesteModel scheduleRequesteModel)
{
var result = await CommandRouter.RouteAsync <CreateScheduleCommand, IdResponse>(
new CreateScheduleCommand(scheduleRequesteModel.ScheduleDay, scheduleRequesteModel.CreatedBy,
scheduleRequesteModel.MischellaneousPallets, scheduleRequesteModel.shifts, scheduleRequesteModel.Intervals, scheduleRequesteModel.ScheduleId
, scheduleRequesteModel.Name));
return(!result.IsSuccessful ? Conflict(result) : new ObjectResult(result));
}
static void Main(string[] args)
{
var commandRouter = new CommandRouter();
commandRouter.Route(new ScheduleEvent
{
Id = Guid.NewGuid()
}).Wait();
Console.ReadKey();
}
public void BeforeEach()
{
var type = typeof (Fodder);
var exports = new List<Export>
{
new Export(type, type.GetMethod("Bantha"), "fodder", "bantha")
};
var routingInfo = new RoutingInfo(exports, "fodder");
_router = new CommandRouter(routingInfo);
}
internal EmacsCommandContext(
EmacsCommandsManager manager,
ITextStructureNavigatorSelectorService textStructureNavigatorSelectorService,
IEditorOperations editorOperations,
ITextView view,
CommandRouter commandRouter)
{
this.Manager = manager;
this.EditorOperations = editorOperations;
this.TextView = view;
this.CommandRouter = commandRouter;
this.TextStructureNavigator = textStructureNavigatorSelectorService.GetTextStructureNavigator(view.TextBuffer);
this.MarkSession = MarkSession.GetSession(view);
}
public CommandRouter GetCommandRouter(ITextView view)
{
return view.Properties.GetOrCreateSingletonProperty<CommandRouter>(
() =>
{
IOleCommandTarget nextCommandTarget = null;
IVsTextView textViewAdapter = EditorAdapterFactoryService.GetViewAdapter(view);
DTE dte = ServiceProvider.GetService<DTE>();
// create a new router and add it to the view's command chain
CommandRouter router = new CommandRouter(view, textViewAdapter as IOleCommandTarget, CompletionBroker, dte);
System.Runtime.InteropServices.Marshal.ThrowExceptionForHR(textViewAdapter.AddCommandFilter(router, out nextCommandTarget));
router.Next = nextCommandTarget;
return router;
});
}
public EmacsCommandsFilter(ITextView view, EmacsCommandsManager manager, CommandRouter router)
{
this.view = view;
this.manager = manager;
this.router = router;
}
void DoPopupMenu (Gdk.EventButton evnt)
{
object commandChain = this;
CommandEntrySet opset = new CommandEntrySet ();
VersionControlItemList items = GetSelectedItems ();
foreach (object ob in AddinManager.GetExtensionNodes ("/MonoDevelop/VersionControl/StatusViewCommands")) {
if (ob is TypeExtensionNode) {
TypeExtensionNode node = (TypeExtensionNode) ob;
opset.AddItem (ParseCommandId (node));
VersionControlCommandHandler handler = node.CreateInstance () as VersionControlCommandHandler;
if (handler == null) {
LoggingService.LogError ("Invalid type specified in extension point 'MonoDevelop/VersionControl/StatusViewCommands'. Subclass of 'VersionControlCommandHandler' expected.");
continue;
}
handler.Init (items);
CommandRouter rt = new CommandRouter (handler);
rt.Next = commandChain;
commandChain = rt;
} else
opset.AddSeparator ();
}
IdeApp.CommandService.ShowContextMenu (filelist, evnt, opset, commandChain);
public static void Initialize(IRepository repository)
{
Repository = repository;
CommandRouter = new CommandRouter(typeof(DomainLayer).Assembly);
}