private void AddBook(object obj)
{
Books book = new Books()
{
ID_Book = Guid.NewGuid().ToString(),
Name = Book.Name,
ID_Company = (SelectedCompany is null) ? null : SelectedCompany.ID_Company,
Year = (Book.Year is null) ? null : Book.Year,
ISBN = Book.ISBN,
Description = Book.Description,
ID_Genre = (SelectedGenre is null) ? null : SelectedGenre.ID_Genre
};
try
{
_dbContext.Books.Add(book);
_dbContext.Authors.SingleOrDefault(x => x.ID_Author == _transferData.ID_Author).Books.Add(book);
_dbContext.SaveChanges();
_transferData.ID_Book = book.ID_Book;
ExitCommand.Execute();
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
}
}
public string Dispatch(string input)
{
string[] args = input.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
string commandName = args.Length > 0 ? args[0] : String.Empty;
string[] commandArgs = args.Skip(1).ToArray();
switch (commandName)
{
case "Exit":
ExitCommand exitCommand = new ExitCommand();
return(exitCommand.Execute(new string[0]));
case "RegisterUser":
RegisterUserCommand registerUserCommand = new RegisterUserCommand(authenticationManager);
return(registerUserCommand.Execute(commandArgs));
case "Login":
LoginCommand loginCommand = new LoginCommand(authenticationManager);
return(loginCommand.Execute(commandArgs));
case "Logout":
LogoutCommand logoutCommand = new LogoutCommand(authenticationManager);
return(logoutCommand.Execute(commandArgs));
case "DeleteUser":
DeleteUserCommand deleteUserCommand = new DeleteUserCommand(authenticationManager);
return(deleteUserCommand.Execute(commandArgs));
default:
throw new NotSupportedException($"Command {commandName} is not supported");
}
}
private void EditCommand(object obj)
{
try
{
var oldEmployee = db.Employees.Where(x => x.EmployeeId == Employee.EmployeeId).SingleOrDefault();
if (oldEmployee != null)
{
//oldEmployee.EmployeeId = Employee.EmployeeId;
oldEmployee.FirstName = Employee.FirstName;
oldEmployee.LastName = Employee.LastName;
oldEmployee.Patronymic = Employee.Patronymic;
oldEmployee.Rank = Employee.Rank;
oldEmployee.Position = Employee.Position;
}
//oldEmployee = Employee;
//db.Employees.Remove(db.Employees.Where(x => x.EmployeeId == employee.EmployeeId).First());
//db.Employees.Add(employee);
db.SaveChanges();
logger.Info("Данные сотрудника изменены на " + Employee.FirstName + " " + Employee.LastName);
MessageBox.Show("Данные сотрудника изменены");
ExitCommand.Execute();
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
logger.Error(exc, "Ошибка c изменением данных сотрудника");
}
}
private void AddCommand(object obj)
{
Material material = new Material()
{
NumberEK = Material.NumberEK,
Story = Material.Story,
DateOfRegistration = Material.DateOfRegistration,
DateOfTerm = Material.DateOfTerm,
Extension = Material.Extension,
Decision = Material.Decision,
ExecutedOrNotExecuted = Material.ExecutedOrNotExecuted,
Perspective = Material.Perspective
};
try
{
//db.Materials.Add(material);
//db.Employees.SingleOrDefault(x => x.EmployeeId == Employee.EmployeeId).Materials.Add(material);
//db.SaveChanges();
CreateMaterialAsync(material, Employee);
logger.Info("Материал ЕК№" + material.NumberEK + " добавлен в БД");
MessageBox.Show("Материал добавлен");
ExitCommand.Execute();
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
logger.Error(exc, "Ошибка c добавлением материала в БД ");
}
}
private void AddCommand(object obj)
{
Employee employee = new Employee()
{
FirstName = Employee.FirstName,
LastName = Employee.LastName,
Patronymic = Employee.Patronymic,
Rank = Employee.Rank,
Position = Employee.Position
};
try
{
CreateEmployeeAsync(employee);
logger.Info("Сотрудник " + employee.FirstName + " " + employee.LastName + " добавлен в БД");
MessageBox.Show("Сотрудник добавлен");
ExitCommand.Execute();
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
logger.Error(exc, "Ошибка c добавлением сотрудника в БД ");
}
}
public string DispatchCommand(string[] commandParameters)
{
string command = commandParameters[0].ToLower();
string result = "";
switch (command)
{
case "exit": result = ExitCommand.Execute();
break;
case "print-info": result = PrintInfo.Execute(commandParameters);
break;
case "buy-ticket": result = BuyTicket.Execute(commandParameters);
break;
case "publish-review": result = PublishReview.Execute(commandParameters);
break;
case "print-reviews": result = PrintReviews.Execute(commandParameters);
break;
case "change-trip-status": result = ChangeTripStatus.Execute(commandParameters);
break;
default:
break;
}
return(result);
}
private void AddCommand(object obj)
{
Employee employee = new Employee()
{
FirstName = Employee.FirstName,
LastName = Employee.LastName,
Patronymic = Employee.Patronymic,
Rank = Employee.Rank,
Position = Employee.Position
//Patronymic = (Author.Patronymic is null) ? "" : Author.Patronymic,
//Nickname = (Author.Nickname is null) ? "" : Author.Nickname
};
try
{
db.Employees.Add(employee);
db.SaveChanges();
logger.Info("Сотрудник " + employee.FirstName + " " + employee.LastName + " добавлен в БД");
MessageBox.Show("Сотрудник добавлен");
//_transferData.ID_Author = author.ID_Author;
ExitCommand.Execute();
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
logger.Error(exc, "Ошибка c добавлением сотрудника в БД ");
}
}
private void AddAuthor(object obj)
{
Authors author = new Authors()
{
ID_Author = Guid.NewGuid().ToString(),
Name = Author.Name,
Surname = Author.Surname,
Patronymic = (Author.Patronymic is null) ? "" : Author.Patronymic,
Nickname = (Author.Nickname is null) ? "" : Author.Nickname
};
try
{
_dbContext.Authors.Add(author);
_dbContext.SaveChanges();
_transferData.ID_Author = author.ID_Author;
ExitCommand.Execute();
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
}
}
public string Dispatch(string input)
{
string result = string.Empty;
string[] inputArgs = input.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
string commandName = inputArgs.Length > 0 ? inputArgs[0] : string.Empty;
inputArgs = inputArgs.Skip(1).ToArray();
switch (commandName)
{
case "Exit":
ExitCommand exit = new ExitCommand();
exit.Execute(inputArgs);
break;
case "RegisterUser":
RegisterUserCommand registerUser = new RegisterUserCommand();
result = registerUser.Execute(inputArgs);
break;
default:
throw new NotSupportedException($"Command {commandName} not supported!");
}
return(result);
}
private void EditCommand(object obj)
{
try
{
//var oldMaterial = db.Materials.Where(x => x.MaterialId == Material.MaterialId).SingleOrDefault();
//if (oldMaterial != null)
//{
// //MaterialId = Material.MaterialId,
// oldMaterial.NumberEK = Material.NumberEK;
// oldMaterial.Story = Material.Story;
// oldMaterial.DateOfRegistration = Material.DateOfRegistration;
// oldMaterial.DateOfTerm = Material.DateOfTerm;
// oldMaterial.Extension = Material.Extension;
// oldMaterial.Decision = Material.Decision;
// oldMaterial.ExecutedOrNotExecuted = Material.ExecutedOrNotExecuted;
// oldMaterial.Perspective = Material.Perspective;
//}
//db.SaveChanges();
UpdateMaterialAsync(Material);
logger.Info("Материал ЕК№" + Material.NumberEK + " изменен");
MessageBox.Show("Материал изменен");
ExitCommand.Execute();
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
logger.Error(exc, "Ошибка c изменением данных материала в БД ");
}
}
public void ExitCommandShouldSetIsCompletedTrue()
{
var command = new ExitCommand(this._invoker);
command.Execute();
Assert.AreEqual(true, this._invoker.IsCompleted);
}
private void model_RevitDocumentLost()
{
var hsvm = (HomeWorkspaceViewModel)HomeSpaceViewModel;
hsvm.CurrentNotificationLevel = NotificationLevel.Error;
hsvm.CurrentNotificationMessage = Resources.DocumentLostWarning;
CloseHomeWorkspaceCommand.Execute(null);
ExitCommand.Execute(null);
}
public void ExitCommandsReturnsExitState()
{
GameState expected = GameState.Exit;
var command = new ExitCommand();
var actual = command.Execute();
Assert.AreEqual(expected, actual);
}
public void Execute_WhenInvoked_ReturnsOne()
{
// Arrange
var subject = new ExitCommand();
// Act
var result = subject.Execute(new ExitOptions());
// Assert
Assert.AreEqual(1, result);
}
public void InvalidArgumentTest()
{
ICommand command = new ExitCommand();
var commandResult = command.Execute(new List <string>()
{
"Some argument"
});
Assert.IsNotNull(commandResult);
Assert.AreEqual(1, commandResult.Count());
Assert.AreEqual("Invalid arguments", commandResult.First());
}
/// <summary>
/// Handles the window closing event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.ComponentModel.CancelEventArgs"/> instance containing the event data.</param>
private void HandleShellClosing(object sender, CancelEventArgs e)
{
var canExit = m_ExitCommand.CanExecute(null);
if (!canExit)
{
e.Cancel = true;
return;
}
m_ExitCommand.Execute(null);
}
public void CallsExit()
{
var viewModel = Mock.Of <IViewModel>();
var command = new ExitCommand(viewModel)
{
Exiter = Mock.Of <IExiter>()
};
command.Execute(null);
Mock.Get(command.Exiter).Verify(x => x.Exit());
}
public string DispatchCommand(string[] commandParameters)
{
string command = commandParameters.First().ToLower();
string[] parameters = commandParameters.ToArray();
int parametersCount = parameters.Length;
string output = string.Empty;
switch (command)
{
case "addemployee":
output = AddEmployeeCommand.Execute(parameters);
break;
case "setbirthday":
output = SetBirthdayCommand.Execute(parameters);
break;
case "setaddress":
output = SetAddressCommand.Execute(parameters);
break;
case "employeeinfo":
output = EmployeeInfoCommand.Execute(parameters);
break;
case "employeepersonalinfo":
output = EmployeePersonalInfoCommand.Execute(parameters);
break;
case "setmanager":
output = SetManagerCommand.Execute(parameters);
break;
case "managerinfo":
output = ManagerInfoCommand.Execute(parameters);
break;
case "listemployeesolderthan":
output = ListEmplyeesOlderThan.Execute(parameters);
break;
case "exit":
output = ExitCommand.Execute();
break;
default: throw new InvalidOperationException($"Command {command} not valid!");
//break;
}
return(output);
}
public void Execute_CancelsToken()
{
var cancellationTokenSource = (CancellationTokenSource)typeof(CommandLoop)
.GetField(
"cancellationTokenSource",
BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(this.commandLoop);
var exitCommand = new ExitCommand(this.commandLoop);
exitCommand.Execute(CancellationToken.None);
Assert.That(cancellationTokenSource.IsCancellationRequested, Is.True);
}
public void CheckIfMethodExitExecuteReturnsProperString()
{
IMatrixField field = FieldFactory.Instance.GetField(5);
IScoreboard scoreboard = new ScoreboardProxy();
IRandomNumberGenerator random = new RandomNumberGenerator();
IGameEngine gameEngine = new GameFifteenEngine(field, scoreboard, random);
ExitCommand exitCommand = new ExitCommand(gameEngine);
string result = exitCommand.Execute();
Assert.AreEqual(result, GlobalConstants.ExitMessage);
}
public override async Task Init()
{
await Task.Delay(1);
//auto back page
Device.StartTimer(TimeSpan.FromSeconds(15), () =>
{
if (FuncHelp.CurrentPage() is CustomerFinishPage)
{
ExitCommand.Execute(null);
}
return(false); // not repeat
});
}
public void Shutdown()
{
var application = new Mock<IAbstractApplications>();
{
application.Setup(a => a.Shutdown())
.Verifiable();
}
var command = new ExitCommand(application.Object);
Assert.IsTrue(command.CanExecute(null));
command.Execute(null);
application.Verify(a => a.Shutdown(), Times.Once());
}
public async void ExitCommand_Execute()
{
// ARRANGE
var interaction = new Mock <IInteractionProvider>();
interaction.SetupGet(_ => _.IsDebugMode).Returns(true);
var command = new ExitCommand(interaction.Object);
// ACT
await command.Execute();
// ASSERT
interaction.Verify(_ => _.Warn(It.IsAny <string>()));
interaction.Verify(_ => _.Exit());
}
public void PromptsUserBeforeExiting()
{
// arrange
var console = new Mock <IConsole>();
console.Setup(x => x.ReadLine(message)).Returns("n");
var executor = new Mock <IRepl>();
var cmd = new ExitCommand(console.Object);
// act
cmd.Execute(executor.Object, null);
// assert
console.Verify(x => x.ReadLine(message));
}
async void SingInAsync()
{
HttpResponseMessage response = await client.GetAsync("Users/SingIn?Name=" + User.Name + "&Password="******"Введены неверные логин или пароль, попробуйте еще раз");
}
}
public string DispatchCommand(string[] commandParameters)
{
string commandName = commandParameters[0];
commandParameters = commandParameters.Skip(1).ToArray();
string result = string.Empty;
EventService eventService = new EventService();
switch (commandName)
{
case "CreateEvent":
CreateEventCommand createEvent = new CreateEventCommand(eventService);
result = createEvent.Execute(commandParameters);
break;
case "DeleteEvent":
DeleteEventCommand deleteEvent = new DeleteEventCommand(eventService);
result = deleteEvent.Execute(commandParameters);
break;
case "EditEvent":
EditEventCommand editEvent = new EditEventCommand(eventService);
result = editEvent.Execute(commandParameters);
break;
case "ListEvents":
ListEventsCommand listEvents = new ListEventsCommand(eventService);
result = listEvents.Execute(commandParameters);
break;
case "Help":
HelpCommand help = new HelpCommand();
result = help.Execute(commandParameters);
break;
case "Exit":
ExitCommand exit = new ExitCommand(eventService);
result = exit.Execute(commandParameters);
break;
default:
result = $@"Command {commandName} does not exist. Type ""Help"" to check the available commands.";
break;
}
return(result);
}
private void EditAuthor(object obj)
{
var oldAuthor = _dbContext.Authors.Where(x => String.Equals(x.ID_Author, _transferData.ID_Author)).SingleOrDefault();
if (oldAuthor != null)
{
oldAuthor.Name = Author.Name;
oldAuthor.Surname = Author.Surname;
oldAuthor.Patronymic = Author.Patronymic;
oldAuthor.Nickname = Author.Nickname;
_dbContext.SaveChanges();
ExitCommand.Execute();
}
}
private void EditCommand(object obj)
{
try
{
UpdateEmployeeAsync(Employee);
logger.Info("Данные сотрудника изменены на " + Employee.FirstName + " " + Employee.LastName);
MessageBox.Show("Данные сотрудника изменены");
ExitCommand.Execute();
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
logger.Error(exc, "Ошибка c изменением данных сотрудника");
}
}
public void DoesNotExitWhenUserAnswersNo()
{
// arrange
var console = new Mock <IConsole>();
console.Setup(x => x.ReadLine()).Returns("n");
var executor = new Mock <IRepl>();
var cmd = new ExitCommand(console.Object);
// act
cmd.Execute(executor.Object, null);
// assert
executor.Verify(x => x.Terminate(), Times.Never);
}
public void PromptsUserBeforeExiting()
{
// arrange
const string message = "Are you sure you wish to exit? (y/n): ";
var console = new Mock <IConsole>();
console.Setup(x => x.ReadLine()).Returns("n");
var executor = new Mock <IRepl>();
var cmd = new ExitCommand(console.Object);
// act
cmd.Execute(executor.Object, null);
// assert
console.Verify(x => x.Write(message));
}
public void ExitsWhenUserAnswersYes()
{
// arrange
var console = new Mock <IConsole>();
console.Setup(x => x.ReadLine(message)).Returns("y");
var executor = new Mock <IRepl>();
var cmd = new ExitCommand(console.Object);
// act
cmd.Execute(executor.Object, null);
// assert
executor.Verify(x => x.Terminate());
}
public void ExecuteExitCommand()
{
ExitCommand cmd = new ExitCommand();
cmd.Execute(null);
}
