public async Task <ActionResult> Create([FromForm] Meeting model)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var client = new MeetingClient(_config);

                    var response = await client.Create(model);

                    if (response.IsSuccessStatusCode)
                    {
                        _toastNotification.AddSuccessToastMessage($"La rencontre du {model.Date} a été ajoutée.");

                        return(RedirectToAction(nameof(Index)));
                    }
                }
                catch
                {
                    return(View(model));
                }
            }

            return(View(model));
        }
        public async Task <ActionResult> Delete(int id, [FromForm] Meeting model)
        {
            try
            {
                var client = new MeetingClient(_config);

                var meeting = await client.Get(id);

                if (null == meeting)
                {
                    return(NotFound());
                }

                var response = await client.Delete(meeting);

                if (response.IsSuccessStatusCode)
                {
                    _toastNotification.AddSuccessToastMessage($"La rencontre du {meeting.Date} a été supprimée.");

                    return(RedirectToAction(nameof(Index)));
                }
            }
            catch
            {
                return(View(model));
            }

            return(View(model));
        }
        public async Task <ActionResult> Refuse(int id, int attendeeId)
        {
            var client = new MeetingClient(_config);

            var meeting = await client.Get(id);

            if (null == meeting)
            {
                return(NotFound());
            }

            var attendee = meeting.Attendees.Where(p => attendeeId == p.Id).SingleOrDefault();

            if (null == attendee)
            {
                return(NotFound());
            }

            var model = new RefuseViewModel
            {
                AttendeeId  = attendeeId,
                MeetingDate = meeting.Date,
                MeetingId   = meeting.Id,
                MeetingName = meeting.Name,
                RoleName    = attendee.Role.Name,
                MemberName  = attendee.Member.Alias,
            };

            return(View(model));
        }
        // GET: Meetings
        public async Task <ActionResult> Index()
        {
            var client = new MeetingClient(_config);

            var meetings = await client.GetAll();

            return(View(meetings));
        }
Пример #5
0
        public async Task <ActionResult> Edit(int meetingId, int attendeeId, [FromForm] AttendeeViewModel model)
        {
            var memberClient = new MemberClient(_config);
            var members      = await memberClient.GetAll();

            if (ModelState.IsValid)
            {
                try
                {
                    var client = new MeetingClient(_config);

                    var attendee = await client.GetAttendee(meetingId, attendeeId);

                    if (null == attendee)
                    {
                        return(NotFound());
                    }

                    if (null == model.MemberId)
                    {
                        attendee.Member = null;
                    }
                    else
                    {
                        attendee.Member = await memberClient.Get(model.MemberId.Value);

                        // Keep only the member alias
                        attendee.Member.Name = attendee.Member.Alias;
                    }

                    var response = await client.UpdateAttendee(meetingId, attendee);

                    if (response.IsSuccessStatusCode)
                    {
                        _toastNotification.AddSuccessToastMessage($"Le participant a été modifiée.");

                        return(RedirectToAction("Details", "Meetings", new { Id = meetingId }));
                    }
                }
                catch
                {
                    model.Members = members.Select(p => new SelectListItem {
                        Value = p.Id.ToString(), Text = p.Alias
                    }).ToList();

                    return(View(model));
                }
            }

            model.Members = members.Select(p => new SelectListItem {
                Value = p.Id.ToString(), Text = p.Alias
            }).ToList();

            return(View(model));
        }
        public async Task <ActionResult> Accept(int id, [FromForm] AcceptViewModel model)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var meetingClient = new MeetingClient(_config);
                    var memberClient  = new MemberClient(_config);

                    var attendee = await meetingClient.GetAttendee(id, model.AttendeeId);

                    if (null == attendee)
                    {
                        return(BadRequest("Attendee not found"));
                    }

                    var member = await memberClient.Get(model.MemberId);

                    if (null == member)
                    {
                        return(BadRequest("Member not found"));
                    }

                    if (null == attendee.Member)
                    {
                        attendee.Member = new Member();
                    }

                    attendee.Member.Id   = member.Id;
                    attendee.Member.Name = member.Alias;

                    var response = await meetingClient.UpdateAttendee(id, attendee);

                    if (response.IsSuccessStatusCode)
                    {
                        _toastNotification.AddSuccessToastMessage($"Merci, le role {attendee.Role.Name} a été assigné à {attendee.Member.Name}.");

                        CookieOptions option = new CookieOptions();

                        option.Expires = DateTime.Now.AddYears(1);

                        Response.Cookies.Append("member", member.Id.ToString(), option);

                        return(RedirectToAction(nameof(Index)));
                    }
                }
                catch
                {
                    return(View(model));
                }
            }

            return(View(model));
        }
        // GET: Meetings/Edit/5
        public async Task <ActionResult> Edit(int id)
        {
            var client = new MeetingClient(_config);

            var meeting = await client.Get(id);

            if (null == meeting)
            {
                return(NotFound());
            }

            return(View(meeting));
        }
        public async Task <ActionResult> Accept(int id, int attendeeId)
        {
            var client = new MeetingClient(_config);

            var meeting = await client.Get(id);

            if (null == meeting)
            {
                return(NotFound());
            }

            var attendee = meeting.Attendees.Where(p => attendeeId == p.Id).SingleOrDefault();

            if (null == attendee)
            {
                return(NotFound());
            }

            var model = new AcceptViewModel
            {
                AttendeeId  = attendeeId,
                MeetingDate = meeting.Date,
                MeetingId   = meeting.Id,
                MeetingName = meeting.Name,
                RoleName    = attendee.Role.Name
            };

            var memberClient = new MemberClient(_config);

            var members = await memberClient.GetAll();

            var buffer = Request.Cookies["member"];
            int memberId;

            if (false == int.TryParse(buffer, out memberId))
            {
                memberId = 0;
            }

            model.MemberId = memberId;
            model.Members  = members.Select(p => new SelectListItem {
                Value = p.Id.ToString(), Text = p.Alias
            }).ToList();

            return(View(model));
        }
        public async Task <ActionResult> Edit(int id, [FromForm] Meeting model)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var client = new MeetingClient(_config);

                    var meeting = await client.Get(id);

                    if (null == meeting)
                    {
                        return(NotFound());
                    }

                    meeting.Name      = model.Name;
                    meeting.Note      = model.Note;
                    meeting.Date      = model.Date;
                    meeting.Cancelled = model.Cancelled;

                    var response = await client.Update(meeting);

                    if (response.IsSuccessStatusCode)
                    {
                        _toastNotification.AddSuccessToastMessage($"La rencontre du {model.Date} a été modifiée.");

                        return(RedirectToAction(nameof(Index)));
                    }
                }
                catch
                {
                    return(View());
                }
            }

            return(View(model));
        }
        public async Task <ActionResult> Refuse(int id, [FromForm] RefuseViewModel model)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var meetingClient = new MeetingClient(_config);
                    var memberClient  = new MemberClient(_config);

                    var attendee = await meetingClient.GetAttendee(id, model.AttendeeId);

                    if (null == attendee)
                    {
                        return(BadRequest("Attendee not found"));
                    }

                    var member = attendee.Member;

                    attendee.Member = null;

                    var response = await meetingClient.UpdateAttendee(id, attendee);

                    if (response.IsSuccessStatusCode)
                    {
                        _toastNotification.AddSuccessToastMessage($"Merci, le rôle {attendee.Role.Name} a été retiré à {member.Name}.");

                        return(RedirectToAction(nameof(Index)));
                    }
                }
                catch
                {
                    return(View());
                }
            }

            return(View(model));
        }
Пример #11
0
        public async Task <ActionResult> Edit(int meetingId, int attendeeId)
        {
            var client   = new MeetingClient(_config);
            var attendee = await client.GetAttendee(meetingId, attendeeId);

            if (null == attendee)
            {
                return(NotFound());
            }

            var model = new AttendeeViewModel
            {
                Id        = attendeeId,
                MeetingId = meetingId,
                RoleId    = attendee.Role.Id,
                RoleName  = attendee.Role.Name
            };

            if (null == attendee.Member)
            {
                model.MemberId = null;
            }
            else
            {
                model.MemberId = attendee.Member.Id;
            }

            var memberClient = new MemberClient(_config);
            var members      = await memberClient.GetAll();

            model.Members = members.Select(p => new SelectListItem {
                Value = p.Id.ToString(), Text = p.Alias
            }).ToList();

            return(View(model));
        }
        public async Task <ActionResult> Index(int id)
        {
            var client = new MeetingClient(_config);

            var meeting = await client.Get(id);

            if (null == meeting)
            {
                return(NotFound());
            }

            var model = new AgendaViewModel
            {
                Date = meeting.Date,
                Name = meeting.Name,
                Note = meeting.Note
            };

            foreach (var attendee in meeting.Attendees)
            {
                switch (attendee.Role.Id)
                {
                case Role.Toastmaster:
                    model.Toastmaster = attendee.Member?.Name ?? string.Empty;
                    break;

                case Role.GeneralEvaluator:
                    model.GeneralEvaluator = attendee.Member?.Name ?? string.Empty;
                    break;

                case Role.WordOfTheDay:
                    model.WordOfTheDay = attendee.Member?.Name ?? string.Empty;
                    break;

                case Role.Toast:
                    model.Toast = attendee.Member?.Name ?? string.Empty;
                    break;

                case Role.Humour:
                    model.Humour = attendee.Member?.Name ?? string.Empty;
                    break;

                case Role.TopicsMaster:
                    model.TopicsMaster = attendee.Member?.Name ?? string.Empty;
                    break;

                case Role.Speaker:
                    model.Speaker = attendee.Member?.Name ?? string.Empty;
                    break;

                case Role.Evaluator:
                    model.Evaluator = attendee.Member?.Name ?? string.Empty;
                    break;

                case Role.Grammarian:
                    model.Grammarian = attendee.Member?.Name ?? string.Empty;
                    break;

                case Role.Listener:
                    model.Listener = attendee.Member?.Name ?? string.Empty;
                    break;

                case Role.Timer:
                    model.Timer = attendee.Member?.Name ?? string.Empty;
                    break;
                }
            }

            return(View(model));
        }
        // GET: Calendar
        public async Task <ActionResult> Index()
        {
            var client = new MeetingClient(_config);

            var meetings = await client.GetPlanning();

            var x        = meetings.Count + 1;
            var y        = meetings[0].Attendees.Count() + 2;
            var calendar = new Calendar(x, y);

            // Add roles
            int m = meetings[0].Attendees.Count();

            calendar[0, 0] = new CalendarCell {
                AttendeeId = 0, Value = string.Empty
            };
            calendar[0, 1] = new CalendarCell {
                AttendeeId = 0, Value = string.Empty
            };

            int k = 0;

            foreach (var attendee in meetings[0].Attendees)
            {
                calendar[0, k + 2] = new CalendarCell {
                    AttendeeId = 0, Value = attendee.Role.Name
                };

                k++;
            }

            int    i = 0, j = 0;
            string value;

            CalendarCell cell;

            foreach (var meeting in meetings)
            {
                i++;
                j = 0;

                // Add Date
                value          = meeting.Date.ToLocalTime().ToString("yyyy-MM-dd");
                calendar[i, 0] = new CalendarCell {
                    MeetingId = meeting.Id, AttendeeId = 0, Value = value
                };

                // Add subject
                calendar[i, 1] = new CalendarCell {
                    MeetingId = meeting.Id, AttendeeId = 0, Value = meeting.Name
                };

                j = 2;

                // Add member
                foreach (var attendee in meeting.Attendees)
                {
                    value = attendee.Member?.Name ?? string.Empty;
                    cell  = new CalendarCell {
                        MeetingId = meeting.Id, AttendeeId = attendee.Id, Value = value
                    };

                    if (null == attendee.Member)
                    {
                        cell.CanAccept = true;
                    }
                    else
                    {
                        cell.CanRefuse = true;
                    }

                    calendar[i, j] = cell;

                    j++;
                }
            }

            return(View(calendar));
        }