public static Boolean SendNotificationToUser(NotificationUser notification, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    TblNotifications notif = new TblNotifications
                    {
                        Description = notification.Description,
                        Hour        = DateTime.Now,
                        Subject     = notification.Subject,
                        Urgency     = notification.Urgency,
                        Approval    = notification.Approval,
                        UserFK      = notification.SenderFK
                    };
                    db.TblNotifications.Add(notif);
                    db.SaveChanges();

                    TblValidations valid = new TblValidations
                    {
                        NotificationFK = notif.ID,
                        ReceiverFK     = notification.ReceiverFK,
                        Accepted       = false,
                        Read           = false,
                        StudentFK      = notification.StudentFK
                    };
                    db.TblValidations.Add(valid);
                    db.SaveChanges();

                    BAction.SetActionToUser(String.Format("enviou uma notificação ao utilizador '{0}'", db.TblUsers.Find(notification.ReceiverFK).Name), userID);
                    return(true);
                }
            }
            catch (Exception) { return(false); }
        }
Example #2
0
        public static Boolean EditUser(User editedUser, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    var user = db.TblUsers.Find(editedUser.ID);

                    user.Name         = editedUser.Name;
                    user.Email        = editedUser.Email;
                    user.Address      = editedUser.Address;
                    user.CitizenCard  = editedUser.CitizenCard;
                    user.Curriculum   = editedUser.Curriculum;
                    user.FiscalNumber = editedUser.FiscalNumber;
                    user.PhoneNumber  = editedUser.PhoneNumber;
                    user.Photo        = editedUser.Photo;
                    user.Function     = editedUser.Function;
                    user.DateOfBirth  = editedUser.DateOfBirth;

                    db.Entry(user).State = EntityState.Modified;
                    db.SaveChanges();


                    BAction.SetActionToUser(String.Format("Editou os dados do utilizador '{0}'", editedUser.Name), userID);
                    return(true);
                }
            }
            catch (Exception) { return(false); }
        }
Example #3
0
        public static Object DeleteDocument(int documentID, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    var document = db.TblDocuments.Find(documentID);
                    if (document.UserFK != userID)
                    {
                        return(new { result = false, info = "Não Autorizado, não foi o utilizador a submeter o documento." });
                    }
                    if (!BClass.GetActivity(document.ClassFK ?? 0))
                    {
                        return(new { result = false, info = "A turma enconstra-se inativa, já não é possível eliminar o documento." });
                    }
                    db.TblDocuments.Remove(document);
                    db.SaveChanges();

                    var cla = db.TblClasses.Find(document.ClassFK);
                    BAction.SetActionToUser(String.Format("Eliminou o documento '{0}' da turma '{1}' da escola '{2}'", document.File.Split('.')[1] + document.File.Split('.')[2], cla.Year + cla.ClassDesc, db.TblSchools.Find(cla.SchoolFK).Name), userID);
                    return(new { result = true });
                }
            }
            catch (Exception) { return(new { result = false, info = "Não foi possível eliminar o documento." }); }
        }
Example #4
0
        public static Boolean EditTask(TblTasks task, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    db.Entry(task).State = EntityState.Modified;
                    db.SaveChanges();

                    BAction.SetActionToUser(String.Format("Editou a tarefa '{0}' ao utilizador '{1}'", task.Description, db.TblUsers.Find(task.UserFK).Name), userID);
                    return(true);
                }
            }
            catch (Exception) { return(false); }
        }
Example #5
0
        public static Object EditClass(TblClasses alteredClass, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    db.Entry(alteredClass).State = EntityState.Modified;
                    db.SaveChanges();

                    BAction.SetActionToUser(String.Format("Editou a turma '{0}' da escola '{1}'", alteredClass.Year + alteredClass.ClassDesc, db.TblSchools.Find(alteredClass.SchoolFK).Name), userID);
                    return(new { result = true });
                }
            }
            catch (Exception) { return(new { result = false, info = "Não foi possível editar a turma." }); }
        }
Example #6
0
        public static Object CreateClass(TblClasses newClass, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    db.TblClasses.Add(newClass);
                    db.SaveChanges();

                    BAction.SetActionToUser(String.Format("Criou a turma '{0}' da escola '{1}'", newClass.Year + newClass.ClassDesc, db.TblSchools.Find(newClass.SchoolFK).Name), userID);
                    return(new { result = true, data = newClass.ID });
                }
            }
            catch (Exception) { return(new { result = false, info = "Não foi possível criar a turma." }); }
        }
        public static Boolean RemoveParenting(int guardianID, int studentID, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    db.TblParenting.Remove(db.TblParenting.Find(studentID, guardianID));
                    db.SaveChanges();

                    BAction.SetActionToUser(String.Format("removeu a associação do encarreagdo de educação '{0}' ao aluno '{1}'", db.TblUsers.Find(guardianID).Name, db.TblUsers.Find(studentID).Name), userID);
                    return(true);
                }
            }
            catch (Exception) { return(false); }
        }
Example #8
0
        public static bool EditNotice(TblNotices notice, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    db.Entry(notice).State = EntityState.Modified;
                    db.SaveChanges();

                    BAction.SetActionToUser(String.Format("Editou o anuncio '{0}' de escola '{1}'", notice.Title, db.TblSchools.Find(notice.SchoolFK).Name), userID);
                    return(true);
                }
            }
            catch (Exception) { return(false); }
        }
Example #9
0
        public static bool DeleteNotice(int noticeid, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    var notice = db.TblNotices.Find(noticeid);
                    db.TblNotices.Remove(notice);
                    db.SaveChanges();

                    BAction.SetActionToUser(String.Format("Removou o anuncio '{0}' de escola '{1}'", notice.Title, db.TblSchools.Find(notice.SchoolFK).Name), userID);
                    return(true);
                }
            }
            catch (Exception) { return(false); }
        }
Example #10
0
        public static Boolean EditSchedule(TblSchedules schedule, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    db.Entry(schedule).State = EntityState.Modified;
                    db.SaveChanges();

                    var clas = db.TblClasses.Find(schedule.ClassFK);
                    BAction.SetActionToUser(String.Format("Editou o horário de uma aula da turma '{0}'", clas.Year + clas.ClassDesc), userID);
                    return(true);
                }
            }
            catch (Exception) { return(false); }
        }
        public static Object CreateEvaluation(TblEvaluations evaluation, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    db.TblEvaluations.Add(evaluation);
                    db.SaveChanges();

                    var cla = db.TblClasses.Find(evaluation.ClassFK);
                    BAction.SetActionToUser(String.Format("Adicionou uma avaliação na turma '{0}' da escola '{1}'", cla.Year + cla.ClassDesc, db.TblSchools.Find(cla.SchoolFK).Name), userID);
                    return(new { result = true });
                }
            }
            catch (Exception) { return(new { result = false, info = "Não foi possível registar a avaliação" }); }
        }
Example #12
0
        public static Object RemoveUser(int classID, int userID, int currentUser)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    var classUser = db.TblClassUsers.Where(x => x.ClassFK == classID && x.UserFK == userID).FirstOrDefault();
                    db.TblClassUsers.Remove(classUser);
                    db.SaveChanges();

                    var cla = db.TblClasses.Find(classUser.ClassFK);
                    BAction.SetActionToUser(String.Format("Removeu o utilizador '{0}' à turma '{1}' da escola {2}", db.TblUsers.Find(classUser.UserFK).Name, cla.Year + cla.ClassDesc, db.TblSchools.Find(cla.SchoolFK).Name), currentUser);
                    return(new { result = true });
                }
            }
            catch (Exception) { return(new { result = false, info = "Não foi possível remover o utilizador à turma." }); }
        }
Example #13
0
        public static Object SwitchActivity(int classID, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    var cla = db.TblClasses.Find(classID);
                    cla.IsActive        = cla.IsActive ? false : true;
                    db.Entry(cla).State = EntityState.Modified;
                    db.SaveChanges();

                    BAction.SetActionToUser(String.Format("Alterou o estado de actividade da turma '{0}' da escola '{1}' para '{2}'", cla.Year + cla.ClassDesc, db.TblSchools.Find(cla.SchoolFK).Name, (cla.IsActive?"ACTIVO":"INACTIVO")), userID);
                    return(new { result = true });
                }
            }
            catch (Exception) { return(new { result = false, info = "Não foi possível alterar estado de atividade da turma." }); }
        }
Example #14
0
        public static Boolean AddParenting(int guardianID, int studentID, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    db.TblParenting.Add(new TblParenting {
                        GuardianFK = guardianID, StudentFK = studentID
                    });
                    db.SaveChanges();

                    BAction.SetActionToUser(String.Format("Associou o encarreagdo de educação '{0}' ao aluno '{1}'", db.TblUsers.Find(guardianID).Name, db.TblUsers.Find(studentID).Name), userID);
                    return(true);
                }
            }
            catch (Exception) { return(false); }
        }
Example #15
0
        public static Object CreateLesson(TblLessons lesson, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    db.TblLessons.Add(lesson);
                    db.SaveChanges();

                    var schedule = db.TblSchedules.Find(lesson.ScheduleFK);
                    var clas     = db.TblClasses.Find(schedule.ClassFK);
                    BAction.SetActionToUser(String.Format("Adicionou uma lição à disciplina '{0}' da turma '{1}' da escola '{2}'", db.TblSubjects.Find(schedule.SubjectFK).Name, clas.Year + clas.ClassDesc, db.TblSchools.Find(clas.SchoolFK).Name), userID);
                    return(new { result = true, data = lesson.ID });
                }
            }
            catch (Exception) { return(new { result = false, info = "Não foi possível criar uma lição." }); }
        }
Example #16
0
        public static bool DeleteSchedule(int scheduleid, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    var schedule = db.TblSchedules.Find(scheduleid);
                    db.TblSchedules.Remove(schedule);
                    db.SaveChanges();

                    var clas = db.TblClasses.Find(schedule.ClassFK);
                    BAction.SetActionToUser(String.Format("Removeu o horário de uma aula da turma '{0}'", clas.Year + clas.ClassDesc), userID);
                    return(true);
                }
            }
            catch (Exception) { return(false); }
        }
Example #17
0
        public static Boolean EditLesson(TblLessons lesson, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    db.Entry(lesson).State = EntityState.Modified;
                    db.SaveChanges();

                    var schedule = db.TblSchedules.Find(lesson.ScheduleFK);
                    var clas     = db.TblClasses.Find(schedule.ClassFK);
                    BAction.SetActionToUser(String.Format("Editou a lição à disciplina '{0}' da turma '{1}' da escola '{2}'", db.TblSubjects.Find(schedule.SubjectFK).Name, clas.Year + clas.ClassDesc, db.TblSchools.Find(clas.SchoolFK).Name), userID);
                    return(true);
                }
            }
            catch (Exception) { return(false); }
        }
Example #18
0
        public static Boolean SwitchActivity(int userID, int currentUser)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    var user = db.TblUsers.Find(userID);
                    user.IsActive        = (bool)user.IsActive ? false : true;
                    db.Entry(user).State = EntityState.Modified;
                    db.SaveChanges();

                    //ActiveDirectory.DisableOrEnableUser(user.Email);

                    BAction.SetActionToUser(String.Format("Alterou o estado de atividade do utilizador '{0}'", user.Name), currentUser);
                    return(true);
                }
            }
            catch (Exception) { return(false); }
        }
Example #19
0
        public static Boolean RemoveRole(int userID, int roleID, int currentUser)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    db.TblUserRoles.Remove(db.TblUserRoles.Find(userID, roleID));
                    db.SaveChanges();

                    var user = db.TblUsers.Find(userID);

                    //ActiveDirectory.RemoveRole(user.Email, roleID);

                    BAction.SetActionToUser(String.Format("Removeu ao utilizador '{0}' a função de '{1}'", db.TblUsers.Find(userID).Name, db.TblRoles.Find(roleID).Name), currentUser);
                    return(true);
                }
            }
            catch (Exception) { return(false); }
        }
Example #20
0
        public static Object AddUser(int classID, int userID, int currentUser)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    var classUser = new TblClassUsers {
                        ClassFK = classID, UserFK = userID
                    };
                    db.TblClassUsers.Add(classUser);
                    db.SaveChanges();

                    var cla = db.TblClasses.Find(classUser.ClassFK);
                    BAction.SetActionToUser(String.Format("Adicionou o utilizador '{0}' à turma '{1}' da escola {2}", db.TblUsers.Find(classUser.UserFK).Name, cla.Year + cla.ClassDesc, db.TblSchools.Find(cla.SchoolFK).Name), currentUser);
                    return(new { result = true });
                }
            }
            catch (Exception) { return(new { result = false, info = "Não foi possível adicionar o utilizador à turma." }); }
        }
Example #21
0
        public static Object CreateDocument(TblDocuments document, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    if (!BClass.GetActivity(document.ClassFK ?? 0))
                    {
                        return(new { result = false, info = "A turma enconstra-se inativa, já não é possível adicionar o documento." });
                    }
                    db.TblDocuments.Add(document);
                    db.SaveChanges();

                    var cla = db.TblClasses.Find(document.ClassFK);
                    BAction.SetActionToUser(String.Format("Adicionou documento '{0}' da turma '{1}' da escola '{2}'", document.File.Split('.')[1] + document.File.Split('.')[2], cla.Year + cla.ClassDesc, db.TblSchools.Find(cla.SchoolFK).Name), userID);
                    return(new { result = true });
                }
            }
            catch (Exception) { return(new { result = false, info = "Não foi possível eliminar o documento." }); }
        }
Example #22
0
        public static Object DoneTask(int taskID, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    if (db.TblTasks.Any(x => x.ID == taskID && x.UserFK == userID))
                    {
                        db.TblDone.Add(new TblDone {
                            Hour = DateTime.Now, TaskFK = taskID
                        });
                        db.SaveChanges();
                        return(new { result = false, info = "Não autorizado." });
                    }

                    BAction.SetActionToUser(String.Format("Realizou a tarefa '{0}'", db.TblTasks.Find(taskID).Description), userID);
                    return(new { result = true });
                }
            }
            catch (Exception) { return(new { result = false, info = "Não foi possivel registar a realização." }); }
        }
        public static Boolean SendNotificationToClass(NotificationClass notification, int userID)
        {
            try
            {
                using (var db = new DBContextModel())
                {
                    TblNotifications notif = new TblNotifications
                    {
                        Description = notification.Description,
                        Hour        = DateTime.Now,
                        Subject     = notification.Subject,
                        Urgency     = notification.Urgency,
                        Approval    = notification.Approval,
                        UserFK      = notification.SenderFK
                    };
                    db.TblNotifications.Add(notif);
                    db.SaveChanges();

                    var students = BClass.GetStudentsByClass(notification.ClassFK);
                    foreach (var student in students)
                    {
                        TblValidations valid = new TblValidations
                        {
                            ReceiverFK = BParenting.GetGuardians(student).FirstOrDefault(),
                            StudentFK  = student,
                            Accepted   = false,
                            Read       = false
                        };
                        db.TblValidations.Add(valid);
                        db.SaveChanges();
                    }

                    var cla = db.TblClasses.Find(notification.ClassFK);
                    BAction.SetActionToUser(String.Format("enviou uma notificação a turma '{0}'", cla.Year + cla.ClassDesc), userID);
                    return(true);
                }
            }
            catch (Exception) { return(false); }
        }