public AccountsViewModel() : base()
{
if (Settings.Accounts == null || !Settings.Accounts.Any())
{
AddCommand.Execute(null);
}
}
[Route(@"api/message/update")] //webhook uri part
public async Task <OkResult> Update([FromBody] Update update)
{
var commands = Bot.Commands;
var message = update.Message;
var client = await Bot.Get();
foreach (var command in commands)
{
if (command.Contains(message.Text))
{
await command.Execute(message, client);
return(Ok());
}
}
AddCommand addCommand = new AddCommand();
if (message.Text.IndexOf('-') != -1 || message.Text.IndexOf('+') != -1)
{
//вызвать addCommand
await addCommand.Execute(message, client);
}
//else
//{
// await addCommand.Add(message, client);
//}
return(Ok());
}
private string InterpredCommand(string[] data, string commandName)
{
Command addCmd = new AddCommand(data, repository, unitFactory);
Command reportcmd = new ReportCommand(data, repository, unitFactory);
Command removecmd = new RemoveCommand(data, repository, unitFactory);
string result = string.Empty;
if (commandName == "fight")
{
Environment.Exit(0);
}
switch (commandName)
{
case "add":
return(addCmd.Execute());
case "report":
return(reportcmd.Execute());
case "fight":
Environment.Exit(0);
break;
case "retire":
return(removecmd.Execute());
default:
throw new InvalidOperationException("Invalid command!");
}
return(result);
}
public void TestAddCommand()
{
var c = new AddCommand(options);
var actualResult = c.Execute(new long[] { 2, 2, 2 });
Assert.Equal(6, actualResult);
}
public void ToSaveRemoveCommandTest()
{
// fake LoadData
var dataAccessMock = new Mock <IDataAccess>();
dataAccessMock.Setup(m => m.ToLoad()).Returns(MockShoppingList());
// input one Item
var viewModel = new MainWindowViewModel(dataAccessMock.Object); // instance MainWindowViewModel
viewModel.WantBuy = "newItem";
// pressed add button
var addCommand = new AddCommand(viewModel);
addCommand.Execute(null);
// before remove
Assert.AreEqual(viewModel.ToBuys.Count, 1);
Assert.AreEqual(viewModel.ToBuys[0].Name, "newItem");
Assert.IsFalse(viewModel.ToBuys[0].IsDone);
// set selected Item
viewModel.SelectedToBuy = viewModel.ToBuys[0];
// delete selected
var removeSelectedCommand = new RemoveSelectedCommand(viewModel);
removeSelectedCommand.Execute(null);
// after clear
Assert.AreEqual(viewModel.ToBuys.Count, 0);
}
private void Insert(ICommand commandToInsert, int index)
{
var addCommand = new AddCommand(_commands, commandToInsert, index);
addCommand.Execute();
_added.Push(addCommand);
}
public void OnKeyUp(object sender, KeyRoutedEventArgs evt)
{
if (evt.Key == Windows.System.VirtualKey.Enter)
{
AddCommand.Execute(null);
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
if (e.OriginalSource is Button button)
{
switch (button.Name)
{
case "buttonEdit":
EditCommand?.Execute(null);
break;
case "buttonDelete":
DeleteCommand?.Execute(null);
break;
case "buttonCancel":
CancelCommand?.Execute(null);
break;
case "buttonSave":
SaveCommand?.Execute(null);
break;
case "buttonAdd":
AddCommand?.Execute(null);
break;
}
}
}
private void _rightMenuButton_Clicked(object sender, System.EventArgs e)
{
switch (RightMenu)
{
case RightMenuIcon.Add:
AddCommand?.Execute(null);
break;
case RightMenuIcon.CustomText:
case RightMenuIcon.CustomIcon:
RightMenuCommand?.Execute(null);
break;
case RightMenuIcon.Delete:
DeleteCommand?.Execute(null);
break;
case RightMenuIcon.Edit:
EditCommand?.Execute(null);
break;
case RightMenuIcon.Save:
SaveCommand?.Execute(null);
break;
case RightMenuIcon.Settings:
SettingsCommand?.Execute(null);
break;
}
}
public void When_deleting_item_in_cache_with_time_when_item_do_not_exists_should_not_block_add_operations()
{
var stream = new MemoryStream();
var command = new DeleteCommand();
command.SetContext(stream);
command.Init("foo2", "500");
command.FinishedExecuting += () => wait.Set();
command.Execute();
wait.WaitOne();
Assert.AreEqual("NOT_FOUND\r\n", ReadAll(stream));
wait.Reset();
var buffer = new byte[] { 1, 2, 3, 4 };
stream = GetStreamWithData(buffer);
var addCommand = new AddCommand();
addCommand.SetContext(stream);
addCommand.Init("foo2", "1", "6000", "4");
addCommand.FinishedExecuting += () => wait.Set();
addCommand.Execute();
wait.WaitOne();
Assert.AreEqual("STORED\r\n", ReadAll(6, stream));
}
/// <summary>
/// Adds/updates a list of documents with an optional Boost Value to all documents specified.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="documents">The documents.</param>
/// <param name="boostValue">The boost value to apply to all documents.</param>
public static void Add <T>(IEnumerable <T> documents, double?boostValue)
{
var docs = documents.Select(d => new KeyValuePair <T, double?>(d, boostValue));
var cmd = new AddCommand <T>(docs, ServiceLocator.Current.GetInstance <ISolrDocumentSerializer <T> >(), null);
cmd.Execute(Connection);
}
public void Execute_PassNull_ThrowsArgumentNullException()
{
// Arrange
var command = new AddCommand(VocabularyStubFactory.Stub());
// Assert
Assert.Throws <ArgumentNullException>(() => command.Execute(null));
}
public ProcessorsNode()
{
ProcessorNodes.CollectionChanged += ProcessorNodes_CollectionChanged;
if (Loaded)
{
AddCommand.Execute(null);
}
}
public void AddCommandTest()
{
ICommand addCommand = new AddCommand("ADD 2 F");
var result = addCommand.Execute(root);
var staff = treeVisitor.Find(root, x => x.Name == "2").Data;
Assert.IsTrue(staff.Permissions.FirstOrDefault(x => x.Name == "F") != null);
}
public void ShouldntAlterOriginalServerUrl()
{
var mocks = new MockRepository();
var conn = mocks.StrictMock <ISolrConnection>();
var docSerializer = new SolrDocumentSerializer <SampleDoc>(new AttributesMappingManager(), new DefaultFieldSerializer());
var cmd = new AddCommand <SampleDoc>(new[] {
new KeyValuePair <SampleDoc, double?>(new SampleDoc(), null),
}, docSerializer, null);
cmd.Execute(conn);
}
private void AddingNewOrder(string name, string position, string fullName, string date, string status)
{
_executorCommands.AddEvent = AddEventHandler;
var newPersonnelOrder = new PersonnelOrder()
{
Date = date, FullName = fullName, Name = name, Position = position, Status = status
};
var command = new AddCommand <PersonnelOrder>(_executorCommands, newPersonnelOrder);
command.Execute();
}
public static void GenerateAndRunTestCases(string command, string expectedDesc, string expectedTag, DateTime expectedDate, string expectedResultMessage, string message)
{
GGList originalList = new GGList();
AddOriginalDataToList(originalList);
GGList expectedList = new GGList();
CreateExpectedList(expectedList, expectedDesc, expectedTag, expectedDate);
AddCommand addCommand = new AddCommand();
GGResult actualResult = addCommand.Execute(command, originalList);
Assert.AreEqual(expectedList, originalList, message);
Assert.AreEqual(expectedResultMessage, actualResult.GetNotice(), "result message");
}
override public void Run(String[] args)
{
options = new CmdParserOptionSet()
{
{ "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() },
#if ported
{ "n|dry-run", "Don't actually add the files, just show if they exist.", v => { isDryRun = true; } },
{ "v|verbose", "Be verbose.", v => { isVerbose = true; } },
{ "f|force", "Allow adding otherwise ignored files.", v => { isForced = true; } },
{ "i|interactive", "Interactive picking.", v => { isInteractive = true; } },
{ "p|patch", "Interactive patching.", v => DoPatch() },
{ "e|edit", "Open the diff vs. the index in an editor and let the user edit it.", v => DoEdit() },
{ "u|update", "Update tracked files.", v => { isUpdateKnown = true; } },
{ "A|all", "Add all files, noticing removal of tracked files.", v => { isUpdateAll = true; } },
{ "N|intent-to-add", "Record only the fact the path will be added later.", v => { isIntentToAdd = true; } },
{ "refresh", "Don't add the files, only refresh the index.", v => { isRefreshOnly = true; } },
{ "ignore-errors", "Just skip files which cannot be added because of errors.", v => { isIgnoreErrors = true; } },
#endif
};
try
{
List <String> arguments = ParseOptions(args);
if (arguments.Count > 0)
{
//Add the file(s)
//DoAdd(arguments);
try
{
cmd.Arguments = arguments;
cmd.Execute();
}
catch (ArgumentException e)
{
Console.WriteLine("Path does not exist: " + e.ParamName);
Console.WriteLine("Adding path(s) has been aborted.");
}
}
else if (args.Length <= 0)
{
//Display the modified files for the existing repository
Console.WriteLine("Nothing specified, nothing added.");
Console.WriteLine("Maybe you wanted to say 'git add .'?");
}
else
{
OfflineHelp();
}
}
catch (OptionException e)
{
Console.WriteLine(e.Message);
}
}
public void Execute_ShouldReturnSuccessMessage_WhenAllDataIsRead()
{
var addCommand = new AddCommand(movieServiceMock.Object, readerMock.Object, writerMock.Object);
readerMock.Setup(x => x.ReadLine()).Returns("10");
var expectedValue = "Movie was added successfully.";
var returnValue = addCommand.Execute(new List <string>());
StringAssert.AreEqualIgnoringCase(expectedValue, returnValue);
}
public void Execute_PassEmptyParameters_ReturnWordIsNotSet()
{
// Arrange
var command = new AddCommand(VocabularyStubFactory.Stub());
// Act
var result = command.Execute(new string[0]);
// Assert
Assert.AreEqual(result, Default.WordIsNotSet);
}
public void TestMethod1()
{
var mwvm = new MainWindowViewModel();
mwvm.X = 1;
mwvm.Y = 2;
var addCommand = new AddCommand(mwvm);
addCommand.Execute(this);
Assert.AreEqual(3, mwvm.Z);
}
private void OnAdd(object sender, EventArgs e)
{
Image image = (Image)sender;
image.SetAnimation();
if (AddCommand != null && AddCommand.CanExecute(ShoppingList))
{
AddCommand.Execute(ShoppingList);
}
}
public void DocumentAddParametersOverwriteSpecifiedTrue()
{
var docSerializer = new SolrDocumentSerializer<TestDocWithString>(new AttributesMappingManager(), new DefaultFieldSerializer());
var conn = new Mocks.MSolrConnection();
conn.post = conn.post
.Args("/update", "<add overwrite=\"true\"><doc boost=\"2.1\" /></add>");
var docs = new[] { new KeyValuePair<TestDocWithString, double?>(new TestDocWithString(), 2.1) };
var parameters = new AddParameters { Overwrite = true };
var cmd = new AddCommand<TestDocWithString>(docs, docSerializer, parameters);
cmd.Execute(conn);
Assert.AreEqual(1, conn.post.Calls);
}
static void Main(string[] args)
{
var receiver = new Calculator(345, 9945);
var addCommand = new AddCommand(receiver);
var subtractCommand = new SubtractCommand(receiver);
var multiplyCommand = new MultiplyCommand(receiver);
Console.WriteLine($"Add command result: {addCommand.Execute()}");
Console.WriteLine($"Subtract command result: {subtractCommand.Execute()}");
Console.WriteLine($"Multiply command result: {multiplyCommand.Execute()}");
Console.ReadKey();
}
public void JobAdd_Execute_ReturnsNotFoundMessage()
{
var command = new AddCommand(_console, LoggerMock.GetLogger <AddCommand>().Object, _projectService.Object, _jobDefinitionService.Object)
{
Project = "Project 2",
Name = "Default 2"
};
var resultMessage = command.Execute();
Assert.Equal("Project Project 2 was not found", resultMessage);
}
public void ModelAdd_Execute_ReturnsSuccessMessage()
{
var command = new AddCommand(_console, LoggerMock.GetLogger <AddCommand>().Object, _projectService.Object, _projectModelService.Object)
{
Project = "Project 1",
Name = "Tag"
};
var resultMessage = command.Execute();
Assert.StartsWith("Model has been added:", resultMessage);
}
public void Execute_PassOnlyWordWithoutMeans_ReturnsMeansAreNotSet()
{
// Arrange
var word = "aaa";
var command = new AddCommand(VocabularyStubFactory.Stub());
// Act
var result = command.Execute(new[] { word });
// Assert
Assert.AreEqual(result, Default.MeansAreNotSet);
}
public void MemberAdd_Execute_ReturnsSuccessMessage()
{
var command = new AddCommand(_console, LoggerMock.GetLogger <AddCommand>().Object, _projectMemberService.Object, _projectService.Object, _accountService.Object)
{
Project = "Project 1",
User = "******"
};
var resultMessage = command.Execute();
Assert.StartsWith("User has been added to project Project 1:", resultMessage);
}
public void JobAdd_Execute_ReturnsSuccessMessage()
{
var command = new AddCommand(_console, LoggerMock.GetLogger <AddCommand>().Object, _projectService.Object, _jobDefinitionService.Object)
{
Project = "Project 1",
Name = "Default 2"
};
var resultMessage = command.Execute();
Assert.StartsWith("Job definition has been added", resultMessage);
}
public void QueueAdd_Execute_ReturnsNotFoundMessage()
{
var command = new AddCommand(_console, LoggerMock.GetLogger <AddCommand>().Object, _projectService.Object, _jobDefinitionService.Object, _jobQueueService.Object)
{
Project = "Project 1",
Job = "Default 2"
};
var resultMessage = command.Execute();
Assert.Equal("Failed to queue job Default 2. Make sure the project and job definition names are correct.", resultMessage);
}
public void QueueAdd_Execute_ReturnsSuccessMessage()
{
var command = new AddCommand(_console, LoggerMock.GetLogger <AddCommand>().Object, _projectService.Object, _jobDefinitionService.Object, _jobQueueService.Object)
{
Project = "Project 1",
Job = "Default"
};
var resultMessage = command.Execute();
Assert.StartsWith("Job Default has been queued successfully:", resultMessage);
}
private void AddingNewVacation(string status, string fullName, string personnelNumber, int quantityDays, string plannedDate, string factDate, string notes)
{
_executorCommands.AddEvent = AddEventHandler;
var newPersonnelVacation = new PersonnelVacation()
{
CountDay = quantityDays, FactDate = factDate, FullName = fullName, Notes = notes,
PersonnelNumber = personnelNumber, PlanDate = plannedDate, Position = status
};
var command = new AddCommand <PersonnelVacation>(_executorCommands, newPersonnelVacation);
command.Execute();
}
public void Execute() {
var conn = new Mocks.MSolrConnection();
conn.post += (url, content) => {
Assert.AreEqual("/update", url);
Assert.AreEqual("<add><doc><field name=\"Id\">id</field><field name=\"Flower\">23.5</field></doc></add>", content);
Console.WriteLine(content);
return null;
};
var docSerializer = new SolrDocumentSerializer<SampleDoc>(new AttributesMappingManager(), new DefaultFieldSerializer());
var docs = new[] {
new KeyValuePair<SampleDoc, double?>(new SampleDoc(), null),
};
var cmd = new AddCommand<SampleDoc>(docs, docSerializer, null);
cmd.Execute(conn);
Assert.AreEqual(1, conn.post.Calls);
}
public void DocumentBoost()
{
var mocks = new MockRepository();
var conn = mocks.StrictMock<ISolrConnection>();
var docSerializer = new SolrDocumentSerializer<TestDocWithString>(new AttributesMappingManager(), new DefaultFieldSerializer());
With.Mocks(mocks).Expecting(() => {
conn.Post("/update",
"<add><doc boost=\"2.1\" /></add>");
LastCall.On(conn).Repeat.Once().Do(new Writer(delegate(string ignored, string s) {
Console.WriteLine(s);
return null;
}));
}).Verify(() => {
var docs = new[] { new KeyValuePair<TestDocWithString, double?>(new TestDocWithString(), 2.1) };
var cmd = new AddCommand<TestDocWithString>(docs, docSerializer);
cmd.Execute(conn);
});
}
public void Execute()
{
var mocks = new MockRepository();
var conn = mocks.CreateMock<ISolrConnection>();
var docSerializer = new SolrDocumentSerializer<SampleDoc>(new AttributesMappingManager(), new DefaultFieldSerializer());
With.Mocks(mocks).Expecting(() => {
conn.Post("/update",
"<add><doc><field name=\"Id\">id</field><field name=\"Flower\">23.5</field></doc></add>");
LastCall.On(conn).Repeat.Once().Do(new Writer(delegate(string ignored, string s) {
Console.WriteLine(s);
return null;
}));
SetupResult.For(conn.ServerURL).Return("");
}).Verify(() => {
var docs = new[] {new SampleDoc()};
var cmd = new AddCommand<SampleDoc>(docs, docSerializer);
cmd.Execute(conn);
});
}
public void ShouldntAlterOriginalServerUrl()
{
var mocks = new MockRepository();
var conn = mocks.StrictMock<ISolrConnection>();
var docSerializer = new SolrDocumentSerializer<SampleDoc>(new AttributesMappingManager(), new DefaultFieldSerializer());
var cmd = new AddCommand<SampleDoc>(new[] {
new KeyValuePair<SampleDoc, double?>(new SampleDoc(), null),
}, docSerializer);
cmd.Execute(conn);
}
public void AddUserProfileTest()
{
var userProfile = new ProfilePostModel
{
UserName = UserNameConst,
Email = UserEmailConst,
Password = UserPassConst,
ConfirmPassword = UserPassConst
};
var command = new AddCommand(GetFakeApiController(), GetFakeUserRepository(), GetFakeAuthenticationKeeper(), userProfile);
Task<HttpResponseMessage> result = command.Execute();
result.Wait();
Assert.IsFalse(result.IsFaulted);
Assert.IsNotNull(result.Result);
Assert.IsInstanceOfType(result.Result, typeof(HttpResponseMessage));
Assert.AreEqual(result.Result.StatusCode, HttpStatusCode.Created);
}
public void SupportsDocumentWithStringCollection()
{
var mocks = new MockRepository();
var conn = mocks.StrictMock<ISolrConnection>();
var docSerializer = new SolrDocumentSerializer<TestDocWithCollections>(new AttributesMappingManager(), new DefaultFieldSerializer());
With.Mocks(mocks).Expecting(() => {
conn.Post("/update",
"<add><doc><field name=\"coll\">one</field><field name=\"coll\">two</field></doc></add>");
LastCall.On(conn).Repeat.Once().Do(new Writer(delegate(string ignored, string s) {
Console.WriteLine(s);
return null;
}));
}).Verify(() => {
var docs = new[] {
new KeyValuePair<TestDocWithCollections, double?>(new TestDocWithCollections(), null),
};
var cmd = new AddCommand<TestDocWithCollections>(docs, docSerializer, null);
cmd.Execute(conn);
});
}
public void FieldBoost()
{
var docSerializer = new SolrDocumentSerializer<TestDocWithFieldBoost>(new AttributesMappingManager(), new DefaultFieldSerializer());
var conn = new Mocks.MSolrConnection();
conn.post = conn.post
.Args("/update", "<add><doc><field name=\"SimpleBoost\" boost=\"20\">simple</field><field name=\"nameandboost\" boost=\"20\">boost</field></doc></add>");
var docs = new[] { new KeyValuePair<TestDocWithFieldBoost, double?>(new TestDocWithFieldBoost(), null) };
var cmd = new AddCommand<TestDocWithFieldBoost>(docs, docSerializer, null);
cmd.Execute(conn);
Assert.AreEqual(1, conn.post.Calls);
}
public void SupportsDocumentWithStringCollection()
{
var docSerializer = new SolrDocumentSerializer<TestDocWithCollections>(new AttributesMappingManager(), new DefaultFieldSerializer());
var conn = new Mocks.MSolrConnection();
conn.post = conn.post
.Args("/update", "<add><doc><field name=\"coll\">one</field><field name=\"coll\">two</field></doc></add>");
var docs = new[] {
new KeyValuePair<TestDocWithCollections, double?>(new TestDocWithCollections(), null),
};
var cmd = new AddCommand<TestDocWithCollections>(docs, docSerializer, null);
cmd.Execute(conn);
Assert.AreEqual(1, conn.post.Calls);
}
public void FieldBoost()
{
var mocks = new MockRepository();
var conn = mocks.StrictMock<ISolrConnection>();
var docSerializer = new SolrDocumentSerializer<TestDocWithFieldBoost>(new AttributesMappingManager(), new DefaultFieldSerializer());
With.Mocks(mocks).Expecting(() =>
{
conn.Post("/update",
"<add><doc><field name=\"SimpleBoost\" boost=\"20\">simple</field><field name=\"nameandboost\" boost=\"20\">boost</field></doc></add>");
LastCall.On(conn).Repeat.Once().Do(new Writer(delegate(string ignored, string s)
{
Console.WriteLine(s);
return null;
}));
Expect.On(conn).Call(conn.ServerURL).Repeat.Any().Return("");
}).Verify(() =>
{
var docs = new[] {
new KeyValuePair<TestDocWithFieldBoost, double?>(new TestDocWithFieldBoost(), null),
};
var cmd = new AddCommand<TestDocWithFieldBoost>(docs, docSerializer);
cmd.Execute(conn);
});
}
public void DocumentBoost()
{
var conn = new Mocks.MSolrConnection();
conn.post += (url, content) => {
Assert.AreEqual("/update", url);
Assert.AreEqual("<add><doc boost=\"2.1\" /></add>", content);
Console.WriteLine(content);
return null;
};
var docSerializer = new SolrDocumentSerializer<TestDocWithString>(new AttributesMappingManager(), new DefaultFieldSerializer());
var docs = new[] { new KeyValuePair<TestDocWithString, double?>(new TestDocWithString(), 2.1) };
var cmd = new AddCommand<TestDocWithString>(docs, docSerializer, null);
cmd.Execute(conn);
Assert.AreEqual(1, conn.post.Calls);
}
