public ActionResult Edit(MagazineViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var imageCode = model.LogoImage;
if (model.Image != null && model.Image.ContentLength > 0)
{
var imageModel = ResourceService.SaveImage(Server.MapPath("~/content/data/"), model.Image, false);
if (imageModel == null)
{
ModelState.AddModelError("", "No se pudo guardar la imagen. Intentalo de nuevo.");
return(View(model));
}
imageCode = imageModel.FullFileName;
}
if (!MagazineService.EditMagazine(model.MagazineId, model.Title, model.Description, imageCode, model.Address,
model.CityId, model.Email, model.IsPrivate, model.Domain, model.FacebookAccount, model.TwitterAccount, model.GoogleAnlyticsId))
{
SetMessage(MagazineService.ServiceTempData);
return(RedirectToAction("Index"));
}
SetMessage("Revista editada exitosamente.", BootstrapAlertTypes.Success);
return(RedirectToAction("Index"));
}
public ActionResult Create(MagazineViewModel model)
{
ViewBag.States = new SelectList(ResourceService.GetStates(), "StateId", "Name", model.StateId);
ViewBag.Cities = new SelectList(ResourceService.GetCities(model.StateId), "CityId", "Name", model.CityId);
if (!ModelState.IsValid)
{
return(View(model));
}
var imageCode = "Expose_Default_Magazine.png";
if (model.Image != null && model.Image.ContentLength > 0)
{
var imageModel = ResourceService.SaveImage(Server.MapPath("~/content/data/"), model.Image, false);
if (imageModel == null)
{
ModelState.AddModelError("", "No se pudo guardar la imagen. Intentalo de nuevo.");
return(View(model));
}
imageCode = imageModel.FullFileName;
}
var create = MagazineService.Create(model.Title, model.Description, imageCode, model.Address, model.CityId,
model.Email, model.IsPrivate, model.Domain, model.FacebookAccount, model.TwitterAccount, model.GoogleAnlyticsId);
if (create == null)
{
SetMessage(MagazineService.ServiceTempData);
return(RedirectToAction("Index"));
}
SetMessage("Revista creada.", BootstrapAlertTypes.Success);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> PutMagazine([FromRoute] int id, [FromBody] MagazineViewModel magazine)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != magazine.Id)
{
return(BadRequest());
}
try
{
await _magazineService.UpdateAsync(magazine);
}
catch (DbUpdateConcurrencyException)
{
if (!MagazineExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Create(MagazineViewModel magazineViewModel)
{
var magazine = Mapper.Map <MagazineViewModel, Magazine>(magazineViewModel);
magazine.Type = LibraryType.Magazines;
_magazineRepository.Create(magazine);
}
async void OnSaveClicked()
{
if (_unknownNativeTitle)
{
_model.NativeTitle = null;
}
else if (string.IsNullOrWhiteSpace(_model.NativeTitle))
{
return;
}
if (_unknownCountry)
{
_model.CountryId = null;
}
else if (_model.CountryId < 0)
{
return;
}
if (_unknownFirstPublication)
{
_model.FirstPublication = null;
}
else if (_model.FirstPublication?.Date >= DateTime.UtcNow.Date)
{
return;
}
if (_unknownIssn)
{
_model.Issn = null;
}
else if (string.IsNullOrWhiteSpace(_model.Issn))
{
return;
}
if (string.IsNullOrWhiteSpace(_model.Title))
{
return;
}
if (_creating)
{
Id = await Service.CreateAsync(_model, (await UserManager.GetUserAsync(_authState.User)).Id);
}
else
{
await Service.UpdateAsync(_model, (await UserManager.GetUserAsync(_authState.User)).Id);
}
_editing = false;
_creating = false;
_model = await Service.GetAsync(Id);
SetCheckboxes();
StateHasChanged();
}
public MagazineViewModel Get(int id)
{
Magazine magazineModel = _unitOfWork.Magazines.Get(id);
MagazineViewModel magazineViewModel = Mapper.Map <Magazine, MagazineViewModel>(magazineModel);
return(magazineViewModel);
}
//Create a copy of a MagazineViewModel
private MagazineViewModel Copy(MagazineViewModel ToCopy)
{
var vm = new MagazineViewModel();
vm.Navn = ToCopy.Navn;
vm.Pris = ToCopy.Pris;
return(vm);
}
public void Update(MagazineViewModel magazineViewModel)
{
var magazine = Mapper.Map <MagazineViewModel, Magazine>(magazineViewModel);
int id = magazine.MagazineId;
magazine.Type = LibraryType.Magazines;
_magazineRepository.Update(magazine);
}
public ActionResult Edit(MagazineViewModel magazine)
{
if (ModelState.IsValid)
{
_magazineService.Update(magazine);
return(RedirectToAction("Index"));
}
return(View(magazine));
}
public ActionResult EditMagazine(MagazineViewModel magazine)
{
if (magazine == null)
{
return(HttpNotFound());
}
magazineService.Update(magazine);
return(Json(magazine));
}
public IActionResult PostMagazine([FromBody] MagazineViewModel magazine)
{
if (ModelState.IsValid)
{
_magazineService.Insert(magazine);
return(Ok(magazine));
}
return(BadRequest(ModelState));
}
public void Update(MagazineViewModel magazine)
{
Magazine magazineModel = _unitOfWork.Magazines.Get(magazine.MagazineId);
magazineModel.Name = magazine.Name;
magazineModel.Number = magazine.Number;
magazineModel.YearOfPublishing = magazine.YearOfPublishing;
_unitOfWork.Magazines.Update(magazineModel);
}
public async Task <IActionResult> PostMagazine([FromBody] MagazineViewModel magazine)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _magazineService.InsertAsync(magazine);
return(Ok(magazine));
}
public ActionResult Edit(int id)
{
MagazineViewModel magazine = _magazineService.Get(id);
if (magazine != null)
{
return(View("Edit", magazine));
}
return(HttpNotFound());
}
public ActionResult EditMagazine(MagazineViewModel magazineViewModel)
{
try
{
_magazineService.EditMagazine(magazineViewModel);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Delete(int id)
{
MagazineViewModel b = magazineService.Get(id);
if (b == null)
{
return(HttpNotFound());
}
magazineService.Remove(id);
return(RedirectToAction("Magazines"));
}
public bool EditMagazine(MagazineViewModel magazineViewModel)
{
try
{
Magazine magazine = Mapper.Map <MagazineViewModel, Magazine>(magazineViewModel);
_magazineRepository.Update(magazine);
return(true);
}
catch
{
return(false);
}
}
public IHttpActionResult Delete(MagazineViewModel magazineFromView)
{
var magazineForDelete = _magazineService.Get().FirstOrDefault(m => m.Id == magazineFromView.Id);
var unitForDelete = _libraryStorageUnitService.Get().FirstOrDefault(u => u.Id == magazineFromView.UnitId);
if (magazineForDelete == null || unitForDelete == null)
{
return(BadRequest());
}
_magazineService.Delete(magazineForDelete);
_libraryStorageUnitService.Delete(unitForDelete);
return(Ok(magazineFromView));
}
public bool AddMagazine(MagazineViewModel magazineViewModel)
{
try
{
Magazine magazine = Mapper.Map <MagazineViewModel, Magazine>(magazineViewModel);
Save.AddItem(magazine, "../Magazines");
_magazineRepository.Add(magazine);
return(true);
}
catch
{
return(false);
}
}
public ActionResult AddMagazine(MagazineViewModel magazineViewModel)
{
try
{
if (ModelState.IsValid)
{
_magazineService.CreateMagazine(magazineViewModel);
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public IActionResult DeleteMagazine([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
MagazineViewModel magazine = _magazineService.GetItem(id);
if (magazine == null)
{
return(NotFound());
}
_magazineService.Delete(id);
return(Ok(magazine));
}
public IActionResult PutMagazine([FromRoute] int id, [FromBody] MagazineViewModel magazine)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != magazine.Id)
{
return(BadRequest());
}
_magazineService.Update(magazine);
return(NoContent());
}
public IHttpActionResult Add(MagazineViewModel magazineFromView)
{
if (magazineFromView == null || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var libraryStorageUnitForAdd = Mapper.Map <MagazineViewModel, LibraryStorageUnitDTO>(magazineFromView);
var magazineForAdd = Mapper.Map <MagazineViewModel, MagazineDTO>(magazineFromView);
magazineForAdd.Unit = libraryStorageUnitForAdd;
_magazineService.Create(magazineForAdd);
return(Ok(magazineFromView));
}
async void OnCancelClicked()
{
_editing = false;
if (_creating)
{
NavigationManager.ToBaseRelativePath("admin/magazines");
return;
}
_model = await Service.GetAsync(Id);
SetCheckboxes();
StateHasChanged();
}
public async Task CreateMagazineAsync([FromBody] MagazineViewModel magazine)
{
if (ModelState.IsValid)
{
try
{
var subject = await subjectRepository.Get(magazine.SubjectId);
if (subject == null)
{
throw new Exception("Subject is not found");
}
Magazine newMagazine = new Magazine()
{
GroupId = magazine.GroupId,
CourseId = magazine.CourseId,
TeacherId = magazine.TeacherId,
SubjectId = magazine.SubjectId,
Semester = magazine.Semester,
Year = magazine.Year,
Filial = magazine.Filial,
Faculty = magazine.Faculty,
Specialty = magazine.Specialty,
Level = magazine.Level,
TypeOfClass = magazine.TypeOfClass
};
await magazineRepository.Insert(newMagazine);
Response.StatusCode = StatusCodes.Status200OK;
await Response.WriteAsync("Ok");
}
catch (Exception e)
{
ModelState.AddModelError("error", e.Message);
await Response.BadRequestHelper(ModelState.Values);
}
}
else
{
await Response.BadRequestHelper(ModelState.Values);
}
}
protected override async Task OnAfterRenderAsync(bool firstRender)
{
if (_loaded)
{
return;
}
_loaded = true;
_creating = NavigationManager.ToBaseRelativePath(NavigationManager.Uri).ToLowerInvariant().
StartsWith("admin/magazines/create", StringComparison.InvariantCulture);
if (Id <= 0 &&
!_creating)
{
return;
}
_countries = await CountriesService.GetAsync();
_companies = await CompaniesService.GetAsync();
_roles = await DocumentRolesService.GetEnabledAsync();
_model = _creating ? new MagazineViewModel() : await Service.GetAsync(Id);
_authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
_addingCompanyRoleId = _roles.First().Id;
_magazineCompanies = await CompaniesByMagazineService.GetByMagazine(Id);
_editing = _creating || NavigationManager.ToBaseRelativePath(NavigationManager.Uri).ToLowerInvariant().
StartsWith("admin/magazines/edit/",
StringComparison.InvariantCulture);
if (_editing)
{
SetCheckboxes();
}
StateHasChanged();
}
public ActionResult Edit(Int32 id)
{
var user = UserService.GetCurrentUser();
var relation = UserService.UserInMagazine(id, user.UserId);
if (!relation || !ModelState.IsValid)
{
return(RedirectToAction("Index", "Magazines"));
}
var magazine = MagazineService.GetMagazineById(id);
if (magazine == null)
{
SetMessage("No se encontró la revista.", BootstrapAlertTypes.Danger);
return(RedirectToAction("Index"));
}
var model = new MagazineViewModel
{
MagazineId = magazine.MagazineId,
Address = magazine.Address,
CityId = magazine.CityId,
Description = magazine.Description,
Email = magazine.Email,
LogoImage = magazine.Logo,
Title = magazine.Title,
Domain = magazine.Domain,
FacebookAccount = magazine.FacebookPage,
GoogleAnlyticsId = magazine.GoogleAnalyticsId,
TwitterAccount = magazine.TwitterPage,
Guid = magazine.Guid
};
var stateId = ResourceService.GetStateByCityId(magazine.CityId);
ViewBag.States = new SelectList(ResourceService.GetStates(), "StateId", "Name", stateId);
ViewBag.Cities = new SelectList(ResourceService.GetCities(stateId), "CityId", "Name", magazine.CityId);
return(View(model));
}
public IHttpActionResult Edit(MagazineViewModel magazineFromView)
{
if (magazineFromView == null || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var libraryStorageUnitForEdit = Mapper.Map <MagazineViewModel, LibraryStorageUnitDTO>(magazineFromView);
_libraryStorageUnitService.Edit(libraryStorageUnitForEdit);
var magazineForEdit = Mapper.Map <MagazineViewModel, MagazineDTO>(magazineFromView);
_magazineService.Edit(magazineForEdit);
}
catch (ObjectNotFoundException)
{
return(BadRequest());
}
return(Ok(magazineFromView));
}
public void SaveData(int?id)
{
XmlSerializer xsSubmit = new XmlSerializer(typeof(MagazineViewModel));
MagazineViewModel magazine = _magazineService.GetMagazine(id.Value);
var xml = "";
using (var sww = new StringWriter())
{
using (XmlWriter writer = XmlWriter.Create(sww))
{
xsSubmit.Serialize(writer, magazine);
xml = sww.ToString();
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
doc.Save(Server.MapPath("~/uploads/magazine.xml"));
}
}
byte[] fileBytes = System.IO.File.ReadAllBytes(Server.MapPath("~/uploads/magazine.xml"));
string fileName = "magazine.xml";
File(fileBytes, System.Net.Mime.MediaTypeNames.Application.Octet, fileName);
}
public void UpdateMagazine(MagazineViewModel magazineViewModel)
{
_magazineRepository.Update(Mapper.Map <MagazineViewModel, Magazine>(magazineViewModel));
}
