public async Task <ActionResult <Book> > PostBook(string[] data)
{
PublishingHouse publishingHouse = _context.PublishingHouse.Where(l => l.Name == data[3]).Include(l => l.Books).FirstOrDefault();
Book book = new Book
{
Name = data[0],
Year = int.Parse(data[1]),
Pages = int.Parse(data[2]),
PublishingHouseId = publishingHouse.Id
};
book.PublishingHouse = publishingHouse;
publishingHouse.Books.Add(book);
if (ModelState.IsValid)
{
_context.Add(book);
await _context.SaveChangesAsync();
}
return(CreatedAtAction("GetBook", new { id = book.Id }, book));
// _context.Book.Add(book);
// await _context.SaveChangesAsync();
// return CreatedAtAction("GetBook", new { id = book.Id }, book);
}
public Book(
string name,
ISet <Author> authors,
PublishingHouse publishingHouse,
Language language,
BookType bookType,
BookCoverType bookCoverType,
int pagesCount,
string description,
string isbn,
int issueYear,
decimal price,
DateTime created,
ProductCategory productCategory,
bool isActive) : base(name, price, productCategory, created, isActive)
{
Authors = authors;
ISBN = isbn;
IssueYear = issueYear;
Language = language;
PublishingHouse = publishingHouse;
PagesCount = pagesCount;
Description = description;
BookType = bookType;
BookCoverType = bookCoverType;
}
/// <summary>
/// Gets Hash Code for current Book instance.
/// </summary>
/// <returns> Hash Code</returns>
public override int GetHashCode()
{
int hash = ((((Author.GetHashCode() * 31 + Title.GetHashCode()) * 31 + PublishingHouse.GetHashCode()) * 31 +
Year.GetHashCode()) * 31 + Genre.GetHashCode()) * 31;
return(hash);
}
private void InitPublishingHouse()
{
var ph1 = new PublishingHouse
{
Name = "Весна",
Country = "Украина",
City = "Харьков",
Address = "пр. Гагарина, д.20",
PostalCode = "61010",
Phone = "+38 (057) 760 23 89",
FoundationDate = new DateTime(2016, 01, 01)
};
var ph2 = new PublishingHouse
{
Name = "Минкуль СССР",
Country = "СССР",
City = "Москва",
FoundationDate = new DateTime(1953, 01, 01)
};
var ph3 = new PublishingHouse
{
Name = "Минздрав СССР",
Country = "СССР",
City = "Москва",
FoundationDate = new DateTime(1933, 01, 01)
};
context.PublishingHouses.Add(ph1);
context.PublishingHouses.Add(ph2);
context.PublishingHouses.Add(ph3);
}
public async Task <IActionResult> PutPublishingHouse(int id, PublishingHouse publishingHouse)
{
if (id != publishingHouse.Id)
{
return(BadRequest());
}
_context.Entry(publishingHouse).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PublishingHouseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <PublishingHouse> > PostPublishingHouse(PublishingHouse publishingHouse)
{
_context.PublishingHouse.Add(publishingHouse);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPublishingHouse", new { id = publishingHouse.Id }, publishingHouse));
}
private void CreatePublishingHouse(PublishingHouseVM publishingHouseVM, HttpPostedFileBase PHImage)
{
bool result = false;
PublishingHouse publishingHouse = new PublishingHouse();
publishingHouse.CompanyName = publishingHouseVM.CompanyName;
publishingHouse.ContactName = publishingHouseVM.ContactName;
publishingHouse.Phone = publishingHouseVM.Phone;
publishingHouse.AddressDetail = publishingHouseVM.AddressDetail;
if (PHImage != null)
{
publishingHouse.ImagePath = CreateImagePath(PHImage, publishingHouse.CompanyName);
}
try
{
result = _publishingHouseService.Add(publishingHouse);
if (result)
{
ViewBag.result = hata.KayıtBasarili;
}
else
{
ViewBag.result = hata.KayıtBasarisiz;
}
}
catch (Exception)
{
ViewBag.result = hata.HataOlustu;
}
}
static void Main(string[] args)
{
Console.WriteLine("-----------------------");
string input = "";
PublishingHouse house = new PublishingHouse("Sun House", new List <Book>(), 2001, 0);
while (true)
{
Console.WriteLine("To publish book press 1");
Console.WriteLine("To print info press 2");
input = Console.ReadLine();
switch (input)
{
case "1":
Console.WriteLine("How many books you want to publish?");
int amount = Int32.Parse(Console.ReadLine());
List <Book> newBooks = new List <Book>();
for (int i = 0; i < amount; i++)
{
newBooks.Add(EnterBook());
}
house.PublishBooks(newBooks);
break;
case "2": Console.WriteLine(house.ToString()); break;
default: Console.WriteLine("Wrong input"); break;
}
}
}
public ActionResult DeleteConfirmed(int id)
{
PublishingHouse publishingHouse = db.PublishingHouses.Find(id);
db.PublishingHouses.Remove(publishingHouse);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult PublishingHouseDeleteConfirmed(int id)
{
PublishingHouse publishingHouse = db.PublishingHouses.Find(id);
db.PublishingHouses.Remove(publishingHouse);
db.SaveChanges();
DisplaySuccessMessage("Has delete a PublishingHouse record");
return(RedirectToAction("PublishingHouseIndex"));
}
public static void Add(PublishingHouse publishingHouse)
{
if (publishingHouse == null)
{
throw new ArgumentNullException(nameof(publishingHouse));
}
DBInstance.DataContext.PublishingHouses.InsertOnSubmit(publishingHouse);
}
public void AddPublishingHouse(PublishingHouseViewModel pvm)
{
PublishingHouse publishingHouse = new PublishingHouse
{
Name = pvm.Name,
};
_publishingHouseRepository.Create(publishingHouse);
}
/// <summary>
/// Reads data from binary file and initialize Books collection property.
/// </summary>
public BinaryBookListRepository()
{
Books = new List <Book>();
RepositoryFileName = Settings.Default.BinaryRepositoryName;
if (!File.Exists(RepositoryFileName))
{
return;
}
Stream stream = File.OpenRead(RepositoryFileName);
using (var reader = new BinaryReader(stream))
{
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
string isbn = reader.ReadString();
string authorFirstName = reader.ReadString();
string authorLastName = reader.ReadString();
string bookName = reader.ReadString();
string publishingHouseName = reader.ReadString();
int publishingYear = reader.ReadInt32();
int numberOfPages = reader.ReadInt32();
decimal price = reader.ReadDecimal();
int numberOfTags = reader.ReadInt32();
var tags = new List <string>();
for (int j = 0; j < numberOfTags; j++)
{
tags.Add(reader.ReadString());
}
var author = new Author()
{
FirstName = authorFirstName, LastName = authorLastName
};
var publishingHouse = new PublishingHouse()
{
Name = publishingHouseName
};
Books.Add(new Book()
{
Isbn = isbn,
Author = author,
Title = bookName,
PublishingHouse = publishingHouse,
PublishingYear = publishingYear,
NumberOfPages = numberOfPages,
Price = price,
Tags = tags
});
}
}
}
public void Delete(PublishingHouse entity)
{
using (BookDatabasesContext context = new BookDatabasesContext())
{
var deletedEntity = context.Entry(entity);
deletedEntity.State = EntityState.Deleted;
context.SaveChanges();
}
}
public void Update(PublishingHouse entity)
{
using (BookDatabasesContext context = new BookDatabasesContext())
{
var updatedEntity = context.Entry(entity);
updatedEntity.State = EntityState.Modified;
context.SaveChanges();
}
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
PublishingHouse publishingHouse = await db.PublishHouses.FindAsync(id);
db.PublishHouses.Remove(publishingHouse);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public void Add(PublishingHouse entity)
{
using (BookDatabasesContext context = new BookDatabasesContext())
{
var addedEntity = context.Entry(entity);
addedEntity.State = EntityState.Added;
context.SaveChanges();
}
}
public async Task <JsonMessageResult> CreatePublishingHouse(PublishingHouse model)
{
var response = await ApiRequestHandler.RequestHandler(HttpRequestMethods.Post,
$"{Route}CreatePublishingHouse",
CommonClass.ClassToDictionary(model));
return(string.IsNullOrEmpty(response)
? MsgProvider.Success("新增成功！")
: JsonConvert.DeserializeObject <JsonMessageResult>(response));
}
public ActionResult Edit([Bind(Include = "Id,Name,Address,Phone")] PublishingHouse publishingHouse)
{
if (ModelState.IsValid)
{
db.Entry(publishingHouse).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(publishingHouse));
}
public async Task <IActionResult> EditPublihingHouse(Guid id)
{
PublishingHouse PublishingHouse = await _context.PublishingHouses.FirstOrDefaultAsync(c => c.Id == id);
if (PublishingHouse != null)
{
return(View(PublishingHouse));
}
return(RedirectToAction("PublihingHouse"));
}
public async Task <IActionResult> Update(PublishingHouse publishingHouse)
{
var result = await _publishingHouseService.UpdateAsync(publishingHouse);
return(Ok(new PublishingHousesInAdminViewModel
{
Id = result.Id,
Name = result.Name,
CreateAt = result.CreateAt.ToLocalTime().ToString("yyyy-MM-dd"),
}));
}
public async Task <ActionResult> Edit([Bind(Include = "ID,Name,ImgUrl,Description")] PublishingHouse publishingHouse)
{
if (ModelState.IsValid)
{
db.Entry(publishingHouse).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(publishingHouse));
}
public ActionResult Create([Bind(Include = "Id,Name,Address,Phone")] PublishingHouse publishingHouse)
{
if (ModelState.IsValid)
{
db.PublishingHouses.Add(publishingHouse);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(publishingHouse));
}
/// <summary>
/// Returns representation of book, including <see cref="formatProvider"/>
/// <list type="bullet">
/// <item>
/// <term>"V"</term>
/// <description>Returns representation of book, including Author,Title,Year,PublishingHouse</description>
/// </item>
/// <item>
/// <term>"B"</term>
/// <description>Returns representation of book, including Author,Title,Year</description>
/// </item>
/// <item>
/// <term>"S"</term>
/// <description>Returns representation of book, including Author,Title</description>
/// </item>
/// <item>
/// <term>"L"</term>
/// <description>Returns representation of book, including Title,Year,PublishingHouse</description>
/// </item>
/// <item>
/// <term>"A"</term>
/// <description>Returns representation of book, including only Author</description>
/// </item>
/// <item>
/// <term>"T"</term>
/// <description>Returns representation of book, including only Title</description>
/// </item>
/// <item>
/// <term>"Y"</term>
/// <description>Returns representation of book, including only Year</description>
/// </item>
/// <item>
/// <term>"H"</term>
/// <description>Returns representation of book, including only PublishingHouse</description>
/// </item>
/// <item>
/// <term>"E"</term>
/// <description>Returns representation of book, including only Edition</description>
/// </item>
/// <item>
/// <term>"P"</term>
/// <description>Returns representation of book, including only Pages</description>
/// </item>
/// </list>
/// </summary>
public string ToString(string format, IFormatProvider formatProvider)
{
if (string.IsNullOrEmpty(format))
{
format = "V";
}
if (formatProvider == null)
{
formatProvider = CultureInfo.CurrentCulture;
}
switch (format.ToUpperInvariant())
{
case "A":
return(Author?.ToString(formatProvider) ?? string.Empty);
case "T":
return(Title?.ToString(formatProvider) ?? string.Empty);
case "Y":
return(Year.ToString(formatProvider));
case "H":
return(PublishingHouse?.ToString(formatProvider) ?? string.Empty);
case "E":
return(Edition.ToString(formatProvider));
case "P":
return(Pages.ToString(formatProvider));
case "V":
return("Book record: " + Author?.ToString(formatProvider) + ", " + Title?.ToString(formatProvider) + ", "
+ Year.ToString(formatProvider) + ", " + PublishingHouse?.ToString(formatProvider));
case "B":
return("Book record: " + Author?.ToString(formatProvider) + ", " + Title?.ToString(formatProvider) + ", "
+ Year.ToString(formatProvider));
case "S":
return("Book record: " + Author?.ToString(formatProvider) + ", " + Title?.ToString(formatProvider));
case "L":
return("Book record: " + Title?.ToString(formatProvider) + ", " + Year.ToString(formatProvider) + ", "
+ PublishingHouse?.ToString(formatProvider));
case string str when !str.Except(new[] { 'T', 'Y', 'H', 'E', 'P', 'A' }).Any():
return(string.Join(", ", format.Select(c => this.ToString(c.ToString(), formatProvider))));
default:
throw new FormatException($"The {format} format string is not supported.");
}
}
public void Update(PublishingHouse publishingHouse)
{
if (publishingHouse.PublishingHouseName.Length >= 2)
{
_publishingHouseDal.Update(publishingHouse);
Console.WriteLine("Yayınevi başarıyla güncellendi.");
}
else
{
Console.WriteLine($"İsim minimum iki karekter olmalıdır! Girdiğiniz yayınevi adı : {publishingHouse.PublishingHouseName}");
}
}
public ActionResult PublishingHouseEdit([Bind(Include = "Editions,Id,Name")] PublishingHouse publishingHouse)
{
if (ModelState.IsValid)
{
db.Entry(publishingHouse).State = EntityState.Modified;
db.SaveChanges();
DisplaySuccessMessage("Has update a PublishingHouse record");
return(RedirectToAction("PublishingHouseIndex"));
}
DisplayErrorMessage();
return(View(publishingHouse));
}
public void CheckPublishingHouse_Null_ShouldNotThrowExtractorException()
{
// Arrange
var data = new TestListsData();
var publishingHouses = data.PublishingHouses;
PublishingHouse publishingHouse = null;
// Act
Action act = () => ImportBookValidator.CheckPublishingHouse(publishingHouses, publishingHouse);
// Assert
act.Should().NotThrow();
}
public async Task <PublishingHouse> UpdateAsync(PublishingHouse publishingHouse)
{
var filter = Builders <PublishingHouse> .Filter.Eq(u => u.Id, publishingHouse.Id);
var update = Builders <PublishingHouse> .Update.Set(u => u.Name, publishingHouse.Name);
await _publishingHouses.UpdateOneAsync(filter, update);
var result = await _publishingHouses.Find <Models.PublishingHouse>(x => x.Id == publishingHouse.Id).FirstOrDefaultAsync();
return(result);
}
public async Task <ActionResult> Create([Bind(Include = "ID,Name,ImgUrl,Description")] PublishingHouse publishingHouse)
{
if (ModelState.IsValid)
{
db.PublishHouses.Add(publishingHouse);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(publishingHouse));
}
/// <summary>
/// Serves as the default hash function
/// </summary>
public override int GetHashCode()
{
unchecked
{
var hashCode = Name?.GetHashCode() ?? 0;
hashCode = (hashCode * 397) ^ (Author?.GetHashCode() ?? 0);
hashCode = (hashCode * 397) ^ (PublishingHouse?.GetHashCode() ?? 0);
hashCode = (hashCode * 397) ^ Year.GetHashCode();
hashCode = (hashCode * 397) ^ (Language?.GetHashCode() ?? 0);
return(hashCode);
}
}
