public async Task <BaseResponseMessage> UpdateEdition([NotNull] EditionModel edition)
{
var editionRepository = _unitOfWork.GetEditionRepository();
var newEdition = _mapper.Map <Edition>(edition);
var response = new BaseResponseMessage();
var editionToUpdate = await editionRepository.GetEdition(newEdition.Id);
if (editionToUpdate == null)
{
response.RawData = $"Edition with {newEdition.Id} wasn't found.";
return(response);
}
if (newEdition.Equals(editionToUpdate))
{
response.RawData = $"Edition {newEdition.Description} already existing with similar data.";
return(response);
}
await editionRepository.UpdateEdition(newEdition);
response.Id = newEdition.Id;
return(response);
}
public ActionResult Topics(int topicId)
{
var topic = _topicRepository.GetById(topicId);
var editions = EditionModel.ToModelList(topic.Editions.ToList());
return(View("Index", editions));
}
public ActionResult Languages(string language)
{
var dbEditions = _editionService.GetEditionsByLanguage(language);
var editions = EditionModel.ToModelList(dbEditions.ToList());
return(View("Index", editions));
}
public ActionResult SortByPrice(bool order)
{
var items = _editionService.SortByPrice(order);
var editions = EditionModel.ToModelList(items);
return(View("Index", editions));
}
public ActionResult EditEdition(int editionId)
{
var item = _editionRepository.GetById(editionId);
var editionModel = EditionModel.FromEdition(item);
return(View(editionModel));
}
public static Edition Map(EditionModel editionModel)
{
return(new Edition
{
DateEnd = editionModel.DateEnd,
DateInit = editionModel.DateInit,
EventId = editionModel.EventId
});
}
public ActionResult EditEdition(EditionModel edition, HttpPostedFileBase image)
{
var item = _editionRepository.GetById(edition.Id);
if (ModelState.IsValid)
{
if (image != null)
{
var filename = image.FileName;
var filePathOriginal = Server.MapPath("~/Content/dbImg");
string savedFileName = Path.Combine(filePathOriginal, filename);
image.SaveAs(savedFileName);
item.Image = filename;
}
item.Name = edition.Name;
item.Price = edition.Price;
item.DateNextPublication = edition.DateNextPublication;
if (!string.IsNullOrEmpty(edition.ISSN))
{
item.ISSN = edition.ISSN;
}
if (edition.Periodicity != 0)
{
item.Periodicity = edition.Periodicity;
}
if (!string.IsNullOrEmpty(edition.Description))
{
item.Description = edition.Description;
}
if (!string.IsNullOrEmpty(edition.Type))
{
item.Type = edition.Type;
}
if (!string.IsNullOrEmpty(edition.Language))
{
item.Language = edition.Language;
}
if (!string.IsNullOrEmpty(edition.TopicName))
{
var topicResult = (_topicRepository as TopicRepository).GetByName(edition.TopicName);
item.Topic = topicResult ?? new Topic()
{
TopicName = edition.TopicName
};
}
_editionRepository.Update(item);
return(RedirectToAction("Edition", new { editionId = edition.Id }));
}
return(View());
}
public ActionResult Search(string search)
{
var result = _editionService.SearchByName(search);
List <EditionModel> editions = EditionModel.ToModelList(result);
//db.Books.Where(a => a.Author.Contains(name)).ToList();
ViewBag.searchString = search;
if (editions.Count <= 0)
{
//return HttpNotFound();
}
return(PartialView("_EditionSearch", editions));
}
public ActionResult Edit(Guid editionId)
{
// Get magazines for correct display for magazine select on create edition page
var magazines = _magazineRepository.GetAll();
ViewBag.MagazineTitles = magazines.Select(a => a.MagazineName);
// Get topics for correct display for topic select on create edition page
var topics = _topicRepository.GetAll();
ViewBag.Topics = topics.Select(a => a.TopicName);
EditionModel edition = _editionRepository.GetById(editionId);
return(View(edition));
}
public async Task <BaseResponseMessage> CreateEdition(EditionModel edition)
{
var editionRepository = _unitOfWork.GetEditionRepository();
var newEdtition = _mapper.Map <Edition>(edition);
var response = new BaseResponseMessage();
if (await editionRepository.CheckEditionForUniqueness(newEdtition))
{
response.RawData = $"Edition {newEdtition.Description} already existing with similar data.";
return(response);
}
var createdEditionId = await editionRepository.CreateEdition(newEdtition);
response.Id = createdEditionId;
return(response);
}
public ActionResult AddEdition(EditionModel newEdition, HttpPostedFileBase image)
{
if (ModelState.IsValid)
{
var edition = newEdition.ToEdition();
if (!string.IsNullOrEmpty(newEdition.TopicName))
{
var topicResult = (_topicRepository as TopicRepository).GetByName(newEdition.TopicName);
edition.Topic = topicResult ?? new Topic()
{
TopicName = newEdition.TopicName
};
}
else
{
edition.Topic = new Topic()
{
TopicName = "No topic"
}
};
if (image != null)
{
var filename = image.FileName;
var filePathOriginal = Server.MapPath("~/Content/dbImg");
string savedFileName = Path.Combine(filePathOriginal, filename);
image.SaveAs(savedFileName);
edition.Image = filename;
}
else
{
edition.Image = "default.jpg";
}
_editionRepository.Add(edition);
return(RedirectToAction("Index"));
}
else
{
return(View(newEdition));
}
}
public ActionResult Edition(int editionId)
{
var item = _editionRepository.GetById(editionId);
EditionModel edition = EditionModel.FromEdition(item);
if (User.Identity.IsAuthenticated)
{
var userId = User.Identity.GetUserId();
var user = _userRepository.GetById(userId);
if (user?.Subscription != null && user.Subscription.Contains(item))
{
ViewBag.Subscpiption = true;
}
else
{
ViewBag.Subscpiption = false;
}
ViewBag.Blocked = user?.LockoutEnabled;
}
return(View(edition));
}
public ActionResult Index()
{
var editions = EditionModel.ToModelList(_editionRepository.List());
return(View(editions));
}
public async Task <HttpResponseMessage> Update([FromBody] EditionModel edition)
{
var result = await _editionService.CreateEdition(edition);
return(result.CreateRespose(HttpStatusCode.OK, HttpStatusCode.NoContent));
}
public async Task <HttpResponseMessage> Create([FromBody] EditionModel edition)
{
var result = await _editionService.CreateEdition(edition);
return(result.CreateRespose(HttpStatusCode.Created, HttpStatusCode.BadRequest));
}
public ActionResult Create(EditionModel edition, string magazineName, string customMagazine, string topicName, HttpPostedFileBase editionCover)
{
// Get magazines for correct display for magazine select on create edition page
var magazines = _magazineRepository.GetAll();
ViewBag.MagazineTitles = magazines.Select(a => a.MagazineName);
// Get topics for correct display for topic select on create edition page
var topics = _topicRepository.GetAll();
ViewBag.Topics = topics.Select(a => a.TopicName);
#region Validation
// Validation of custom fields
if (String.IsNullOrWhiteSpace(magazineName) && String.IsNullOrWhiteSpace(customMagazine))
{
ModelState.AddModelError(nameof(magazineName), "The Magazine field is reqiured.");
}
if (!String.IsNullOrWhiteSpace(magazineName) && !String.IsNullOrWhiteSpace(customMagazine))
{
ModelState.AddModelError(nameof(magazineName), "Select existing magazine or create new, not both.");
}
if (String.IsNullOrWhiteSpace(topicName))
{
ModelState.AddModelError(nameof(topicName), "The Topic field is reqiured.");
}
if (String.IsNullOrWhiteSpace(customMagazine) && String.IsNullOrWhiteSpace(magazineName))
{
ModelState.AddModelError(nameof(magazineName), "The Magazine field is reqiured.");
}
if (customMagazine.Length > 200 || magazineName.Length > 200)
{
ModelState.AddModelError(nameof(magazineName), "The Magazine name field must be less than 200 characters.");
}
if (edition.EditionMonth == 0)
{
ModelState.AddModelError(nameof(edition.EditionMonth), "The Edition month field is required.");
}
// Clear errors from model field, because we have our custom field
ModelState[nameof(edition.EditionImage)].Errors.Clear();
// Checks if image is null
if (editionCover == null)
{
ModelState.AddModelError(nameof(editionCover), "Edition cover is required.");
}
// if not null checks for type
else if (editionCover.ContentType != "image/png" && editionCover.ContentType != @"image/jpeg")
{
ModelState.AddModelError(nameof(editionCover), "Only png and jpeg allowed");
}
// If not null and proper type checks if file is smaller than 3mb
else if (editionCover.ContentLength > 3000000)
{
ModelState.AddModelError(nameof(editionCover), "Cover must be smaller than 3mb.");
}
#endregion
if (ModelState.IsValid)
{
string magName = String.Empty;
// Checks what custom field for magazine selection was selected
if (!String.IsNullOrWhiteSpace(magazineName))
{
magName = magazineName;
}
else
{
// If custom field was selected, the new Magazine is creating
MagazineModel magazineCreated = new MagazineModel()
{
MagazineId = Guid.NewGuid(), MagazineName = customMagazine
};
_magazineRepository.Create(magazineCreated);
_magazineRepository.Save();
magName = customMagazine;
}
MagazineModel magazine = _magazineRepository.GetByName(magName);
TopicModel topic = _topicRepository.GetByName(topicName);
// Converting image to byte array
byte[] bytes;
using (BinaryReader br = new BinaryReader(editionCover.InputStream))
{
bytes = br.ReadBytes(editionCover.ContentLength);
}
// Sets retrieved data from custom fields
edition.EditionId = Guid.NewGuid();
edition.MagazineId = magazine.MagazineId;
edition.TopicId = topic.TopicId;
edition.EditionStatus = EditionStatus.Creating;
edition.EditionImage = bytes;
_editionRepository.Create(edition);
_editionRepository.Save();
return(RedirectToAction("Index", "Edition", new { magazine = magazine.MagazineName, year = edition.EditionYear, month = (int)edition.EditionMonth }));
}
return(View(edition));
}
