Esempio n. 1
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,CallingName")] Calling calling)
        {
            if (id != calling.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(calling);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!CallingExists(calling.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(calling));
        }
Esempio n. 2
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Topic")] SpeakerTopic speakerTopic)
        {
            if (id != speakerTopic.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(speakerTopic);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!SpeakerTopicExists(speakerTopic.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(speakerTopic));
        }
Esempio n. 3
0
        public async Task <IActionResult> Edit(int id, [Bind("id,MeetingProgramID,hymnNumber,name,location")] Hymn hymn)
        {
            if (id != hymn.id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(hymn);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!HymnExists(hymn.id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction("Index", "MeetingPrograms"));
            }
            return(View(hymn));
        }
        public async Task <IActionResult> Edit(int id, [Bind("ID,name,subject,MeetingID")] Speaker speaker)
        {
            if (id != speaker.ID)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(speaker);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!SpeakerExists(speaker.ID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(speaker));
        }
Esempio n. 5
0
        public async Task <IActionResult> Edit(int id, [Bind("PlannerId,PlannedDate,Conducting,OpeningHymn,Invocation,SacramentHymn,Topic,Topic1,Topic2,ClosingHymn,Benediction")] Planner planner)
        {
            if (id != planner.PlannerId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(planner);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!PlannerExists(planner.PlannerId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(planner));
        }
Esempio n. 6
0
        public async Task <IActionResult> Edit(int id, [Bind("ID,FirstName,LastName,Calling,PhoneNumber")] Member member)
        {
            if (id != member.ID)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(member);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!MemberExists(member.ID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(member));
        }
        public async Task <IActionResult> Edit(int id, [Bind("id,MeetingProgramID,speaker,location")] Prayer prayer)
        {
            if (id != prayer.id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(prayer);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!PrayerExists(prayer.id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction("Index", "MeetingPrograms"));
            }
            return(View(prayer));
        }
Esempio n. 8
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,MeetingDate,ConductingLeader,OpeningSong,SacramentSong,ClosingSong,IntermediateSong,OpeningPrayer,ClosingPrayer")] Meeting meeting)
        {
            if (id != meeting.MeetingID)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(meeting);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!MeetingExists(meeting.MeetingID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(meeting));
        }
        public async Task <IActionResult> Edit(int id, [Bind("ID,SacramentDate,Topic,ConductingBishopric,OpeningPrayer,OpeningHymnId," +
                                                             "SacramentHymnId,IntermediateHymn,ClosingHymnId,ClosingPrayer,Speaker1,Speaker2,Speaker3,Speaker4,Speaker5,Speaker6")] SacramentMeeting sacramentMeeting)
        {
            if (id != sacramentMeeting.ID)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(sacramentMeeting);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!SacramentMeetingExists(sacramentMeeting.ID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(sacramentMeeting));
        }
Esempio n. 10
0
        public async Task <IActionResult> Edit(int id, [Bind("SpeakerID,MembersID,Topic,MeetingId")] Speaker speaker)
        {
            if (id != speaker.SpeakerID)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(speaker);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!SpeakerExists(speaker.SpeakerID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["MeetingId"] = new SelectList(_context.Meetings, "Id", "Id", speaker.MeetingId);
            ViewData["MembersID"] = new SelectList(_context.Members, "MembersID", "MembersID", speaker.MembersID);
            return(View(speaker));
        }
Esempio n. 11
0
        public async Task <IActionResult> Edit(int id, [Bind("ID,Preside,Conduct,MeetingDate,OpeningPrayer,ClosingPrayer,Hymn_1Num,Hymn_1,Hymn_2Num,Hymn_2,Hymn_3Num,Hymn_3,Hymn_4Num,Hymn_4,FirstName_1,LastName_1,FirstName_2,LastName_2,FirstName_3,LastName_3,FirstName_4,LastName_4,Topic_1,Topic_2,Topic_3,Topic_4")] Meeting meeting)
        {
            if (id != meeting.ID)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(meeting);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!MeetingExists(meeting.ID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }

            ViewBag.Hymns  = getHymnList();
            ViewBag.Topics = getTopicList();

            return(View(meeting));
        }
Esempio n. 12
0
        public async Task <IActionResult> Edit(int id, [Bind("id,MeetingProgramID,speaker,topic,Reading,order")] Talk talk)
        {
            if (id != talk.id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(talk);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!TalkExists(talk.id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction("Index", "MeetingPrograms"));
            }
            return(View(talk));
        }
        public async Task <IActionResult> Edit(
            int id,
            [Bind("Id,date,OpeningSong,SacramentSong,IntermediateSong,ClosingSong")] Sacrament sacrament,
            string[] selectedSpeakers,
            String[] SpeakerTopic,
            string Presiding,
            string Conducting,
            string Invocation,
            string Benediction
            )
        {
            if (id != sacrament.Id)
            {
                return(NotFound());
            }
            GetMembersForDropdown();
            sacrament.Presiding = await getMember(Presiding);

            sacrament.Conducting = await getMember(Conducting);

            sacrament.Invocation = await getMember(Invocation);

            sacrament.Benediction = await getMember(Benediction);

            if (ModelState.IsValid)
            {
                _context.Attach(sacrament);
                ;
                await UpdateSpeakers(sacrament, selectedSpeakers, SpeakerTopic);

                try
                {
                    _context.Update(sacrament);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!SacramentExists(sacrament.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(sacrament));
        }