/// <summary> /// Handles the Load event of the Page control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param> protected void Page_Load( object sender, EventArgs e ) { // get error level int errorLevel = 0; if ( Request["error"] != null ) errorLevel = Int32.Parse( Request["error"].ToString() ); if ( errorLevel == 1 ) { // check to see if the user is an admin, if so allow them to view the error details var userLogin = Rock.Model.UserLoginService.GetCurrentUser(); GroupService service = new GroupService(); Group adminGroup = service.GetByGuid( new Guid( Rock.SystemGuid.Group.GROUP_ADMINISTRATORS ) ); if ( userLogin != null && adminGroup.Members.Where( m => m.PersonId == userLogin.PersonId ).Count() > 0 ) { // is an admin lErrorInfo.Text = "<h3>Exception Log:</h3>"; // get exception from Session if ( Session["Exception"] != null ) { ProcessException( (Exception)Session["Exception"], " " ); } } } // clear session object Session.Remove( "Exception" ); }
/// <summary> /// Handles the Click event of the btnSave control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param> protected void btnSave_Click( object sender, EventArgs e ) { Group group; GroupService groupService = new GroupService(); int groupId = int.Parse( hfGroupId.Value ); if ( groupId == 0 ) { group = new Group(); group.IsSystem = false; groupService.Add( group, CurrentPersonId ); } else { // just in case this group is or was a SecurityRole Rock.Security.Role.Flush( groupId ); group = groupService.Get( groupId ); } group.Name = tbName.Text; group.Description = tbDescription.Text; group.CampusId = ddlCampus.SelectedValue.Equals( None.IdValue ) ? (int?)null : int.Parse( ddlCampus.SelectedValue ); group.GroupTypeId = int.Parse( ddlGroupType.SelectedValue ); group.ParentGroupId = ddlParentGroup.SelectedValue.Equals( None.IdValue ) ? (int?)null : int.Parse( ddlParentGroup.SelectedValue ); group.IsSecurityRole = cbIsSecurityRole.Checked; // check for duplicates within GroupType if ( groupService.Queryable().Where( g => g.GroupTypeId.Equals( group.GroupTypeId ) ).Count( a => a.Name.Equals( group.Name, StringComparison.OrdinalIgnoreCase ) && !a.Id.Equals( group.Id ) ) > 0 ) { tbName.ShowErrorMessage( WarningMessage.DuplicateFoundMessage( "name", Group.FriendlyTypeName ) ); return; } if ( !group.IsValid ) { // Controls will render the error messages return; } RockTransactionScope.WrapTransaction( () => { groupService.Save( group, CurrentPersonId ); } ); // just in case this group is or was a SecurityRole Rock.Security.Authorization.Flush(); NavigateToParentPage(); }
public ServiceList(string url, ResponseToken token) { this.eventService = new EventService(url, token); this.categoryService = new CategoryService(url, token); this.clubService = new ClubService(url, token); this.userService = new UserService(url, token); this.ticketService = new TicketService(url, token); this.meetingService = new MeetingService(url, token); this.invoiceService = new InvoiceService(url, token); this.groupService = new GroupService(url, token); this.expenseService = new ExpenseService(url, token); this.emailService = new EmailService(url, token); this.depositService = new DepositService(url, token); this.customFieldService = new CustomFieldService(url, token); this.taskService = new TaskService(url, token); this.contactService = new ContactService(url, token); }
/// <summary> /// Handles the Delete event of the gGroups control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="RowEventArgs" /> instance containing the event data.</param> protected void gGroups_Delete( object sender, RowEventArgs e ) { RockTransactionScope.WrapTransaction( () => { GroupService groupService = new GroupService(); AuthService authService = new AuthService(); Group group = groupService.Get( (int)e.RowKeyValue ); if ( group != null ) { string errorMessage; if ( !groupService.CanDelete( group, out errorMessage ) ) { mdGridWarning.Show( errorMessage, ModalAlertType.Information ); return; } bool isSecurityRoleGroup = group.IsSecurityRole; if ( isSecurityRoleGroup ) { foreach ( var auth in authService.Queryable().Where( a => a.GroupId.Equals( group.Id ) ).ToList() ) { authService.Delete( auth, CurrentPersonId ); authService.Save( auth, CurrentPersonId ); } } groupService.Delete( group, CurrentPersonId ); groupService.Save( group, CurrentPersonId ); if ( isSecurityRoleGroup ) { Rock.Security.Authorization.Flush(); Rock.Security.Role.Flush( group.Id ); } } } ); BindGrid(); }
/// <summary> /// Loads the drop downs. /// </summary> private void LoadDropDowns() { GroupTypeService groupTypeService = new GroupTypeService(); var groupTypeQry = groupTypeService.Queryable(); // limit GroupType selection to what Block Attributes allow List<int> groupTypeIds = AttributeValue( "GroupTypes" ).SplitDelimitedValues().Select( a => int.Parse( a ) ).ToList(); if ( groupTypeIds.Count > 0 ) { groupTypeQry = groupTypeQry.Where( a => groupTypeIds.Contains( a.Id ) ); } List<GroupType> groupTypes = groupTypeQry.OrderBy( a => a.Name ).ToList(); ddlGroupType.DataSource = groupTypes; ddlGroupType.DataBind(); int currentGroupId = int.Parse( hfGroupId.Value ); // TODO: Only include valid Parent choices (no circular references) GroupService groupService = new GroupService(); List<Group> groups = groupService.Queryable().Where( g => g.Id != currentGroupId ).OrderBy( a => a.Name ).ToList(); groups.Insert( 0, new Group { Id = None.Id, Name = None.Text } ); ddlParentGroup.DataSource = groups; ddlParentGroup.DataBind(); CampusService campusService = new CampusService(); List<Campus> campuses = campusService.Queryable().OrderBy( a => a.Name ).ToList(); campuses.Insert( 0, new Campus { Id = None.Id, Name = None.Text } ); ddlCampus.DataSource = campuses; ddlCampus.DataBind(); }
public GroupsController() { GroupService = new GroupService(UnitOfWork); }
public void SetUp() { mockRepo = new Mock<IRepository<Group>>(); testService = new GroupService(mockRepo.Object); }
private bool HydrateObjects() { LoadWorkflowType(); // Set the note type if this is first request if (!Page.IsPostBack) { var entityType = EntityTypeCache.Read(typeof(Rock.Model.Workflow)); var noteTypes = NoteTypeCache.GetByEntity(entityType.Id, string.Empty, string.Empty); ncWorkflowNotes.NoteTypes = noteTypes; } if (_workflowType == null) { ShowNotes(false); ShowMessage(NotificationBoxType.Danger, "Configuration Error", "Workflow type was not configured or specified correctly."); return(false); } if (!_workflowType.IsAuthorized(Authorization.VIEW, CurrentPerson)) { ShowNotes(false); ShowMessage(NotificationBoxType.Warning, "Sorry", "You are not authorized to view this type of workflow."); return(false); } if (!(_workflowType.IsActive ?? true)) { ShowNotes(false); ShowMessage(NotificationBoxType.Warning, "Sorry", "This type of workflow is not active."); return(false); } // If operating against an existing workflow, get the workflow and load attributes if (!WorkflowId.HasValue) { WorkflowId = PageParameter("WorkflowId").AsIntegerOrNull(); if (!WorkflowId.HasValue) { Guid guid = PageParameter("WorkflowGuid").AsGuid(); if (!guid.IsEmpty()) { _workflow = _workflowService.Queryable() .Where(w => w.Guid.Equals(guid) && w.WorkflowTypeId == _workflowType.Id) .FirstOrDefault(); if (_workflow != null) { WorkflowId = _workflow.Id; } } } } if (WorkflowId.HasValue) { if (_workflow == null) { _workflow = _workflowService.Queryable() .Where(w => w.Id == WorkflowId.Value && w.WorkflowTypeId == _workflowType.Id) .FirstOrDefault(); } if (_workflow != null) { hlblWorkflowId.Text = _workflow.WorkflowId; _workflow.LoadAttributes(); foreach (var activity in _workflow.Activities) { activity.LoadAttributes(); } } } // If an existing workflow was not specified, activate a new instance of workflow and start processing if (_workflow == null) { string workflowName = PageParameter("WorkflowName"); if (string.IsNullOrWhiteSpace(workflowName)) { workflowName = "New " + _workflowType.WorkTerm; } _workflow = Rock.Model.Workflow.Activate(_workflowType, workflowName); if (_workflow != null) { // If a PersonId or GroupId parameter was included, load the corresponding // object and pass that to the actions for processing object entity = null; int? personId = PageParameter("PersonId").AsIntegerOrNull(); if (personId.HasValue) { entity = new PersonService(_rockContext).Get(personId.Value); } else { int?groupId = PageParameter("GroupId").AsIntegerOrNull(); if (groupId.HasValue) { entity = new GroupService(_rockContext).Get(groupId.Value); } } // Loop through all the query string parameters and try to set any workflow // attributes that might have the same key foreach (var param in RockPage.PageParameters()) { if (param.Value != null && param.Value.ToString().IsNotNullOrWhitespace()) { _workflow.SetAttributeValue(param.Key, param.Value.ToString()); } } List <string> errorMessages; if (!_workflowService.Process(_workflow, entity, out errorMessages)) { ShowNotes(false); ShowMessage(NotificationBoxType.Danger, "Workflow Processing Error(s):", "<ul><li>" + errorMessages.AsDelimited("</li><li>") + "</li></ul>"); return(false); } if (_workflow.Id != 0) { WorkflowId = _workflow.Id; } } } if (_workflow == null) { ShowNotes(false); ShowMessage(NotificationBoxType.Danger, "Workflow Activation Error", "Workflow could not be activated."); return(false); } var canEdit = UserCanEdit || _workflow.IsAuthorized(Authorization.EDIT, CurrentPerson); if (_workflow.IsActive) { if (ActionTypeId.HasValue) { foreach (var activity in _workflow.ActiveActivities) { _action = activity.Actions.Where(a => a.ActionTypeId == ActionTypeId.Value).FirstOrDefault(); if (_action != null) { _activity = activity; _activity.LoadAttributes(); _actionType = _action.ActionTypeCache; ActionTypeId = _actionType.Id; return(true); } } } // Find first active action form int personId = CurrentPerson != null ? CurrentPerson.Id : 0; int?actionId = PageParameter("ActionId").AsIntegerOrNull(); foreach (var activity in _workflow.Activities .Where(a => a.IsActive && (!actionId.HasValue || a.Actions.Any(ac => ac.Id == actionId.Value)) && ( (canEdit) || (!a.AssignedGroupId.HasValue && !a.AssignedPersonAliasId.HasValue) || (a.AssignedPersonAlias != null && a.AssignedPersonAlias.PersonId == personId) || (a.AssignedGroup != null && a.AssignedGroup.Members.Any(m => m.PersonId == personId)) ) ) .ToList() .OrderBy(a => a.ActivityTypeCache.Order)) { if (canEdit || (activity.ActivityTypeCache.IsAuthorized(Authorization.VIEW, CurrentPerson))) { foreach (var action in activity.ActiveActions .Where(a => (!actionId.HasValue || a.Id == actionId.Value))) { if (action.ActionTypeCache.WorkflowForm != null && action.IsCriteriaValid) { _activity = activity; _activity.LoadAttributes(); _action = action; _actionType = _action.ActionTypeCache; ActionTypeId = _actionType.Id; return(true); } } } } lSummary.Text = string.Empty; } else { if (GetAttributeValue("ShowSummaryView").AsBoolean() && !string.IsNullOrWhiteSpace(_workflowType.SummaryViewText)) { var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(this.RockPage, this.CurrentPerson); mergeFields.Add("Action", _action); mergeFields.Add("Activity", _activity); mergeFields.Add("Workflow", _workflow); lSummary.Text = _workflowType.SummaryViewText.ResolveMergeFields(mergeFields, CurrentPerson); lSummary.Visible = true; } } if (lSummary.Text.IsNullOrWhiteSpace()) { if (_workflowType.NoActionMessage.IsNullOrWhiteSpace()) { ShowMessage(NotificationBoxType.Warning, string.Empty, "The selected workflow is not in a state that requires you to enter information."); } else { var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(this.RockPage, this.CurrentPerson); mergeFields.Add("Action", _action); mergeFields.Add("Activity", _activity); mergeFields.Add("Workflow", _workflow); ShowMessage(NotificationBoxType.Warning, string.Empty, _workflowType.NoActionMessage.ResolveMergeFields(mergeFields, CurrentPerson)); } } ShowNotes(false); return(false); }
/// <summary> /// Binds the grid. /// </summary> protected void BindGrid() { AddScheduleColumns(); var rockContext = new RockContext(); var groupLocationService = new GroupLocationService(rockContext); var groupTypeService = new GroupTypeService(rockContext); var groupService = new GroupService(rockContext); IEnumerable <GroupTypePath> groupPaths = new List <GroupTypePath>(); var groupLocationQry = groupLocationService.Queryable(); List <int> currentAndDescendantGroupTypeIds = new List <int>(); var currentGroupTypeIds = this.CurrentGroupTypeIds.ToList(); currentAndDescendantGroupTypeIds.AddRange(currentGroupTypeIds); foreach (var templateGroupType in groupTypeService.Queryable().Where(a => currentGroupTypeIds.Contains(a.Id))) { foreach (var childGroupType in groupTypeService.GetChildGroupTypes(templateGroupType.Id)) { currentAndDescendantGroupTypeIds.Add(childGroupType.Id); currentAndDescendantGroupTypeIds.AddRange(groupTypeService.GetAllAssociatedDescendents(childGroupType.Id).Select(a => a.Id).ToList()); } } groupLocationQry = groupLocationQry.Where(a => currentAndDescendantGroupTypeIds.Contains(a.Group.GroupTypeId)); groupLocationQry = groupLocationQry.OrderBy(a => a.Group.Name).ThenBy(a => a.Location.Name); List <int> currentDeviceLocationIdList = this.GetGroupTypesLocations(rockContext).Select(a => a.Id).Distinct().ToList(); var qryList = groupLocationQry .Where(a => currentDeviceLocationIdList.Contains(a.LocationId)) .Select(a => new { GroupLocationId = a.Id, a.Location, GroupId = a.GroupId, GroupName = a.Group.Name, ScheduleIdList = a.Schedules.Select(s => s.Id), GroupTypeId = a.Group.GroupTypeId }).ToList(); var locationService = new LocationService(rockContext); // put stuff in a datatable so we can dynamically have columns for each Schedule DataTable dataTable = new DataTable(); dataTable.Columns.Add("GroupLocationId"); dataTable.Columns.Add("GroupId"); dataTable.Columns.Add("GroupName"); dataTable.Columns.Add("GroupPath"); dataTable.Columns.Add("LocationName"); dataTable.Columns.Add("LocationPath"); foreach (var field in gGroupLocationSchedule.Columns.OfType <CheckBoxEditableField>()) { dataTable.Columns.Add(field.DataField, typeof(bool)); } var locationPaths = new Dictionary <int, string>(); foreach (var row in qryList) { DataRow dataRow = dataTable.NewRow(); dataRow["GroupLocationId"] = row.GroupLocationId; dataRow["GroupName"] = groupService.GroupAncestorPathName(row.GroupId); dataRow["GroupPath"] = groupPaths.Where(gt => gt.GroupTypeId == row.GroupTypeId).Select(gt => gt.Path).FirstOrDefault(); dataRow["LocationName"] = row.Location.Name; if (row.Location.ParentLocationId.HasValue) { int locationId = row.Location.ParentLocationId.Value; if (!locationPaths.ContainsKey(locationId)) { var locationNames = new List <string>(); var parentLocation = locationService.Get(locationId); while (parentLocation != null) { locationNames.Add(parentLocation.Name); parentLocation = parentLocation.ParentLocation; } if (locationNames.Any()) { locationNames.Reverse(); locationPaths.Add(locationId, locationNames.AsDelimited(" > ")); } else { locationPaths.Add(locationId, string.Empty); } } dataRow["LocationPath"] = locationPaths[locationId]; } foreach (var field in gGroupLocationSchedule.Columns.OfType <CheckBoxEditableField>()) { int scheduleId = int.Parse(field.DataField.Replace("scheduleField_", string.Empty)); dataRow[field.DataField] = row.ScheduleIdList.Any(a => a == scheduleId); } dataTable.Rows.Add(dataRow); } gGroupLocationSchedule.EntityTypeId = EntityTypeCache.Read <GroupLocation>().Id; gGroupLocationSchedule.DataSource = dataTable; gGroupLocationSchedule.DataBind(); }
public void Execute(IJobExecutionContext context) { var rockContext = new RockContext(); var dataMap = context.JobDetail.JobDataMap; var systemEmailGuid = dataMap.GetString("Email").AsGuidOrNull(); var groupFieldGuid = dataMap.GetString("RootGroup").AsGuidOrNull(); string appRoot = GlobalAttributesCache.Read().GetValue("ExternalApplicationRoot"); if (systemEmailGuid == null) { throw new Exception("A system email template needs to be set."); } var systemEmailTemplate = new SystemEmailService(rockContext).Get(systemEmailGuid.Value); if (systemEmailTemplate == null) { throw new Exception("The system email template setting is not a valid system email template."); } if (groupFieldGuid == null) { throw new Exception("A group must be specified"); } var groupService = new GroupService(rockContext); var rootGroup = groupService.GetByGuid(groupFieldGuid.Value); var validGroupIds = new List <int> { rootGroup.Id }; validGroupIds.AddRange(groupService.GetAllDescendents(rootGroup.Id).Select(g => g.Id)); // Check to see if we should skip this week var definedTypeId = new DefinedTypeService(rockContext).Queryable().FirstOrDefault(dt => dt.Name == "Volunteer Reminder Exclusions")?.Id; if (definedTypeId == null) { context.Result = "Could not get Volunteer Reminder Exclusions defined type"; return; } var datesToSkip = new DefinedValueService(rockContext).GetByDefinedTypeId(definedTypeId.Value); foreach (var dateToSkipValue in datesToSkip) { dateToSkipValue.LoadAttributes(); var date = dateToSkipValue.GetAttributeValue("Date").AsDateTime(); if (date != null && DatesAreInTheSameWeek(date.Value, RockDateTime.Today)) { context.Result = "This week should be skipped because of the exclusion " + date.Value.ToString("o"); return; } } string weekTeam = "Team " + Utils.ServingWeek.GetTeamNumber(); var attributeService = new AttributeService(rockContext); var attributeIds = attributeService.GetByEntityTypeId( EntityTypeCache.Read(Rock.SystemGuid.EntityType.GROUP_MEMBER.AsGuid()).Id).Where(a => a.Key == "AssignedTeam").Select(a => a.Id); var attributeValueService = new AttributeValueService(rockContext); var groupMemberIds = new List <int>(); foreach (int attributeId in attributeIds) { var attributeValues = attributeValueService.GetByAttributeId(attributeId).AsQueryable().AsNoTracking().Where(av => av.Value.Contains(weekTeam)); groupMemberIds.AddRange(attributeValues.Where(av => av.EntityId != null).Select(av => av.EntityId.Value)); } var groupMembers = new GroupMemberService(rockContext).GetListByIds(groupMemberIds).Where(gm => validGroupIds.Contains(gm.GroupId)).Distinct(); int mailedCount = 0; foreach (var groupMember in groupMembers) { var mergeFields = new Dictionary <string, object> { { "GroupMember", groupMember }, { "Person", groupMember.Person }, { "Group", groupMember.Group } }; var recipients = new List <string> { groupMember.Person.Email }; Email.Send(systemEmailTemplate.From.ResolveMergeFields(mergeFields), systemEmailTemplate.FromName.ResolveMergeFields(mergeFields), systemEmailTemplate.Subject.ResolveMergeFields(mergeFields), recipients, systemEmailTemplate.Body.ResolveMergeFields(mergeFields), appRoot, null, null); mailedCount++; } context.Result = string.Format("{0} reminders were sent ", mailedCount); }
/// <summary> /// Sets the value on select. /// </summary> protected override void SetValueOnSelect() { var group = new GroupService(new RockContext()).Get(int.Parse(ItemId)); SetValue(group); }
/// <summary> /// Gets the expression. /// </summary> /// <param name="entityType">Type of the entity.</param> /// <param name="serviceInstance">The service instance.</param> /// <param name="parameterExpression">The parameter expression.</param> /// <param name="selection">The selection.</param> /// <returns></returns> public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection) { string[] selectionValues = selection.Split('|'); var rockContext = ( RockContext )serviceInstance.Context; if (selectionValues.Length >= 2) { GroupMemberService groupMemberService = new GroupMemberService(rockContext); List <Guid> groupGuids = selectionValues[0].Split(',').AsGuidList(); var groupService = new GroupService(rockContext); var groupIds = groupService.GetByGuids(groupGuids).Select(a => a.Id).Distinct().ToList(); bool includeChildGroups = false; bool includeChildGroupsIncludeSelected = false; bool includeChildGroupsPlusDescendants = false; bool includeInactiveGroups = false; if (selectionValues.Length >= 3) { includeChildGroups = selectionValues[2].AsBooleanOrNull() ?? false; } if (selectionValues.Length >= 6) { includeChildGroupsIncludeSelected = selectionValues[4].AsBooleanOrNull() ?? false; includeChildGroupsPlusDescendants = selectionValues[5].AsBooleanOrNull() ?? false; } else if (includeChildGroups) { // in case the selection was saved before these options where added includeChildGroupsIncludeSelected = true; includeChildGroupsPlusDescendants = true; } if (selectionValues.Length >= 7) { includeInactiveGroups = selectionValues[6].AsBooleanOrNull() ?? true; } else { // if options where saved before this option was added, set to false, even though it would have included inactive before includeInactiveGroups = false; } GroupMemberStatus?groupMemberStatus = null; if (selectionValues.Length >= 4) { groupMemberStatus = selectionValues[3].ConvertToEnumOrNull <GroupMemberStatus>(); } var groupMemberServiceQry = groupMemberService.Queryable(); List <int> childGroupIds = new List <int>(); if (includeChildGroups) { foreach (var groupId in groupIds) { if (includeChildGroupsPlusDescendants) { // get all children and descendants of the selected group(s) var descendants = groupService.GetAllDescendents(groupId); if (!includeInactiveGroups) { descendants = descendants.Where(a => a.IsActive == true); } childGroupIds.AddRange(descendants.Select(a => a.Id).Distinct().ToList()); } else { // get only immediate children of the selected group(s) var childGroups = groupService.Queryable().Where(a => a.ParentGroupId == groupId); if (!includeInactiveGroups) { childGroups = childGroups.Where(a => a.IsActive == true); } childGroupIds.AddRange(childGroups.Select(a => a.Id)); } } if (includeChildGroupsIncludeSelected) { groupMemberServiceQry = groupMemberServiceQry.Where(xx => groupIds.Contains(xx.GroupId) || childGroupIds.Contains(xx.GroupId)); } else { groupMemberServiceQry = groupMemberServiceQry.Where(xx => childGroupIds.Contains(xx.GroupId)); } } else { groupMemberServiceQry = groupMemberServiceQry.Where(xx => groupIds.Contains(xx.GroupId)); } if (groupMemberStatus.HasValue) { groupMemberServiceQry = groupMemberServiceQry.Where(xx => xx.GroupMemberStatus == groupMemberStatus.Value); } var groupRoleGuids = selectionValues[1].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(n => n.AsGuid()).ToList(); if (groupRoleGuids.Count() > 0) { var groupRoleIds = new GroupTypeRoleService(( RockContext )serviceInstance.Context).Queryable().Where(a => groupRoleGuids.Contains(a.Guid)).Select(a => a.Id).ToList(); groupMemberServiceQry = groupMemberServiceQry.Where(xx => groupRoleIds.Contains(xx.GroupRoleId)); } if (selectionValues.Length >= 8) { string addedOnSlidingDelimitedValues = selectionValues[7].Replace(',', '|'); DateRange dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(addedOnSlidingDelimitedValues); if (dateRange.Start.HasValue) { groupMemberServiceQry = groupMemberServiceQry.Where(xx => xx.DateTimeAdded >= dateRange.Start.Value); } if (dateRange.End.HasValue) { groupMemberServiceQry = groupMemberServiceQry.Where(xx => xx.DateTimeAdded < dateRange.End.Value); } } IQueryable <PersonIdFirstAttendance> firstAttendanceDateQry = null; IQueryable <PersonIdLastAttendance> lastAttendanceDateQry = null; if (selectionValues.Length >= 10) { List <int> attendanceGroupIds = null; if (includeChildGroups) { if (includeChildGroupsIncludeSelected) { attendanceGroupIds = new List <int>(); attendanceGroupIds.AddRange(groupIds); attendanceGroupIds.AddRange(childGroupIds); } else { attendanceGroupIds = childGroupIds; } } else { attendanceGroupIds = groupIds; } var groupAttendanceQuery = new AttendanceService(rockContext).Queryable().Where(a => a.DidAttend == true && a.GroupId.HasValue && attendanceGroupIds.Contains(a.GroupId.Value)); string firstAttendanceSlidingDelimitedValues = selectionValues[8].Replace(',', '|'); DateRange firstAttendanceDateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(firstAttendanceSlidingDelimitedValues); if (firstAttendanceDateRange.Start.HasValue || firstAttendanceDateRange.End.HasValue) { firstAttendanceDateQry = groupAttendanceQuery .GroupBy(xx => xx.PersonAlias.PersonId) .Select(ss => new PersonIdFirstAttendance { PersonId = ss.Key, FirstAttendanceSundayDate = ss.Min(a => a.SundayDate) }); if (firstAttendanceDateRange.Start.HasValue) { firstAttendanceDateQry = firstAttendanceDateQry.Where(xx => xx.FirstAttendanceSundayDate >= firstAttendanceDateRange.Start.Value); } if (firstAttendanceDateRange.End.HasValue) { firstAttendanceDateQry = firstAttendanceDateQry.Where(xx => xx.FirstAttendanceSundayDate < firstAttendanceDateRange.End.Value); } } string lastAttendanceSlidingDelimitedValues = selectionValues[9].Replace(',', '|'); DateRange lastAttendanceDateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(lastAttendanceSlidingDelimitedValues); if (lastAttendanceDateRange.Start.HasValue || lastAttendanceDateRange.End.HasValue) { lastAttendanceDateQry = groupAttendanceQuery .GroupBy(xx => xx.PersonAlias.PersonId) .Select(ss => new PersonIdLastAttendance { PersonId = ss.Key, LastAttendanceSundayDate = ss.Max(a => a.SundayDate) }); if (lastAttendanceDateRange.Start.HasValue) { lastAttendanceDateQry = lastAttendanceDateQry.Where(xx => xx.LastAttendanceSundayDate >= lastAttendanceDateRange.Start.Value); } if (lastAttendanceDateRange.End.HasValue) { lastAttendanceDateQry = lastAttendanceDateQry.Where(xx => xx.LastAttendanceSundayDate < lastAttendanceDateRange.End.Value); } } } IQueryable <Rock.Model.Person> qry = null; if (lastAttendanceDateQry == null && firstAttendanceDateQry == null) { qry = new PersonService(( RockContext )serviceInstance.Context).Queryable() .Where(p => groupMemberServiceQry.Any(xx => xx.PersonId == p.Id)); } else { if (firstAttendanceDateQry != null && lastAttendanceDateQry != null) { qry = new PersonService(( RockContext )serviceInstance.Context).Queryable() .Where(p => groupMemberServiceQry.Any(xx => xx.PersonId == p.Id) && firstAttendanceDateQry.Any(aa => aa.PersonId == p.Id) && lastAttendanceDateQry.Any(bb => bb.PersonId == p.Id)); } else if (firstAttendanceDateQry != null) { qry = new PersonService(( RockContext )serviceInstance.Context).Queryable() .Where(p => groupMemberServiceQry.Any(xx => xx.PersonId == p.Id) && firstAttendanceDateQry.Any(aa => aa.PersonId == p.Id)); } else if (lastAttendanceDateQry != null) { qry = new PersonService(( RockContext )serviceInstance.Context).Queryable() .Where(p => groupMemberServiceQry.Any(xx => xx.PersonId == p.Id) && lastAttendanceDateQry.Any(aa => aa.PersonId == p.Id)); } } Expression extractedFilterExpression = FilterExpressionExtractor.Extract <Rock.Model.Person>(qry, parameterExpression, "p"); return(extractedFilterExpression); } return(null); }
/// <summary> /// Raises the <see cref="E:System.Web.UI.Control.Load" /> event. /// </summary> /// <param name="e">The <see cref="T:System.EventArgs" /> object that contains the event data.</param> protected override void OnLoad(EventArgs e) { base.OnLoad(e); if (!Page.IsPostBack) { RockContext rockContext = new RockContext(); var groupService = new GroupService(rockContext); Group group = null; Guid personGuid = Guid.Empty; GroupTypeRole groupMemberRole = null; // get group id from url Guid?groupGuid = PageParameter("GroupGuid").AsGuidOrNull(); if (groupGuid.HasValue) { group = groupService.Queryable("GroupType,GroupType.Roles").Where(g => g.Guid == groupGuid.Value).FirstOrDefault(); } if (group == null && GetAttributeValue("EnablePassingGroupId").AsBoolean(true)) { int?groupId = PageParameter("GroupId").AsIntegerOrNull(); if (groupId.HasValue) { group = groupService.Queryable("GroupType,GroupType.Roles").Where(g => g.Id == groupId).FirstOrDefault(); } } if (group == null) { groupGuid = GetAttributeValue("DefaultGroup").AsGuidOrNull(); if (groupGuid.HasValue) { group = groupService.Queryable("GroupType,GroupType.Roles").Where(g => g.Guid == groupGuid.Value).FirstOrDefault(); } } if (group == null) { lAlerts.Text = "Could not determine the group to add to."; return; } // Validate the group type. if (!string.IsNullOrEmpty(GetAttributeValue("LimitGroupType"))) { bool groupTypeMatch = GetAttributeValue("LimitGroupType") .Split(',') .Contains(group.GroupType.Guid.ToString(), StringComparer.CurrentCultureIgnoreCase); if (!groupTypeMatch) { lAlerts.Text = "Invalid group specified."; return; } } // get group role id from url if (Request["GroupMemberRoleId"] != null) { int groupMemberRoleId = 0; if (Int32.TryParse(Request["GroupMemberRoleId"], out groupMemberRoleId)) { groupMemberRole = new GroupTypeRoleService(rockContext).Get(groupMemberRoleId); } } else if (!string.IsNullOrWhiteSpace(GetAttributeValue("DefaultGroupMemberRole"))) { Guid groupMemberRoleGuid = Guid.Empty; if (Guid.TryParse(GetAttributeValue("DefaultGroupMemberRole"), out groupMemberRoleGuid)) { groupMemberRole = new GroupTypeRoleService(rockContext).Get(groupMemberRoleGuid); } } else { groupMemberRole = group.GroupType.DefaultGroupRole; } if (groupMemberRole == null) { lAlerts.Text += "Could not determine the group role to use for the add."; return; } // get person if (Request["PersonGuid"] != null) { Guid.TryParse(Request["PersonGuid"], out personGuid); } if (personGuid == Guid.Empty) { lAlerts.Text += "A valid person identifier was not found in the page address."; return; } // ensure that the group type has this role if (!group.GroupType.Roles.Contains(groupMemberRole)) { lAlerts.Text += "The group you have provided does not have the group member role configured."; return; } // get person Person person = new PersonService(rockContext).Get(personGuid); if (person == null) { lAlerts.Text += "A person could not be found for the identifier provided."; return; } // hide alert divAlert.Visible = false; // get status var groupMemberStatus = this.GetAttributeValue("GroupMemberStatus").ConvertToEnum <GroupMemberStatus>(GroupMemberStatus.Active); // load merge fields var mergeFields = new Dictionary <string, object>(); mergeFields.Add("GroupMemberStatus", groupMemberStatus.ToString()); mergeFields.Add("Group", group); mergeFields.Add("Person", person); mergeFields.Add("Role", groupMemberRole); mergeFields.Add("CurrentPerson", CurrentPerson); // ensure that the person is not already in the group if (group.Members.Where(m => m.PersonId == person.Id && m.GroupRoleId == groupMemberRole.Id).Count() != 0) { string templateInGroup = GetAttributeValue("AlreadyInGroupMessage"); lContent.Text = templateInGroup.ResolveMergeFields(mergeFields); return; } // add person to group GroupMember groupMember = new GroupMember(); groupMember.GroupId = group.Id; groupMember.PersonId = person.Id; groupMember.GroupRoleId = groupMemberRole.Id; groupMember.GroupMemberStatus = groupMemberStatus; group.Members.Add(groupMember); try { rockContext.SaveChanges(); } catch (Exception ex) { divAlert.Visible = true; lAlerts.Text = String.Format("An error occurred adding {0} to the group {1}. Message: {2}.", person.FullName, group.Name, ex.Message); } string templateSuccess = GetAttributeValue("SuccessMessage"); lContent.Text = templateSuccess.ResolveMergeFields(mergeFields); } }
/// <summary> /// Handles the SelectItem event of the gp control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param> protected void gp_SelectItem(object sender, EventArgs e) { var rockContext = new RockContext(); var groupIdList = gp.SelectedValues.AsIntegerList(); var groupService = new GroupService(rockContext); var qryGroups = groupService.GetByIds(groupIdList); if (qryGroups.Any()) { var groupTypeRoleService = new GroupTypeRoleService(rockContext); var qryGroupTypeRoles = groupTypeRoleService.Queryable(); List <int> selectedGroupTypeIds = qryGroups.Select(a => a.GroupTypeId).Distinct().ToList(); if (cbChildGroups.Checked) { List <int> childGroupTypeIds = new List <int>(); foreach (var groupId in qryGroups.Select(a => a.Id).ToList()) { if (cbChildGroupsPlusDescendants.Checked) { // get all children and descendants of the selected group(s) var descendants = groupService.GetAllDescendents(groupId); if (!cbIncludeInactiveGroups.Checked) { descendants = descendants.Where(a => a.IsActive == true); } childGroupTypeIds.AddRange(descendants.Select(a => a.GroupTypeId).Distinct().ToList()); } else { // get only immediate children of the selected group(s) var childGroups = groupService.Queryable().Where(a => a.ParentGroupId == groupId); if (!cbIncludeInactiveGroups.Checked) { childGroups = childGroups.Where(a => a.IsActive == true); } childGroupTypeIds.AddRange(childGroups.Select(a => a.GroupTypeId).Distinct().ToList()); } } childGroupTypeIds = childGroupTypeIds.Distinct().ToList(); if (cbIncludeSelectedGroup.Checked) { qryGroupTypeRoles = qryGroupTypeRoles.Where(a => a.GroupTypeId.HasValue && (selectedGroupTypeIds.Contains(a.GroupTypeId.Value) || childGroupTypeIds.Contains(a.GroupTypeId.Value))); } else { qryGroupTypeRoles = qryGroupTypeRoles.Where(a => a.GroupTypeId.HasValue && childGroupTypeIds.Contains(a.GroupTypeId.Value)); } } else { qryGroupTypeRoles = qryGroupTypeRoles.Where(a => a.GroupTypeId.HasValue && selectedGroupTypeIds.Contains(a.GroupTypeId.Value)); } var list = qryGroupTypeRoles.OrderBy(a => a.GroupType.Order).ThenBy(a => a.GroupType.Name).ThenBy(a => a.Order).ThenBy(a => a.Name).ToList(); cblRole.Items.Clear(); foreach (var item in list) { cblRole.Items.Add(new ListItem(string.Format("{0} ({1})", item.Name, item.GroupType.Name), item.Guid.ToString())); } cblRole.Visible = list.Count > 0; } else { cblRole.Visible = false; } }
/// <summary> /// Sets the selection. /// </summary> /// <param name="entityType">Type of the entity.</param> /// <param name="controls">The controls.</param> /// <param name="selection">The selection.</param> public override void SetSelection(Type entityType, Control[] controls, string selection) { if (controls.Count() < 8) { return; } GroupPicker groupPicker = controls[0] as GroupPicker; RockCheckBox cbChildGroups = controls[1] as RockCheckBox; RockCheckBox cbIncludeSelectedGroup = controls[2] as RockCheckBox; RockCheckBox cbChildGroupsPlusDescendants = controls[3] as RockCheckBox; RockCheckBoxList cblRoles = controls[4] as RockCheckBoxList; RockDropDownList ddlGroupMemberStatus = controls[5] as RockDropDownList; RockCheckBox cbIncludeInactive = controls[6] as RockCheckBox; SlidingDateRangePicker addedOnDateRangePicker = controls[7] as SlidingDateRangePicker; SlidingDateRangePicker firstAttendanceDateRangePicker = controls[9] as SlidingDateRangePicker; SlidingDateRangePicker lastAttendanceDateRangePicker = controls[10] as SlidingDateRangePicker; string[] selectionValues = selection.Split('|'); if (selectionValues.Length >= 2) { List <Guid> groupGuids = selectionValues[0].Split(',').AsGuidList(); var groups = new GroupService(new RockContext()).GetByGuids(groupGuids); if (groups != null) { groupPicker.SetValues(groups); } if (selectionValues.Length >= 3) { cbChildGroups.Checked = selectionValues[2].AsBooleanOrNull() ?? false; } if (selectionValues.Length >= 6) { cbIncludeSelectedGroup.Checked = selectionValues[4].AsBooleanOrNull() ?? false; cbChildGroupsPlusDescendants.Checked = selectionValues[5].AsBooleanOrNull() ?? false; } else { cbIncludeSelectedGroup.Checked = true; cbChildGroupsPlusDescendants.Checked = true; } if (selectionValues.Length >= 7) { cbIncludeInactiveGroups.Checked = selectionValues[6].AsBooleanOrNull() ?? false; } else { // if options where saved before this option was added, set to false, even though it would have included inactive before cbIncludeInactiveGroups.Checked = false; } gp_SelectItem(this, new EventArgs()); string[] selectedRoleGuids = selectionValues[1].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); foreach (var item in cblRoles.Items.OfType <ListItem>()) { item.Selected = selectedRoleGuids.Contains(item.Value); } if (selectionValues.Length >= 4) { ddlGroupMemberStatus.SetValue(selectionValues[3]); } else { ddlGroupMemberStatus.SetValue(string.Empty); } if (selectionValues.Length >= 8) { // convert comma delimited to pipe addedOnDateRangePicker.DelimitedValues = selectionValues[7].Replace(',', '|'); } if (selectionValues.Length >= 10) { // convert comma delimited to pipe firstAttendanceDateRangePicker.DelimitedValues = selectionValues[8].Replace(',', '|'); // convert comma delimited to pipe lastAttendanceDateRangePicker.DelimitedValues = selectionValues[9].Replace(',', '|'); } } }
/// <summary> /// Formats the selection for the InGroupFilter/NotInGroupFilter based on if we are in "Not" mode /// </summary> /// <param name="selection">The selection.</param> /// <param name="not">if set to <c>true</c> [not].</param> /// <returns></returns> public virtual string GroupFilterFormatSelection(string selection, bool not) { string result = "Group Member"; string[] selectionValues = selection.Split('|'); if (selectionValues.Length >= 2) { var rockContext = new RockContext(); var groupGuids = selectionValues[0].Split(',').AsGuidList(); var groups = new GroupService(rockContext).GetByGuids(groupGuids); var groupTypeRoleGuidList = selectionValues[1].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(a => a.AsGuid()).ToList(); var groupTypeRoles = new GroupTypeRoleService(rockContext).Queryable().Where(a => groupTypeRoleGuidList.Contains(a.Guid)).ToList(); bool includeChildGroups = false; bool includeChildGroupsPlusDescendants = false; bool includeChildGroupsIncludeSelected = false; bool includeInactiveGroups = false; string addedOnDateRangeText = null; string firstAttendanceDateRangeText = null; string lastAttendanceDateRangeText = null; if (selectionValues.Length >= 3) { includeChildGroups = selectionValues[2].AsBooleanOrNull() ?? false; if (selectionValues.Length >= 6) { includeChildGroupsIncludeSelected = selectionValues[4].AsBooleanOrNull() ?? false; includeChildGroupsPlusDescendants = selectionValues[5].AsBooleanOrNull() ?? false; } if (selectionValues.Length >= 7) { includeInactiveGroups = selectionValues[6].AsBooleanOrNull() ?? false; } if (selectionValues.Length >= 8) { // convert comma delimited to pipe then get date range text addedOnDateRangeText = SlidingDateRangePicker.FormatDelimitedValues(selectionValues[7].Replace(',', '|')); } if (selectionValues.Length >= 10) { // convert comma delimited to pipe then get date range text firstAttendanceDateRangeText = SlidingDateRangePicker.FormatDelimitedValues(selectionValues[8].Replace(',', '|')); // convert comma delimited to pipe then get date range text lastAttendanceDateRangeText = SlidingDateRangePicker.FormatDelimitedValues(selectionValues[9].Replace(',', '|')); } } GroupMemberStatus?groupMemberStatus = null; if (selectionValues.Length >= 4) { groupMemberStatus = selectionValues[3].ConvertToEnumOrNull <GroupMemberStatus>(); } if (groups != null) { result = string.Format(not ? "Not in groups: {0}" : "In groups: {0}", groups.Select(a => a.Name).ToList().AsDelimited(", ", " or ")); if (includeChildGroups) { if (includeChildGroupsPlusDescendants) { result += " or descendant groups"; } else { result += " or child groups"; } if (includeInactiveGroups) { result += ", including inactive groups"; } if (!includeChildGroupsIncludeSelected) { result += ", not including selected groups"; } } if (groupTypeRoles.Count() > 0) { result += string.Format(", with role(s): {0}", groupTypeRoles.Select(a => string.Format("{0} ({1})", a.Name, a.GroupType.Name)).ToList().AsDelimited(",")); } if (groupMemberStatus.HasValue) { result += string.Format(", with member status: {0}", groupMemberStatus.ConvertToString()); } if (!string.IsNullOrEmpty(addedOnDateRangeText)) { result += string.Format(", added to group in Date Range: {0}", addedOnDateRangeText); } if (!string.IsNullOrEmpty(firstAttendanceDateRangeText)) { result += string.Format(", first attendance to group in Date Range: {0}", firstAttendanceDateRangeText); } if (!string.IsNullOrEmpty(lastAttendanceDateRangeText)) { result += string.Format(", last attendance to group in Date Range: {0}", lastAttendanceDateRangeText); } } } return(result); }
public MemberController() { groupService = new GroupService(); mgrService = new MemberGroupService(); }
/// <summary> /// Displays the edit group panel. /// </summary> private void DisplayEditGroup() { this.IsEditingGroup = true; if (_groupId != -1) { RockContext rockContext = new RockContext(); GroupService groupService = new GroupService(rockContext); var qry = groupService .Queryable("GroupLocations,GroupType,Schedule") .Where(g => g.Id == _groupId); var group = qry.FirstOrDefault(); if (group.IsAuthorized(Authorization.EDIT, CurrentPerson)) { tbName.Text = group.Name; tbDescription.Text = group.Description; cbIsActive.Checked = group.IsActive; cbIsPublic.Checked = group.IsPublic; if ((group.GroupType.AllowedScheduleTypes & ScheduleType.Weekly) == ScheduleType.Weekly) { pnlSchedule.Visible = group.Schedule == null || group.Schedule.ScheduleType == ScheduleType.Weekly; if (group.Schedule != null) { dowWeekly.SelectedDayOfWeek = group.Schedule.WeeklyDayOfWeek; timeWeekly.SelectedTime = group.Schedule.WeeklyTimeOfDay; } else { dowWeekly.SelectedDayOfWeek = null; timeWeekly.SelectedTime = null; } } else { pnlSchedule.Visible = false; } nbGroupCapacity.Text = group.GroupCapacity.ToString(); bool enableGroupCapacityEdit = this.GetAttributeValue("EnableGroupCapacityEdit").AsBooleanOrNull() ?? false; if (enableGroupCapacityEdit) { nbGroupCapacity.Visible = group.GroupType.GroupCapacityRule != GroupCapacityRule.None; } group.LoadAttributes(); phAttributes.Controls.Clear(); Rock.Attribute.Helper.AddEditControls(group, phAttributes, true, BlockValidationGroup); // enable editing location pnlGroupEditLocations.Visible = GetAttributeValue("EnableLocationEdit").AsBoolean(); if (GetAttributeValue("EnableLocationEdit").AsBoolean()) { ConfigureGroupLocationControls(group); // set location tabs rptLocationTypes.DataSource = _tabs; rptLocationTypes.DataBind(); } } else { lContent.Text = "<div class='alert alert-warning'>You do not have permission to edit this group.</div>"; } } else { lContent.Text = "<div class='alert alert-warning'>No group was available from the querystring.</div>"; } }
/// <summary> /// Handles the Click event of the btnSaveGroup control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param> protected void btnSaveGroup_Click(object sender, EventArgs e) { var rockContext = new RockContext(); GroupService groupService = new GroupService(rockContext); Group group = groupService.Get(_groupId); if (group != null && group.IsAuthorized(Authorization.EDIT, CurrentPerson)) { group.Name = tbName.Text; group.Description = tbDescription.Text; group.IsActive = cbIsActive.Checked; group.IsPublic = cbIsPublic.Checked; if (pnlSchedule.Visible) { if (group.Schedule == null) { group.Schedule = new Schedule(); group.Schedule.iCalendarContent = null; } group.Schedule.WeeklyDayOfWeek = dowWeekly.SelectedDayOfWeek; group.Schedule.WeeklyTimeOfDay = timeWeekly.SelectedTime; } if (nbGroupCapacity.Visible) { group.GroupCapacity = nbGroupCapacity.Text.AsIntegerOrNull(); } // set attributes group.LoadAttributes(rockContext); Rock.Attribute.Helper.GetEditValues(phAttributes, group); // configure locations if (GetAttributeValue("EnableLocationEdit").AsBoolean()) { // get selected location Location location = null; int? memberPersonAliasId = null; if (LocationTypeTab.Equals(MEMBER_LOCATION_TAB_TITLE)) { if (ddlMember.SelectedValue != null) { var ids = ddlMember.SelectedValue.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries); if (ids.Length == 2) { var dbLocation = new LocationService(rockContext).Get(int.Parse(ids[0])); if (dbLocation != null) { location = dbLocation; } memberPersonAliasId = new PersonAliasService(rockContext).GetPrimaryAliasId(int.Parse(ids[1])); } } } else { if (locpGroupLocation.Location != null) { location = new LocationService(rockContext).Get(locpGroupLocation.Location.Id); } } if (location != null) { GroupLocation groupLocation = group.GroupLocations.FirstOrDefault(); if (groupLocation == null) { groupLocation = new GroupLocation(); group.GroupLocations.Add(groupLocation); } groupLocation.GroupMemberPersonAliasId = memberPersonAliasId; groupLocation.Location = location; groupLocation.LocationId = groupLocation.Location.Id; groupLocation.GroupLocationTypeValueId = ddlLocationType.SelectedValueAsId(); } } rockContext.SaveChanges(); group.SaveAttributeValues(rockContext); } this.IsEditingGroup = false; // reload the group info pnlGroupEdit.Visible = false; pnlGroupView.Visible = true; DisplayViewGroup(); }
public ActivityScheduleController(RasporedContext context, ScheduleService scheduleService, GroupService groupService) { this._context = context; this.scheduleService = scheduleService; this.groupService = groupService; }
/// <summary> /// Binds the grid. /// </summary> private void BindGrid() { GroupService groupService = new GroupService(); SortProperty sortProperty = gGroups.SortProperty; var qry = groupService.Queryable(); List<int> groupTypeIds = AttributeValue( "GroupTypes" ).SplitDelimitedValues().Select( a => int.Parse( a ) ).ToList(); if ( groupTypeIds.Count > 0 ) { qry = qry.Where( a => groupTypeIds.Contains( a.GroupTypeId ) ); } if ( AttributeValue( "LimittoSecurityRoleGroups" ).FromTrueFalse() ) { qry = qry.Where( a => a.IsSecurityRole ); } if ( ContextEntities.ContainsKey( "Rock.Model.Group" ) ) { Group parentGroup = ContextEntities["Rock.Model.Group"] as Group; if ( parentGroup != null ) { qry = qry.Where( a => a.IsAncestorOfGroup( parentGroup.Id ) ); } } if ( sortProperty != null ) { gGroups.DataSource = qry.Sort( sortProperty ).ToList(); } else { gGroups.DataSource = qry.OrderBy( p => p.Name ).ToList(); } gGroups.DataBind(); }
/// <summary> /// Handles the Click event of the lbMerge control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param> protected void lbMerge_Click(object sender, EventArgs e) { if (MergeData.People.Count < 2) { nbPeople.Visible = true; return; } bool reconfirmRequired = (MergeData.People.Select(p => p.Email).Distinct().Count() > 1 && MergeData.People.Where(p => p.HasLogins).Any()); GetValuesSelection(); int?primaryPersonId = null; var oldPhotos = new List <int>(); var rockContext = new RockContext(); rockContext.WrapTransaction(() => { var personService = new PersonService(rockContext); var userLoginService = new UserLoginService(rockContext); var familyService = new GroupService(rockContext); var familyMemberService = new GroupMemberService(rockContext); var binaryFileService = new BinaryFileService(rockContext); var phoneNumberService = new PhoneNumberService(rockContext); Person primaryPerson = personService.Get(MergeData.PrimaryPersonId ?? 0); if (primaryPerson != null) { primaryPersonId = primaryPerson.Id; var changes = new List <string>(); foreach (var p in MergeData.People.Where(p => p.Id != primaryPerson.Id)) { changes.Add(string.Format("Merged <span class='field-value'>{0} [ID: {1}]</span> with this record.", p.FullName, p.Id)); } // Photo Id int?newPhotoId = MergeData.GetSelectedValue(MergeData.GetProperty("Photo")).Value.AsIntegerOrNull(); if (!primaryPerson.PhotoId.Equals(newPhotoId)) { changes.Add("Modified the photo."); primaryPerson.PhotoId = newPhotoId; } primaryPerson.TitleValueId = GetNewIntValue("Title", changes); primaryPerson.FirstName = GetNewStringValue("FirstName", changes); primaryPerson.NickName = GetNewStringValue("NickName", changes); primaryPerson.MiddleName = GetNewStringValue("MiddleName", changes); primaryPerson.LastName = GetNewStringValue("LastName", changes); primaryPerson.SuffixValueId = GetNewIntValue("Suffix", changes); primaryPerson.RecordTypeValueId = GetNewIntValue("RecordType", changes); primaryPerson.RecordStatusValueId = GetNewIntValue("RecordStatus", changes); primaryPerson.RecordStatusReasonValueId = GetNewIntValue("RecordStatusReason", changes); primaryPerson.ConnectionStatusValueId = GetNewIntValue("ConnectionStatus", changes); primaryPerson.IsDeceased = GetNewBoolValue("Deceased", changes); primaryPerson.Gender = (Gender)GetNewEnumValue("Gender", typeof(Gender), changes); primaryPerson.MaritalStatusValueId = GetNewIntValue("MaritalStatus", changes); primaryPerson.SetBirthDate(GetNewDateTimeValue("BirthDate", changes)); primaryPerson.AnniversaryDate = GetNewDateTimeValue("AnniversaryDate", changes); primaryPerson.GraduationYear = GetNewIntValue("GraduationYear", changes); primaryPerson.Email = GetNewStringValue("Email", changes); primaryPerson.IsEmailActive = GetNewBoolValue("EmailActive", changes); primaryPerson.EmailNote = GetNewStringValue("EmailNote", changes); primaryPerson.EmailPreference = (EmailPreference)GetNewEnumValue("EmailPreference", typeof(EmailPreference), changes); primaryPerson.SystemNote = GetNewStringValue("InactiveReasonNote", changes); primaryPerson.SystemNote = GetNewStringValue("SystemNote", changes); // Update phone numbers var phoneTypes = DefinedTypeCache.Read(Rock.SystemGuid.DefinedType.PERSON_PHONE_TYPE.AsGuid()).DefinedValues; foreach (var phoneType in phoneTypes) { var phoneNumber = primaryPerson.PhoneNumbers.Where(p => p.NumberTypeValueId == phoneType.Id).FirstOrDefault(); string oldValue = phoneNumber != null ? phoneNumber.Number : string.Empty; string key = "phone_" + phoneType.Id.ToString(); string newValue = GetNewStringValue(key, changes); if (!oldValue.Equals(newValue, StringComparison.OrdinalIgnoreCase)) { // New phone doesn't match old if (!string.IsNullOrWhiteSpace(newValue)) { // New value exists if (phoneNumber == null) { // Old value didn't exist... create new phone record phoneNumber = new PhoneNumber { NumberTypeValueId = phoneType.Id }; primaryPerson.PhoneNumbers.Add(phoneNumber); } // Update phone number phoneNumber.Number = newValue; } else { // New value doesn't exist if (phoneNumber != null) { // old value existed.. delete it primaryPerson.PhoneNumbers.Remove(phoneNumber); phoneNumberService.Delete(phoneNumber); } } } } // Save the new record rockContext.SaveChanges(); // Update the attributes primaryPerson.LoadAttributes(rockContext); foreach (var property in MergeData.Properties.Where(p => p.Key.StartsWith("attr_"))) { string attributeKey = property.Key.Substring(5); string oldValue = primaryPerson.GetAttributeValue(attributeKey) ?? string.Empty; string newValue = GetNewStringValue(property.Key, changes) ?? string.Empty; if (!oldValue.Equals(newValue)) { var attribute = primaryPerson.Attributes[attributeKey]; Rock.Attribute.Helper.SaveAttributeValue(primaryPerson, attribute, newValue, rockContext); } } HistoryService.SaveChanges(rockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), primaryPerson.Id, changes); // Delete the unselected photos string photoKeeper = primaryPerson.PhotoId.HasValue ? primaryPerson.PhotoId.Value.ToString() : string.Empty; foreach (var photoValue in MergeData.Properties .Where(p => p.Key == "Photo") .SelectMany(p => p.Values) .Where(v => v.Value != "" && v.Value != photoKeeper) .Select(v => v.Value)) { int photoId = 0; if (int.TryParse(photoValue, out photoId)) { var photo = binaryFileService.Get(photoId); if (photo != null) { string errorMessages; if (binaryFileService.CanDelete(photo, out errorMessages)) { binaryFileService.Delete(photo); } } } } rockContext.SaveChanges(); // Delete merged person's family records and any families that would be empty after merge foreach (var p in MergeData.People.Where(p => p.Id != primaryPersonId.Value)) { // Delete the merged person's phone numbers (we've already updated the primary persons values) foreach (var phoneNumber in phoneNumberService.GetByPersonId(p.Id)) { phoneNumberService.Delete(phoneNumber); } // If there was more than one email address and user has logins, then set any of the local // logins ( database & AD ) to require a reconfirmation if (reconfirmRequired) { foreach (var login in userLoginService.GetByPersonId(p.Id)) { var component = Rock.Security.AuthenticationContainer.GetComponent(login.EntityType.Name); if (!component.RequiresRemoteAuthentication) { login.IsConfirmed = false; } } } rockContext.SaveChanges(); // Delete the merged person's other family member records and the family if they were the only one in the family Guid familyGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid(); foreach (var familyMember in familyMemberService.Queryable().Where(m => m.PersonId == p.Id && m.Group.GroupType.Guid == familyGuid)) { familyMemberService.Delete(familyMember); rockContext.SaveChanges(); // Get the family var family = familyService.Queryable("Members").Where(f => f.Id == familyMember.GroupId).FirstOrDefault(); if (!family.Members.Any()) { // If there are not any other family members, delete the family record. var oldFamilyChanges = new List <string>(); History.EvaluateChange(oldFamilyChanges, "Family", family.Name, string.Empty); HistoryService.SaveChanges(rockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(), primaryPersonId.Value, oldFamilyChanges, family.Name, typeof(Group), family.Id); // If theres any people that have this group as a giving group, set it to null (the person being merged should be the only one) foreach (Person gp in personService.Queryable().Where(g => g.GivingGroupId == family.Id)) { gp.GivingGroupId = null; } // Delete the family familyService.Delete(family); rockContext.SaveChanges(); } } } } }); foreach (var p in MergeData.People.Where(p => p.Id != primaryPersonId.Value)) { // Run merge proc to merge all associated data var parms = new Dictionary <string, object>(); parms.Add("OldId", p.Id); parms.Add("NewId", primaryPersonId.Value); DbService.ExecuteCommand("spCrm_PersonMerge", CommandType.StoredProcedure, parms); } NavigateToLinkedPage("PersonDetailPage", "PersonId", primaryPersonId.Value); }
/// <summary> /// Updates Group Historical for any groups that have data group history enabled /// </summary> /// <param name="context">The context.</param> public void UpdateGroupHistorical(IJobExecutionContext context) { var rockContext = new RockContext(); var groupHistoricalService = new GroupHistoricalService(rockContext); var groupService = new GroupService(rockContext); // Note that this query utilizes .AsNoFilter() to avoid having archived groups filtered out by the GroupConfiguration class. var groupsWithHistoryEnabledQuery = groupService.AsNoFilter() .Where(a => a.GroupType.EnableGroupHistory == true) .AsNoTracking(); var groupHistoricalsCurrentQuery = groupHistoricalService.Queryable().Where(a => a.CurrentRowIndicator == true).AsNoTracking(); // Mark GroupHistorical Rows as History ( CurrentRowIndicator = false, etc ) if any of the tracked field values change var groupHistoricalNoLongerCurrent = groupHistoricalsCurrentQuery.Join( groupsWithHistoryEnabledQuery, gh => gh.GroupId, g => g.Id, (gh, g) => new { Group = g, GroupHistorical = gh }) .Where(a => a.Group.Name != a.GroupHistorical.GroupName || a.Group.GroupType.Name != a.GroupHistorical.GroupTypeName || a.Group.CampusId != a.GroupHistorical.CampusId || a.Group.ParentGroupId != a.GroupHistorical.ParentGroupId || a.Group.ScheduleId != a.GroupHistorical.ScheduleId || (a.Group.ScheduleId.HasValue && (a.Group.Schedule.ModifiedDateTime != a.GroupHistorical.ScheduleModifiedDateTime)) || a.Group.Description != a.GroupHistorical.Description || a.Group.StatusValueId != a.GroupHistorical.StatusValueId || a.Group.IsArchived != a.GroupHistorical.IsArchived || a.Group.ArchivedDateTime != a.GroupHistorical.ArchivedDateTime || a.Group.ArchivedByPersonAliasId != a.GroupHistorical.ArchivedByPersonAliasId || a.Group.IsActive != a.GroupHistorical.IsActive || a.Group.InactiveDateTime != a.GroupHistorical.InactiveDateTime ).Select(a => a.GroupHistorical).AsNoTracking(); var effectiveExpireDateTime = RockDateTime.Now; int groupsLoggedToHistory = 0; int groupsSaveToHistoryCurrent = 0; if (groupHistoricalNoLongerCurrent.Any()) { groupsLoggedToHistory = rockContext.BulkUpdate(groupHistoricalNoLongerCurrent, gh => new GroupHistorical { CurrentRowIndicator = false, ExpireDateTime = effectiveExpireDateTime }); } // Insert Groups (that have GroupType.EnableGroupHistory) that don't have a CurrentRowIndicator row yet ( or don't have a CurrentRowIndicator because it was stamped with CurrentRowIndicator=false ) var groupsToAddToHistoricalCurrentsQuery = groupsWithHistoryEnabledQuery.Where(g => !groupHistoricalsCurrentQuery.Any(gh => gh.GroupId == g.Id)).AsNoTracking(); if (groupsToAddToHistoricalCurrentsQuery.Any()) { List <GroupHistorical> groupHistoricalCurrentsToInsert = groupsToAddToHistoricalCurrentsQuery .Include(a => a.GroupType) .Include(a => a.Schedule) .ToList() .Select(g => GroupHistorical.CreateCurrentRowFromGroup(g, effectiveExpireDateTime)).ToList(); groupsSaveToHistoryCurrent = groupHistoricalCurrentsToInsert.Count(); rockContext.BulkInsert(groupHistoricalCurrentsToInsert); } if (groupsLoggedToHistory > 0) { _jobStatusMessages.Add($"Logged {groupsLoggedToHistory} {"group history snapshot".PluralizeIf( groupsLoggedToHistory != 0 )}"); } if (groupsSaveToHistoryCurrent > 0) { int newGroupsAddedToHistory = groupsSaveToHistoryCurrent - groupsLoggedToHistory; if (newGroupsAddedToHistory > 0) { _jobStatusMessages.Add($"Added {newGroupsAddedToHistory} new {"group history snapshot".PluralizeIf( newGroupsAddedToHistory != 0 )}"); } } }
private void ShowReadonlyDetails() { hfMode.Value = "View"; HideSecondaryBlocks(false); if (Workflow != null) { if (_canView) { if (Workflow.WorkflowType != null) { var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(this.RockPage, this.CurrentPerson); mergeFields.Add("Workflow", Workflow); lSummary.Text = Workflow.WorkflowType.SummaryViewText.ResolveMergeFields(mergeFields, CurrentPerson); } tdName.Description = Workflow.Name; tdStatus.Description = Workflow.Status; if (Workflow.InitiatorPersonAlias != null && Workflow.InitiatorPersonAlias.Person != null) { var person = Workflow.InitiatorPersonAlias.Person; tdInitiator.Description = string.Format("<a href='{0}{1}'>{2}</a>", ResolveRockUrl("~/Person/"), person.Id, person.FullName); } else { tdInitiator.Description = string.Empty; } if (Workflow.ActivatedDateTime.HasValue) { tdActivatedWhen.Description = string.Format("{0} {1} ({2})", Workflow.ActivatedDateTime.Value.ToShortDateString(), Workflow.ActivatedDateTime.Value.ToShortTimeString(), Workflow.ActivatedDateTime.Value.ToRelativeDateString()); } if (Workflow.LastProcessedDateTime.HasValue) { tdLastProcessed.Description = string.Format("{0} {1} ({2})", Workflow.LastProcessedDateTime.Value.ToShortDateString(), Workflow.LastProcessedDateTime.Value.ToShortTimeString(), Workflow.LastProcessedDateTime.Value.ToRelativeDateString()); } if (Workflow.CompletedDateTime.HasValue) { tdCompletedWhen.Description = string.Format("{0} {1} ({2})", Workflow.CompletedDateTime.Value.ToShortDateString(), Workflow.CompletedDateTime.Value.ToShortTimeString(), Workflow.CompletedDateTime.Value.ToRelativeDateString()); } ShowAttributeValues(); var rockContext = new RockContext(); _personAliasService = new PersonAliasService(rockContext); _groupService = new GroupService(rockContext); rptrActivities.DataSource = Workflow.Activities.OrderBy(a => a.ActivatedDateTime).ToList(); rptrActivities.DataBind(); BindLog(); } else { nbNotAuthorized.Visible = true; pnlContent.Visible = false; HideSecondaryBlocks(true); } } }
/// <summary> /// Executes the specified workflow. /// </summary> /// <param name="rockContext">The rock context.</param> /// <param name="action">The action.</param> /// <param name="entity">The entity.</param> /// <param name="errorMessages">The error messages.</param> /// <returns></returns> public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages) { errorMessages = new List <string>(); // Determine which group to add the person to Group group = null; int? groupRoleId = null; var groupAndRoleValues = (GetAttributeValue(action, "GroupAndRole") ?? string.Empty).Split('|'); if (groupAndRoleValues.Count() > 1) { var groupGuid = groupAndRoleValues[1].AsGuidOrNull(); if (groupGuid.HasValue) { group = new GroupService(rockContext).Get(groupGuid.Value); if (groupAndRoleValues.Count() > 2) { var groupTypeRoleGuid = groupAndRoleValues[2].AsGuidOrNull(); if (groupTypeRoleGuid.HasValue) { var groupRole = new GroupTypeRoleService(rockContext).Get(groupTypeRoleGuid.Value); if (groupRole != null) { groupRoleId = groupRole.Id; } } } } } if (group == null) { errorMessages.Add("No group was provided"); } // determine the person that will be added to the group Person person = null; // get the Attribute.Guid for this workflow's Person Attribute so that we can lookup the value var guidPersonAttribute = GetAttributeValue(action, "Person").AsGuidOrNull(); if (guidPersonAttribute.HasValue) { var attributePerson = AttributeCache.Get(guidPersonAttribute.Value, rockContext); if (attributePerson != null) { string attributePersonValue = action.GetWorklowAttributeValue(guidPersonAttribute.Value); if (!string.IsNullOrWhiteSpace(attributePersonValue)) { if (attributePerson.FieldType.Class == typeof(Rock.Field.Types.PersonFieldType).FullName) { Guid personAliasGuid = attributePersonValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person) .FirstOrDefault(); } } else { errorMessages.Add("The attribute used to provide the person was not of type 'Person'."); } } } } if (person == null) { errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString())); } // Remove Person from Group if (!errorMessages.Any()) { try { var groupMemberService = new GroupMemberService(rockContext); var groupMembers = groupMemberService.Queryable().Where(m => m.PersonId == person.Id && m.GroupId == group.Id); if (groupRoleId.HasValue) { groupMembers = groupMembers.Where(m => m.GroupRoleId == groupRoleId.Value); } foreach (var groupMember in groupMembers) { groupMemberService.Delete(groupMember); } rockContext.SaveChanges(); } catch (Exception ex) { errorMessages.Add(string.Format("An error occurred while removing the group member: {0}", ex.Message)); } } errorMessages.ForEach(m => action.AddLogEntry(m, true)); return(true); }
/// <summary> /// Handles the Click event of the btnSave control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param> protected void btnSave_Click(object sender, EventArgs e) { if (!Page.IsValid) { return; } var rockContext = new RockContext(); var communicationTemplateService = new CommunicationTemplateService(rockContext); var communicationTemplateAttachmentService = new CommunicationTemplateAttachmentService(rockContext); var binaryFileService = new BinaryFileService(rockContext); CommunicationTemplate communicationTemplate = null; var communicationTemplateId = hfCommunicationTemplateId.Value.AsIntegerOrNull(); if (communicationTemplateId.HasValue) { communicationTemplate = communicationTemplateService.Get(communicationTemplateId.Value); } var newTemplate = false; if (communicationTemplate == null) { newTemplate = true; communicationTemplate = new CommunicationTemplate(); communicationTemplateService.Add(communicationTemplate); } communicationTemplate.Name = tbName.Text; communicationTemplate.IsActive = cbIsActive.Checked; communicationTemplate.Description = tbDescription.Text; if (communicationTemplate.ImageFileId != imgTemplatePreview.BinaryFileId) { var oldImageTemplatePreview = binaryFileService.Get(communicationTemplate.ImageFileId ?? 0); if (oldImageTemplatePreview != null) { // the old image template preview won't be needed anymore, so make it IsTemporary and have it get cleaned up later oldImageTemplatePreview.IsTemporary = true; } } communicationTemplate.ImageFileId = imgTemplatePreview.BinaryFileId; // Ensure that the ImagePreview is not set as IsTemporary=True if (communicationTemplate.ImageFileId.HasValue) { var imageTemplatePreview = binaryFileService.Get(communicationTemplate.ImageFileId.Value); if (imageTemplatePreview != null && imageTemplatePreview.IsTemporary) { imageTemplatePreview.IsTemporary = false; } } // Note: If the Logo has changed, we can't get rid of it since existing communications might use it communicationTemplate.LogoBinaryFileId = imgTemplateLogo.BinaryFileId; // Ensure that the ImagePreview is not set as IsTemporary=True if (communicationTemplate.LogoBinaryFileId.HasValue) { var newImageTemplateLogo = binaryFileService.Get(communicationTemplate.LogoBinaryFileId.Value); if (newImageTemplateLogo != null && newImageTemplateLogo.IsTemporary) { newImageTemplateLogo.IsTemporary = false; } } communicationTemplate.FromName = tbFromName.Text; communicationTemplate.FromEmail = tbFromAddress.Text; communicationTemplate.ReplyToEmail = tbReplyToAddress.Text; communicationTemplate.CCEmails = tbCCList.Text; communicationTemplate.BCCEmails = tbBCCList.Text; communicationTemplate.LavaFields = kvlMergeFields.Value.AsDictionaryOrNull(); communicationTemplate.CssInliningEnabled = cbCssInliningEnabled.Checked; var binaryFileIds = hfAttachedBinaryFileIds.Value.SplitDelimitedValues().AsIntegerList(); // delete any attachments that are no longer included foreach (var attachment in communicationTemplate.Attachments .Where(a => !binaryFileIds.Contains(a.BinaryFileId)).ToList()) { communicationTemplate.Attachments.Remove(attachment); communicationTemplateAttachmentService.Delete(attachment); } // add any new attachments that were added foreach (var attachmentBinaryFileId in binaryFileIds.Where(a => communicationTemplate.Attachments.All(x => x.BinaryFileId != a))) { communicationTemplate.Attachments.Add(new CommunicationTemplateAttachment { BinaryFileId = attachmentBinaryFileId, CommunicationType = CommunicationType.Email }); } communicationTemplate.Subject = tbEmailSubject.Text; communicationTemplate.Message = ceEmailTemplate.Text; communicationTemplate.SMSFromDefinedValueId = dvpSMSFrom.SelectedValue.AsIntegerOrNull(); communicationTemplate.SMSMessage = tbSMSTextMessage.Text; communicationTemplate.CategoryId = cpCategory.SelectedValueAsInt(); rockContext.SaveChanges(); var personalView = GetAttributeValue("PersonalTemplatesView").AsBoolean(); if (newTemplate) { communicationTemplate = communicationTemplateService.Get(communicationTemplate.Id); if (communicationTemplate != null) { if (personalView) { // If editing personal templates, make the new template is private/personal to current user communicationTemplate.MakePrivate(Authorization.VIEW, CurrentPerson); communicationTemplate.MakePrivate(Authorization.EDIT, CurrentPerson); communicationTemplate.MakePrivate(Authorization.ADMINISTRATE, CurrentPerson); } else { // Otherwise, make sure user can view and edit the new template. if (!communicationTemplate.IsAuthorized(Authorization.VIEW, CurrentPerson)) { communicationTemplate.AllowPerson(Authorization.VIEW, CurrentPerson); } // Make sure user can edit the new template. if (!communicationTemplate.IsAuthorized(Authorization.EDIT, CurrentPerson)) { communicationTemplate.AllowPerson(Authorization.EDIT, CurrentPerson); } } // Always make sure RSR-Admin and Communication Admin can see var groupService = new GroupService(rockContext); var communicationAdministrators = groupService.Get(Rock.SystemGuid.Group.GROUP_COMMUNICATION_ADMINISTRATORS.AsGuid()); if (communicationAdministrators != null) { communicationTemplate.AllowSecurityRole(Authorization.VIEW, communicationAdministrators, rockContext); communicationTemplate.AllowSecurityRole(Authorization.EDIT, communicationAdministrators, rockContext); communicationTemplate.AllowSecurityRole(Authorization.ADMINISTRATE, communicationAdministrators, rockContext); } var rockAdministrators = groupService.Get(Rock.SystemGuid.Group.GROUP_ADMINISTRATORS.AsGuid()); if (rockAdministrators != null) { communicationTemplate.AllowSecurityRole(Authorization.VIEW, rockAdministrators, rockContext); communicationTemplate.AllowSecurityRole(Authorization.EDIT, rockAdministrators, rockContext); communicationTemplate.AllowSecurityRole(Authorization.ADMINISTRATE, rockAdministrators, rockContext); } } } NavigateToParentPage(); }
public Group_ElectionViewModel(Election election, Guid?userId) { if (election != null) { Id = election.Id; Title = election.Title; Stage = (ElectionStage)election.Stage; Quorum = election.Quorum; Turnout = election.Turnout; GroupModersCount = election.Group.ModeratorsCount; About = new Group_Election_AboutViewModel(election); GroupMember gm = null; if (userId.HasValue && election.GroupId.HasValue) { gm = GroupService.UserInGroup(userId.Value, election.GroupId.Value); } IEnumerable <Candidate> candidates = election.Candidates.Where(x => x.Petition != null).OrderByDescending(x => x.Petition.Signers.Count); candidates = candidates.Union(election.Candidates.Where(x => x.Petition == null)); if (election.Stage != (byte)ElectionStage.Agitation) { candidates = candidates.Where(x => x.Status == (byte)CandidateStatus.Confirmed); } Candidates = candidates.Select(x => new Group_Election_CandidateViewModel(x, gm)).ToList(); Winners = election.Candidates .Where(x => x.Status == (byte)CandidateStatus.Winner) .OrderByDescending(x => x.Electorate.Count) .Select(x => new Group_Election_CandidateViewModel(x, gm)) .ToList(); switch (Stage) { case ElectionStage.Agitation: ElectionCandidates = new Group_ElectionCandidatesViewModel(election, userId); break; case ElectionStage.Voting: ElectionVoting = new Group_ElectionVotingViewModel(election, userId); break; } } else { Candidates = new List <Group_Election_CandidateViewModel>(); Winners = new List <Group_Election_CandidateViewModel>(); About = new Group_Election_AboutViewModel(); ElectionCandidates = new Group_ElectionCandidatesViewModel(); ElectionVoting = new Group_ElectionVotingViewModel(); } if (UserContext.Current != null) { var candidate = Candidates.FirstOrDefault(x => x.UserId == UserContext.Current.Id); if (candidate != null) { IsCandidate = true; CandidateId = candidate.Id; } else { CandidateId = null; } } }
public static List <CheckInLabel> GenerateLabels(List <Person> people, Device kioskDevice, Guid?aggregateLabelGuid) { var labels = new List <CheckInLabel>(); var globalAttributes = Rock.Web.Cache.GlobalAttributesCache.Get(); var globalMergeValues = Rock.Lava.LavaHelper.GetCommonMergeFields(null); RockContext rockContext = new RockContext(); AttendanceService attendanceService = new AttendanceService(rockContext); foreach (var person in people) { var attendances = AttendanceCache.All() .Where(a => a.PersonId == person.Id && a.AttendanceState != AttendanceState.CheckedOut) .ToList(); if (!attendances.Any()) { continue; } var groupIds = attendances.Select(a => a.GroupId).Distinct().ToList(); GroupService groupService = new GroupService(new RockContext()); var groupTypeIds = groupService.Queryable() .Where(g => groupIds.Contains(g.Id)) .Select(g => g.GroupTypeId) .Distinct() .ToList(); var groupTypes = groupTypeIds .Select(i => GroupTypeCache.Get(i)) .OrderBy(gt => gt.Order) .ToList(); List <Guid> labelGuids = new List <Guid>(); var mergeObjects = new Dictionary <string, object>(); foreach (var keyValue in globalMergeValues) { mergeObjects.Add(keyValue.Key, keyValue.Value); } var checkinPerson = new CheckInPerson { Person = person, SecurityCode = attendances.OrderByDescending(a => a.CreatedDateTime).FirstOrDefault().Code }; mergeObjects.Add("Person", checkinPerson); mergeObjects.Add("GroupTypes", groupTypes); List <Rock.Model.Group> mergeGroups = new List <Rock.Model.Group>(); List <Location> mergeLocations = new List <Location>(); List <Schedule> mergeSchedules = new List <Schedule>(); var sets = attendanceService .Queryable().AsNoTracking().Where(a => a.PersonAlias.Person.Id == person.Id && a.StartDateTime >= Rock.RockDateTime.Today && a.EndDateTime == null && a.Occurrence.Group != null && a.Occurrence.Schedule != null && a.Occurrence.Location != null ) .Select(a => new { Group = a.Occurrence.Group, Location = a.Occurrence.Location, Schedule = a.Occurrence.Schedule, AttendanceGuid = a.Guid } ) .ToList() .OrderBy(a => a.Schedule.StartTimeOfDay); //Load breakout group var breakoutGroupItems = GetBreakoutGroupItems(person); //Add in an empty object as a placeholder for our breakout group mergeObjects.Add("BreakoutGroup", ""); //Add in GUID for QR code if (sets.Any()) { mergeObjects.Add("AttendanceGuid", sets.FirstOrDefault().AttendanceGuid.ToString()); } foreach (var set in sets) { mergeGroups.Add(set.Group); mergeLocations.Add(set.Location); mergeSchedules.Add(set.Schedule); //Add the breakout group mergefield if (breakoutGroupItems.Any()) { var breakoutGroupItem = breakoutGroupItems.Where(g => g.ScheduleId == set.Schedule.Id).FirstOrDefault(); if (breakoutGroupItem != null) { mergeObjects["BreakoutGroup"] = breakoutGroupItem.Letter; } } } mergeObjects.Add("Groups", mergeGroups); mergeObjects.Add("Locations", mergeLocations); mergeObjects.Add("Schedules", mergeSchedules); foreach (var groupType in groupTypes) { var groupTypeLabels = new List <CheckInLabel>(); GetGroupTypeLabels(groupType, groupTypeLabels, mergeObjects, labelGuids); var PrinterIPs = new Dictionary <int, string>(); foreach (var label in groupTypeLabels) { label.PrintFrom = kioskDevice.PrintFrom; label.PrintTo = kioskDevice.PrintToOverride; if (label.PrintTo == PrintTo.Default) { label.PrintTo = groupType.AttendancePrintTo; } if (label.PrintTo == PrintTo.Kiosk) { var device = kioskDevice; if (device != null) { label.PrinterDeviceId = device.PrinterDeviceId; } } if (label.PrinterDeviceId.HasValue) { if (PrinterIPs.ContainsKey(label.PrinterDeviceId.Value)) { label.PrinterAddress = PrinterIPs[label.PrinterDeviceId.Value]; } else { var printerDevice = new DeviceService(rockContext).Get(label.PrinterDeviceId.Value); if (printerDevice != null) { PrinterIPs.Add(printerDevice.Id, printerDevice.IPAddress); label.PrinterAddress = printerDevice.IPAddress; } } } labels.Add(label); } } } if (aggregateLabelGuid.HasValue) { labels.AddRange(GenerateAggregateLabel(aggregateLabelGuid.Value, kioskDevice, people)); } return(labels); }
/// <summary> /// Executes the specified workflow. /// </summary> /// <param name="rockContext">The rock context.</param> /// <param name="action">The action.</param> /// <param name="entity">The entity.</param> /// <param name="errorMessages">The error messages.</param> /// <returns></returns> public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages) { errorMessages = new List <string>(); // Determine which group to add the person to Group group = null; int? groupRoleId = null; var guidGroupAttribute = GetAttributeValue(action, "Group").AsGuidOrNull(); if (guidGroupAttribute.HasValue) { var attributeGroup = AttributeCache.Read(guidGroupAttribute.Value, rockContext); if (attributeGroup != null) { var groupGuid = action.GetWorklowAttributeValue(guidGroupAttribute.Value).AsGuidOrNull(); if (groupGuid.HasValue) { group = new GroupService(rockContext).Get(groupGuid.Value); if (group != null) { // use the group's grouptype's default group role if a group role wasn't specified groupRoleId = group.GroupType.DefaultGroupRoleId; } } } } if (group == null) { errorMessages.Add("No group was provided"); } if (!groupRoleId.HasValue) { errorMessages.Add("Provided group doesn't have a default group role"); } // determine the person that will be added to the group Person person = null; // get the Attribute.Guid for this workflow's Person Attribute so that we can lookup the value var guidPersonAttribute = GetAttributeValue(action, "Person").AsGuidOrNull(); if (guidPersonAttribute.HasValue) { var attributePerson = AttributeCache.Read(guidPersonAttribute.Value, rockContext); if (attributePerson != null) { string attributePersonValue = action.GetWorklowAttributeValue(guidPersonAttribute.Value); if (!string.IsNullOrWhiteSpace(attributePersonValue)) { if (attributePerson.FieldType.Class == typeof(Rock.Field.Types.PersonFieldType).FullName) { Guid personAliasGuid = attributePersonValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person) .FirstOrDefault(); } } else { errorMessages.Add("The attribute used to provide the person was not of type 'Person'."); } } } } if (person == null) { errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString())); } // Add Person to Group if (!errorMessages.Any()) { var groupMemberService = new GroupMemberService(rockContext); var groupMember = new GroupMember(); groupMember.PersonId = person.Id; groupMember.GroupId = group.Id; groupMember.GroupRoleId = groupRoleId.Value; groupMember.GroupMemberStatus = GroupMemberStatus.Active; if (groupMember.IsValid) { groupMemberService.Add(groupMember); rockContext.SaveChanges(); } else { // if the group member couldn't be added (for example, one of the group membership rules didn't pass), add the validation messages to the errormessages errorMessages.AddRange(groupMember.ValidationResults.Select(a => a.ErrorMessage)); } } errorMessages.ForEach(m => action.AddLogEntry(m, true)); return(true); }
public override Expression GetExpression(RockContext context, MemberExpression entityIdProperty, string selection) { var settings = new ParticipationRateSelectSettings(selection); if (!settings.IsValid()) { return(this.GetDefaultSelectExpression(context, entityIdProperty)); } // Get the Person Data View that defines the set of candidates from which matching Group Members can be selected. DataView dataView = null; if (settings.DataViewGuid.HasValue) { var dsService = new DataViewService(context); dataView = dsService.Get(settings.DataViewGuid.Value); // Verify that there is not a child filter that uses this view (would result in stack-overflow error) if (dsService.IsViewInFilter(dataView.Id, dataView.DataViewFilter)) { throw new Exception("Filter issue(s): One of the filters contains a circular reference to the Data View itself."); } } if (dataView == null || dataView.DataViewFilter == null) { return(this.GetDefaultSelectExpression(context, entityIdProperty)); } // Evaluate the Data View that defines the candidate population. List <string> errorMessages; var personService = new PersonService(context); var personQuery = personService.Queryable(); var paramExpression = personService.ParameterExpression; var whereExpression = dataView.GetExpression(personService, paramExpression, out errorMessages); if (errorMessages.Any()) { throw new Exception("Filter issue(s): " + errorMessages.AsDelimited("; ")); } personQuery = personQuery.Where(paramExpression, whereExpression, null); var populationIds = personQuery.Select(x => x.Id); // Construct the Query to return the measure of matches for each Group. IQueryable <decimal> resultQuery; switch (settings.MeasureType) { case MeasureTypeSpecifier.ParticipationRateOfGroup: { // Percentage of Group Members that are also in the candidate population. resultQuery = new GroupService(context).Queryable() .Select(p => (p.Members.Count == 0) ? 0 : ((decimal)p.Members.Count(a => (populationIds.Contains(a.PersonId))) / (decimal)p.Members.Count) * 100); } break; case MeasureTypeSpecifier.ParticipationRateOfCandidates: { // Percentage of candidate population that are also Group Members. decimal populationCount = populationIds.Count(); resultQuery = new GroupService(context).Queryable() .Select(p => (p.Members.Count == 0) ? 0 : ((decimal)p.Members.Count(a => (populationIds.Contains(a.PersonId))) / populationCount) * 100); } break; case MeasureTypeSpecifier.NumberOfParticipants: default: { // Number resultQuery = new GroupService(context).Queryable() .Select(p => (decimal)p.Members.Count(a => populationIds.Contains(a.PersonId))); } break; } var selectExpression = SelectExpressionExtractor.Extract <Rock.Model.Group>(resultQuery, entityIdProperty, "p"); return(selectExpression); }
/// <summary> /// Executes the specified workflow. /// </summary> /// <param name="rockContext">The rock context.</param> /// <param name="action">The action.</param> /// <param name="entity">The entity.</param> /// <param name="errorMessages">The error messages.</param> /// <returns></returns> public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages) { errorMessages = new List <string>(); // get person Person person = null; string personAttributeValue = GetAttributeValue(action, "Person"); Guid? guidPersonAttribute = personAttributeValue.AsGuidOrNull(); if (guidPersonAttribute.HasValue) { var attributePerson = AttributeCache.Get(guidPersonAttribute.Value, rockContext); if (attributePerson != null || attributePerson.FieldType.Class != "Rock.Field.Types.PersonFieldType") { string attributePersonValue = action.GetWorkflowAttributeValue(guidPersonAttribute.Value); if (!string.IsNullOrWhiteSpace(attributePersonValue)) { Guid personAliasGuid = attributePersonValue.AsGuid(); if (!personAliasGuid.IsEmpty()) { person = new PersonAliasService(rockContext).Queryable() .Where(a => a.Guid.Equals(personAliasGuid)) .Select(a => a.Person) .FirstOrDefault(); if (person == null) { errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString())); return(false); } } } } } if (person == null) { errorMessages.Add("The attribute used to provide the person was invalid, or not of type 'Person'."); return(false); } // determine the location type to edit DefinedValueCache locationType = null; var locationTypeAttributeValue = action.GetWorkflowAttributeValue(GetAttributeValue(action, "LocationTypeAttribute").AsGuid()); if (locationTypeAttributeValue != null) { locationType = DefinedValueCache.Get(locationTypeAttributeValue.AsGuid()); } if (locationType == null) { locationType = DefinedValueCache.Get(GetAttributeValue(action, "LocationType").AsGuid()); } if (locationType == null) { errorMessages.Add("The location type to be updated was not selected."); return(false); } // get the new phone number value Location location = null; string locationValue = GetAttributeValue(action, "Location"); Guid? locationGuid = locationValue.AsGuidOrNull(); if (!locationGuid.HasValue || locationGuid.Value.IsEmpty()) { string locationAttributeValue = GetAttributeValue(action, "LocationAttribute"); Guid? locationAttributeValueGuid = locationAttributeValue.AsGuidOrNull(); if (locationAttributeValueGuid.HasValue) { locationGuid = action.GetWorkflowAttributeValue(locationAttributeValueGuid.Value).AsGuidOrNull(); } } if (locationGuid.HasValue) { location = new LocationService(rockContext).Get(locationGuid.Value); } if (location == null) { errorMessages.Add("The location value could not be determined."); return(false); } // gets value indicating if location is a mailing location string mailingValue = GetAttributeValue(action, "IsMailing"); Guid? mailingValueGuid = mailingValue.AsGuidOrNull(); if (mailingValueGuid.HasValue) { mailingValue = action.GetWorkflowAttributeValue(mailingValueGuid.Value); } else { mailingValue = mailingValue.ResolveMergeFields(GetMergeFields(action)); } bool?mailing = mailingValue.AsBooleanOrNull(); // gets value indicating if location is a mapped location string mappedValue = GetAttributeValue(action, "IsMapped"); Guid? mappedValueGuid = mappedValue.AsGuidOrNull(); if (mappedValueGuid.HasValue) { mappedValue = action.GetWorkflowAttributeValue(mappedValueGuid.Value); } else { mappedValue = mappedValue.ResolveMergeFields(GetMergeFields(action)); } bool?mapped = mappedValue.AsBooleanOrNull(); var savePreviousAddress = GetAttributeValue(action, "SavePreviousAddress").AsBoolean(); var locationService = new LocationService(rockContext); locationService.Verify(location, false); var groupLocationService = new GroupLocationService(rockContext); foreach (var family in person.GetFamilies(rockContext).ToList()) { bool locationUpdated = false; if (savePreviousAddress) { // Get all existing addresses of the specified type var groupLocations = family.GroupLocations.Where(l => l.GroupLocationTypeValueId == locationType.Id).ToList(); // Create a new address of the specified type, saving all existing addresses of that type as Previous Addresses // Use the specified Is Mailing and Is Mapped values from the action's parameters if they are set, // otherwise set them to true if any of the existing addresses of that type have those values set to true GroupService.AddNewGroupAddress(rockContext, family, locationType.Guid.ToString(), location.Id, true, $"the {action.ActionTypeCache.ActivityType.WorkflowType.Name} workflow", mailing ?? groupLocations.Any(x => x.IsMailingLocation), mapped ?? groupLocations.Any(x => x.IsMappedLocation)); } else { var groupLocation = family.GroupLocations.FirstOrDefault(l => l.GroupLocationTypeValueId == locationType.Id); string oldValue = string.Empty; if (groupLocation == null) { groupLocation = new GroupLocation(); groupLocation.GroupId = family.Id; groupLocation.GroupLocationTypeValueId = locationType.Id; groupLocationService.Add(groupLocation); } else { oldValue = groupLocation.Location.ToString(); } locationUpdated = oldValue != location.ToString(); groupLocation.Location = location; if (mailing.HasValue) { if (((oldValue == string.Empty) ? null : groupLocation.IsMailingLocation.ToString()) != mailing.Value.ToString()) { locationUpdated = true; } groupLocation.IsMailingLocation = mailing.Value; } if (mapped.HasValue) { if (((oldValue == string.Empty) ? null : groupLocation.IsMappedLocation.ToString()) != mapped.Value.ToString()) { locationUpdated = true; } groupLocation.IsMappedLocation = mapped.Value; } } if (locationUpdated) { var groupChanges = new History.HistoryChangeList(); groupChanges.AddChange(History.HistoryVerb.Modify, History.HistoryChangeType.Record, "Location").SourceOfChange = $"{action.ActionTypeCache.ActivityType.WorkflowType.Name} workflow"; foreach (var fm in family.Members) { HistoryService.SaveChanges( rockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(), fm.PersonId, groupChanges, family.Name, typeof(Group), family.Id, false, null, rockContext.SourceOfChange); } } rockContext.SaveChanges(); action.AddLogEntry(string.Format("Updated the {0} location for {1} (family: {2}) to {3}", locationType.Value, person.FullName, family.Name, location.ToString())); } return(true); }
private void ShowException() { pnlException.Visible = true; // get error level int errorLevel = 0; if ( Request["error"] != null ) { errorLevel = Int32.Parse( Request["error"].ToString() ); } else { if (Request.RequestContext.HttpContext.Items["error"] != null) { errorLevel = Int32.Parse( Request.RequestContext.HttpContext.Items["error"].ToString() ); } } switch ( errorLevel ) { case 1: // check to see if the user is an admin, if so allow them to view the error details var userLogin = Rock.Model.UserLoginService.GetCurrentUser(); try { GroupService service = new GroupService( new RockContext() ); Group adminGroup = service.GetByGuid( new Guid( Rock.SystemGuid.Group.GROUP_ADMINISTRATORS ) ); if ( userLogin != null && adminGroup.Members.Where( m => m.PersonId == userLogin.PersonId ).Count() > 0 ) { // get exception from Session if ( Session["Exception"] != null ) { // is an admin lErrorInfo.Text = "<h3>Exception Log:</h3>"; ProcessException( (Exception)Session["Exception"], " " ); } } } catch { } break; case 66: // massive errors from global.asax.cs or routehandler if ( Session["Exception"] != null ) { lErrorInfo.Text = "<h3>Exception Log:</h3>"; ProcessException( (Exception)Session["Exception"], " " ); } else { if (Request.RequestContext.HttpContext.Items["Exception"] != null) { lErrorInfo.Text = "<h3>Exception Log:</h3>"; ProcessException( (Exception)Request.RequestContext.HttpContext.Items["Exception"], " " ); } } break; } // clear session object Session.Remove( "Exception" ); }
/// <summary> /// Shows the detail. /// </summary> /// <param name="groupId">The group id.</param> protected void ShowDetail( int groupId ) { GroupService groupService = new GroupService(); Group group = groupService.Get( groupId ); bool readOnly = false; hfGroupId.Value = groupId.ToString(); LoadDropDowns(); if ( group != null ) { iconIsSystem.Visible = group.IsSystem; hfGroupId.Value = group.Id.ToString(); tbName.Text = group.Name; tbDescription.Text = group.Description; ddlGroupType.SelectedValue = group.GroupTypeId.ToString(); ddlParentGroup.SelectedValue = ( group.ParentGroupId ?? None.Id ).ToString(); ddlCampus.SelectedValue = ( group.CampusId ?? None.Id ).ToString(); cbIsSecurityRole.Checked = group.IsSecurityRole; readOnly = group.IsSystem; if ( group.IsSystem ) { lActionTitle.Text = ActionTitle.View( Group.FriendlyTypeName ); btnCancel.Text = "Close"; } else { lActionTitle.Text = ActionTitle.Edit( Group.FriendlyTypeName ); btnCancel.Text = "Cancel"; } } else { lActionTitle.Text = ActionTitle.Add( Group.FriendlyTypeName ); iconIsSystem.Visible = false; hfGroupId.Value = 0.ToString(); tbName.Text = string.Empty; tbDescription.Text = string.Empty; ddlGroupType.SelectedValue = null; ddlParentGroup.SelectedValue = None.IdValue; ddlCampus.SelectedValue = None.IdValue; cbIsSecurityRole.Checked = false; } ddlGroupType.Enabled = !readOnly; ddlParentGroup.Enabled = !readOnly; ddlCampus.Enabled = !readOnly; cbIsSecurityRole.Enabled = !readOnly; tbName.ReadOnly = readOnly; tbDescription.ReadOnly = readOnly; btnSave.Visible = !readOnly; // if this block's attribute limit group to SecurityRoleGroups, don't let them edit the SecurityRole checkbox value if ( AttributeValue( "LimittoSecurityRoleGroups" ).FromTrueFalse() ) { cbIsSecurityRole.Enabled = false; cbIsSecurityRole.Checked = true; } }
public GroupsController(IUnitOfWork unitOfWork) : base(unitOfWork) { GroupService = new GroupService(UnitOfWork); }
private static List <BreakoutGroupItem> GetBreakoutGroupItems(Person person) { List <BreakoutGroupItem> allBreakoutGroupItems = RockCache.Get(cacheKey) as List <BreakoutGroupItem>; if (allBreakoutGroupItems == null || !allBreakoutGroupItems.Any()) { allBreakoutGroupItems = new List <BreakoutGroupItem>(); RockContext rockContext = new RockContext(); var attributeService = new AttributeService(rockContext); var attributeValueService = new AttributeValueService(rockContext); var groupEntityTypeId = EntityTypeCache.GetId(typeof(Rock.Model.Group)); var breakoutGroupGroupTypeId = GroupTypeCache.GetId(Constants.GROUP_TYPE_BREAKOUT_GROUPS.AsGuid()); if (groupEntityTypeId == null || breakoutGroupGroupTypeId == null) { ExceptionLogService.LogException(new Exception("Could not load breakout groups due to missing breakoutgroup type")); return(new List <BreakoutGroupItem>()); } var letterAttribute = attributeService.GetByEntityTypeQualifier(groupEntityTypeId, "GroupTypeId", breakoutGroupGroupTypeId.Value.ToString(), false) .Where(a => a.Key == Constants.GROUP_ATTRIBUTE_KEY_LETTER) .FirstOrDefault(); if (letterAttribute == null) { ExceptionLogService.LogException(new Exception("Could not load breakout group letter attribute.")); return(new List <BreakoutGroupItem>()); } var attributeQueryable = attributeValueService.Queryable().AsNoTracking() .Where(av => letterAttribute.Id == av.AttributeId); //Get all the data in one go var breakoutData = new GroupService(rockContext) .Queryable() .AsNoTracking() .Where(g => g.GroupTypeId == breakoutGroupGroupTypeId && g.IsActive && !g.IsArchived) .Join(attributeQueryable, g => g.Id, av => av.EntityId, (g, av) => new { ScheduleId = g.ScheduleId ?? 0, PersonIds = g.Members.Where(gm => gm.IsArchived == false && gm.GroupMemberStatus == GroupMemberStatus.Active).Select(gm => gm.PersonId), Letter = av.Value }) .ToList(); foreach (var item in breakoutData) { foreach (var personId in item.PersonIds) { allBreakoutGroupItems.Add(new BreakoutGroupItem { Letter = item.Letter, PersonId = personId, ScheduleId = item.ScheduleId }); } } RockCache.AddOrUpdate(cacheKey, null, allBreakoutGroupItems, RockDateTime.Now.AddMinutes(10), Constants.CACHE_TAG); } return(allBreakoutGroupItems.Where(i => i.PersonId == person.Id).ToList()); }
/// <summary> /// Handles the Click event of the btnSave control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param> protected void btnSave_Click(object sender, EventArgs e) { if (Page.IsValid) { var rockContext = new RockContext(); GroupMemberService groupMemberService = new GroupMemberService(rockContext); GroupMemberRequirementService groupMemberRequirementService = new GroupMemberRequirementService(rockContext); GroupMember groupMember; int groupMemberId = int.Parse(hfGroupMemberId.Value); GroupTypeRole role = new GroupTypeRoleService(rockContext).Get(ddlGroupRole.SelectedValueAsInt() ?? 0); // check to see if the user selected a role if (role == null) { nbErrorMessage.Title = "Please select a Role"; return; } // if adding a new group member if (groupMemberId.Equals(0)) { groupMember = new GroupMember { Id = 0 }; groupMember.GroupId = hfGroupId.ValueAsInt(); } else { // load existing group member groupMember = groupMemberService.Get(groupMemberId); } groupMember.PersonId = ppGroupMemberPerson.PersonId.Value; groupMember.GroupRoleId = role.Id; groupMember.Note = tbNote.Text; groupMember.GroupMemberStatus = rblStatus.SelectedValueAsEnum <GroupMemberStatus>(); if (cbIsNotified.Visible) { groupMember.IsNotified = cbIsNotified.Checked; } if (pnlRequirements.Visible) { foreach (var checkboxItem in cblManualRequirements.Items.OfType <ListItem>()) { int groupRequirementId = checkboxItem.Value.AsInteger(); var groupMemberRequirement = groupMember.GroupMemberRequirements.FirstOrDefault(a => a.GroupRequirementId == groupRequirementId); bool metRequirement = checkboxItem.Selected; if (metRequirement) { if (groupMemberRequirement == null) { groupMemberRequirement = new GroupMemberRequirement(); groupMemberRequirement.GroupRequirementId = groupRequirementId; groupMember.GroupMemberRequirements.Add(groupMemberRequirement); } // set the RequirementMetDateTime if it hasn't been set already groupMemberRequirement.RequirementMetDateTime = groupMemberRequirement.RequirementMetDateTime ?? RockDateTime.Now; groupMemberRequirement.LastRequirementCheckDateTime = RockDateTime.Now; } else { if (groupMemberRequirement != null) { // doesn't meets the requirement groupMemberRequirement.RequirementMetDateTime = null; groupMemberRequirement.LastRequirementCheckDateTime = RockDateTime.Now; } } } } groupMember.LoadAttributes(); Rock.Attribute.Helper.GetEditValues(phAttributes, groupMember); if (!Page.IsValid) { return; } // if the groupMember IsValue is false, and the UI controls didn't report any errors, it is probably because the custom rules of GroupMember didn't pass. // So, make sure a message is displayed in the validation summary cvGroupMember.IsValid = groupMember.IsValid; if (!cvGroupMember.IsValid) { cvGroupMember.ErrorMessage = groupMember.ValidationResults.Select(a => a.ErrorMessage).ToList().AsDelimited("<br />"); return; } // using WrapTransaction because there are three Saves rockContext.WrapTransaction(() => { if (groupMember.Id.Equals(0)) { groupMemberService.Add(groupMember); } rockContext.SaveChanges(); groupMember.SaveAttributeValues(rockContext); }); groupMember.CalculateRequirements(rockContext, true); Group group = new GroupService(rockContext).Get(groupMember.GroupId); if (group.IsSecurityRole || group.GroupType.Guid.Equals(Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid())) { Rock.Security.Role.Flush(group.Id); Rock.Security.Authorization.Flush(); } } Dictionary <string, string> qryString = new Dictionary <string, string>(); qryString["GroupId"] = hfGroupId.Value; NavigateToParentPage(qryString); }
public SubscribersController(IUnitOfWork unitOfWork) : base(unitOfWork) { SubscriberService = new SubscriberService(UnitOfWork); GroupService = new GroupService(UnitOfWork); }
protected void btnSave_Click(object sender, EventArgs e) { if (lopAddress.Location == null || string.IsNullOrWhiteSpace(lopAddress.Location.Street1) || string.IsNullOrWhiteSpace(lopAddress.Location.PostalCode)) { nbValidation.Visible = true; ScriptManager.RegisterStartupScript(Page, this.GetType(), "ScrollPage", "setTimeout(function(){window.scroll(0,0);},200)", true); return; } else { nbValidation.Visible = false; } if (_group == null) { ShowMessage("There was an issue with the viewstate. Please reload and try again. If the problem perssits contact an administrator.", "Error", "panel panel-danger"); return; } GroupService groupService = new GroupService(_rockContext); //Add basic information Group group; if (_group.Id == 0) { group = new Group() { GroupTypeId = _groupType.Id }; var destinationGroup = groupService.Get(GetAttributeValue("DestinationGroup").AsGuid()); if (destinationGroup != null) { group.ParentGroupId = destinationGroup.Id; } var parentMapping = GetAttributeValue("CampusGroupMap").ToKeyValuePairList(); foreach (var pair in parentMapping) { if (pair.Key.AsInteger() == cpCampus.SelectedValueAsId()) { group.ParentGroupId = (( string )pair.Value).AsInteger(); } } var zip = "No Zip"; if (lopAddress.Location != null && !string.IsNullOrWhiteSpace(lopAddress.Location.PostalCode)) { zip = lopAddress.Location.PostalCode; } group.Name = string.Format("{0} - {1}", tbName.Text, zip); groupService.Add(group); group.CreatedByPersonAliasId = _person.PrimaryAliasId; group.IsActive = true; } else { group = groupService.Get(_group.Id); group.IsActive = true; } group.CampusId = cpCampus.SelectedValueAsId(); group.Description = tbDescription.Text; //Set location if (lopAddress.Location != null && lopAddress.Location.Id != 0) { if (group.GroupLocations != null && !group.GroupLocations.Select(gl => gl.LocationId).Contains(lopAddress.Location.Id)) { // Disassociate the old address(es) GroupLocationService groupLocationService = new GroupLocationService(_rockContext); var meetingLocationDv = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_MEETING_LOCATION); var homeLocationDv = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME); groupLocationService.DeleteRange(group.GroupLocations.Where(gl => gl.GroupLocationTypeValueId == meetingLocationDv.Id || gl.GroupLocationTypeValueId == homeLocationDv.Id || gl.GroupLocationTypeValueId == null)); group.GroupLocations.Add(new GroupLocation() { LocationId = lopAddress.Location.Id, GroupLocationTypeValueId = meetingLocationDv.Id }); } } //Set Schedule if (_groupType.AllowedScheduleTypes != ScheduleType.None) { switch (rblSchedule.SelectedValueAsEnum <ScheduleType>()) { case ScheduleType.None: group.ScheduleId = null; break; case ScheduleType.Weekly: var weeklySchedule = new Schedule() { WeeklyDayOfWeek = dowWeekly.SelectedDayOfWeek, WeeklyTimeOfDay = timeWeekly.SelectedTime }; group.Schedule = weeklySchedule; break; case ScheduleType.Custom: var customSchedule = new Schedule() { iCalendarContent = sbSchedule.iCalendarContent }; group.Schedule = customSchedule; break; case ScheduleType.Named: if (spSchedule.SelectedValue.AsInteger() != 0) { group.ScheduleId = spSchedule.SelectedValue.AsInteger(); } break; default: break; } } if (group.Members != null && group.Members.Any()) { foreach (var member in group.Members.Where(gm => gm.PersonId != _person.Id)) { member.GroupMemberStatus = GroupMemberStatus.Inactive; } foreach (int groupMemberId in gMembers.SelectedKeys) { var groupMember = group.Members.Where(m => m.Id == groupMemberId).FirstOrDefault(); if (groupMember != null) { groupMember.GroupMemberStatus = GroupMemberStatus.Active; } } } else { var groupRoleId = new GroupTypeRoleService(_rockContext).Get(GetAttributeValue("GroupRole").AsGuid()).Id; group.Members.Add(new GroupMember() { PersonId = _person.Id, GroupRoleId = groupRoleId }); } //Save attributes _rockContext.SaveChanges(); group.LoadAttributes(); Rock.Attribute.Helper.GetEditValues(phAttributes, group); var attributeGuid = GetAttributeValue("MultiSelectAttribute"); var multiselectAttribute = new AttributeService(_rockContext).Get(attributeGuid.AsGuid()); if (multiselectAttribute != null) { var attributeValue = group.GetAttributeValue(multiselectAttribute.Key) .Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries) .ToList(); var newAttributeText = GetAttributeValue("AttributeText"); if (!attributeValue.Contains(newAttributeText)) { attributeValue.Add(newAttributeText); } group.SetAttributeValue(multiselectAttribute.Key, string.Join(",", attributeValue)); } group.SaveAttributeValues(); //Update cache var availableGroupIds = (List <int>)GetCacheItem(GetAttributeValue("DestinationGroup")); if (availableGroupIds != null) { availableGroupIds.Add(group.Id); AddCacheItem(GetAttributeValue("DestinationGroup"), availableGroupIds); } var workflowTypeService = new WorkflowTypeService(_rockContext); WorkflowTypeCache workflowType = null; Guid?workflowTypeGuid = GetAttributeValue("Workflow").AsGuidOrNull(); if (workflowTypeGuid.HasValue) { workflowType = WorkflowTypeCache.Get(workflowTypeGuid.Value); } GroupMember currentGroupMember = group.Members.Where(gm => gm.PersonId == _person.Id).FirstOrDefault(); if (currentGroupMember != null && workflowType != null && (workflowType.IsActive ?? true)) { try { List <string> workflowErrors; var workflow = Workflow.Activate(workflowType, _person.FullName); if (workflow.AttributeValues.ContainsKey("Group")) { if (group != null) { workflow.AttributeValues["Group"].Value = group.Guid.ToString(); } } if (workflow.AttributeValues.ContainsKey("Person")) { if (_person != null) { workflow.AttributeValues["Person"].Value = _person.PrimaryAlias.Guid.ToString(); } } new WorkflowService(_rockContext).Process(workflow, currentGroupMember, out workflowErrors); } catch (Exception ex) { ExceptionLogService.LogException(ex, this.Context); } } ShowMessage(GetAttributeValue("SuccessText"), "Thank you!", "panel panel-success"); }
private List<string> GetRole( string role ) { Dictionary<string, List<string>> applicationRoles = GetRoles(); if ( applicationRoles == null ) { applicationRoles = new Dictionary<string, List<string>>(); GroupService GroupService = new GroupService(); Rock.Models.Groups.Group groupModel = GroupService.GetGroupByGuid( new Guid( role ) ); if (groupModel != null) { List<string> usernames = new List<string>(); foreach ( Rock.Models.Groups.Member member in groupModel.Members) foreach ( Rock.Models.Cms.User userModel in member.Person.Users) usernames.Add( userModel.Username ); applicationRoles.Add( groupModel.Name, usernames ); } } if ( applicationRoles.ContainsKey( role ) ) return applicationRoles[role]; else return null; }
/// <summary> /// Handles the SaveClick event of the mdLinkConversation control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param> protected void mdLinkConversation_SaveClick(object sender, EventArgs e) { // Do some validation on entering a new person/family first if (hfActiveTab.Value != "Existing") { var validationMessages = new List <string>(); bool isValid = true; DateTime?birthdate = dpNewPersonBirthDate.SelectedDate; if (!dpNewPersonBirthDate.IsValid) { validationMessages.Add("Birthdate is not valid."); isValid = false; } if (!isValid) { if (validationMessages.Any()) { nbAddPerson.Text = "<ul><li>" + validationMessages.AsDelimited("</li><li>") + "</li></lu>"; nbAddPerson.Visible = true; } return; } } using (var rockContext = new RockContext()) { int mobilePhoneTypeId = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_MOBILE).Id; if (hfActiveTab.Value == "Existing") { if (ppPerson.PersonId.HasValue) { // All we need to do here is add the mobile phone number and save var personService = new PersonService(rockContext); var person = personService.Get(ppPerson.PersonId.Value); bool hasSmsNumber = person.PhoneNumbers.Where(p => p.IsMessagingEnabled).Any(); var phoneNumber = person.PhoneNumbers.FirstOrDefault(n => n.NumberTypeValueId == mobilePhoneTypeId); if (phoneNumber == null) { phoneNumber = new PhoneNumber { NumberTypeValueId = mobilePhoneTypeId, IsMessagingEnabled = !hasSmsNumber, Number = hfSelectedMessageKey.Value }; person.PhoneNumbers.Add(phoneNumber); } else { phoneNumber.Number = hfSelectedMessageKey.Value; if (!hasSmsNumber) { // If they don't have a number then use this one, otherwise don't do anything phoneNumber.IsMessagingEnabled = true; } } rockContext.SaveChanges(); hfSelectedRecipientId.Value = person.PrimaryAliasId.ToString(); } } else { // new Person and new family var person = new Person(); person.TitleValueId = dvpNewPersonTitle.SelectedValueAsId(); person.FirstName = tbNewPersonFirstName.Text; person.NickName = tbNewPersonFirstName.Text; person.LastName = tbNewPersonLastName.Text; person.SuffixValueId = dvpNewPersonSuffix.SelectedValueAsId(); person.Gender = rblNewPersonGender.SelectedValueAsEnum <Gender>(); person.MaritalStatusValueId = dvpNewPersonMaritalStatus.SelectedValueAsInt(); person.PhoneNumbers = new List <PhoneNumber>(); var phoneNumber = new PhoneNumber { NumberTypeValueId = mobilePhoneTypeId, IsMessagingEnabled = true, Number = hfSelectedMessageKey.Value }; person.PhoneNumbers.Add(phoneNumber); var birthMonth = person.BirthMonth; var birthDay = person.BirthDay; var birthYear = person.BirthYear; var birthday = dpNewPersonBirthDate.SelectedDate; if (birthday.HasValue) { person.BirthMonth = birthday.Value.Month; person.BirthDay = birthday.Value.Day; if (birthday.Value.Year != DateTime.MinValue.Year) { person.BirthYear = birthday.Value.Year; } else { person.BirthYear = null; } } else { person.SetBirthDate(null); } person.GradeOffset = ddlGradePicker.SelectedValueAsInt(); person.ConnectionStatusValueId = dvpNewPersonConnectionStatus.SelectedValueAsId(); var groupMember = new GroupMember(); groupMember.GroupRoleId = rblNewPersonRole.SelectedValueAsInt() ?? 0; groupMember.Person = person; var groupMembers = new List <GroupMember>(); groupMembers.Add(groupMember); Group group = GroupService.SaveNewFamily(rockContext, groupMembers, null, true); hfSelectedRecipientId.Value = person.PrimaryAliasId.ToString(); } new CommunicationResponseService(rockContext).UpdatePersonAliasByMessageKey(hfSelectedRecipientId.ValueAsInt(), hfSelectedMessageKey.Value, PersonAliasType.FromPersonAlias); } ppPerson.Required = false; tbNewPersonFirstName.Required = false; tbNewPersonLastName.Required = false; rblNewPersonRole.Required = false; rblNewPersonGender.Required = false; dvpNewPersonConnectionStatus.Required = false; hfActiveTab.Value = string.Empty; mdLinkConversation.Hide(); HideDialog(); LoadResponseListing(); }
public ActionResult GroupView(int id) { GroupService service = new GroupService(); var group = service.GetById(id); GMRService<Module> moduleSvc = new GMRService<Module>(); ViewGroupPermissionModel model = new ViewGroupPermissionModel() { GroupId = id, Name = group.GroupName, Modules = moduleSvc.GetPaged(p => p.Keys != "SA", new IOrderByClause<Module>[] { new OrderByClause<Module, string>(p => p.Name, SortDirection.Ascending) }, 1, int.MaxValue) }; return View(model); }
public void Remove(string gid) { GroupService.Remove(gid.ToLong(0)); Response.Redirect("/Group/"); }
/// <summary> /// Handles the Click event of the btnSave control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param> protected void btnSave_Click(object sender, EventArgs e) { if (string.IsNullOrWhiteSpace(txtFirstName.Text) || string.IsNullOrWhiteSpace(txtLastName.Text) || string.IsNullOrWhiteSpace(txtEmail.Text)) { ShowError("Missing Information", "Please enter a value for First Name, Last Name, and Email"); } else { var rockContext = new RockContext(); var person = GetPerson(rockContext); if (person != null) { Guid?groupGuid = GetAttributeValue("Group").AsGuidOrNull(); if (groupGuid.HasValue) { var groupService = new GroupService(rockContext); var groupMemberService = new GroupMemberService(rockContext); var group = groupService.Get(groupGuid.Value); if (group != null && group.GroupType.DefaultGroupRoleId.HasValue) { string linkedPage = GetAttributeValue("ConfirmationPage"); if (!string.IsNullOrWhiteSpace(linkedPage)) { var member = group.Members.Where(m => m.PersonId == person.Id).FirstOrDefault(); // If person has not registered or confirmed their registration if (member == null || member.GroupMemberStatus != GroupMemberStatus.Active) { Guid confirmationEmailTemplateGuid = Guid.Empty; if (!Guid.TryParse(GetAttributeValue("ConfirmationEmail"), out confirmationEmailTemplateGuid)) { confirmationEmailTemplateGuid = Guid.Empty; } if (member == null) { member = new GroupMember(); member.GroupId = group.Id; member.PersonId = person.Id; member.GroupRoleId = group.GroupType.DefaultGroupRoleId.Value; // If a confirmation email is configured, set status to Pending otherwise set it to active member.GroupMemberStatus = confirmationEmailTemplateGuid != Guid.Empty ? GroupMemberStatus.Pending : GroupMemberStatus.Active; groupMemberService.Add(member); rockContext.SaveChanges(); member = groupMemberService.Get(member.Id); } // Send the confirmation if (confirmationEmailTemplateGuid != Guid.Empty) { var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(this.RockPage, this.CurrentPerson); mergeFields.Add("Member", member); var pageParams = new Dictionary <string, string>(); pageParams.Add("GM", member.UrlEncodedKey); var pageReference = new Rock.Web.PageReference(linkedPage, pageParams); mergeFields.Add("ConfirmationPage", pageReference.BuildUrl()); var emailMessage = new RockEmailMessage(confirmationEmailTemplateGuid); emailMessage.AddRecipient(new RockEmailMessageRecipient(person, mergeFields)); emailMessage.AppRoot = ResolveRockUrl("~/"); emailMessage.ThemeRoot = ResolveRockUrl("~~/"); emailMessage.Send(); } ShowSuccess(GetAttributeValue("SuccessMessage")); } else { var pageParams = new Dictionary <string, string>(); pageParams.Add("GM", member.UrlEncodedKey); var pageReference = new Rock.Web.PageReference(linkedPage, pageParams); Response.Redirect(pageReference.BuildUrl(), false); } } else { ShowError("Configuration Error", "Invalid Confirmation Page setting"); } } else { ShowError("Configuration Error", "The configured group does not exist, or its group type does not have a default role configured."); } } else { ShowError("Configuration Error", "Invalid Group setting"); } } } }
/// <summary> /// Handles the Click event of the btnMoveGroupMember control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param> protected void btnMoveGroupMember_Click(object sender, EventArgs e) { var rockContext = new RockContext(); var groupMemberService = new GroupMemberService(rockContext); var groupMember = groupMemberService.Get(hfGroupMemberId.Value.AsInteger()); groupMember.LoadAttributes(); int destGroupId = gpMoveGroupMember.SelectedValue.AsInteger(); var destGroup = new GroupService(rockContext).Get(destGroupId); var destGroupMember = groupMemberService.Queryable().Where(a => a.GroupId == destGroupId && a.PersonId == groupMember.PersonId && a.GroupRoleId == grpMoveGroupMember.GroupRoleId).FirstOrDefault(); if (destGroupMember != null) { nbMoveGroupMemberWarning.Visible = true; nbMoveGroupMemberWarning.Text = string.Format("{0} is already in {1}", groupMember.Person, destGroupMember.Group); return; } if (!grpMoveGroupMember.GroupRoleId.HasValue) { nbMoveGroupMemberWarning.Visible = true; nbMoveGroupMemberWarning.Text = string.Format("Please select a Group Role"); return; } string canDeleteWarning; if (!groupMemberService.CanDelete(groupMember, out canDeleteWarning)) { nbMoveGroupMemberWarning.Visible = true; nbMoveGroupMemberWarning.Text = string.Format("Unable to remove {0} from {1}: {2}", groupMember.Person, groupMember.Group, canDeleteWarning); return; } destGroupMember = new GroupMember(); destGroupMember.GroupId = destGroupId; destGroupMember.GroupRoleId = grpMoveGroupMember.GroupRoleId.Value; destGroupMember.PersonId = groupMember.PersonId; destGroupMember.LoadAttributes(); foreach (var attribute in groupMember.Attributes) { if (destGroupMember.Attributes.Any(a => a.Key == attribute.Key && a.Value.FieldTypeId == attribute.Value.FieldTypeId)) { destGroupMember.SetAttributeValue(attribute.Key, groupMember.GetAttributeValue(attribute.Key)); } } // Un-link any registrant records that point to this group member. foreach (var registrant in new RegistrationRegistrantService(rockContext).Queryable() .Where(r => r.GroupMemberId == groupMember.Id)) { registrant.GroupMemberId = null; } rockContext.WrapTransaction(() => { groupMemberService.Add(destGroupMember); rockContext.SaveChanges(); destGroupMember.SaveAttributeValues(rockContext); // move any Note records that were associated with the old groupMember to the new groupMember record if (cbMoveGroupMemberMoveNotes.Checked) { destGroupMember.Note = groupMember.Note; int groupMemberEntityTypeId = EntityTypeCache.GetId <Rock.Model.GroupMember>().Value; var noteService = new NoteService(rockContext); var groupMemberNotes = noteService.Queryable().Where(a => a.NoteType.EntityTypeId == groupMemberEntityTypeId && a.EntityId == groupMember.Id); foreach (var note in groupMemberNotes) { note.EntityId = destGroupMember.Id; } rockContext.SaveChanges(); } groupMemberService.Delete(groupMember); rockContext.SaveChanges(); destGroupMember.CalculateRequirements(rockContext, true); }); var queryString = new Dictionary <string, string>(); queryString.Add("GroupMemberId", destGroupMember.Id.ToString()); this.NavigateToPage(this.RockPage.Guid, queryString); }