Exemplo n.º 1
0
        public JsonResult EditSection(EditSectionViewModel model)
        {
            try
            {
                if ("colour".Equals(model.BackgroundType, StringComparison.OrdinalIgnoreCase))
                {
                    _sectionService.EditBackgroundType(model.SectionId, false);

                    if (!string.IsNullOrWhiteSpace(model.BackgroundColour))
                    {
                        _sectionService.EditBackgroundColour(model.SectionId, model.BackgroundColour);
                    }
                }
                else
                {
                    _sectionService.EditBackgroundType(model.SectionId, true);

                    if (model.BackgroundImageId > 0)
                    {
                        _sectionService.EditBackgroundImage(model.SectionId, model.BackgroundImageId);
                    }

                    _sectionService.EditBackgroundStyle(model.SectionId, model.PageSectionBackgroundStyle);
                }

                _sectionService.EditHeight(model.SectionId, model.PageSectionHeight);
                _associationService.EditRoles(model.PageAssociationId, model.SelectedRoleList);

                return(Json(new { State = true, SectionMarkup = _sectionService.Get(model.SectionId).PageSectionBody }));
            }
            catch (Exception)
            {
                return(Json(new { State = false }));
            }
        }
Exemplo n.º 2
0
        public ActionResult EditSection(int pageAssociationId)
        {
            var pageAssociation = _associationService.Get(pageAssociationId);

            var pageSection = _sectionService.Get(pageAssociation.PageSection.PageSectionId);

            var model = new EditSectionViewModel
            {
                PageAssociationId = pageAssociationId,
                SectionId         = pageSection.PageSectionId,
                MediaLibrary      = new PaginationViewModel
                {
                    ImageList        = _imageService.Get(),
                    TargetInputField = "BackgroundImageId",
                    PaginationType   = "section"
                },
                PageSectionHeight          = _sectionService.DetermineSectionHeight(pageSection.PageSectionId),
                PageSectionBackgroundStyle = _sectionService.DetermineBackgroundStyle(pageSection.PageSectionId),
                BackgroundType             = _sectionService.DetermineBackgroundType(pageSection.PageSectionId),
                BackgroundColour           = _sectionService.DetermineBackgroundColour(pageSection.PageSectionId),
                RoleList         = _roleService.Get(),
                SelectedRoleList = pageAssociation.PageAssociationRoles.Select(x => x.Role.RoleName).ToList()
            };

            return(View("_EditSection", model));
        }
Exemplo n.º 3
0
        public async Task <IActionResult> Edit(int eventId, int id, EditSectionViewModel model)
        {
            var evt = await _dbContext.Events.FindAsync(eventId);

            if (evt == null)
            {
                // TODO: Diplay error
                return(RedirectToAction("Index", "Events"));
            }

            var section = await _dbContext.Sections.FindAsync(id);

            if (section == null || section.EventId != eventId)
            {
                return(RedirectToAction("Details", "Events", new { slug = evt.Slug }));
            }

            if (model.StartOn < evt.StartOn || model.StartOn > evt.EndOn)
            {
                ModelState.AddModelError(nameof(model.StartOn), "Must be during event times");
            }

            if (model.EndOn < evt.StartOn || model.EndOn > evt.EndOn)
            {
                ModelState.AddModelError(nameof(model.EndOn), "Must be during event times");
            }

            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            try
            {
                section.Name        = model.Name;
                section.Description = model.Description;
                section.StartOn     = model.StartOn;
                section.EndOn       = model.EndOn;

                await _dbContext.SaveChangesAsync();

                return(RedirectToAction("Details", "Events", new { slug = evt.Slug }));
            }
            catch (Exception ex)
            {
                _logger.LogError(3, ex, "Error updating section");

                ModelState.AddModelError("", "There was an error updating the section.  Try again.");
                return(View(model));
            }
        }
Exemplo n.º 4
0
        public async Task <IActionResult> Edit(long id, [FromBody] EditSectionViewModel vm)
        {
            var section = await _sectionsRepository.GetByIdAsync(id);

            if (section != null)
            {
                section.Name = vm.Name;
                await _sectionsRepository.UpdateAsync(section);

                return(Ok());
            }

            return(BadRequest());
        }
Exemplo n.º 5
0
 public IActionResult Edit(EditSectionViewModel model)
 {
     if (ModelState.IsValid)
     {
         Section section = db.Sections.FirstOrDefault(t => t.Id == model.Id);
         if (section != null)
         {
             section.Name = model.Name;
             db.Sections.Update(section);
             db.SaveChanges();
         }
     }
     return(View(model));
 }
Exemplo n.º 6
0
        public async Task <IActionResult> Index()
        {
            EditSectionViewModel model = new EditSectionViewModel()
            {
                Units        = await db.Units.ToListAsync(),
                TypeSections = await db.TypeSections.ToListAsync(),
                Sections     = await db.Sections.ToListAsync(),
                SubSections  = await db.SubSections.ToListAsync(),
                SubSection1s = await db.SubSection1s.ToListAsync(),
                DataYears    = await db.DataYears.ToListAsync(),
            };

            return(View(model));
        }
        public IActionResult Index()
        {
            var viewModel = new EditSectionViewModel
            {
                AllSections = this.editSectionService.GetAllSections(),
            };

            var model = new EditSectionBaseModel
            {
                EditSectionInputModel = new EditSectionInputModel(),
                EditSectionViewModel  = viewModel,
            };

            return(this.View(model));
        }
Exemplo n.º 8
0
        public async Task <IActionResult> CreateUnit(EditSectionViewModel model)
        {
            Unit unit = await db.Units.FirstOrDefaultAsync(u => u.Name == model.Name);

            if (unit == null)
            {
                Unit _unit = new Unit()
                {
                    Name = model.Name
                };
                db.Units.Add(_unit);
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            return(NotFound());
        }
Exemplo n.º 9
0
        public async Task <IActionResult> CreateDataYear(EditSectionViewModel model)
        {
            DataYear dataYear = await db.DataYears.FirstOrDefaultAsync(u => u.Name == model.Name);

            if (dataYear == null)
            {
                DataYear _dataYear = new DataYear()
                {
                    Name = model.Name
                };
                db.DataYears.Add(_dataYear);
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            return(NotFound());
        }
Exemplo n.º 10
0
        public async Task <IActionResult> CreateSection(EditSectionViewModel model)
        {
            Section Section = await db.Sections.FirstOrDefaultAsync(u => u.Name == model.Name);

            if (Section == null)
            {
                Section _Section = new Section()
                {
                    Name = model.Name
                };
                db.Sections.Add(_Section);
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            return(NotFound());
        }
Exemplo n.º 11
0
        public async Task <IActionResult> CreateSubSection1(EditSectionViewModel model)
        {
            SubSection1 subSection1 = await db.SubSection1s.FirstOrDefaultAsync(sub => sub.Name == model.Name);

            if (subSection1 == null)
            {
                SubSection1 _subSection1 = new SubSection1()
                {
                    Name         = model.Name,
                    SubSectionId = model.id
                };
                db.SubSection1s.Add(_subSection1);
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            return(NotFound());
        }
Exemplo n.º 12
0
        public async Task <IActionResult> Create(int eventId)
        {
            var evt = await _dbContext.Events.FindAsync(eventId);

            if (evt == null)
            {
                // TODO: Diplay error
                return(RedirectToAction("Index", "Events"));
            }

            var model = new EditSectionViewModel();

            model.EventId   = evt.Id;
            model.EventName = evt.Name;
            model.StartOn   = evt.StartOn;
            model.EndOn     = evt.StartOn;

            return(View(model));
        }
Exemplo n.º 13
0
        public IActionResult Edit(int id)
        {
            Section section = db.Sections.FirstOrDefault(t => t.Id == id);

            if (section == null)
            {
                return(NotFound());
            }
            EditSectionViewModel model = new EditSectionViewModel {
                Id = section.Id, Name = section.Name
            };
            List <string> list = new List <string>();

            foreach (Test test in db.Tests)
            {
                list.Add(test.Name);
            }
            ViewBag.Tests = list;
            db.SaveChanges();
            return(View(model));
        }
Exemplo n.º 14
0
        public async Task <JsonResult> EditSection(EditSectionViewModel model)
        {
            try
            {
                if ("colour".Equals(model.BackgroundType, StringComparison.OrdinalIgnoreCase))
                {
                    await _sectionService.EditBackgroundTypeAsync(model.SectionId, false);

                    if (!string.IsNullOrWhiteSpace(model.BackgroundColour))
                    {
                        await _sectionService.EditBackgroundColourAsync(model.SectionId, model.BackgroundColour);
                    }
                }
                else
                {
                    await _sectionService.EditBackgroundTypeAsync(model.SectionId, true);

                    if (model.BackgroundImageId > 0)
                    {
                        var selectedBackgroundImage = await _imageService.GetAsync(model.BackgroundImageId);

                        await _sectionService.EditBackgroundImageAsync(model.SectionId, selectedBackgroundImage.CDNImagePath(), selectedBackgroundImage.ImageCategory);
                    }

                    await _sectionService.EditBackgroundStyleAsync(model.SectionId, model.PageSectionBackgroundStyle);
                }

                await _sectionService.EditHeightAsync(model.SectionId, model.PageSectionHeight);

                await _associationService.EditRolesAsync(model.PageAssociationId, model.SelectedRoleList);

                var pageSection = await _sectionService.GetAsync(model.SectionId);

                return(Json(new { State = true, SectionMarkup = pageSection.PageSectionBody }));
            }
            catch (Exception)
            {
                return(Json(new { State = false }));
            }
        }