public ActionResult EditRoleMember(int participateid)
        {
            Participate user = participateService.findMemberInGroup(participateid);

            if (user == null)
            {
                return(HttpNotFound());
            }

            int   groupid = (int)Session["groupid"];
            Group group   = groupService.findGroup(groupid);

            if (group == null)
            {
                return(HttpNotFound());
            }



            ////////////////////////////////////////////////////////////////////////////
            //NOTE
            //Tại owner không được sửa quyền sửa role của chính nó
            //TODO
            //Hỏi customer lại về vụ nè
            //Nếu sửa role của chính nó thì sẽ báo lỗi gì??tạm thời return 404
            ///////////////////////////////////////////////////////////////////////////
            if (user.IsOwner)
            {
                SetFlash(FlashType.error, "Owner cant change their role");
                return(RedirectToRoute("GroupControlLocalizedDefault", new { action = "setting", groupslug = group.groupSlug, groupid = group.Id }));
            }
            return(View(user));
        }
Example #2
0
        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            Group group;

            if (ownerSlug != null || groupSlug != null)
            {
                group = groupService.findGroup(ownerSlug, groupSlug);
            }
            else
            {
                group = groupService.findGroup(groupid);
            }
            Participate user    = db.Participates.Where(m => m.IdGroup == group.Id && m.IdUser == this.idUser).FirstOrDefault();
            bool        isOwner = db.Groups.Where(m => m.Id == group.Id && m.IdOwner == this.idUser).Count() > 1 ? true : false;

            if (user.IsAdmin)
            {
                this.userRoles[0] = "Admin";
            }
            if (user.IsManager)
            {
                this.userRoles[1] = "Manager";
            }
            if (isOwner)
            {
                this.userRoles[2] = "Owner";
            }
            bool checkrole = this.userRoles.Intersect(this.allowedRoles).Any();

            if (!checkrole)
            {
                filterContext.Result = new HttpStatusCodeResult(404);
            }
            //return checkrole;
        }
        public ActionResult DeleteMember(int participateid)
        {
            Participate user = participateService.findMemberInGroup(participateid);

            if (user == null)
            {
                return(HttpNotFound());
            }
            string userName = user.AspNetUser.UserName;
            int    groupId  = (int)Session["groupid"];
            Group  group    = groupService.findGroup(groupId);

            ////////////////////////////////////////////////////////////////////////////
            //NOTE
            //Không được xóa đi owner,không được xóa thành viên khác group
            ///////////////////////////////////////////////////////////////////////////
            if (user.IsOwner)
            {
                SetFlash(FlashType.error, "You cant remove owner");
            }
            else
            {
                participateService.removeUserInGroup(user);
                SetFlash(FlashType.success, "Removed " + userName + " Successfully");
            }

            return(RedirectToRoute("GroupControlLocalizedDefault", new { action = "setting", groupslug = group.groupSlug, groupid = group.Id }));
        }
Example #4
0
        public ActionResult DeleteTask(int taskid)
        {
            //TODO: Check lại
            TaskProcess task = taskService.findTask(taskid);

            if (task == null)
            {
                return(HttpNotFound());
            }
            Step step = stepService.findStep(task.Step.Id);
            //lấy group thuộc process
            int    idGroup = task.Step.Process.Group.Id;
            string idUser  = User.Identity.GetUserId();
            Group  group   = groupService.findGroup(idGroup);

            //check xem có thuộc process trong group
            Participate user = participateService.findMemberInGroup(idUser, idGroup);

            if (user == null)
            {
                return(HttpNotFound());
            }

            string taskPath = string.Format("Upload/{0}/{1}/{2}/{3}", task.Step.Process.Group.Id, task.Step.Process.Id, task.Step.Id, task.Id);

            fileService.removeDirectory(taskPath);

            taskService.deletetask(task);

            SetFlash(FlashType.success, "Delete Successfully");
            return(RedirectToRoute("GroupControlLocalizedDefault", new { controller = "process", action = "show", groupslug = group.groupSlug, groupid = group.Id, processid = step.IdProcess }));
        }
        public void BaseAuthorize(ActionExecutingContext filterContext, Participate user)
        {
            int groupid;

            if (filterContext.RouteData.Values["groupid"] != null)
            {
                groupid = int.Parse(filterContext.RouteData.Values["groupid"].ToString());
            }
            else if (HttpContext.Current.Session["groupid"] != null)
            {
                groupid = (int)HttpContext.Current.Session["groupid"];
            }
            else
            {
                filterContext.Result = new HttpStatusCodeResult(HttpStatusCode.NotFound);
                return;
            }

            Group group = groupService.findGroup(groupid);

            if (group == null)
            {
                filterContext.Result = new HttpStatusCodeResult(HttpStatusCode.NotFound);
                return;
            }

            string idUser = HttpContext.Current.User.Identity.GetUserId();

            user = db.Participates.Where(x => x.IdUser == idUser && x.IdGroup == group.Id).FirstOrDefault();
            if (user == null)
            {
                filterContext.Result = new HttpStatusCodeResult(HttpStatusCode.Unauthorized);
                //return new HttpStatusCodeResult(HttpStatusCode.Unauthorized);
                return;
            }
            if (Role != null)
            {
                bool       isOwner   = group.IdOwner == idUser ? true : false;
                UserRole[] userRoles = new UserRole[3];
                if (isOwner)
                {
                    userRoles[0] = UserRole.Owner;
                }
                if (user.IsAdmin)
                {
                    userRoles[1] = UserRole.Admin;
                }
                if (user.IsManager)
                {
                    userRoles[2] = UserRole.Manager;
                }
                bool checkrole = userRoles.Intersect(this.Role).Any();
                if (!checkrole)
                {
                    filterContext.Result = new HttpStatusCodeResult(HttpStatusCode.Unauthorized);
                    return;
                }
            }
            HttpContext.Current.Session["idgroup"] = groupid;
        }
Example #6
0
        public IActionResult RSVP(bool IsParticipating, int exerciseId, int userId, Participate newParticipate)
        {
            Participate existingRSVP = db.Participates
                                       .FirstOrDefault(participate => participate.ExerciseId == exerciseId &&
                                                       participate.UserId == userId);

            // List of activities that the current user is currently rsvp'ed to
            // List<Exercise> listofParticipatingExercises = db.Exercises
            //     .Include(exercise => exercise.Participants)
            //         .ThenInclude(user => user.User)
            //     .Where(u => u.Participants.
            //     );

            if (existingRSVP == null)
            {
                db.Participates.Add(newParticipate);
                db.SaveChanges();
            }

            else if (existingRSVP != null)
            {
                existingRSVP.IsParticipating = IsParticipating;
                existingRSVP.UpdatedAt       = DateTime.Now;
                db.Participates.Update(existingRSVP);
                db.SaveChanges();
            }
            return(RedirectToAction("Dashboard"));
        }
        public ActionResult EditRoleMember(Participate model)
        {
            int         groupId = (int)Session["groupid"];
            Group       group   = groupService.findGroup(groupId);
            Participate user    = participateService.findMemberInGroup(model.Id);

            if (user == null)
            {
                return(HttpNotFound());
            }

            //chỉnh sửa role của 1 user

            if (!user.IsOwner)
            {
                participateService.editRoleUser(model);
                SetFlash(FlashType.success, "Edited Role of " + user.AspNetUser.UserName + " Successfully");
            }
            else
            {
                SetFlash(FlashType.error, "Owner cant change their role");
            }

            return(RedirectToRoute("GroupControlLocalizedDefault", new { action = "setting", groupslug = group.groupSlug, groupid = group.Id }));
        }
        public ActionResult MemberLeaveGroup(int participateid)
        {
            string      idUser = User.Identity.GetUserId();
            Participate user   = participateService.findMemberInGroup(participateid);

            if (user == null)
            {
                return(HttpNotFound());
            }
            string groupName = user.Group.Name;

            //xóa thành viên trong group
            ////////////////////////////////////////////////////////////////////////////
            //NOTE
            //Chỉ xóa được chính bản thân mình ra khỏi group
            ///////////////////////////////////////////////////////////////////////////
            if (user.IdUser == idUser)
            {
                participateService.removeUserInGroup(user);
                SetFlash(FlashType.success, "Left Group " + groupName + " Successfully");
                return(RedirectToAction("Index"));
            }
            else
            {
                SetFlash(FlashType.error, "Left Group " + groupName + " Failed");
                return(RedirectToRoute("GroupControlLocalizedDefault", new { action = "setting", groupslug = user.Group.groupSlug, groupid = user.Group.Id }));
            }
        }
Example #9
0
        public JsonResult DoneTaskRun(int idtaskrun, string valuetext, string valuefile, HttpPostedFileBase fileupload, string comment, bool isEdit)
        {
            string         IdUser = User.Identity.GetUserId();
            HttpStatusCode status = HttpStatusCode.OK;
            string         message;
            object         response;
            TaskProcessRun taskrun = taskService.findTaskRun(idtaskrun);

            if (taskrun == null)
            {
                status   = HttpStatusCode.NotFound;
                message  = "TaskRun Not Found";
                response = new { message = message, status = status };
                SetFlash(FlashType.error, message);
                return(Json(response, JsonRequestBehavior.AllowGet));
            }
            List <RoleRun> listrole = roleService.findlistrolerunbyidroleprocess(taskrun.IdRole);
            Participate    user     = participateService.findMemberInGroup(IdUser, taskrun.StepRun.ProcessRun.Process.IdGroup);
            bool           haveRole = false;

            foreach (RoleRun role in listrole)
            {
                if (IdUser == role.IdUser)
                {
                    haveRole = true;
                    break;
                }
            }
            if (user.IsManager == true || haveRole)
            {
                taskService.submitTask(IdUser, valuetext, valuefile, idtaskrun, true);
                int    groupid     = taskrun.StepRun.ProcessRun.Process.IdGroup;
                string taskRunPath = string.Format("Upload/{0}/run/{1}/{2}/{3}", groupid, taskrun.StepRun.ProcessRun.Id, taskrun.StepRun.Id, taskrun.Id);
                if (!isEdit)
                {
                    fileService.removeDirectory(taskRunPath);
                    fileService.createDirectory(taskRunPath);
                    fileService.saveFile(groupid, fileupload, taskRunPath, Direction.TaskRun);
                }
                if (comment.Trim() != "")
                {
                    Comment cm = new Comment();
                    cm.IdUser      = IdUser;
                    cm.IdDirection = taskrun.Id;
                    cm.Direction   = Direction.TaskRun.ToString();
                    cm.Content     = comment;
                    cm.isAction    = true;
                    cm.Create_At   = DateTime.Now;
                    cm.Update_At   = DateTime.Now;
                    db.Comments.Add(cm);
                    db.SaveChanges();
                }
            }


            message  = "Submit Task Successfully";
            response = new { message = message, status = status };
            SetFlash(FlashType.success, message);
            return(Json(response, JsonRequestBehavior.AllowGet));
        }
        public JsonResult LeaveGroup(int groupid)
        {
            HttpStatusCode status = HttpStatusCode.OK;
            string         message;
            object         response;
            string         IdUser = User.Identity.GetUserId();

            try
            {
                Participate user = participateService.findMemberInGroup(IdUser, groupid);
                if (user == null)
                {
                    throw new ServerSideException("You not belong to this group");
                }
                if (user.IsOwner)
                {
                    throw new ServerSideException("You cant leave your group");
                }
                participateService.removeUserInGroup(user);
                message  = "Leave group successfully";
                response = new { message = message, status = status };
                return(Json(response, JsonRequestBehavior.AllowGet));
            }
            catch (Exception e)
            {
                status   = HttpStatusCode.InternalServerError;
                message  = e.GetType().Name == "ServerSideException" ? e.Message : "Something not right";
                response = new { message = message, detail = e.Message, status = status };
                return(Json(response, JsonRequestBehavior.AllowGet));
            }
        }
        public async Task <IActionResult> PutParticipate(int id, Participate participate)
        {
            if (id != participate.UserId)
            {
                return(BadRequest());
            }

            _context.Entry(participate).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ParticipateExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public JsonResult DeleteUser(int groupid, string userid)
        {
            HttpStatusCode status = HttpStatusCode.OK;
            string         message;
            object         response;

            try
            {
                Participate user = participateService.findMemberInGroup(userid, groupid);
                if (user == null)
                {
                    throw new ServerSideException("User not belong to this group");
                }
                participateService.removeUserInGroup(user);
                message  = "Delete user Successfully";
                response = new { message = message, status = status };
                return(Json(response, JsonRequestBehavior.AllowGet));
            }
            catch (Exception e)
            {
                status   = HttpStatusCode.InternalServerError;
                message  = e.GetType().Name == "ServerSideException" ? e.Message : "Something not right";
                response = new { message = message, detail = e.Message, status = status };
                return(Json(response, JsonRequestBehavior.AllowGet));
            }
        }
        public JsonResult addMember(string id)
        {
            HttpStatusCode status = HttpStatusCode.OK;
            string         message;
            int            groupid = (int)Session["groupid"];
            Group          group   = groupService.findGroup(groupid);
            AspNetUser     user    = userService.findUser(id);

            if (user == null)
            {
                status  = HttpStatusCode.InternalServerError;
                message = "User not found";
            }
            else
            {
                Participate checkExist = participateService.checkMemberExist(user.Id, group.Id);
                if (checkExist != null)
                {
                    status  = HttpStatusCode.InternalServerError;
                    message = "User exist in group";
                }
                else
                {
                    participateService.addMember(user.Id, group.Id);
                    message = "Added member sucessfully";
                }
            }
            var response = new { message = message, status = status };

            return(Json(response, JsonRequestBehavior.AllowGet));
        }
        public JsonResult editRole(int id, string roles)
        {
            HttpStatusCode status = HttpStatusCode.OK;
            string         message;
            JObject        jRoles = JObject.Parse(roles);
            Participate    user   = participateService.findMemberInGroup(id);

            if (user == null)
            {
                status  = HttpStatusCode.InternalServerError;
                message = "User not in group";
            }
            else
            {
                user.IsAdmin   = bool.Parse(jRoles["isAdmin"].ToString());
                user.IsManager = bool.Parse(jRoles["isManager"].ToString());
                participateService.editRoleUser(user);

                status  = HttpStatusCode.OK;
                message = "Updated role sucessfully";
            }
            var response = new { message = message, status = status };

            return(Json(response, JsonRequestBehavior.AllowGet));
        }
        public IActionResult LeaveActivity(int activity_id)
        {
            Participate currentParticipate = mycontext.Participate.SingleOrDefault(p => p.UserId == ActiveUser.UserId && p.ActivityId == activity_id);

            mycontext.Participate.Remove(currentParticipate);
            mycontext.SaveChanges();
            return(RedirectToAction("Index"));
        }
Example #16
0
        public IActionResult Leave(int eventId, int userId)
        {
            Participate Leave = context.Join.FirstOrDefault(l => l.DojoEventId == eventId && l.UserId == userId);

            context.Join.Remove(Leave);
            context.SaveChanges();
            return(RedirectToAction("Home"));
        }
Example #17
0
        public IActionResult UNRSVP(int partid)
        {
            Participate thisPartID = dbContext.Participations.FirstOrDefault(x => x.ParticipateID == partid);

            dbContext.Participations.Remove(thisPartID);
            dbContext.SaveChanges();

            return(RedirectToAction("Dashboard"));
        }
Example #18
0
        public IActionResult Attend(int eventId, int userId)
        {
            Participate newJoin = new Participate();

            newJoin.UserId      = userId;
            newJoin.DojoEventId = eventId;
            context.Join.Add(newJoin);
            context.SaveChanges();
            return(RedirectToAction("Home"));
        }
        public async Task <IHttpActionResult> GetParticipate(Guid id)
        {
            Participate existedParticipate = await db.Participates.FindAsync(id);

            if (existedParticipate == null)
            {
                return(NotFound());
            }
            return(Ok(existedParticipate));
        }
Example #20
0
        /// <summary>
        /// Thay đổi role của một user
        /// </summary>
        /// <param name="model">Participate model</param>
        public void editRoleUser(Participate model)
        {
            Participate user = findMemberInGroup(model.Id);

            user.IsAdmin         = model.IsAdmin;
            user.IsManager       = model.IsManager;
            user.Updated_At      = DateTime.Now;
            db.Entry(user).State = System.Data.Entity.EntityState.Modified;
            db.SaveChanges();
        }
        public async Task <IHttpActionResult> PostParticipate(Participate participate)
        {
            db.Participates.Add(participate);
            await db.SaveChangesAsync();

            await db.Entry(participate).GetDatabaseValuesAsync();

            participate.Owner = await db.Activities.FindAsync(participate.OwnerId);

            return(Ok(participate));
        }
Example #22
0
        public void addMember(string idUser, int idGroup)
        {
            Participate role = new Participate();

            role.IdUser     = idUser;
            role.IdGroup    = idGroup;
            role.Created_At = DateTime.Now;
            role.Updated_At = DateTime.Now;
            db.Participates.Add(role);
            db.SaveChanges();
        }
        public async Task <IHttpActionResult> DeleteParticipate(Guid id)
        {
            Participate existedParticipate = await db.Participates.FindAsync(id);

            if (existedParticipate == null)
            {
                return(NotFound());
            }
            db.Participates.Remove(existedParticipate);
            await db.SaveChangesAsync();

            return(Ok());
        }
Example #24
0
        /// <summary>
        /// Add nhiều member vào group
        /// </summary>
        /// <param name="group">Model Group</param>
        /// <param name="listUser">Danh sách email của member</param>
        public void addMembers(Group group, List <string> listUser)
        {
            foreach (string user in listUser)
            {
                Participate role = new Participate();
                role.IdUser     = db.AspNetUsers.SingleOrDefault(x => x.Email == user).Id;
                role.IdGroup    = group.Id;
                role.Created_At = DateTime.Now;
                role.Updated_At = DateTime.Now;

                db.Participates.Add(role);
            }
            db.SaveChanges();
        }
        public IActionResult UnParticipate(int activityId)
        {
            Participate participant = db.Participates.FirstOrDefault(a => a.ActivityId == activityId && a.UserId == uid);

            if (participant == null)
            {
                return(RedirectToAction("Dashboard", "Home"));
            }

            db.Participates.Remove(participant);
            db.SaveChanges();

            return(RedirectToAction("Dashboard", "Home"));
        }
Example #26
0
        public IActionResult JoinActivity(int activity_id)
        {
            if (HttpContext.Session.GetInt32("id") == null)
            {
                return(RedirectToAction("Index", "User"));
            }
            // insert part 2 here
            //not able to joy the overlap activities
            var      ParticipatingActivities = mycontext.Participate.Where(p => p.UserId == ActiveUser.UserId).Select(u => u.ParticipatingActivities).ToList();
            Activity currentActivity         = mycontext.Activities.SingleOrDefault(a => a.ActivityId == activity_id);

            foreach (var activity in ParticipatingActivities)
            {
                DateTime start_date = activity.Date;
                DateTime end_date   = start_date.AddMinutes((double)activity.Duration);
                Console.WriteLine(end_date);
                System.Console.WriteLine("Is this getting joined or not #$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
                DateTime activity_date     = currentActivity.Date;
                DateTime activity_end_date = activity_date.AddMinutes((double)currentActivity.Duration);
                if (activity_date < start_date && activity_end_date < start_date)
                {
                    currentActivity.Date     = currentActivity.Date;
                    currentActivity.Duration = currentActivity.Duration;
                }
                else if (activity_date > start_date && activity_date > end_date)
                {
                    currentActivity.Date     = currentActivity.Date;
                    currentActivity.Duration = currentActivity.Duration;
                }
                else
                {
                    ViewBag.Error     = null;
                    TempData["error"] = "Activity Conflict!!!!! You cannot be at 2 places at once";
                    Console.WriteLine("Dashboard");
                    return(Redirect("/Dashboard"));
                }
            }
            // end part 2

            Participate newParticipation = new Participate
            {
                UserId     = ActiveUser.UserId,
                ActivityId = activity_id
            };

            mycontext.Participate.Add(newParticipation);
            mycontext.SaveChanges();
            return(RedirectToAction("Index"));
        }
        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            Participate user = new Participate();

            if (!isAjaxRequest(filterContext))
            {
                //form request
                BaseAuthorize(filterContext, user);
            }
            else
            {
                //ajax request
                AjaxAuthorize(filterContext, user);
            }
        }
        public IActionResult Participate(Participate newParticipant)
        {
            Participate alreadyParticipating = db.Participates.FirstOrDefault(u => u.UserId == uid && u.ActivityId == newParticipant.ActivityId);

            if (alreadyParticipating != null)
            {
                return(RedirectToAction("Dashboard", "Home"));
            }

            newParticipant.UserId = (int)uid;
            db.Participates.Add(newParticipant);
            db.SaveChanges();

            return(RedirectToAction("Dashboard", "Home"));
        }
Example #29
0
        public JsonResult SaveTaskRun(int idtaskrun, string valuetext, string valuefile, HttpPostedFileBase fileupload, bool isEdit)
        {
            //TODO: Chưa phân quyền
            string         IdUser = User.Identity.GetUserId();
            HttpStatusCode status = HttpStatusCode.OK;
            string         message;
            object         response;
            TaskProcessRun taskrun = taskService.findTaskRun(idtaskrun);

            if (taskrun == null)
            {
                status   = HttpStatusCode.NotFound;
                message  = "TaskRun Not Found";
                response = new { message = message, status = status };
                SetFlash(FlashType.error, message);
                return(Json(response, JsonRequestBehavior.AllowGet));
            }
            List <RoleRun> listrole = roleService.findlistrolerunbyidroleprocess(taskrun.IdRole);
            Participate    user     = participateService.findMemberInGroup(IdUser, taskrun.StepRun.ProcessRun.Process.IdGroup);
            bool           haveRole = false;

            foreach (RoleRun role in listrole)
            {
                if (IdUser == role.IdUser)
                {
                    haveRole = true;
                    break;
                }
            }
            if (user.IsManager == true || haveRole)
            {
                taskService.submitTask(IdUser, valuetext, valuefile, idtaskrun);
                int    groupid     = taskrun.StepRun.ProcessRun.Process.IdGroup;
                string taskRunPath = string.Format("Upload/{0}/run/{1}/{2}/{3}", groupid, taskrun.StepRun.ProcessRun.Id, taskrun.StepRun.Id, taskrun.Id);
                if (!isEdit)
                {
                    fileService.emptyDirectory(taskRunPath);
                }
                fileService.createDirectory(taskRunPath);
                fileService.saveFile(groupid, fileupload, taskRunPath, Direction.TaskRun);
            }

            message  = "Save Task Successfully";
            response = new { message = message, status = status };
            SetFlash(FlashType.success, "Save Task Successfully");
            return(Json(response, JsonRequestBehavior.AllowGet));
        }
        public IActionResult JoinActivity(int activity_id)
        {
            if (HttpContext.Session.GetInt32("id") == null)
            {
                return(RedirectToAction("Index", "User"));
            }
            List <Activity> ParticipatingActivities = DbContext.Participate.Where(p => p.UserId == ActiveUser.UserId).Select(u => u.ParticipatingActivities).ToList();
            Activity        currentActivity         = DbContext.Activities.SingleOrDefault(a => a.ActivityId == activity_id);

            foreach (var activity in ParticipatingActivities)
            {
                DateTime start_date = activity.Date;
                DateTime end_date   = start_date.AddMinutes((double)activity.Duration);
                Console.WriteLine(end_date);
                DateTime activity_date     = currentActivity.Date;
                DateTime activity_end_date = activity_date.AddMinutes((double)currentActivity.Duration);
                if (activity_date < start_date && activity_end_date < start_date)
                {
                    currentActivity.Date     = currentActivity.Date;
                    currentActivity.Duration = currentActivity.Duration;
                }
                else if (activity_date > start_date && activity_date > end_date)
                {
                    currentActivity.Date     = currentActivity.Date;
                    currentActivity.Duration = currentActivity.Duration;
                }
                else
                {
                    ViewBag.Error     = null;
                    TempData["error"] = "Can not join activity because it conflicts with a currenty activity";
                    return(Redirect("/Dashboard"));
                }
            }
            Participate newParticipation = new Participate
            {
                UserId     = ActiveUser.UserId,
                ActivityId = activity_id
            };

            DbContext.Participate.Add(newParticipation);
            DbContext.SaveChanges();
            return(RedirectToAction("Index"));
        }
 public ActionResult Participate(Participate form)
 {
     return Handle(form, RedirectToAction("Index", "Home"));
 }
 public void Add(Participate participate)
 {
     _participates.Add(participate);
 }