public PublisherViewModel Get(string name)
{
PublisherDTO publisherDto = _publisherService.GetByName(name);
var publisherViewModel = Mapper.Map <PublisherViewModel>(publisherDto);
return(publisherViewModel);
}
private Publisher GetPublisher(PublisherDTO publisherDTO)
{
var newPublisher = new Publisher(publisherDTO.Name);
newPublisher.DefineId(publisherDTO.Id);
return(newPublisher);
}
private void Save_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(txtbox_PublisherName.Text))
{
ShowMsg("Adding error", "First fill all fields");
}
else
{
PublisherDTO publisherDTO = new PublisherDTO()
{
Name = txtbox_PublisherName.Text
};
IBLLClass bLLClass = new BLLClass();
if (!bLLClass.IsExistPublisher(publisherDTO))
{
bLLClass.AddPublisher(publisherDTO);
publishers.LoadPublishers();
ShowMsg("Adding", "Publisher added!");
this.Close();
}
else
{
ShowMsg("Adding error", "Such publisher already exists!");
}
}
}
public void AddPublisher(PublisherDTO publisher)
{
var id = GetPublishers().Max(x => x.Id) + 1;
publisher.Id = id;
MockData.Current.Publishers.Add(publisher);
}
public IActionResult Post([FromBody] PublisherDTO DTO)
{
if (DTO == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var itemToCreate = Mapper.Map <Publisher>(DTO);
_rep.Add(itemToCreate);
if (!_rep.Save())
{
return(StatusCode(500,
"A problem occurred while handling your request."));
}
var createdDTO = Mapper.Map <PublisherDTO>(itemToCreate);
return(CreatedAtRoute("GetGenericPublisher",
new { id = createdDTO.Id }, createdDTO));
}
private Publisher MapToPublisher(PublisherDTO publisher)
{
return(new Publisher
{
Name = publisher.Name,
});
}
public IActionResult Post([FromBody] PublisherCreateDTO publisher)
{
if (publisher == null)
{
return(BadRequest());
}
if (publisher.Established < 1534)
{
ModelState.AddModelError("Established", "The first publishing house was founded in 1534.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var publisherToAdd = new PublisherDTO
{
Established = publisher.Established,
Name = publisher.Name
};
_rep.AddPublisher(publisherToAdd);
_rep.Save();
return(CreatedAtRoute("GetPublisher", new { id = publisherToAdd.Id }, publisherToAdd));
}
public IActionResult Post([FromBody] PublisherCreateDTO publisher)
{
if (publisher == null)
{
return(BadRequest());
}
if (publisher.Established < 1534 || publisher.Established > DateTime.Now.Year)
{
ModelState.AddModelError("Established", "Первое издательское агенство было основано в 1534 г.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var publisherToAdd = new PublisherDTO
{
Established = publisher.Established,
Name = publisher.Name
};
_rep.AddPublisher(publisherToAdd);
_rep.Save();
return(CreatedAtAction("GetPublisher",
new { id = publisherToAdd.Id }, publisherToAdd));
}
public EditPublisher(Grid parent, Publishers publishers, PublisherDTO publisherDTO)
{
InitializeComponent();
this.parent = parent;
this.publishers = publishers;
this.publisherDTO = publisherDTO;
txtbox_PublisherName.Text = publisherDTO.Name;
}
public void AddPublisher(PublisherDTO publisher)
{
// For Demo purposes only: Get next id
var id = GetPublishers().Max(m => m.Id) + 1;
publisher.Id = id;
MockData.Current.Publishers.Add(publisher);
}
public static Publisher MapPublisher(this PublisherDTO publisherDTO)
{
return(new Publisher
{
Id = publisherDTO.Id,
Name = publisherDTO.Name,
Country = publisherDTO.Country
});
}
/// <summary>
/// Удаляем издателя
/// </summary>
/// <param name="publisher"></param>
public void DeletePublisher(PublisherDTO publisher)
{
foreach (var book in publisher.Books)
{
DeleteBook(book);
}
MockData.Current.Publishers.Remove(publisher);
}
public Publisher Post(PublisherDTO value)
{
Publisher model = new Publisher()
{
Name = value.Name
};
return IPublisherRepository.Create(model);
}
public void DeletePublisher(PublisherDTO publisher)
{
var publisherToDelete = _db.Publishers.FirstOrDefault(x => x.Id.Equals(publisher.Id));
if (publisherToDelete != null)
{
_db.Publishers.Remove(publisherToDelete);
}
}
public void AddPublisher(PublisherDTO publisherDTO)
{
var _publisher = new Publisher()
{
Name = publisherDTO.Name
};
_context.Publishers.Add(_publisher);
_context.SaveChanges();
}
public IEnumerable <GameViewModel> Games(string name)
{
PublisherDTO publisher = _publisherService.GetByName(name);
var gamesDto = new List <GameDTO>();
publisher.GamesKey.ForEach(x => _gameService.GetByKey(x));
var games = Mapper.Map <IEnumerable <GameViewModel> >(gamesDto);
return(games);
}
public Publisher Put(int id, PublisherDTO value)
{
Publisher model = IPublisherRepository.Get(id);
if (value.Name != null)
{
model.Name = value.Name;
}
return IPublisherRepository.Update(model);
}
public static void Validate(PublisherDTO publisher)
{
if (publisher == null)
{
throw new ValidationException("Cannot create publisher from null", "Publisher");
}
if (publisher.Translates.Any(x => string.IsNullOrEmpty(x.Name)))
{
throw new ValidationException("Property name cannot be empty: PublisherDTO", "Name");
}
}
public void DeletePublisher(PublisherDTO publisher)
{
foreach (var book in publisher.Books)
{
DeleteBook(book);
}
// Alternative implementation to remove the books from a publisher
// MockData.Current.Books.RemoveAll(b => b.PublisherId.Equals(publisher.Id));
MockData.Current.Publishers.Remove(publisher);
}
public void Create(PublisherDTO entity)
{
if (entity == null)
{
throw new ArgumentNullException();
}
var publisher = Mapper.Map <PublisherDTO, Publisher>(entity);
Database.Publishers.Create(publisher);
Database.Save();
}
public List <PublisherDTO> GetListPublisher()
{
List <PublisherDTO> publisherDTOs = new List <PublisherDTO>();
string query = string.Format("SELECT * FROM dbo.Publisher");
DataTable dataTable = DataProvider.Instance.ExcuteQuery(query);
foreach (DataRow item in dataTable.Rows)
{
PublisherDTO publisherDTO = new PublisherDTO(item);
publisherDTOs.Add(publisherDTO);
}
return(publisherDTOs);
}
public void RemovePublisher(PublisherDTO publisher)
{
if (this.dbContext.Publishers.Any(x => x.Name == publisher.Name))
{
var publisherToRemove = this.dbContext.Publishers.First(x => x.Name == publisher.Name);
this.dbContext.Publishers.Remove(publisherToRemove);
this.dbContext.SaveChanges();
}
else
{
throw new ArgumentException("The publisher that you are trying to remove does not exist.");
}
}
public IActionResult AddPublisher(PublisherDTO publisher)
{
Publisher newPublisher = _mapper.Map <Publisher>(publisher);
using (var _context = new BookStoreDbContext())
{
_context.Publishers.Add(newPublisher);
_context.SaveChanges();
}
return(Ok());
}
public void Edit_should_throw_PublisherNotFoundException_if_publisher_with_specified_id_does_not_exist_in_the_database()
{
//Arrange
var publisher = new PublisherDTO()
{
Name = It.IsAny <string>()
};
_publisherRepository.Setup(x => x.Get(It.IsAny <int>())).Returns <Publisher>(null);
//Act & Assert
Assert.Throws <PublisherNotFoundException>(() => _publisherService.Edit(publisher));
}
public MainViewModel(IPortalPersistence model, PublisherDTO author)
{
_model = model ?? throw new ArgumentNullException("model");
_isLoaded = false;
_publisher = author;
EditArticleCommand = new DelegateCommand(param => EditArticleAction((int)param));
ExitCommand = new DelegateCommand(_ => ExitApplication?.Invoke(this, EventArgs.Empty));
CreateArticleCommand = new DelegateCommand(_ => CreateArticleAction());
Refresh();
}
private void LoginSuccess(object sender, PublisherDTO author)
{
mainViewModel = new MainViewModel(persistence, author);
mainViewModel.CreateArticle += MainViewModel_CreateArticle;
mainViewModel.EditArticle += MainViewModel_EditArticle;
mainViewModel.ExitApplication += ExitApplication;
mainViewModel.MessageApplication += ViewModel_MessageApplication;
mainWindow = new MainWindow();
mainWindow.DataContext = mainViewModel;
mainWindow.Show();
loginWindow.Close();
}
private void ButtonEdit_Click(object sender, RoutedEventArgs e)
{
if (dataGrid.SelectedItem != null)
{
PublisherDTO publisherDTO = dataGrid.SelectedItem as PublisherDTO;
EditPublisher edit = new EditPublisher(grid, this, publisherDTO);
edit.OpenMsg += ShowMsg;
grid.Children.Add(edit);
}
else
{
ShowMsg("Editing a publisher", "First select publisher");
}
}
public void Create_should_create_publisher()
{
//Arrange
var publisher = new PublisherDTO()
{
Name = It.IsAny <string>()
};
//Act
_publisherService.Create(publisher);
//Assert
_publisherRepository.Verify(x => x.Create(It.IsAny <Publisher>()));
}
public List <PublisherDTO> SearchPublisherByName(string name)
{
List <PublisherDTO> publisherDTOs = new List <PublisherDTO>();
string query = string.Format("SELECT * FROM dbo.Publisher WHERE dbo.fuConvertToUnsign1(name) " +
"LIKE N'%' + dbo.fuConvertToUnsign1(N'{0}') + '%'", name);
DataTable dataTable = DataProvider.Instance.ExcuteQuery(query);
foreach (DataRow item in dataTable.Rows)
{
PublisherDTO publisherDTO = new PublisherDTO(item);
publisherDTOs.Add(publisherDTO);
}
return(publisherDTOs);
}
public PublisherDTO Parse(PublisherModel model)
{
PublisherDTO publisherdto = new PublisherDTO();
if (model.Name != null)
{
publisherdto.Name = model.Name;
}
if (model.Contact != 0)
{
publisherdto.ContactNumber = model.Contact;
}
return(publisherdto);
}
