public JsonResult json_login()
        {
            var pars = Request.Params;

            string username = pars["username"];
            string password = pars["password"];



            Models.prjEntities ctx = new Models.prjEntities();
            var curUser            =
                (
                    from u in ctx.user
                    where u.username == username && u.password == password
                    select u
                );

            if (curUser.Count() == 1)
            {
                Session["user"] = curUser.First();
                return(Json(new { result = 1 }, JsonRequestBehavior.AllowGet));
            }

            else
            {
                return(Json(new { result = 0 }, JsonRequestBehavior.AllowGet));
            }
        }
        public IEnumerable <object> getExistingUsers()
        {
            Models.prjEntities ctx = new Models.prjEntities();

            //Note to paor new ss any object to view we need to use built-in types or newly defined types
            var Q =
                (
                    from p in ctx.person
                    where p.users.Any()
                    select new px()
            {
                person_id = p.person_id,
                fname = p.fname,
                lname = p.lname,
                userInfo =
                    (
                        from u in p.users
                        where u.person_id == p.person_id
                        select new ux()
                {
                    username = u.username,
                    password = u.password
                }
                    )
            }
                );

            return(Q);
        }
        public JsonResult json_saveNewTask()
        {
            var    pars             = Request.Params;
            string task_title       = pars["Task_title"];
            string task_description = pars["Task_description"];
            string task_deadline    = pars["task_deadline"];
            string filenames        = pars["filenames"];


            using (Models.prjEntities ctx = new Models.prjEntities())
            {
                Models.task newTask = new Models.task()
                {
                    title          = task_title,
                    description    = task_description,
                    task_status_id = 2,/*Progressing*/
                    stamp          = DateTime.Now,
                    is_active      = true
                };
                ctx.task.AddObject(newTask);
                ctx.SaveChanges();
            }

            //(2) add document objects for Task


            return(Json(new { result = "done" }, JsonRequestBehavior.AllowGet));
        }
        public IEnumerable<object> getExistingUsers()
        {
            Models.prjEntities ctx = new Models.prjEntities();

            //Note to paor new ss any object to view we need to use built-in types or newly defined types
            var Q =
            (
                from p in ctx.person
                where p.users.Any()
                select new px()
                {
                    person_id = p.person_id,
                    fname = p.fname,
                    lname = p.lname,
                    userInfo =
                    (
                        from u in p.users
                        where u.person_id == p.person_id
                        select new ux()
                        {
                            username=u.username,
                            password=u.password
                        }
                    )
                }
            );
            return Q;
        }
        //Adds new descriptive content for specific task person
        public JsonResult json_saveNewTaskStat()
        {
            var pars = Request.Params;

            int    task_id     = Convert.ToInt32(pars["task_id"]);
            string description = pars["description"];

            var curUser   = Session["user"];
            int person_id = Convert.ToInt32(((Models.user)curUser).person_id);

            int task_person_id = this.getCurTaskPerson(task_id, person_id).First().task_person_id;

            using (Models.prjEntities ctx = new Models.prjEntities())
            {
                var newTaskProgress = new Models.tp_progress()
                {
                    t_p_id      = task_person_id,
                    description = description,
                    datetime    = DateTime.Now
                };

                ctx.tp_progress.AddObject(newTaskProgress);
                ctx.SaveChanges();
            }

            return(Json(new { result = "done" }, JsonRequestBehavior.AllowGet));
        }
        public JsonResult json_saveUserSequence()
        {
            var pars    = Request.Params;
            int task_id = Convert.ToInt32(pars["task_id"]);

            string[] person_ids = pars["taskUsersSequence"].Split(',');


            using (Models.prjEntities ctx = new Models.prjEntities())
            {
                foreach (var item in person_ids)
                {
                    Models.task_person tp = new Models.task_person()
                    {
                        task_id             = task_id,
                        person_id           = Convert.ToInt32(item),
                        user_task_status_id = 1 /*Not Started*/
                    };
                    ctx.task_person.AddObject(tp);
                    ctx.SaveChanges();
                }
            }

            return(Json(new { result = "done" }, JsonRequestBehavior.AllowGet));
        }
        public JsonResult json_savePermissions()
        {
            var pars = Request.Params;

            string roleIds = pars["roleIds"];


            using (TransactionScope t = new TransactionScope())
            {
                using (Models.prjEntities ctx = new Models.prjEntities())
                {
                    //Delete all related permissions first
                    var allUserPermissions =
                        (
                            from p in ctx.permission
                            select p
                        );
                    foreach (var pi in allUserPermissions)
                    {
                        ctx.permission.DeleteObject(pi);
                        ctx.SaveChanges();
                    }
                    if (!String.IsNullOrEmpty(roleIds))
                    {
                        string[] roles = roleIds.Split(',');
                        foreach (var role in roles)
                        {
                            var roleId = Convert.ToInt32(role);
                            //Check if already exists
                            var roleUserExists =
                                (
                                    from p in ctx.permission
                                    where p.user_id == 1 && p.role_id == (int)roleId
                                    select new { temp = 1 }
                                );

                            if (roleUserExists.Count() != 0)
                            {
                                continue;
                            }

                            //Build New Permission Object
                            var newPermission = new Models.permission()
                            {
                                user_id = 1,
                                role_id = roleId
                            };

                            ctx.permission.AddObject(newPermission);
                            ctx.SaveChanges();
                        }
                    }

                    t.Complete();
                }
            }

            return(Json(new { result = "Done" }, JsonRequestBehavior.AllowGet));
        }
        //update timer
        public JsonResult json_updateTaskProgress()
        {
            var pars    = Request.Params;
            int task_id = Convert.ToInt32(pars["task_id"]);

            var curUser   = Session["user"];
            int person_id = Convert.ToInt32(((Models.user)curUser).person_id);

            int task_person_id = this.getCurTaskPerson(task_id, person_id).First().task_person_id;

            using (Models.prjEntities ctx = new Models.prjEntities())
            {
                var cur_task_person =
                    (
                        from tp in ctx.task_person
                        where tp.task_person_id == task_person_id
                        select tp
                    ).First();


                /* First check if there is any open timer then update end_timestamp else create new with open end_timestamp */
                var q =
                    (
                        from tpt in ctx.tp_timer
                        where
                        tpt.task_person.task_person_id == task_person_id &&
                        tpt.task_person.user_task_status_id != 3 &&/*Not Finalized*/
                        tpt.end_stamp == null    /*open timer*/
                        select tpt
                    );
                if (q.Count() != 0)
                {
                    q.First().end_stamp = DateTime.Now;
                    q.First().is_commited = true;
                    q.First().task_person.user_task_status_id = 2 /*Progressing*/;
                    ctx.SaveChanges();
                }
                else
                {
                    var newTimer = new Models.tp_timer()
                    {
                        t_p_id      = task_person_id,
                        start_stamp = DateTime.Now,
                        end_stamp   = null,
                        is_commited = false
                    };

                    ctx.tp_timer.AddObject(newTimer);
                    ctx.SaveChanges();
                }
            }

            //return back current timer status after operation
            return(Json(new { result = this.getTaskPersontimerStat(task_id, person_id) }, JsonRequestBehavior.AllowGet));
        }
        //get Existing office List
        public IEnumerable<object> getExistingOffices()
        {
            Models.prjEntities ctx = new Models.prjEntities();

            var Q =
            (
                from r in ctx.organization
                select r
            );
            return Q;
        }
        public IEnumerable<object> getExistingRoles(int user_id)
        {
            Models.prjEntities ctx = new Models.prjEntities();

            var Q2 =
                ctx.lu_role
                .GroupJoin(ctx.permission, r => r.role_id, p => p.role_id, (r, p) => new { r, p })
                    .Where(x => x.p.All(x2 => x2.user_id == user_id))
                    .Where(x => x.p.All(x2 => x2.permission_id == null))
                    .Select(x=>new x(){role_id=x.r.role_id,role_name=x.r.role_name});
                    ;

            return Q2;
        }
        public IEnumerable <object> getUserAssignedRoles(int user_id)
        {
            Models.prjEntities ctx = new Models.prjEntities();

            var Q =
                (
                    from r in ctx.lu_role
                    from p in r.permissions
                    where p.user_id == user_id && r.permissions.Any()
                    select r
                );

            return(Q);
        }
        //get list of specific task progress history
        public IEnumerable<dynamic> getCurUserTimeTrackerHistory(int task_id, int person_id)
        {
            Models.prjEntities ctx = new Models.prjEntities();

            var Q =
            (
                from tp in ctx.tp_progress

                where tp.task_person.task_id == task_id
                orderby tp.t_p_p_id descending

                select tp

            );
            return Q;
        }
        //check wheter or not the current use has turn in this specific task
        public IEnumerable<Models.task_person> getCurTaskPerson(int task_id, int person_id)
        {
            Models.prjEntities ctx = new Models.prjEntities();

            var Q =
            (
                from tp in ctx.task_person

                where   tp.task_id == task_id
                        && tp.person_id==person_id
                        && tp.user_task_status_id!=3 /*NOT (finalized)*/
                orderby tp.task_person_id ascending
                select tp
            );
            return Q;
        }
        public IEnumerable <object> getExistingRoles(int user_id)
        {
            Models.prjEntities ctx = new Models.prjEntities();


            var Q2 =
                ctx.lu_role
                .GroupJoin(ctx.permission, r => r.role_id, p => p.role_id, (r, p) => new { r, p })
                .Where(x => x.p.All(x2 => x2.user_id == user_id))
                .Where(x => x.p.All(x2 => x2.permission_id == null))
                .Select(x => new x()
            {
                role_id = x.r.role_id, role_name = x.r.role_name
            });

            ;

            return(Q2);
        }
        //get User by OfficeId
        public IEnumerable<object> getExistingOfficeUsers(int org_id)
        {
            Models.prjEntities ctx = new Models.prjEntities();

            var Q =
            (
                from p in ctx.person
                join po in ctx.person_org on p.person_id equals po.person_id into joint
                from leftjoint in joint
                where leftjoint.org_id == org_id
                select new
                {
                    person_id = p.person_id,
                    fname = p.fname,
                    lname = p.lname,
                    thumbnail = "/resources/components/workflow1/task/assignment/images/user.png"
                }
            );
            return Q;
        }
Esempio n. 16
0
        //if tjhere is any open timer close it . and finalu task_person obect goes to finalize stat
        public JsonResult json_finalizeTaskPerson()
        {
            var pars = Request.Params;

            int task_id   = Convert.ToInt32(pars["task_id"]);
            var curUser   = Session["user"];
            int person_id = Convert.ToInt32(((Models.user)curUser).person_id);

            using (Models.prjEntities ctx = new Models.prjEntities())
            {
                var cur_task_person =
                    (
                        from tp in ctx.task_person

                        where tp.task_id == task_id && tp.user_task_status_id != 3 /*NOT (finalized)*/
                        orderby tp.task_person_id ascending
                        select tp
                    ).First();



                if (this.getTaskPersontimerStat(task_id, person_id) == "pause")   //timer open
                {
                    //close timer
                    var open_time_task_person = (
                        from tpt in ctx.tp_timer
                        where
                        tpt.task_person.task_person_id == cur_task_person.task_person_id &&
                        tpt.task_person.user_task_status_id == 2 &&    /*Progressing*/
                        tpt.end_stamp == null        /*open timer*/
                        select tpt
                        ).First();
                    open_time_task_person.end_stamp = DateTime.Now;
                }
                //finally finalize task person
                cur_task_person.user_task_status_id = 3;
                ctx.SaveChanges();
            }

            return(Json(new { result = "done" }, JsonRequestBehavior.AllowGet));
        }
        public IEnumerable<object> getUserAssignedRoles(int user_id)
        {
            Models.prjEntities ctx = new Models.prjEntities();

            var Q =
            (
                from r in ctx.lu_role
                from p in r.permissions
                where p.user_id==user_id && r.permissions.Any()
                select r
            );
            return Q;
        }
        public JsonResult json_savePermissions()
        {
            var pars = Request.Params;

            string roleIds = pars["roleIds"];

            using (TransactionScope t = new TransactionScope())
            {
                using (Models.prjEntities ctx = new Models.prjEntities())
                {
                    //Delete all related permissions first
                    var allUserPermissions =
                    (
                            from p in ctx.permission
                            select p
                    );
                    foreach (var pi in allUserPermissions)
                    {
                        ctx.permission.DeleteObject(pi);
                        ctx.SaveChanges();
                    }
                    if (!String.IsNullOrEmpty(roleIds))
                    {
                        string[] roles = roleIds.Split(',');
                        foreach (var role in roles)
                        {
                            var roleId = Convert.ToInt32(role);
                            //Check if already exists
                            var roleUserExists =
                            (
                               from p in ctx.permission
                               where p.user_id == 1 && p.role_id == (int)roleId
                               select new { temp = 1 }
                            );

                            if (roleUserExists.Count() != 0)
                                continue;

                            //Build New Permission Object
                            var newPermission = new Models.permission()
                            {
                                user_id = 1,
                                role_id = roleId
                            };

                            ctx.permission.AddObject(newPermission);
                            ctx.SaveChanges();
                        }
                    }

                    t.Complete();
                }

            }

            return Json(new { result = "Done" }, JsonRequestBehavior.AllowGet);
        }
        public JsonResult json_login()
        {
            var pars = Request.Params;

            string username = pars["username"];
            string password = pars["password"];

            Models.prjEntities ctx = new Models.prjEntities();
                var curUser =
                (
                     from u in ctx.user
                     where u.username == username && u.password == password
                     select u
                );
                if (curUser.Count() == 1)
                {
                    Session["user"] = curUser.First();
                    return Json(new { result = 1 }, JsonRequestBehavior.AllowGet);
                }

                else
                    return Json(new { result = 0 }, JsonRequestBehavior.AllowGet);
        }
        //get Users assigned to Task
        public IEnumerable<object> getTaskAssignedUsers(int task_id)
        {
            Models.prjEntities ctx = new Models.prjEntities();

            var Q =
            (
                from tp in ctx.task_person
                join p in ctx.person on tp.person_id equals p.person_id into joint1

                from jointItem1 in joint1
                join po in ctx.person_org on jointItem1.person_id equals po.person_id into joint2

                from jointItem2 in joint2

                where tp.task_id == task_id
                orderby tp.task_person_id, jointItem2.org_id ascending
                select new
                {
                    org_id = jointItem2.org_id,
                    person_id = jointItem1.person_id,
                    fname = jointItem1.fname,
                    lname = jointItem1.lname
                }
            );
            return Q;
        }