public void AddUserSkillMapping(int skillId, int userId, int addedByUser) { try { using (var context = new TrainingTrackerEntities()) { var skillMapping = context.UserSkillMappings.SingleOrDefault(x => x.SkillId == skillId && x.UserId == userId); if (skillMapping == null) { return; } context.UserSkillMappings.Add(new UserSkillMapping { SkillId = skillId, AddedBy = addedByUser, UserId = userId, AddedOn = DateTime.Now }); context.SaveChanges(); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); } }
public bool AddSubtopicContent(SubtopicContent dataToAdd, out int id) { try { using (var context = new TrainingTrackerEntities()) { EntityFramework.SubtopicContent entityToAdd = new EntityFramework.SubtopicContent { Name = dataToAdd.Name, Description = dataToAdd.Description, CourseSubtopicId = dataToAdd.CourseSubtopicId, Url = dataToAdd.Url, SortOrder = context.SubtopicContents.Where(s => s.CourseSubtopicId == dataToAdd.CourseSubtopicId).Count() + 1, AddedBy = dataToAdd.AddedBy, CreatedOn = dataToAdd.CreatedOn, IsActive = dataToAdd.IsActive }; context.SubtopicContents.Add(entityToAdd); context.SaveChanges(); id = entityToAdd.Id; return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); id = 0; return(false); } }
public bool AddQuestionMapping(List <QuestionLevelMapping> mappings, int questionId) { try { using (var context = new TrainingTrackerEntities()) { foreach (var questionLevelMapping in mappings) { context.QuestionLevelMappings.Add(new EntityFramework.QuestionLevelMapping { QuestionId = questionId, Level = questionLevelMapping.Level, ExperienceStartRange = questionLevelMapping.ExperienceStartRange, ExperienceEndRange = questionLevelMapping.ExperienceEndRange }); } context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
public bool UpdateSubtopicContent(SubtopicContent dataToUpdate) { try { using (var context = new TrainingTrackerEntities()) { var entityToUpdate = context.SubtopicContents.Find(dataToUpdate.Id); if (entityToUpdate == null) { return(false); } entityToUpdate.Name = dataToUpdate.Name; entityToUpdate.Description = dataToUpdate.Description; entityToUpdate.Url = dataToUpdate.Url; entityToUpdate.CourseSubtopicId = dataToUpdate.CourseSubtopicId; context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
/// <summary> /// Delete Learning Map data by making its IsDeleted attribute to true. /// </summary> /// <param name="id">Learning Map Id whose data is to be deleted</param> /// <returns>true if Learning Map data is deleted successfully and false if data to be deleted is not found or some other exception occurs.</returns> public bool DeleteLearningMap(int id) { try { using (var context = new TrainingTrackerEntities()) { var learningMapEntity = context.LearningMaps.First(x => x.Id == id); if (learningMapEntity == null) { return(false); } learningMapEntity.IsDeleted = true; context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
public bool UpdateCourse(Course courseToUpdate) { try { using (var context = new TrainingTrackerEntities()) { var courseEntity = context.Courses.FirstOrDefault(x => x.Id == courseToUpdate.Id); if (courseEntity == null) { return(false); } courseEntity.Name = courseToUpdate.Name; courseEntity.Description = courseToUpdate.Description; courseEntity.Icon = courseToUpdate.Icon; courseEntity.Duration = courseToUpdate.Duration; context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
public bool SaveSubtopicContentProgress(int subtopicContentId, int userId) { try { using (var context = new TrainingTrackerEntities()) { var newEntity = new EntityFramework.SubtopicContentUserMap { SubtopicContentId = subtopicContentId, UserId = userId, Seen = true, CreatedOn = DateTime.Now }; context.SubtopicContentUserMaps.Add(newEntity); context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
public bool AddAssignment(Assignment dataToAdd, out int id) { try { using (var context = new TrainingTrackerEntities()) { EntityFramework.Assignment newEntity = new EntityFramework.Assignment { Name = dataToAdd.Name, Description = dataToAdd.Description, AddedBy = dataToAdd.AddedBy, IsActive = dataToAdd.IsActive, CreatedOn = dataToAdd.CreatedOn, AssignmentAsset = dataToAdd.AssignmentAsset }; context.Assignments.Add(newEntity); context.SaveChanges(); id = newEntity.Id; AddAssignmentSubtopicMapping(id, dataToAdd.CourseSubtopicId); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); id = 0; return(false); } }
/// <summary> /// Signature for method to update the Current User's and course Mapping /// </summary> /// <param name="currentUser">Session instance of current user</param> /// <param name="courseId">course id to be mapped</param> /// <returns>Status if mapping added or not.</returns> /// <exception >on exception return false</exception> public bool StartCourseForTrainee(Common.Entity.User currentUser, int courseId) { try { using (TrainingTrackerEntities context = new TrainingTrackerEntities()) { if (!context.CourseUserMappings.Any(x => x.CourseId == courseId && x.UserId == currentUser.UserId)) { context.CourseUserMappings.Add(new CourseUserMapping { CourseId = courseId, UserId = currentUser.UserId, StartedOn = DateTime.Now }); return(context.SaveChanges() == 1); } return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
public bool AddQuestion(Question question) { try { var newQuestion = new EntityFramework.Question { QuestionText = question.QuestionText, Description = question.Description, SkillId = question.SkillId, AddedBy = question.AddedBy, AddedDate = question.AddedDate }; using (var context = new TrainingTrackerEntities()) { context.Questions.Add(newQuestion); context.SaveChanges(); } return(AddQuestionMapping(question.LevelMapping, newQuestion.Id)); } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
public bool UpdateCourseSubtopic(CourseSubtopic subtopicToUpdate) { try { using (var context = new TrainingTrackerEntities()) { var subtopicEntityToUpdate = context.CourseSubtopics.Find(subtopicToUpdate.Id); if (subtopicEntityToUpdate == null) { return(false); } subtopicEntityToUpdate.Name = subtopicToUpdate.Name; subtopicEntityToUpdate.Description = subtopicToUpdate.Description; subtopicEntityToUpdate.CourseId = subtopicToUpdate.CourseId; context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
public int AddCourseSubtopic(CourseSubtopic subtopicToAdd) { try { using (var context = new TrainingTrackerEntities()) { EntityFramework.CourseSubtopic newSubtopicEntity = new EntityFramework.CourseSubtopic { Name = subtopicToAdd.Name, CourseId = subtopicToAdd.CourseId, Description = subtopicToAdd.Description, SortOrder = context.CourseSubtopics.Where(c => c.CourseId == subtopicToAdd.CourseId).Count() + 1, AddedBy = subtopicToAdd.AddedBy, IsActive = subtopicToAdd.IsActive, CreatedOn = subtopicToAdd.CreatedOn }; context.CourseSubtopics.Add(newSubtopicEntity); context.SaveChanges(); return(newSubtopicEntity.Id); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(0); } }
/// <summary> /// Data Access method to Save response for the survey /// </summary> /// <param name="response">instance of response</param> /// <param name="survey">instance of survey</param> /// <returns>id of saved feedback</returns> public int SaveWeeklySurveyResponseForTrainee(Common.Entity.SurveyResponse response, Common.Entity.Survey survey) { try { using (TrainingTrackerEntities context = new TrainingTrackerEntities()) { SurveyCompletedMetaData instanceMetaData = new SurveyCompletedMetaData { SurveyId = survey.SurveyId, SurveyTakenBy = response.AddedBy.UserId, DateCompleted = DateTime.Now }; Feedback feedback = new Feedback { AddedBy = response.Feedback.AddedBy.UserId, AddedFor = response.Feedback.AddedFor.UserId, AddedOn = DateTime.Now, SkillId = 0, FeedbackText = response.Feedback.FeedbackText, FeedbackType = response.Feedback.FeedbackType.FeedbackTypeId, Title = response.Feedback.FeedbackType.Description, StartDate = response.Feedback.StartDate, EndDate = response.Feedback.EndDate, ProjectId = 0, Rating = (short?)response.Feedback.Rating }; foreach (var ans in response.Response) { instanceMetaData.SurveyResponses.Add(new SurveyResponse { SurveyQuestionId = ans.QuestionId, SurveyAnswerId = ans.AnswerId, AdditionalNote = ans.AdditionalNotes, DateCreated = DateTime.Now }); } context.SurveyCompletedMetaDatas.Add(instanceMetaData); context.Feedbacks.Add(feedback); context.WeeklyFeedbackSurveyMappings.Add(new WeeklyFeedbackSurveyMapping { FeedbackId = feedback.FeedbackId, SurveyCompletedMetaDataId = instanceMetaData.SurveyCompletedMetaDataId }); context.SaveChanges(); return(feedback.FeedbackId); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(-1); } }
/// <summary> /// Add Learning Map data along with the mapping details of all courses and trainees included in the Learning Map(if any). /// </summary> /// <param name="data">Learning Map object which contain Learning map data along with the Course list(if any) and Trainee /// list(if any) included in the Learning map</param> /// <returns>Id of the Learning map if successfully added otherwise zero</returns> public int AddLearningMap(LearningMap data) { try { using (var context = new TrainingTrackerEntities()) { var newLearningMapEntity = new EntityFramework.LearningMap { Title = data.Title, Notes = data.Notes, Duration = data.Duration, DateCreated = DateTime.Now, IsCourseRestricted = data.IsCourseRestricted, TeamId = data.TeamId, CreatedBy = data.CreatedBy, IsDeleted = data.IsDeleted, LearningMapCourseMappings = (data.Courses != null) ? data.Courses.Select(x => new LearningMapCourseMapping { //LearningMapId = newLearningMapEntity.Id, CourseId = x.Id, SortOrder = x.SortOrder, IsDeleted = false, DateInserted = DateTime.Now }).ToList() : null, LearningMapUserMappings = (data.Trainees != null) ? data.Trainees.Select(x => new LearningMapUserMapping { //LearningMapId = newLearningMapEntity.Id, UserId = x.UserId, DateInserted = DateTime.Now }).ToList() : null }; context.LearningMaps.Add(newLearningMapEntity); context.SaveChanges(); return(newLearningMapEntity.Id); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(0); } }
/// <summary> /// Calls stored procedure which updates user. /// </summary> /// <param name="userData">User data object.</param> /// <returns>True if updated.</returns> public bool UpdateUser(User userData) { if (userData.UserId <= 0) { return(false); } try { using (TrainingTrackerEntities context = new TrainingTrackerEntities()) { var userContext = context.Users.FirstOrDefault(x => x.UserId == userData.UserId); if (userContext == null) { return(false); } userContext.FirstName = userData.FirstName; userContext.LastName = userData.LastName; userContext.UserName = userData.UserName; userContext.Email = userData.Email; userContext.Designation = userData.Designation; userContext.ProfilePictureName = userData.ProfilePictureName; userContext.IsFemale = userData.IsFemale; userContext.IsAdministrator = userData.IsAdministrator; userContext.IsTrainer = userData.IsTrainer; userContext.IsTrainee = userData.IsTrainee; userContext.IsManager = userData.IsManager; userContext.IsActive = userData.IsActive; userContext.EmployeeId = userData.EmployeeId; if (!string.IsNullOrEmpty(userData.Password)) { userContext.Password = userData.Password; } userContext.TeamId = userData.TeamId; context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
/// <summary> /// Clear All the pending Notification(except action type notification) for user /// </summary> /// <param name="userId">passed userid</param> /// <returns>success flag </returns> public bool MarkAllNotificationAsRead(int userId) { try { using (TrainingTrackerEntities context = new TrainingTrackerEntities()) { context.UserNotificationMappings.Where(u => u.UserId == userId && !u.Seen && u.Notification.NotificationType != (int)Common.Enumeration.NotificationType.NewActionToPerform).ToList().ForEach(x => x.Seen = true); context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
public bool DeleteAssignment(int id) { try { using (var context = new TrainingTrackerEntities()) { var entity = context.Assignments.Find(id); entity.IsActive = false; context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
/// <summary> /// Add Course /// </summary> /// <param name="courseToAdd">Course data object</param> /// <returns>Course Id of the added course if successful otherwise 0 </returns> public int AddCourse(Course courseToAdd) { try { using (var context = new TrainingTrackerEntities()) { EntityFramework.Course newCourseEntity = ModelMapper.MapToCourseModel(courseToAdd); context.Courses.Add(newCourseEntity); context.SaveChanges(); return(newCourseEntity.Id); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(0); } }
public bool AddSkill(Skill skill) { try { using (var context = new TrainingTrackerEntities()) { context.Skills.Add(new EntityFramework.Skill { Name = skill.Name, AddedBy = skill.AddedBy, AddedOn = DateTime.Now }); return(context.SaveChanges() > 0); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
public bool UpdateAssignment(Assignment dataToUpdate) { try { using (var context = new TrainingTrackerEntities()) { var entity = context.Assignments.Where(a => a.IsActive && a.Id == dataToUpdate.Id).FirstOrDefault(); entity.AssignmentAsset = dataToUpdate.AssignmentAsset; entity.Description = dataToUpdate.Description; entity.Name = dataToUpdate.Name; context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
/// <summary> /// Add mapping data for the Assignment and Feedback in AssignmentFeedbackMapping table /// </summary> /// <param name="feedbackId">Id of the added feedback</param> /// <param name="assignmentId">Id of the assignment for which feedback is added</param> /// <returns> true if successfully adds the mapping data otherwise false</returns> public bool AddFeedbackAssignmentMapping(int feedbackId, int assignmentId) { try { using (var context = new TrainingTrackerEntities()) { var newMappingEntity = new EntityFramework.AssignmentFeedbackMapping { AssignmentId = assignmentId, FeedbackId = feedbackId }; context.AssignmentFeedbackMappings.Add(newMappingEntity); return(context.SaveChanges() > 0); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
/// <summary> /// Update notification as make seen status true. /// </summary> /// <param name="userId">UserId</param> /// <param name="notification">Notification object</param> /// <returns>Returns boolean value according to Notification is added successfully or not</returns> public bool UpdateNotification(int userId, Common.Entity.Notification notification) { try { using (TrainingTrackerEntities context = new TrainingTrackerEntities()) { context.UserNotificationMappings .Where(s => s.UserId == userId && !s.Seen && s.NotificationId == notification.NotificationId) .ToList() .ForEach(s => { s.Seen = true; }); context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
/// <summary> /// Dal method to Add feedback /// </summary> /// <param name="feedbackData">feedback instance</param> /// <returns>int of feedback</returns> public int AddFeedback(Feedback feedbackData) { try { var feedback = new EntityFramework.Feedback { FeedbackText = feedbackData.FeedbackText.Trim(), Title = feedbackData.Title, FeedbackType = feedbackData.FeedbackType.FeedbackTypeId, ProjectId = feedbackData.Project.ProjectId, SkillId = feedbackData.Skill.SkillId, Rating = (short?)feedbackData.Rating, AddedBy = feedbackData.AddedBy.UserId, AddedFor = feedbackData.AddedFor.UserId, StartDate = feedbackData.StartDate, EndDate = feedbackData.EndDate, AddedOn = feedbackData.AddedOn == DateTime.MinValue ? DateTime.Now : feedbackData.AddedOn }; using (var context = new TrainingTrackerEntities()) { context.Feedbacks.Add(feedback); context.SaveChanges(); // Add new mapping for user and skill if (feedbackData.FeedbackType.FeedbackTypeId == (int)Common.Enumeration.FeedbackType.Skill) { SkillDal.AddUserSkillMapping(feedbackData.Skill.SkillId, feedbackData.AddedFor.UserId, feedbackData.AddedBy.UserId); } return(feedback.FeedbackId); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(0); } }
/// <summary> /// Calls stored procedure which adds user. /// </summary> /// <param name="userData">User data object.</param> /// <param name="userId">Out parameter created UserId.</param> /// <returns>True if added.</returns> public bool AddUser(User userData, out int userId) { userId = 0; try { using (TrainingTrackerEntities context = new TrainingTrackerEntities()) { EntityFramework.User objUser = new EntityFramework.User { FirstName = userData.FirstName, LastName = userData.LastName, UserName = userData.UserName, Password = userData.Password, Email = userData.Email, Designation = userData.Designation, ProfilePictureName = userData.ProfilePictureName, IsFemale = userData.IsFemale, IsAdministrator = userData.IsAdministrator, IsTrainer = userData.IsTrainer, IsTrainee = userData.IsTrainee, IsManager = userData.IsManager, DateAddedToSystem = DateTime.Now, IsActive = userData.IsActive, TeamId = userData.TeamId, EmployeeId = userData.EmployeeId }; context.Users.Add(objUser); context.SaveChanges(); userId = objUser.UserId; return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
/// <summary> /// Data access method to update the course status to completed for trainee /// </summary> /// <param name="courseId">course Id to be updated</param> /// <param name="traineeId">trainee Id to be updated</param> /// <returns>success flag for updation of the context</returns> public bool CompleteCourseForTrainee(int courseId, int traineeId) { try { using (TrainingTrackerEntities context = new TrainingTrackerEntities()) { CourseUserMapping courseUserMap = context.CourseUserMappings.FirstOrDefault(x => x.CourseId == courseId && x.UserId == traineeId && x.CompletedOn == null); if (courseUserMap != null) { courseUserMap.CompletedOn = DateTime.Now; return(context.SaveChanges() == 1); } throw new Exception("No course user mapping already existing"); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
public bool PublishCourse(int id) { try { using (var context = new TrainingTrackerEntities()) { var course = context.Courses.Find(id); if (course != null) { course.IsPublished = true; context.SaveChanges(); return(true); } return(false); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
public bool AddAssignmentSubtopicMapping(int assignmentId, int subtopicId) { try { using (var context = new TrainingTrackerEntities()) { EntityFramework.AssignmentSubtopicMap newEntity = new EntityFramework.AssignmentSubtopicMap { AssignmentId = assignmentId, SubtopicId = subtopicId }; context.AssignmentSubtopicMaps.Add(newEntity); context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
/// <summary> /// Add New Thread to Feedback /// </summary> /// <param name="thread">instance of thread</param> /// <returns>Succes event of flag</returns> public bool AddNewThread(Threads thread) { try { using (TrainingTrackerEntities context = new TrainingTrackerEntities()) { context.FeedbackThreads.Add(new FeedbackThread { FeedbackId = thread.FeedbackId, Comments = thread.Comments, DateTimeInserted = DateTime.Now, AddedBy = thread.AddedBy.UserId, }); context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
public bool DeleteSubtopicContent(int id) { try { using (var context = new TrainingTrackerEntities()) { var entityToDelete = context.SubtopicContents.Find(id); if (entityToDelete == null) { return(false); } entityToDelete.IsActive = false; context.SaveChanges(); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }
public bool SaveSubtopicContentOrder(List <SubtopicContent> data) { try { using (var context = new TrainingTrackerEntities()) { data.ForEach(x => { var entity = context.SubtopicContents.Find(x.Id); entity.SortOrder = x.SortOrder; context.SaveChanges(); } ); return(true); } } catch (Exception ex) { LogUtility.ErrorRoutine(ex); return(false); } }