/// <summary> /// Gets the by alias unique identifier. /// </summary> /// <param name="aliasPersonGuid">The alias person unique identifier.</param> /// <returns></returns> public virtual PersonAlias GetByAliasGuid( Guid aliasPersonGuid ) { var personAlias = Queryable( "Person" ).Where( a => a.AliasPersonGuid == aliasPersonGuid ).FirstOrDefault(); if ( personAlias != null ) { return personAlias; } else { // If the personId is valid, there should be a personAlias with the AliasPersonID equal // to that personId. If there isn't for some reason, create it now. var person = new PersonService( (RockContext)this.Context ).Get( aliasPersonGuid ); if ( person != null ) { personAlias = new PersonAlias(); personAlias.Guid = Guid.NewGuid(); personAlias.AliasPersonId = person.Id; personAlias.AliasPersonGuid = person.Guid; personAlias.PersonId = person.Id; // Use a different context so calling method's changes are not yet saved var rockContext = new RockContext(); new PersonAliasService( rockContext ).Add( personAlias ); rockContext.SaveChanges(); return Get( personAlias.Id ); } } return null; }
/// <summary> /// Shows the detail. /// </summary> /// <param name="itemKey">The item key.</param> /// <param name="itemKeyValue">The item key value.</param> public void ShowDetail( string itemKey, int itemKeyValue ) { var rockContext = new RockContext(); pnlDetails.Visible = false; if ( !itemKey.Equals( "businessId" ) ) { return; } bool editAllowed = true; Person business = null; // A business is a person if ( !itemKeyValue.Equals( 0 ) ) { business = new PersonService( rockContext ).Get( itemKeyValue ); editAllowed = business.IsAuthorized( Authorization.EDIT, CurrentPerson ); } else { business = new Person { Id = 0 }; } if ( business == null ) { return; } pnlDetails.Visible = true; hfBusinessId.Value = business.Id.ToString(); bool readOnly = false; nbEditModeMessage.Text = string.Empty; if ( !editAllowed || !IsUserAuthorized( Authorization.EDIT ) ) { readOnly = true; nbEditModeMessage.Text = EditModeMessage.ReadOnlyEditActionNotAllowed( Person.FriendlyTypeName ); } if ( readOnly ) { ShowSummary( business ); } else { if ( business.Id > 0 ) { ShowSummary( business ); } else { ShowEditDetails( business ); } } BindContactListGrid( business ); }
/// <summary> /// Shows the detail. /// </summary> /// <param name="businessId">The business identifier.</param> public void ShowDetail( int businessId ) { var rockContext = new RockContext(); // Load the Campus drop down ddlCampus.Items.Clear(); ddlCampus.Items.Add( new ListItem( string.Empty, string.Empty ) ); foreach ( var campus in CampusCache.All() ) { ListItem li = new ListItem( campus.Name, campus.Id.ToString() ); ddlCampus.Items.Add( li ); } Person business = null; // A business is a person if ( !businessId.Equals( 0 ) ) { business = new PersonService( rockContext ).Get( businessId ); pdAuditDetails.SetEntity( business, ResolveRockUrl( "~" ) ); } if ( business == null ) { business = new Person { Id = 0, Guid = Guid.NewGuid() }; // hide the panel drawer that show created and last modified dates pdAuditDetails.Visible = false; } bool editAllowed = business.IsAuthorized( Authorization.EDIT, CurrentPerson ); hfBusinessId.Value = business.Id.ToString(); bool readOnly = false; nbEditModeMessage.Text = string.Empty; if ( !editAllowed || !IsUserAuthorized( Authorization.EDIT ) ) { readOnly = true; nbEditModeMessage.Text = EditModeMessage.ReadOnlyEditActionNotAllowed( Person.FriendlyTypeName ); } if ( readOnly ) { ShowSummary( businessId ); } else { if ( business.Id > 0 ) { ShowSummary( business.Id ); } else { ShowEditDetails( business ); } } BindContactListGrid( business ); }
/// <summary> /// Returns a list of matching people /// </summary> /// <param name="searchterm"></param> /// <returns></returns> public override IQueryable<string> Search( string searchterm ) { var personService = new PersonService( new RockContext() ); return personService.Queryable(). Where( p => p.Email.Contains( searchterm ) ). OrderBy( p => p.Email ). Select( p => p.Email ).Distinct(); }
/// <summary> /// Shows the detail. /// </summary> /// <param name="businessId">The business identifier.</param> public void ShowDetail( int businessId ) { var rockContext = new RockContext(); // Load the Campus drop down ddlCampus.Items.Clear(); ddlCampus.Items.Add( new ListItem( string.Empty, string.Empty ) ); var campusService = new CampusService( new RockContext() ); foreach ( Campus campus in campusService.Queryable() ) { ListItem li = new ListItem( campus.Name, campus.Id.ToString() ); ddlCampus.Items.Add( li ); } Person business = null; // A business is a person if ( !businessId.Equals( 0 ) ) { business = new PersonService( rockContext ).Get( businessId ); } if ( business == null ) { business = new Person { Id = 0, Guid = Guid.NewGuid() }; } bool editAllowed = business.IsAuthorized( Authorization.EDIT, CurrentPerson ); hfBusinessId.Value = business.Id.ToString(); bool readOnly = false; nbEditModeMessage.Text = string.Empty; if ( !editAllowed || !IsUserAuthorized( Authorization.EDIT ) ) { readOnly = true; nbEditModeMessage.Text = EditModeMessage.ReadOnlyEditActionNotAllowed( Person.FriendlyTypeName ); } if ( readOnly ) { ShowSummary( businessId ); } else { if ( business.Id > 0 ) { ShowSummary( business.Id ); } else { ShowEditDetails( business ); } } BindContactListGrid( business ); }
protected Person GetPersonFromId(string PersonId) { int intPersonId = Int32.Parse(PersonId); PersonService personService = new PersonService(rockContext); var person = personService.Queryable().FirstOrDefault(p => p.Id == intPersonId); return person; }
/// <summary> /// Creates the email communication. /// </summary> /// <param name="recipientEmails">The recipient emails.</param> /// <param name="fromName">From name.</param> /// <param name="fromAddress">From address.</param> /// <param name="replyTo">The reply to.</param> /// <param name="subject">The subject.</param> /// <param name="htmlMessage">The HTML message.</param> /// <param name="textMessage">The text message.</param> /// <param name="bulkCommunication">if set to <c>true</c> [bulk communication].</param> /// <param name="recipientStatus">The recipient status.</param> /// <param name="senderPersonAliasId">The sender person alias identifier.</param> /// <returns></returns> public Communication CreateEmailCommunication( List<string> recipientEmails, string fromName, string fromAddress, string replyTo, string subject, string htmlMessage, string textMessage, bool bulkCommunication, CommunicationRecipientStatus recipientStatus = CommunicationRecipientStatus.Delivered, int? senderPersonAliasId = null ) { var recipients = new PersonService( (RockContext)this.Context ) .Queryable() .Where( p => recipientEmails.Contains( p.Email ) ) .ToList(); if ( recipients.Any() ) { Rock.Model.Communication communication = new Rock.Model.Communication(); communication.Status = CommunicationStatus.Approved; communication.SenderPersonAliasId = senderPersonAliasId; communication.Subject = subject; Add( communication ); communication.IsBulkCommunication = bulkCommunication; communication.MediumEntityTypeId = EntityTypeCache.Read( "Rock.Communication.Medium.Email" ).Id; communication.FutureSendDateTime = null; // add each person as a recipient to the communication foreach ( var person in recipients ) { int? personAliasId = person.PrimaryAliasId; if ( personAliasId.HasValue ) { var communicationRecipient = new CommunicationRecipient(); communicationRecipient.PersonAliasId = personAliasId.Value; communicationRecipient.Status = recipientStatus; communication.Recipients.Add( communicationRecipient ); } } // add the MediumData to the communication communication.MediumData.Clear(); communication.MediumData.Add( "FromName", fromName ); communication.MediumData.Add( "FromAddress", fromAddress ); communication.MediumData.Add( "ReplyTo", replyTo ); communication.MediumData.Add( "Subject", subject ); communication.MediumData.Add( "HtmlMessage", htmlMessage ); communication.MediumData.Add( "TextMessage", textMessage ); return communication; } return null; }
/// <summary> /// Gfs the pledges_ display filter value. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The e.</param> /// <exception cref="System.NotImplementedException"></exception> protected void gfPledges_DisplayFilterValue( object sender, GridFilter.DisplayFilterValueArgs e ) { switch ( e.Key ) { case "Date Range": e.Value = DateRangePicker.FormatDelimitedValues( e.Value ); break; case "Person": int? personId = e.Value.AsIntegerOrNull(); if ( personId != null ) { var person = new PersonService( new RockContext() ).Get( personId.Value ); if ( person != null ) { e.Value = person.ToString(); } else { e.Value = string.Empty; } } else { e.Value = string.Empty; } break; case "Accounts": var accountIdList = e.Value.Split( ',' ).AsIntegerList(); if ( accountIdList.Any() ) { var service = new FinancialAccountService( new RockContext() ); var accounts = service.GetByIds( accountIdList ); if ( accounts != null && accounts.Any() ) { e.Value = accounts.Select( a => a.Name ).ToList().AsDelimited( "," ); } else { e.Value = string.Empty; } } else { e.Value = string.Empty; } break; default: e.Value = string.Empty; break; } }
/// <summary> /// Handles the Click event of the btnSubmit 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 btnSubmit_Click( object sender, EventArgs e ) { if (_person != null) { var rockContext = new RockContext(); var service = new PersonService( rockContext ); var person = service.Get(_person.Id); if ( person != null ) { switch ( rblEmailPreference.SelectedValue ) { case "0": { person.EmailPreference = EmailPreference.EmailAllowed; break; } case "1": { person.EmailPreference = EmailPreference.NoMassEmails; break; } case "2": case "3": { person.EmailPreference = EmailPreference.DoNotEmail; break; } } if (rblEmailPreference.SelectedValue == "3") { person.RecordStatusValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE ).Id; person.RecordStatusReasonValueId = ddlInactiveReason.SelectedValue.AsInteger().Value; person.ReviewReasonValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_REVIEW_REASON_SELF_INACTIVATED ).Id; if ( string.IsNullOrWhiteSpace( person.ReviewReasonNote ) ) { person.ReviewReasonNote = tbInactiveNote.Text; } else { person.ReviewReasonNote += " " + tbInactiveNote.Text; } } else { person.RecordStatusValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_ACTIVE ).Id; person.RecordStatusReasonValueId = null; } rockContext.SaveChanges(); nbMessage.Visible = true; return; } } }
protected void btnSend_Click( object sender, EventArgs e ) { var mergeObjects = new Dictionary<string, object>(); var url = LinkedPageUrl( "ConfirmationPage" ); if ( string.IsNullOrWhiteSpace( url ) ) { url = ResolveRockUrl( "~/ConfirmAccount" ); } mergeObjects.Add( "ConfirmAccountUrl", RootPath + url.TrimStart( new char[] { '/' } ) ); var personDictionaries = new List<IDictionary<string, object>>(); var personService = new PersonService(); var userLoginService = new UserLoginService(); foreach ( Person person in personService.GetByEmail( tbEmail.Text ) ) { var users = new List<IDictionary<string,object>>(); foreach ( UserLogin user in userLoginService.GetByPersonId( person.Id ) ) { if ( user.EntityType != null ) { var component = AuthenticationContainer.GetComponent( user.EntityType.Name ); if ( component.ServiceType == AuthenticationServiceType.Internal ) { users.Add( user.ToDictionary() ); } } } if (users.Count > 0) { IDictionary<string,object> personDictionary = person.ToDictionary(); personDictionary.Add("Users", users.ToArray()); personDictionaries.Add( personDictionary ); } } if ( personDictionaries.Count > 0 ) { mergeObjects.Add( "Persons", personDictionaries.ToArray() ); var recipients = new Dictionary<string, Dictionary<string, object>>(); recipients.Add( tbEmail.Text, mergeObjects ); Email email = new Email( GetAttributeValue( "EmailTemplate" ) ); email.Send( recipients ); pnlEntry.Visible = false; pnlSuccess.Visible = true; } else pnlWarning.Visible = true; }
/// <summary> /// Binds the grid. /// </summary> private void RunCommand() { gReport.CreatePreviewColumns( typeof( Person ) ); var service = new PersonService(); var people = service.Queryable().Where( p => p.LastName == "Turner" ); var parents = service.Transform( people, new Rock.Reporting.DataTransform.Person.ParentTransform() ); gReport.DataSource = parents.ToList(); gReport.DataBind(); }
protected Person GetPersonFromForm(string formId) { AttributeValueService attributeValueService = new AttributeValueService(rockContext); PersonService personService = new PersonService(rockContext); PersonAliasService personAliasService = new PersonAliasService(rockContext); var formAttribute = attributeValueService.Queryable().FirstOrDefault(a => a.Value == formId); var person = personService.Queryable().FirstOrDefault(p => p.Id == formAttribute.EntityId); return person; }
/// <summary> /// Handles the Click event of the btnSend 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 btnSend_Click( object sender, EventArgs e ) { var url = LinkedPageUrl( "ConfirmationPage" ); if ( string.IsNullOrWhiteSpace( url ) ) { url = ResolveRockUrl( "~/ConfirmAccount" ); } var mergeObjects = GlobalAttributesCache.GetMergeFields( CurrentPerson ); mergeObjects.Add( "ConfirmAccountUrl", RootPath + url.TrimStart( new char[] { '/' } ) ); var results = new List<IDictionary<string, object>>(); var rockContext = new RockContext(); var personService = new PersonService( rockContext ); var userLoginService = new UserLoginService( rockContext ); foreach ( Person person in personService.GetByEmail( tbEmail.Text ) .Where( p => p.Users.Any())) { var users = new List<UserLogin>(); foreach ( UserLogin user in userLoginService.GetByPersonId( person.Id ) ) { if ( user.EntityType != null ) { var component = AuthenticationContainer.GetComponent( user.EntityType.Name ); if ( !component.RequiresRemoteAuthentication ) { users.Add( user ); } } } var resultsDictionary = new Dictionary<string, object>(); resultsDictionary.Add( "Person", person); resultsDictionary.Add( "Users", users ); results.Add( resultsDictionary ); } if ( results.Count > 0 ) { mergeObjects.Add( "Results", results.ToArray() ); var recipients = new List<RecipientData>(); recipients.Add( new RecipientData( tbEmail.Text, mergeObjects ) ); Email.Send( GetAttributeValue( "EmailTemplate" ).AsGuid(), recipients, ResolveRockUrlIncludeRoot( "~/" ), ResolveRockUrlIncludeRoot( "~~/" ) ); pnlEntry.Visible = false; pnlSuccess.Visible = true; } else { pnlWarning.Visible = true; } }
/// <summary> /// Handles the Delete event of the gBusinessList control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="Rock.Web.UI.Controls.RowEventArgs"/> instance containing the event data.</param> protected void gBusinessList_Delete( object sender, Rock.Web.UI.Controls.RowEventArgs e ) { var rockContext = new RockContext(); PersonService service = new PersonService( rockContext ); Person business = service.Get( e.RowKeyId ); if ( business != null ) { business.RecordStatusValueId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE ) ).Id; rockContext.SaveChanges(); } BindGrid(); }
/// <summary> /// Raises the <see cref="E:System.Web.UI.Control.Init" /> event. /// </summary> /// <param name="e">An <see cref="T:System.EventArgs" /> object that contains the event data.</param> protected override void OnInit( EventArgs e ) { base.OnInit( e ); try { var groupGuid = GetAttributeValue( "Group" ).AsGuidOrNull(); string personKey = PageParameter( "Person" ); if ( !groupGuid.HasValue ) { ShowConfigError( "The 'Group' configuration for this block has not been set." ); } else if ( string.IsNullOrWhiteSpace( personKey ) ) { ShowError( "Missing Parameter Value" ); } else { RockContext rockContext = new RockContext(); Person targetPerson = null; targetPerson = new PersonService( rockContext ).GetByUrlEncodedKey( personKey ); if ( targetPerson == null ) { ShowError( "We can't find a record in our system for you." ); } else { GroupService groupService = new GroupService( rockContext ); Group group = groupService.Get( groupGuid.Value ); if ( group == null ) { ShowConfigError( "The 'Group' configuration for this block is incorrect." ); } else { AddOrUpdatePersonInGroup( targetPerson, group, rockContext ); } } } } catch ( System.FormatException ) { ShowError( "Something is wrong with that link. Are you sure you copied it correctly?" ); } catch ( SystemException ex ) { ShowError( ex.Message ); } }
/// <summary> /// Executes the specified workflow. /// </summary> /// <param name="action">The workflow action.</param> /// <param name="entity">The entity.</param> /// <param name="errorMessages">The error messages.</param> /// <returns></returns> /// <exception cref="System.NotImplementedException"></exception> public override bool Execute( Model.WorkflowAction action, Object entity, out List<string> errorMessages ) { var checkInState = GetCheckInState( entity, out errorMessages ); if (checkInState != null) { using ( new Rock.Data.UnitOfWorkScope() ) { var personService = new PersonService(); var memberService = new GroupMemberService(); IQueryable<Person> people = null; if ( checkInState.CheckIn.SearchType.Guid.Equals( new Guid( SystemGuid.DefinedValue.CHECKIN_SEARCH_TYPE_PHONE_NUMBER ) ) ) { people = personService.GetByPhonePartial( checkInState.CheckIn.SearchValue ); } else if ( checkInState.CheckIn.SearchType.Guid.Equals( new Guid( SystemGuid.DefinedValue.CHECKIN_SEARCH_TYPE_NAME ) ) ) { people = personService.GetByFullName( checkInState.CheckIn.SearchValue ); } else { errorMessages.Add( "Invalid Search Type" ); return false; } foreach ( var person in people.ToList() ) { foreach ( var group in person.Members.Where( m => m.Group.GroupType.Guid == new Guid( SystemGuid.GroupType.GROUPTYPE_FAMILY ) ).Select( m => m.Group ).ToList() ) { var family = checkInState.CheckIn.Families.Where( f => f.Group.Id == group.Id ).FirstOrDefault(); if ( family == null ) { family = new CheckInFamily(); family.Group = group.Clone( false ); family.Group.LoadAttributes(); family.Caption = group.ToString(); family.SubCaption = memberService.GetFirstNames( group.Id ).ToList().AsDelimited( ", " ); checkInState.CheckIn.Families.Add( family ); } } } return true; } } errorMessages.Add( "Invalid Check-in State" ); return false; }
private void BindGrid() { var HtmlService = new HtmlContentService(); var content = HtmlService.GetContent(CurrentBlock.Id, EntityValue()); var personService = new Rock.Model.PersonService(); var versionAudits = new Dictionary <int, Rock.Model.Audit>(); var modifiedPersons = new Dictionary <int, string>(); foreach (var version in content) { var lastAudit = HtmlService.Audits(version) .Where(a => a.AuditType == Rock.Model.AuditType.Add || a.AuditType == Rock.Model.AuditType.Modify) .OrderByDescending(h => h.DateTime) .FirstOrDefault(); if (lastAudit != null) { versionAudits.Add(version.Id, lastAudit); } } foreach (var audit in versionAudits.Values) { if (audit.PersonId.HasValue && !modifiedPersons.ContainsKey(audit.PersonId.Value)) { var modifiedPerson = personService.Get(audit.PersonId.Value, true); modifiedPersons.Add(audit.PersonId.Value, modifiedPerson != null ? modifiedPerson.FullName : string.Empty); } } var versions = content. Select(v => new { v.Id, v.Version, v.Content, ModifiedDateTime = versionAudits.ContainsKey(v.Id) ? versionAudits[v.Id].DateTime.ToElapsedString() : string.Empty, ModifiedByPerson = versionAudits.ContainsKey(v.Id) && versionAudits[v.Id].PersonId.HasValue ? modifiedPersons[versionAudits[v.Id].PersonId.Value] : string.Empty, Approved = v.IsApproved, ApprovedByPerson = v.ApprovedByPerson != null ? v.ApprovedByPerson.FullName : "", v.StartDateTime, v.ExpireDateTime }).ToList(); rGrid.DataSource = versions; rGrid.DataBind(); }
/// <summary> /// Returns the field's current value(s) /// </summary> /// <param name="parentControl">The parent control.</param> /// <param name="value">Information about the value</param> /// <param name="configurationValues">The configuration values.</param> /// <param name="condensed">Flag indicating if the value should be condensed (i.e. for use in a grid column)</param> /// <returns></returns> public override string FormatValue( System.Web.UI.Control parentControl, string value, Dictionary<string, ConfigurationValue> configurationValues, bool condensed ) { string formattedValue = string.Empty; if ( !string.IsNullOrWhiteSpace( value ) ) { var service = new PersonService(); var person = service.Get( new Guid( value ) ); if ( person != null ) { formattedValue = person.FullName; } } return base.FormatValue( parentControl, formattedValue, null, condensed ); }
protected void btnUpdate_Click( object sender, EventArgs e ) { if ( Page.IsValid && person != null) { PersonService personService = new PersonService(); person.GivenName = txtFirstName.Text; person.NickName = txtNickName.Text; person.LastName = txtLastName.Text; if ( person.Guid == Guid.Empty ) personService.Add( person, CurrentPersonId ); personService.Save( person, CurrentPersonId ); } }
protected void Page_Load(object sender, EventArgs e) { //Set the person picker to the currently logged in person. PersonService personService = new PersonService(rockContext); var personObject = personService.Get(CurrentPerson.Guid); //Get the person from the URL string qsPersonId = PageParameter("PersonId"); int iPersonId = Int32.Parse(qsPersonId); var thePerson = personService.Get(iPersonId); //Get the URL encoded key from the person object var urlEncodedKey = thePerson.UrlEncodedKey; PageViewHistoryUrl = ResolveUrl("~/page/279?Person=" + urlEncodedKey); }
public void DeleteKnownRelationship( int personId, int relatedPersonId, int relationshipRoleId ) { SetProxyCreation( true ); var rockContext = this.Service.Context as RockContext; var personService = new PersonService( rockContext ); var person = personService.Get( personId ); var relatedPerson = personService.Get( relatedPersonId ); CheckCanEdit( person ); CheckCanEdit( relatedPerson ); System.Web.HttpContext.Current.Items.Add( "CurrentPerson", GetPerson() ); var groupMemberService = new GroupMemberService( rockContext ); groupMemberService.DeleteKnownRelationship( personId, relatedPersonId, relationshipRoleId ); }
protected void btnSubmit_OnClick(object sender, EventArgs e) { pnlOpportunities.Visible = true; pnlSignature.Visible = false; pnlSuccess.Visible = true; AttributeValueService attributeValueService = new AttributeValueService(rockContext); PersonService personService = new PersonService(rockContext); List<Guid> personGuidList = new List<Guid>(); personGuidList.Add(_targetPerson.Guid); var p = attributeValueService.GetByAttributeIdAndEntityId(906, _targetPerson.Id); var p2 = attributeValueService.GetByAttributeIdAndEntityId(1434, _targetPerson.Id); var personFromService = personService.GetByGuids(personGuidList).FirstOrDefault(); DateTime dateToSave = DateTime.Now.AddYears(CurrentYearAdd); p.Value = dateToSave.ToString(); if (p2.Value.IsNullOrWhiteSpace()) { p2.Value = dateToSave.Year.ToString(); } else { if (!p2.Value.Contains(dateToSave.Year.ToString())) { p2.Value = p2.Value + "," + dateToSave.Year.ToString(); } } personFromService.ConnectionStatusValue.Value = "Partner"; personFromService.ConnectionStatusValueId = 65; rockContext.SaveChanges(); LoadOpportunities(); if (GetAttributeValue("SendConfirmationEmail") == "True") { SendEmail(personFromService.Email, CurrentDateTime.Year.ToString() + " Partnership Covenant", rockContext); } }
protected void Page_Load( object sender, EventArgs e ) { person = CurrentPage.GetCurrentContext( "Rock.Model.Person" ) as Rock.Model.Person; if (person == null) { PersonService personService = new PersonService(); person = new Person(); personService.Add( person, CurrentPersonId ); } if ( !IsPostBack ) { txtFirstName.Text = person.FirstName; txtNickName.Text = person.NickName; txtLastName.Text = person.LastName; } }
/// <summary> /// Shows the detail. /// </summary> /// <param name="restUserId">The rest user identifier.</param> public void ShowDetail( int restUserId ) { var rockContext = new RockContext(); Person restUser = null; if ( !restUserId.Equals( 0 ) ) { restUser = new PersonService( rockContext ).Get( restUserId ); } if ( restUser == null ) { restUser = new Person { Id = 0 }; } bool editAllowed = restUser.IsAuthorized( Authorization.EDIT, CurrentPerson ); hfRestUserId.Value = restUser.Id.ToString(); lTitle.Text = ActionTitle.Edit( "REST Key" ).FormatAsHtmlTitle(); if ( restUser.Id > 0 ) { tbName.Text = restUser.LastName; cbActive.Checked = false; var activeStatusId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_ACTIVE.AsGuid() ).Id; if ( restUser.RecordStatusValueId == activeStatusId ) { cbActive.Checked = true; } var noteService = new NoteService( rockContext ); var description = noteService.Queryable().Where( a => a.EntityId == restUser.Id ).FirstOrDefault(); if ( description != null ) { tbDescription.Text = description.Text; } var userLoginService = new UserLoginService( rockContext ); var userLogin = userLoginService.Queryable().Where( a => a.PersonId == restUser.Id ).FirstOrDefault(); if ( userLogin != null ) { tbKey.Text = userLogin.ApiKey; } } }
public GroupOfTypeResult GetInGroupOfType(int personId, Guid groupTypeId) { GroupOfTypeResult result = new GroupOfTypeResult(); result.PersonId = personId; result.PersonInGroup = false; result.GroupList = new List<GroupSummary>(); // get person info Person person = new PersonService( (Rock.Data.RockContext)Service.Context ).Get( personId ); if (person != null) { result.NickName = person.NickName; result.LastName = person.LastName; } // get group type info GroupType groupType = new GroupTypeService( (Rock.Data.RockContext)Service.Context ).Get( groupTypeId ); if (groupType != null) { result.GroupTypeName = groupType.Name; result.GroupTypeIconCss = groupType.IconCssClass; result.GroupTypeId = groupType.Id; } // determine if person is in this type of group GroupMemberService groupMemberService = new GroupMemberService( (Rock.Data.RockContext)Service.Context ); IQueryable<GroupMember> groupMembershipsQuery = groupMemberService.Queryable("Person,GroupRole,Group") .Where(t => t.Group.GroupType.Guid == groupTypeId && t.PersonId == personId ) .OrderBy(g => g.GroupRole.Order); foreach (GroupMember member in groupMembershipsQuery) { result.PersonInGroup = true; GroupSummary group = new GroupSummary(); group.GroupName = member.Group.Name; group.GroupId = member.Group.Id; group.RoleName = member.GroupRole.Name; result.GroupList.Add(group); } return result; }
public System.Net.Http.HttpResponseMessage CreateKnownRelationship( int personId, int relatedPersonId, int relationshipRoleId ) { SetProxyCreation( true ); var rockContext = this.Service.Context as RockContext; var personService = new PersonService(rockContext); var person = personService.Get(personId); var relatedPerson = personService.Get(relatedPersonId); CheckCanEdit( person ); CheckCanEdit( relatedPerson ); System.Web.HttpContext.Current.Items.Add( "CurrentPerson", GetPerson() ); var groupMemberService = new GroupMemberService(rockContext); groupMemberService.CreateKnownRelationship( personId, relatedPersonId, relationshipRoleId ); return ControllerContext.Request.CreateResponse( HttpStatusCode.Created ); }
/// <summary> /// Raises the <see cref="E:System.Web.UI.Control.Init" /> event. /// </summary> /// <param name="e">An <see cref="T:System.EventArgs" /> object that contains the event data.</param> protected override void OnInit( EventArgs e ) { base.OnInit( e ); var mergeObjects = GlobalAttributesCache.GetMergeFields( CurrentPerson ); LoadDropdowns( mergeObjects ); var key = PageParameter( "Person" ); if ( !string.IsNullOrWhiteSpace( key ) ) { var service = new PersonService( new RockContext() ); _person = service.GetByUrlEncodedKey( key ); } if ( _person == null && CurrentPerson != null ) { _person = CurrentPerson; } if (_person != null) { nbMessage.NotificationBoxType = NotificationBoxType.Success; nbMessage.Text = GetAttributeValue( "SuccessText" ).ResolveMergeFields( mergeObjects ); } else { nbMessage.NotificationBoxType = NotificationBoxType.Danger; nbMessage.Text = "Unfortunately, we're unable to update your email preference, as we're not sure who you are."; nbMessage.Visible = true; btnSubmit.Visible = false; } string script = string.Format( @" $(""input[id^='{0}'"").click(function () {{ if ($(this).val() == '3') {{ $('#{1}').slideDown('fast'); }} else {{ $('#{1}').slideUp('fast'); }} }}); ", rblEmailPreference.ClientID, divNotInvolved.ClientID ); ScriptManager.RegisterStartupScript( rblEmailPreference, rblEmailPreference.GetType(), "toggle-preference" + this.BlockId.ToString(), script, true ); }
/// <summary> /// Handles the Delete event of the gRestKeyList 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 gRestKeyList_Delete( object sender, RowEventArgs e ) { var rockContext = new RockContext(); var personService = new PersonService( rockContext ); var userLoginService = new UserLoginService( rockContext ); var restUser = personService.Get( e.RowKeyId ); if ( restUser != null ) { restUser.RecordStatusValueId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE ) ).Id; // remove all user logins for key foreach ( var login in restUser.Users.ToList() ) { userLoginService.Delete( login ); } rockContext.SaveChanges(); } BindGrid(); }
/// <summary> /// Raises the <see cref="E:System.Web.UI.Control.Init" /> event. /// </summary> /// <param name="e">An <see cref="T:System.EventArgs" /> object that contains the event data.</param> protected override void OnInit( EventArgs e ) { base.OnInit( e ); ddlTitle.BindToDefinedType( DefinedTypeCache.Read( new Guid( Rock.SystemGuid.DefinedType.PERSON_TITLE ) ), true ); ddlSuffix.BindToDefinedType( DefinedTypeCache.Read( new Guid( Rock.SystemGuid.DefinedType.PERSON_SUFFIX ) ), true ); rblMaritalStatus.BindToDefinedType( DefinedTypeCache.Read( new Guid( Rock.SystemGuid.DefinedType.PERSON_MARITAL_STATUS ) ) ); rblStatus.BindToDefinedType( DefinedTypeCache.Read( new Guid( Rock.SystemGuid.DefinedType.PERSON_CONNECTION_STATUS ) ) ); ddlRecordStatus.BindToDefinedType( DefinedTypeCache.Read( new Guid( Rock.SystemGuid.DefinedType.PERSON_RECORD_STATUS ) ) ); ddlReason.BindToDefinedType( DefinedTypeCache.Read( new Guid( Rock.SystemGuid.DefinedType.PERSON_RECORD_STATUS_REASON ) ), true ); ddlGivingGroup.Items.Clear(); ddlGivingGroup.Items.Add( new ListItem( None.Text, None.IdValue ) ); if ( Person != null ) { var personService = new PersonService(); foreach ( var family in personService.GetFamilies( Person ) ) { ddlGivingGroup.Items.Add( new ListItem( family.Name, family.Id.ToString() ) ); } } }
/// <summary> /// Returns a list of each person and their GroupRequiremnt status for this group requirement /// </summary> /// <param name="rockContext">The rock context.</param> /// <param name="personQry">The person qry.</param> /// <param name="groupId">The group identifier.</param> /// <param name="groupRoleId">The group role identifier.</param> /// <returns></returns> /// <exception cref="System.Exception">No dataview assigned to Group Requirement Type: " + this.GroupRequirementType.Name</exception> public IEnumerable <PersonGroupRequirementStatus> PersonQueryableMeetsGroupRequirement(RockContext rockContext, IQueryable <Person> personQry, int groupId, int?groupRoleId) { if ((this.GroupRoleId != null) && (groupRoleId != null) && (this.GroupRoleId != groupRoleId)) { // if this GroupRequirement is for a specific role, the groupRole we are checking for is something different var result = personQry.ToList().Select(a => new PersonGroupRequirementStatus { PersonId = a.Id, GroupRequirement = this, MeetsGroupRequirement = MeetsGroupRequirement.NotApplicable }); return(result); } if (this.GroupRequirementType.RequirementCheckType == RequirementCheckType.Dataview) { if (this.GroupRequirementType.DataViewId.HasValue) { var errorMessages = new List <string>(); var personService = new PersonService(rockContext); var paramExpression = personService.ParameterExpression; var dataViewWhereExpression = this.GroupRequirementType.DataView.GetExpression(personService, paramExpression, out errorMessages); var dataViewQry = personService.Get(paramExpression, dataViewWhereExpression); IQueryable <Person> warningDataViewQry = null; if (this.GroupRequirementType.WarningDataViewId.HasValue) { var warningDataViewWhereExpression = this.GroupRequirementType.WarningDataView.GetExpression(personService, paramExpression, out errorMessages); warningDataViewQry = personService.Get(paramExpression, warningDataViewWhereExpression); } if (dataViewQry != null) { var personWithRequirements = from p in personQry join d in dataViewQry on p equals d into oj from d in oj.DefaultIfEmpty() select new { PersonId = p.Id, Included = d != null, WarningIncluded = false }; // if a Warning Database was specified, set the WarningIncluded flag to true if they are included in the Warning Dataview if (warningDataViewQry != null) { personWithRequirements = personWithRequirements.Select(a => new { a.PersonId, a.Included, WarningIncluded = warningDataViewQry.Any(w => w.Id == a.PersonId) }); } var result = personWithRequirements.ToList().Select(a => new PersonGroupRequirementStatus { PersonId = a.PersonId, GroupRequirement = this, MeetsGroupRequirement = a.Included ? (a.WarningIncluded ? MeetsGroupRequirement.MeetsWithWarning : MeetsGroupRequirement.Meets) : MeetsGroupRequirement.NotMet }); return(result); } } else { throw new Exception("No dataview assigned to Group Requirement Type: " + this.GroupRequirementType.Name); } } else if (this.GroupRequirementType.RequirementCheckType == RequirementCheckType.Sql) { // if requirement set on GroupType, this.Group is null var targetGroup = this.Group ?? new GroupService(rockContext).Get(groupId); string formattedSql = this.GroupRequirementType.SqlExpression.ResolveMergeFields(this.GroupRequirementType.GetMergeObjects(targetGroup)); string warningFormattedSql = this.GroupRequirementType.WarningSqlExpression.ResolveMergeFields(this.GroupRequirementType.GetMergeObjects(targetGroup)); try { var tableResult = DbService.GetDataTable(formattedSql, System.Data.CommandType.Text, null); if (tableResult.Columns.Count > 0) { IEnumerable <int> personIds = tableResult.Rows.OfType <System.Data.DataRow>().Select(r => Convert.ToInt32(r[0])); IEnumerable <int> warningPersonIds = null; // if a Warning SQL was specified, get a list of PersonIds that should have a warning with their status if (!string.IsNullOrWhiteSpace(warningFormattedSql)) { var warningTableResult = DbService.GetDataTable(warningFormattedSql, System.Data.CommandType.Text, null); if (warningTableResult.Columns.Count > 0) { warningPersonIds = warningTableResult.Rows.OfType <System.Data.DataRow>().Select(r => Convert.ToInt32(r[0])); } } var result = personQry.Select(a => a.Id).ToList().Select(a => new PersonGroupRequirementStatus { PersonId = a, GroupRequirement = this, MeetsGroupRequirement = personIds.Contains(a) ? ((warningPersonIds != null && warningPersonIds.Contains(a)) ? MeetsGroupRequirement.MeetsWithWarning : MeetsGroupRequirement.Meets ) : MeetsGroupRequirement.NotMet, }); return(result); } } catch (Exception ex) { // Exception occurred (probably due to bad SQL) ExceptionLogService.LogException(ex, System.Web.HttpContext.Current); var result = personQry.Select(a => a.Id).ToList().Select(a => new PersonGroupRequirementStatus { PersonId = a, GroupRequirement = this, MeetsGroupRequirement = MeetsGroupRequirement.Error }); return(result); } } else { // manual var groupMemberRequirementQry = new GroupMemberRequirementService(rockContext).Queryable().Where(a => a.GroupMember.GroupId == groupId && a.GroupRequirementId == this.Id && a.RequirementMetDateTime.HasValue); var result = personQry.ToList().Select(a => new PersonGroupRequirementStatus { PersonId = a.Id, GroupRequirement = this, MeetsGroupRequirement = groupMemberRequirementQry.Any(r => r.GroupMember.PersonId == a.Id) ? MeetsGroupRequirement.Meets : MeetsGroupRequirement.NotMet }); return(result); } // shouldn't happen return(null); }
/// <summary> /// Gets the existing value for a specific field for the given registrant. /// </summary> /// <param name="registrant">The registrant.</param> /// <param name="person">The person.</param> /// <param name="family">The family.</param> /// <param name="Field">The field.</param> /// <param name="rockContext">The rock context.</param> /// <returns></returns> public object GetRegistrantValue(RegistrationRegistrant registrant, Person person, Group family, RegistrationTemplateFormField Field, RockContext rockContext) { if (Field.FieldSource == RegistrationFieldSource.PersonField) { if (person != null) { DefinedValueCache dvPhone = null; switch (Field.PersonFieldType) { case RegistrationPersonFieldType.FirstName: return(person.NickName); case RegistrationPersonFieldType.LastName: return(person.LastName); case RegistrationPersonFieldType.Campus: { if (family != null) { return(family.CampusId); } break; } case RegistrationPersonFieldType.Address: { var location = person.GetHomeLocation(rockContext); if (location != null) { return(location.Clone()); } break; } case RegistrationPersonFieldType.Email: return(person.Email); case RegistrationPersonFieldType.Birthdate: return(person.BirthDate); case RegistrationPersonFieldType.Gender: return(person.Gender); case RegistrationPersonFieldType.MaritalStatus: return(person.MaritalStatusValueId); case RegistrationPersonFieldType.MobilePhone: { dvPhone = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_MOBILE); break; } case RegistrationPersonFieldType.HomePhone: { dvPhone = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME); break; } case RegistrationPersonFieldType.WorkPhone: { dvPhone = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_WORK); break; } } if (dvPhone != null) { var phoneNumber = new PersonService(rockContext).GetPhoneNumber(person, dvPhone); if (phoneNumber != null) { return(phoneNumber.Clone()); } } } } else { var attribute = AttributeCache.Read(Field.AttributeId ?? 0); if (attribute != null) { switch (Field.FieldSource) { case RegistrationFieldSource.PersonAttribute: { if (person != null) { if (person.Attributes == null) { person.LoadAttributes(); } return(person.GetAttributeValue(attribute.Key)); } break; } case RegistrationFieldSource.GroupMemberAttribute: { if (registrant.GroupMember != null) { if (registrant.GroupMember.Attributes == null) { registrant.GroupMember.LoadAttributes(); } return(registrant.GroupMember.GetAttributeValue(attribute.Key)); } break; } case RegistrationFieldSource.RegistrationAttribute: { if (registrant.Attributes == null) { registrant.LoadAttributes(); } return(registrant.GetAttributeValue(attribute.Key)); } } } } return(null); }
/// <summary> /// Sends the specified recipients. /// </summary> /// <param name="recipients">The recipients.</param> /// <param name="from">From.</param> /// <param name="fromName">From name.</param> /// <param name="subject">The subject.</param> /// <param name="body">The body.</param> /// <param name="appRoot">The application root.</param> /// <param name="themeRoot">The theme root.</param> /// <param name="attachments">Attachments.</param> /// <param name="createCommunicationHistory">if set to <c>true</c> [create communication history].</param> public void Send(List<string> recipients, string from, string fromName, string subject, string body, string appRoot, string themeRoot, List<Attachment> attachments, bool createCommunicationHistory ) { try { var globalAttributes = GlobalAttributesCache.Read(); if ( string.IsNullOrWhiteSpace( from ) ) { from = globalAttributes.GetValue( "OrganizationEmail" ); } if ( !string.IsNullOrWhiteSpace( from ) ) { // Resolve any possible merge fields in the from address var globalConfigValues = Rock.Web.Cache.GlobalAttributesCache.GetMergeFields( null ); string msgFrom = from.ResolveMergeFields( globalConfigValues ); string msgSubject = subject; string msgBody = body; if ( !string.IsNullOrWhiteSpace( themeRoot ) ) { msgSubject = msgSubject.Replace( "~~/", themeRoot ); msgBody = msgBody.Replace( "~~/", themeRoot ); } if ( !string.IsNullOrWhiteSpace( appRoot ) ) { msgSubject = msgSubject.Replace( "~/", appRoot ); msgBody = msgBody.Replace( "~/", appRoot ); msgBody = msgBody.Replace( @" src=""/", @" src=""" + appRoot ); msgBody = msgBody.Replace( @" href=""/", @" href=""" + appRoot ); } MailMessage message = new MailMessage(); // set from if ( !string.IsNullOrWhiteSpace( fromName ) ) { message.From = new MailAddress( msgFrom, fromName ); } else { message.From = new MailAddress( msgFrom ); } CheckSafeSender( message, globalAttributes ); message.IsBodyHtml = true; message.Priority = MailPriority.Normal; message.To.Clear(); recipients.ForEach( r => message.To.Add( r ) ); message.Subject = msgSubject; // strip out any unsubscribe links since we don't know the person msgBody = Regex.Replace( msgBody, @"\[\[\s*UnsubscribeOption\s*\]\]", string.Empty ); message.Body = msgBody; // add attachments if ( attachments != null ) { foreach ( var attachment in attachments ) { message.Attachments.Add(attachment); } } using ( var smtpClient = GetSmtpClient() ) { smtpClient.Send( message ); } if ( createCommunicationHistory ) { using ( var rockContext = new RockContext() ) { int? senderPersonAliasId = null; if ( createCommunicationHistory ) { var sender = new PersonService( rockContext ) .Queryable().AsNoTracking() .Where( p => p.Email == from ) .FirstOrDefault(); senderPersonAliasId = sender != null ? sender.PrimaryAliasId : (int?)null; } new CommunicationService( rockContext ).CreateEmailCommunication( recipients, fromName, from, from, subject, body, string.Empty, false, CommunicationRecipientStatus.Delivered, senderPersonAliasId ); rockContext.SaveChanges(); } } } } catch ( Exception ex ) { ExceptionLogService.LogException( ex, null ); } }
/// <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 ) { var rockContext = new RockContext(); rockContext.WrapTransaction( () => { var personService = new PersonService( rockContext ); var changes = new List<string>(); var person = personService.Get( CurrentPersonId ?? 0 ); if ( person != null ) { int? orphanedPhotoId = null; if ( person.PhotoId != imgPhoto.BinaryFileId ) { orphanedPhotoId = person.PhotoId; person.PhotoId = imgPhoto.BinaryFileId; if ( orphanedPhotoId.HasValue ) { if ( person.PhotoId.HasValue ) { changes.Add( "Modified the photo." ); } else { changes.Add( "Deleted the photo." ); } } else if ( person.PhotoId.HasValue ) { changes.Add( "Added a photo." ); } } int? newTitleId = ddlTitle.SelectedValueAsInt(); History.EvaluateChange( changes, "Title", DefinedValueCache.GetName( person.TitleValueId ), DefinedValueCache.GetName( newTitleId ) ); person.TitleValueId = newTitleId; History.EvaluateChange( changes, "First Name", person.FirstName, tbFirstName.Text ); person.FirstName = tbFirstName.Text; History.EvaluateChange(changes, "Nick Name", person.NickName, tbNickName.Text); person.NickName = tbNickName.Text; History.EvaluateChange( changes, "Last Name", person.LastName, tbLastName.Text ); person.LastName = tbLastName.Text; int? newSuffixId = ddlSuffix.SelectedValueAsInt(); History.EvaluateChange( changes, "Suffix", DefinedValueCache.GetName( person.SuffixValueId ), DefinedValueCache.GetName( newSuffixId ) ); person.SuffixValueId = newSuffixId; var birthMonth = person.BirthMonth; var birthDay = person.BirthDay; var birthYear = person.BirthYear; var birthday = bpBirthDay.SelectedDate; if ( birthday.HasValue ) { // If setting a future birthdate, subtract a century until birthdate is not greater than today. var today = RockDateTime.Today; while ( birthday.Value.CompareTo( today ) > 0 ) { birthday = birthday.Value.AddYears( -100 ); } 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 ); } History.EvaluateChange( changes, "Birth Month", birthMonth, person.BirthMonth ); History.EvaluateChange( changes, "Birth Day", birthDay, person.BirthDay ); History.EvaluateChange( changes, "Birth Year", birthYear, person.BirthYear ); var newGender = rblGender.SelectedValue.ConvertToEnum<Gender>(); History.EvaluateChange( changes, "Gender", person.Gender, newGender ); person.Gender = newGender; var phoneNumberTypeIds = new List<int>(); bool smsSelected = false; foreach ( RepeaterItem item in rContactInfo.Items ) { HiddenField hfPhoneType = item.FindControl( "hfPhoneType" ) as HiddenField; PhoneNumberBox pnbPhone = item.FindControl( "pnbPhone" ) as PhoneNumberBox; CheckBox cbUnlisted = item.FindControl( "cbUnlisted" ) as CheckBox; CheckBox cbSms = item.FindControl( "cbSms" ) as CheckBox; if ( hfPhoneType != null && pnbPhone != null && cbSms != null && cbUnlisted != null ) { if ( !string.IsNullOrWhiteSpace( PhoneNumber.CleanNumber( pnbPhone.Number ) ) ) { int phoneNumberTypeId; if ( int.TryParse( hfPhoneType.Value, out phoneNumberTypeId ) ) { var phoneNumber = person.PhoneNumbers.FirstOrDefault( n => n.NumberTypeValueId == phoneNumberTypeId ); string oldPhoneNumber = string.Empty; if ( phoneNumber == null ) { phoneNumber = new PhoneNumber { NumberTypeValueId = phoneNumberTypeId }; person.PhoneNumbers.Add( phoneNumber ); } else { oldPhoneNumber = phoneNumber.NumberFormattedWithCountryCode; } phoneNumber.CountryCode = PhoneNumber.CleanNumber( pnbPhone.CountryCode ); phoneNumber.Number = PhoneNumber.CleanNumber( pnbPhone.Number ); // Only allow one number to have SMS selected if ( smsSelected ) { phoneNumber.IsMessagingEnabled = false; } else { phoneNumber.IsMessagingEnabled = cbSms.Checked; smsSelected = cbSms.Checked; } phoneNumber.IsUnlisted = cbUnlisted.Checked; phoneNumberTypeIds.Add( phoneNumberTypeId ); History.EvaluateChange( changes, string.Format( "{0} Phone", DefinedValueCache.GetName( phoneNumberTypeId ) ), oldPhoneNumber, phoneNumber.NumberFormattedWithCountryCode ); } } } } // Remove any blank numbers var phoneNumberService = new PhoneNumberService( rockContext ); foreach ( var phoneNumber in person.PhoneNumbers .Where( n => n.NumberTypeValueId.HasValue && !phoneNumberTypeIds.Contains( n.NumberTypeValueId.Value ) ) .ToList() ) { History.EvaluateChange( changes, string.Format( "{0} Phone", DefinedValueCache.GetName( phoneNumber.NumberTypeValueId ) ), phoneNumber.ToString(), string.Empty ); person.PhoneNumbers.Remove( phoneNumber ); phoneNumberService.Delete( phoneNumber ); } History.EvaluateChange( changes, "Email", person.Email, tbEmail.Text ); person.Email = tbEmail.Text.Trim(); var newEmailPreference = rblEmailPreference.SelectedValue.ConvertToEnum<EmailPreference>(); History.EvaluateChange( changes, "Email Preference", person.EmailPreference, newEmailPreference ); person.EmailPreference = newEmailPreference; if ( person.IsValid ) { if ( rockContext.SaveChanges() > 0 ) { if ( changes.Any() ) { HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), person.Id, changes ); } if ( orphanedPhotoId.HasValue ) { BinaryFileService binaryFileService = new BinaryFileService( rockContext ); var binaryFile = binaryFileService.Get( orphanedPhotoId.Value ); if ( binaryFile != null ) { // marked the old images as IsTemporary so they will get cleaned up later binaryFile.IsTemporary = true; rockContext.SaveChanges(); } } // if they used the ImageEditor, and cropped it, the uncropped file is still in BinaryFile. So clean it up if ( imgPhoto.CropBinaryFileId.HasValue ) { if ( imgPhoto.CropBinaryFileId != person.PhotoId ) { BinaryFileService binaryFileService = new BinaryFileService( rockContext ); var binaryFile = binaryFileService.Get( imgPhoto.CropBinaryFileId.Value ); if ( binaryFile != null && binaryFile.IsTemporary ) { string errorMessage; if ( binaryFileService.CanDelete( binaryFile, out errorMessage ) ) { binaryFileService.Delete( binaryFile ); rockContext.SaveChanges(); } } } } } // save address if ( pnlAddress.Visible ) { Guid? familyGroupTypeGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuidOrNull(); if ( familyGroupTypeGuid.HasValue ) { var familyGroup = new GroupService( rockContext ).Queryable() .Where( f => f.GroupType.Guid == familyGroupTypeGuid.Value && f.Members.Any( m => m.PersonId == person.Id ) ) .FirstOrDefault(); if ( familyGroup != null ) { Guid? addressTypeGuid = GetAttributeValue("LocationType").AsGuidOrNull(); if ( addressTypeGuid.HasValue ) { var groupLocationService = new GroupLocationService( rockContext ); var dvHomeAddressType = DefinedValueCache.Read( addressTypeGuid.Value ); var familyAddress = groupLocationService.Queryable().Where( l => l.GroupId == familyGroup.Id && l.GroupLocationTypeValueId == dvHomeAddressType.Id ).FirstOrDefault(); if ( familyAddress != null && string.IsNullOrWhiteSpace( acAddress.Street1 ) ) { // delete the current address History.EvaluateChange( changes, familyAddress.GroupLocationTypeValue.Value + " Location", familyAddress.Location.ToString(), string.Empty ); groupLocationService.Delete( familyAddress ); rockContext.SaveChanges(); } else { if ( !string.IsNullOrWhiteSpace( acAddress.Street1 ) ) { if ( familyAddress == null ) { familyAddress = new GroupLocation(); groupLocationService.Add( familyAddress ); familyAddress.GroupLocationTypeValueId = dvHomeAddressType.Id; familyAddress.GroupId = familyGroup.Id; familyAddress.IsMailingLocation = true; familyAddress.IsMappedLocation = true; } else if ( hfStreet1.Value != string.Empty ) { // user clicked move so create a previous address var previousAddress = new GroupLocation(); groupLocationService.Add( previousAddress ); var previousAddressValue = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_PREVIOUS.AsGuid() ); if ( previousAddressValue != null ) { previousAddress.GroupLocationTypeValueId = previousAddressValue.Id; previousAddress.GroupId = familyGroup.Id; Location previousAddressLocation = new Location(); previousAddressLocation.Street1 = hfStreet1.Value; previousAddressLocation.Street2 = hfStreet2.Value; previousAddressLocation.City = hfCity.Value; previousAddressLocation.State = hfState.Value; previousAddressLocation.PostalCode = hfPostalCode.Value; previousAddressLocation.Country = hfCountry.Value; previousAddress.Location = previousAddressLocation; } } familyAddress.IsMailingLocation = cbIsMailingAddress.Checked; familyAddress.IsMappedLocation = cbIsPhysicalAddress.Checked; var updatedHomeAddress = new Location(); acAddress.GetValues( updatedHomeAddress ); History.EvaluateChange( changes, dvHomeAddressType.Value + " Location", familyAddress.Location != null ? familyAddress.Location.ToString() : string.Empty, updatedHomeAddress.ToString() ); familyAddress.Location = updatedHomeAddress; rockContext.SaveChanges(); } } HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), person.Id, changes ); } } } } NavigateToParentPage(); } } } ); }
/// <summary> /// Updates the last login and writes to the person's history log /// </summary> /// <param name="userName">Name of the user.</param> public static void UpdateLastLogin(string userName) { if (!string.IsNullOrWhiteSpace(userName)) { using (var rockContext = new RockContext()) { int? personId = null; bool impersonated = userName.StartsWith("rckipid="); if (!impersonated) { var userLogin = new UserLoginService(rockContext).GetByUserName(userName); if (userLogin != null) { userLogin.LastLoginDateTime = RockDateTime.Now; personId = userLogin.PersonId; } } else { var impersonationToken = userName.Substring(8); personId = new PersonService(rockContext).GetByImpersonationToken(impersonationToken, false, null)?.Id; } if (personId.HasValue) { var relatedDataBuilder = new System.Text.StringBuilder(); int?relatedEntityTypeId = null; int?relatedEntityId = null; if (impersonated) { var impersonatedByUser = HttpContext.Current?.Session["ImpersonatedByUser"] as UserLogin; relatedEntityTypeId = EntityTypeCache.GetId <Rock.Model.Person>(); relatedEntityId = impersonatedByUser?.PersonId; if (impersonatedByUser != null) { relatedDataBuilder.Append($" impersonated by { impersonatedByUser.Person.FullName }"); } } if (HttpContext.Current != null && HttpContext.Current.Request != null) { string cleanUrl = PersonToken.ObfuscateRockMagicToken(HttpContext.Current.Request.Url.AbsoluteUri); // obfuscate the url specified in the returnurl, just in case it contains any sensitive information (like a rckipid) Regex returnurlRegEx = new Regex(@"returnurl=([^&]*)"); cleanUrl = returnurlRegEx.Replace(cleanUrl, "returnurl=XXXXXXXXXXXXXXXXXXXXXXXXXXXX"); relatedDataBuilder.AppendFormat(" to <span class='field-value'>{0}</span>, from <span class='field-value'>{1}</span>", cleanUrl, HttpContext.Current.Request.UserHostAddress); } var historyChangeList = new History.HistoryChangeList(); var historyChange = historyChangeList.AddChange(History.HistoryVerb.Login, History.HistoryChangeType.Record, userName); if (relatedDataBuilder.Length > 0) { historyChange.SetRelatedData(relatedDataBuilder.ToString(), null, null); } HistoryService.SaveChanges(rockContext, typeof(Rock.Model.Person), Rock.SystemGuid.Category.HISTORY_PERSON_ACTIVITY.AsGuid(), personId.Value, historyChangeList, true); } } } }
/// <summary> /// Creates and stores a new PersonToken for a person using the specified ExpireDateTime, UsageLimit, and Page /// Returns the encrypted URLEncoded Token which can be used as a rckipid /// </summary> /// <param name="personAlias">The person alias.</param> /// <param name="expireDateTime">The expire date time.</param> /// <param name="usageLimit">The usage limit.</param> /// <param name="pageId">The page identifier.</param> /// <returns></returns> public static string CreateNew(PersonAlias personAlias, DateTime?expireDateTime, int?usageLimit, int?pageId) { if (personAlias == null) { return(null); } using (var rockContext = new RockContext()) { var person = personAlias.Person; if (person == null) { person = new PersonService(rockContext).Get(personAlias.PersonId); } if (person == null) { return(null); } // If a token is disallowed by security settings, return an error message. if (!person.IsPersonTokenUsageAllowed()) { return("TokenProhibited"); } var token = Rock.Security.Encryption.GenerateUniqueToken(); PersonToken personToken = new PersonToken(); personToken.PersonAliasId = personAlias.Id; personToken.Token = token; if (expireDateTime != null) { personToken.ExpireDateTime = expireDateTime; } else { int?tokenExpireMinutes = GlobalAttributesCache.Get().GetValue("core.PersonTokenExpireMinutes").AsIntegerOrNull(); if (tokenExpireMinutes.HasValue) { personToken.ExpireDateTime = RockDateTime.Now.AddMinutes(tokenExpireMinutes.Value); } else { personToken.ExpireDateTime = null; } } personToken.TimesUsed = 0; personToken.UsageLimit = usageLimit ?? GlobalAttributesCache.Get().GetValue("core.PersonTokenUsageLimit").AsIntegerOrNull(); personToken.PageId = pageId; var personTokenService = new PersonTokenService(rockContext); personTokenService.Add(personToken); rockContext.SaveChanges(true); var encryptedToken = Rock.Security.Encryption.EncryptString(token); // do a Replace('%', '!') after we UrlEncode it (to make it more safely embeddable in HTML and cross browser compatible) return(System.Web.HttpUtility.UrlEncode(encryptedToken).Replace('%', '!')); } }
/// <summary> /// Gets the chart data. /// </summary> /// <param name="groupBy">The group by.</param> /// <param name="graphBy">The graph by.</param> /// <param name="startDate">The start date.</param> /// <param name="endDate">The end date.</param> /// <param name="groupIds">The group ids.</param> /// <param name="campusIds">The campus ids. Include the keyword 'null' in the list to include CampusId is null</param> /// <param name="scheduleIds">The schedule ids.</param> /// <param name="dataViewId">The data view identifier.</param> /// <returns></returns> public IEnumerable <IChartData> GetChartData(ChartGroupBy groupBy = ChartGroupBy.Week, AttendanceGraphBy graphBy = AttendanceGraphBy.Total, DateTime?startDate = null, DateTime?endDate = null, string groupIds = null, string campusIds = null, int?dataViewId = null, string scheduleIds = null) { var qryAttendance = Queryable().AsNoTracking() .Where(a => a.DidAttend.HasValue && a.DidAttend.Value && a.PersonAlias != null); if (startDate.HasValue) { startDate = startDate.Value.Date; qryAttendance = qryAttendance.Where(a => a.Occurrence.OccurrenceDate >= startDate.Value); } if (endDate.HasValue) { qryAttendance = qryAttendance.Where(a => a.Occurrence.OccurrenceDate < endDate.Value); } if (dataViewId.HasValue) { var rockContext = (RockContext)this.Context; var dataView = new DataViewService(rockContext).Get(dataViewId.Value); if (dataView != null) { var personService = new PersonService(rockContext); var errorMessages = new List <string>(); var paramExpression = personService.ParameterExpression; var whereExpression = dataView.GetExpression(personService, paramExpression, out errorMessages); Rock.Web.UI.Controls.SortProperty sort = null; var dataViewPersonIdQry = personService .Queryable().AsNoTracking() .Where(paramExpression, whereExpression, sort) .Select(p => p.Id); qryAttendance = qryAttendance.Where(a => dataViewPersonIdQry.Contains(a.PersonAlias.PersonId)); } } if (!string.IsNullOrWhiteSpace(groupIds)) { var groupIdList = groupIds.Split(',').AsIntegerList(); qryAttendance = qryAttendance .Where(a => a.Occurrence.GroupId.HasValue && groupIdList.Contains(a.Occurrence.GroupId.Value)); } // If campuses were included, filter attendances by those that have selected campuses // if 'null' is one of the campuses, treat that as a 'CampusId is Null' var includeNullCampus = (campusIds ?? "").Split(',').ToList().Any(a => a.Equals("null", StringComparison.OrdinalIgnoreCase)); var campusIdList = (campusIds ?? "").Split(',').AsIntegerList(); // remove 0 from the list, just in case it is there campusIdList.Remove(0); if (campusIdList.Any()) { if (includeNullCampus) { // show records that have a campusId in the campusIdsList + records that have a null campusId qryAttendance = qryAttendance.Where(a => (a.CampusId.HasValue && campusIdList.Contains(a.CampusId.Value)) || !a.CampusId.HasValue); } else { // only show records that have a campusId in the campusIdList qryAttendance = qryAttendance.Where(a => a.CampusId.HasValue && campusIdList.Contains(a.CampusId.Value)); } } else if (includeNullCampus) { // 'null' was the only campusId in the campusIds parameter, so only show records that have a null CampusId qryAttendance = qryAttendance.Where(a => !a.CampusId.HasValue); } // If schedules were included, filter attendances by those that have selected schedules var scheduleIdList = (scheduleIds ?? "").Split(',').AsIntegerList(); scheduleIdList.Remove(0); if (scheduleIdList.Any()) { qryAttendance = qryAttendance.Where(a => a.Occurrence.ScheduleId.HasValue && scheduleIdList.Contains(a.Occurrence.ScheduleId.Value)); } var qryAttendanceWithSummaryDateTime = qryAttendance.GetAttendanceWithSummaryDateTime(groupBy); var summaryQry = qryAttendanceWithSummaryDateTime.Select(a => new { a.SummaryDateTime, Campus = new { Id = a.Attendance.CampusId, Name = a.Attendance.Campus.Name }, Group = new { Id = a.Attendance.Occurrence.GroupId, Name = a.Attendance.Occurrence.Group.Name }, Schedule = new { Id = a.Attendance.Occurrence.ScheduleId, Name = a.Attendance.Occurrence.Schedule.Name }, Location = new { Id = a.Attendance.Occurrence.LocationId, Name = a.Attendance.Occurrence.Location.Name } }); List <SummaryData> result = null; if (graphBy == AttendanceGraphBy.Total) { var groupByQry = summaryQry.GroupBy(a => new { a.SummaryDateTime }).Select(s => new { s.Key, Count = s.Count() }).OrderBy(o => o.Key); result = groupByQry.ToList().Select(a => new SummaryData { DateTimeStamp = a.Key.SummaryDateTime.ToJavascriptMilliseconds(), DateTime = a.Key.SummaryDateTime, SeriesName = "Total", YValue = a.Count }).ToList(); } else if (graphBy == AttendanceGraphBy.Campus) { var groupByQry = summaryQry.GroupBy(a => new { a.SummaryDateTime, Series = a.Campus }).Select(s => new { s.Key, Count = s.Count() }).OrderBy(o => o.Key); result = groupByQry.ToList().Select(a => new SummaryData { DateTimeStamp = a.Key.SummaryDateTime.ToJavascriptMilliseconds(), DateTime = a.Key.SummaryDateTime, SeriesName = a.Key.Series.Name, YValue = a.Count }).ToList(); } else if (graphBy == AttendanceGraphBy.Group) { var groupByQry = summaryQry.GroupBy(a => new { a.SummaryDateTime, Series = a.Group }).Select(s => new { s.Key, Count = s.Count() }).OrderBy(o => o.Key); result = groupByQry.ToList().Select(a => new SummaryData { DateTimeStamp = a.Key.SummaryDateTime.ToJavascriptMilliseconds(), DateTime = a.Key.SummaryDateTime, SeriesName = a.Key.Series.Name, YValue = a.Count }).ToList(); } else if (graphBy == AttendanceGraphBy.Schedule) { var groupByQry = summaryQry.GroupBy(a => new { a.SummaryDateTime, Series = a.Schedule }).Select(s => new { s.Key, Count = s.Count() }).OrderBy(o => o.Key); result = groupByQry.ToList().Select(a => new SummaryData { DateTimeStamp = a.Key.SummaryDateTime.ToJavascriptMilliseconds(), DateTime = a.Key.SummaryDateTime, SeriesName = a.Key.Series.Name, YValue = a.Count }).ToList(); } else if (graphBy == AttendanceGraphBy.Location) { var groupByQry = summaryQry.GroupBy(a => new { a.SummaryDateTime, Series = a.Location }).Select(s => new { s.Key, Count = s.Count() }).OrderBy(o => o.Key); result = groupByQry.ToList().Select(a => new SummaryData { DateTimeStamp = a.Key.SummaryDateTime.ToJavascriptMilliseconds(), DateTime = a.Key.SummaryDateTime, SeriesName = a.Key.Series.Name, YValue = a.Count }).ToList(); } return(result); }
/// <summary> /// Gets the group placement registrants. /// </summary> /// <param name="options">The options.</param> /// <param name="currentPerson">The current person.</param> /// <returns></returns> public List <GroupPlacementRegistrant> GetGroupPlacementRegistrants(GetGroupPlacementRegistrantsParameters options, Person currentPerson) { var rockContext = this.Context as RockContext; var registrationRegistrantService = new RegistrationRegistrantService(rockContext); var registrationRegistrantQuery = registrationRegistrantService.Queryable(); registrationRegistrantQuery = registrationRegistrantQuery .Where(a => a.Registration.RegistrationInstance.RegistrationTemplateId == options.RegistrationTemplateId); if (options.RegistrationInstanceId.HasValue) { registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.Registration.RegistrationInstanceId == options.RegistrationInstanceId.Value); } else if (options.RegistrationTemplateInstanceIds?.Any() == true) { registrationRegistrantQuery = registrationRegistrantQuery.Where(a => options.RegistrationTemplateInstanceIds.Contains(a.Registration.RegistrationInstanceId)); } if (options.RegistrantPersonDataViewFilterId.HasValue) { var dataFilter = new DataViewFilterService(rockContext).Get(options.RegistrantPersonDataViewFilterId.Value); var personService = new PersonService(rockContext); var paramExpression = personService.ParameterExpression; var personWhereExpression = dataFilter?.GetExpression(typeof(Person), personService, paramExpression); if (personWhereExpression != null) { var personIdQry = personService.Queryable().Where(paramExpression, personWhereExpression, null).Select(x => x.Id); registrationRegistrantQuery = registrationRegistrantQuery.Where(a => personIdQry.Contains(a.PersonAlias.PersonId)); } } if (options.RegistrantId.HasValue) { registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.Id == options.RegistrantId.Value); } Block registrationInstanceGroupPlacementBlock = new BlockService(rockContext).Get(options.BlockId); if (registrationInstanceGroupPlacementBlock != null && currentPerson != null) { const string RegistrantAttributeFilter_RegistrationInstanceId = "RegistrantAttributeFilter_RegistrationInstanceId_{0}"; const string RegistrantAttributeFilter_RegistrationTemplateId = "RegistrantAttributeFilter_RegistrationTemplateId_{0}"; string userPreferenceKey; if (options.RegistrationInstanceId.HasValue) { userPreferenceKey = PersonService.GetBlockUserPreferenceKeyPrefix(options.BlockId) + string.Format(RegistrantAttributeFilter_RegistrationInstanceId, options.RegistrationInstanceId); } else { userPreferenceKey = PersonService.GetBlockUserPreferenceKeyPrefix(options.BlockId) + string.Format(RegistrantAttributeFilter_RegistrationTemplateId, options.RegistrationTemplateId); } var attributeFilters = PersonService.GetUserPreference(currentPerson, userPreferenceKey).FromJsonOrNull <Dictionary <int, string> >() ?? new Dictionary <int, string>(); var parameterExpression = registrationRegistrantService.ParameterExpression; Expression registrantWhereExpression = null; foreach (var attributeFilter in attributeFilters) { var attribute = AttributeCache.Get(attributeFilter.Key); var attributeFilterValues = attributeFilter.Value.FromJsonOrNull <List <string> >(); var entityField = EntityHelper.GetEntityFieldForAttribute(attribute); if (entityField != null && attributeFilterValues != null) { var attributeWhereExpression = ExpressionHelper.GetAttributeExpression(registrationRegistrantService, parameterExpression, entityField, attributeFilterValues); if (registrantWhereExpression == null) { registrantWhereExpression = attributeWhereExpression; } else { registrantWhereExpression = Expression.AndAlso(registrantWhereExpression, attributeWhereExpression); } } } if (registrantWhereExpression != null) { registrationRegistrantQuery = registrationRegistrantQuery.Where(parameterExpression, registrantWhereExpression); } } var registrationTemplatePlacement = new RegistrationTemplatePlacementService(rockContext).Get(options.RegistrationTemplatePlacementId); if (options.FilterFeeId.HasValue) { registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.Fees.Any(f => f.RegistrationTemplateFeeId == options.FilterFeeId.Value)); } if (options.FilterFeeOptionIds?.Any() == true) { registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.Fees.Any(f => f.RegistrationTemplateFeeItemId.HasValue && options.FilterFeeOptionIds.Contains(f.RegistrationTemplateFeeItemId.Value))); } // don't include registrants that are on the waiting list registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.OnWaitList == false); registrationRegistrantQuery = registrationRegistrantQuery.OrderBy(a => a.PersonAlias.Person.LastName).ThenBy(a => a.PersonAlias.Person.NickName); var registrationTemplatePlacementService = new RegistrationTemplatePlacementService(rockContext); var registrationInstanceService = new RegistrationInstanceService(rockContext); // get a queryable of PersonIds for the registration template shared groups so we can determine if the registrant has been placed var registrationTemplatePlacementGroupsPersonIdQuery = registrationTemplatePlacementService.GetRegistrationTemplatePlacementPlacementGroups(registrationTemplatePlacement).SelectMany(a => a.Members).Select(a => a.PersonId); // and also get a queryable of PersonIds for the registration instance placement groups so we can determine if the registrant has been placed IQueryable <InstancePlacementGroupPersonId> allInstancesPlacementGroupInfoQuery = null; if (!options.RegistrationInstanceId.HasValue && (options.RegistrationTemplateInstanceIds == null || !options.RegistrationTemplateInstanceIds.Any())) { // if neither RegistrationInstanceId or RegistrationTemplateInstanceIds was specified, use all of the RegistrationTemplates instances options.RegistrationTemplateInstanceIds = new RegistrationTemplateService(rockContext).GetSelect(options.RegistrationTemplateId, s => s.Instances.Select(i => i.Id)).ToArray(); } if (options.RegistrationInstanceId.HasValue) { allInstancesPlacementGroupInfoQuery = registrationInstanceService.GetRegistrationInstancePlacementGroups(registrationInstanceService.Get(options.RegistrationInstanceId.Value)) .Where(a => a.GroupTypeId == registrationTemplatePlacement.GroupTypeId) .SelectMany(a => a.Members).Select(a => a.PersonId) .Select(s => new InstancePlacementGroupPersonId { PersonId = s, RegistrationInstanceId = options.RegistrationInstanceId.Value }); } else if (options.RegistrationTemplateInstanceIds?.Any() == true) { foreach (var registrationInstanceId in options.RegistrationTemplateInstanceIds) { var instancePlacementGroupInfoQuery = registrationInstanceService.GetRegistrationInstancePlacementGroups(registrationInstanceService.Get(registrationInstanceId)) .Where(a => a.GroupTypeId == registrationTemplatePlacement.GroupTypeId) .SelectMany(a => a.Members).Select(a => a.PersonId) .Select(s => new InstancePlacementGroupPersonId { PersonId = s, RegistrationInstanceId = registrationInstanceId }); if (allInstancesPlacementGroupInfoQuery == null) { allInstancesPlacementGroupInfoQuery = instancePlacementGroupInfoQuery; } else { allInstancesPlacementGroupInfoQuery = allInstancesPlacementGroupInfoQuery.Union(instancePlacementGroupInfoQuery); } } } if (allInstancesPlacementGroupInfoQuery == null) { throw new ArgumentNullException("Registration Instance(s) must be specified"); } // select in a way to avoid lazy loading var registrationRegistrantPlacementQuery = registrationRegistrantQuery.Select(r => new { Registrant = r, r.PersonAlias.Person, r.Registration.RegistrationInstance, // marked as AlreadyPlacedInGroup if the Registrant is a member of any of the registrant template placement group or the registration instance placement groups AlreadyPlacedInGroup = registrationTemplatePlacementGroupsPersonIdQuery.Contains(r.PersonAlias.PersonId) || allInstancesPlacementGroupInfoQuery.Any(x => x.RegistrationInstanceId == r.Registration.RegistrationInstanceId && x.PersonId == r.PersonAlias.PersonId) }); var registrationRegistrantPlacementList = registrationRegistrantPlacementQuery.AsNoTracking().ToList(); var groupPlacementRegistrantList = registrationRegistrantPlacementList .Select(x => new GroupPlacementRegistrant(x.Registrant, x.Person, x.AlreadyPlacedInGroup, x.RegistrationInstance, options)) .ToList(); return(groupPlacementRegistrantList.ToList()); }
public static Group SaveNewFamily(RockContext rockContext, Person person, int?campusId, bool savePersonAttributes) { return(PersonService.SaveNewPerson(person, rockContext, campusId, savePersonAttributes)); }
/// <summary> /// Saves the new family. /// </summary> /// <param name="rockContext">The rock context.</param> /// <param name="familyMembers">The family members.</param> /// <param name="campusId">The campus identifier.</param> /// <param name="savePersonAttributes">if set to <c>true</c> [save person attributes].</param> /// <returns></returns> public static Group SaveNewFamily(RockContext rockContext, List <GroupMember> familyMembers, int?campusId, bool savePersonAttributes) { var familyGroupType = GroupTypeCache.GetFamilyGroupType(); var familyChanges = new List <string>(); var familyMemberChanges = new Dictionary <Guid, List <string> >(); var familyDemographicChanges = new Dictionary <Guid, List <string> >(); if (familyGroupType != null) { var groupService = new GroupService(rockContext); var familyGroup = new Group(); familyGroup.GroupTypeId = familyGroupType.Id; familyGroup.Name = familyMembers.FirstOrDefault().Person.LastName + " Family"; History.EvaluateChange(familyChanges, "Family", string.Empty, familyGroup.Name); if (campusId.HasValue) { History.EvaluateChange(familyChanges, "Campus", string.Empty, CampusCache.Read(campusId.Value).Name); } familyGroup.CampusId = campusId; int?childRoleId = null; var childRole = new GroupTypeRoleService(rockContext).Get(new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD)); if (childRole != null) { childRoleId = childRole.Id; } foreach (var familyMember in familyMembers) { var person = familyMember.Person; if (person != null) { familyGroup.Members.Add(familyMember); var demographicChanges = new List <string>(); demographicChanges.Add("Created"); History.EvaluateChange(demographicChanges, "Record Type", string.Empty, person.RecordTypeValueId.HasValue ? DefinedValueCache.GetName(person.RecordTypeValueId.Value) : string.Empty); History.EvaluateChange(demographicChanges, "Record Status", string.Empty, person.RecordStatusValueId.HasValue ? DefinedValueCache.GetName(person.RecordStatusValueId.Value) : string.Empty); History.EvaluateChange(demographicChanges, "Record Status Reason", string.Empty, person.RecordStatusReasonValueId.HasValue ? DefinedValueCache.GetName(person.RecordStatusReasonValueId.Value) : string.Empty); History.EvaluateChange(demographicChanges, "Connection Status", string.Empty, person.ConnectionStatusValueId.HasValue ? DefinedValueCache.GetName(person.ConnectionStatusValueId) : string.Empty); History.EvaluateChange(demographicChanges, "Deceased", false.ToString(), (person.IsDeceased).ToString()); History.EvaluateChange(demographicChanges, "Title", string.Empty, person.TitleValueId.HasValue ? DefinedValueCache.GetName(person.TitleValueId) : string.Empty); History.EvaluateChange(demographicChanges, "First Name", string.Empty, person.FirstName); History.EvaluateChange(demographicChanges, "Nick Name", string.Empty, person.NickName); History.EvaluateChange(demographicChanges, "Middle Name", string.Empty, person.MiddleName); History.EvaluateChange(demographicChanges, "Last Name", string.Empty, person.LastName); History.EvaluateChange(demographicChanges, "Suffix", string.Empty, person.SuffixValueId.HasValue ? DefinedValueCache.GetName(person.SuffixValueId) : string.Empty); History.EvaluateChange(demographicChanges, "Birth Date", null, person.BirthDate); History.EvaluateChange(demographicChanges, "Gender", null, person.Gender); History.EvaluateChange(demographicChanges, "Marital Status", string.Empty, person.MaritalStatusValueId.HasValue ? DefinedValueCache.GetName(person.MaritalStatusValueId) : string.Empty); History.EvaluateChange(demographicChanges, "Anniversary Date", null, person.AnniversaryDate); History.EvaluateChange(demographicChanges, "Graduation Year", null, person.GraduationYear); History.EvaluateChange(demographicChanges, "Email", string.Empty, person.Email); History.EvaluateChange(demographicChanges, "Email Active", false.ToString(), person.IsEmailActive.ToString()); History.EvaluateChange(demographicChanges, "Email Note", string.Empty, person.EmailNote); History.EvaluateChange(demographicChanges, "Email Preference", null, person.EmailPreference); History.EvaluateChange(demographicChanges, "Inactive Reason Note", string.Empty, person.InactiveReasonNote); History.EvaluateChange(demographicChanges, "System Note", string.Empty, person.SystemNote); familyDemographicChanges.Add(person.Guid, demographicChanges); var memberChanges = new List <string>(); string roleName = familyGroupType.Roles .Where(r => r.Id == familyMember.GroupRoleId) .Select(r => r.Name) .FirstOrDefault(); History.EvaluateChange(memberChanges, "Role", string.Empty, roleName); familyMemberChanges.Add(person.Guid, memberChanges); } } groupService.Add(familyGroup); rockContext.SaveChanges(); var personService = new PersonService(rockContext); foreach (var groupMember in familyMembers) { var person = groupMember.Person; if (savePersonAttributes) { var newValues = person.AttributeValues; person.LoadAttributes(); foreach (var attributeCache in person.Attributes.Select(a => a.Value)) { string oldValue = person.GetAttributeValue(attributeCache.Key) ?? string.Empty; string newValue = string.Empty; if (newValues != null && newValues.ContainsKey(attributeCache.Key) && newValues[attributeCache.Key] != null) { newValue = newValues[attributeCache.Key].Value ?? string.Empty; } if (!oldValue.Equals(newValue)) { History.EvaluateChange(familyDemographicChanges[person.Guid], attributeCache.Name, attributeCache.FieldType.Field.FormatValue(null, oldValue, attributeCache.QualifierValues, false), attributeCache.FieldType.Field.FormatValue(null, newValue, attributeCache.QualifierValues, false)); Rock.Attribute.Helper.SaveAttributeValue(person, attributeCache, newValue); } } } person = personService.Get(groupMember.PersonId); if (person != null) { bool updateRequired = false; var changes = familyDemographicChanges[person.Guid]; if (groupMember.GroupRoleId != childRoleId) { person.GivingGroupId = familyGroup.Id; updateRequired = true; History.EvaluateChange(changes, "Giving Group", string.Empty, familyGroup.Name); } if (updateRequired) { rockContext.SaveChanges(); } HistoryService.SaveChanges(rockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), person.Id, changes); HistoryService.SaveChanges(rockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(), person.Id, familyMemberChanges[person.Guid], familyGroup.Name, typeof(Group), familyGroup.Id); HistoryService.SaveChanges(rockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(), person.Id, familyChanges, familyGroup.Name, typeof(Group), familyGroup.Id); } } return(familyGroup); } return(null); }
/// <summary> /// Gets financial transaction details based on selected filter values. /// </summary> /// <param name="start">The start.</param> /// <param name="end">The end.</param> /// <param name="minAmount">The minimum amount.</param> /// <param name="maxAmount">The maximum amount.</param> /// <param name="currencyTypeIds">The currency type ids.</param> /// <param name="sourceTypeIds">The source type ids.</param> /// <param name="accountIds">The account ids.</param> /// <param name="dataViewId">The data view identifier.</param> /// <returns></returns> public IQueryable <FinancialTransactionDetail> GetGifts( DateTime?start, DateTime?end, decimal?minAmount, decimal?maxAmount, List <int> currencyTypeIds, List <int> sourceTypeIds, List <int> accountIds, int?dataViewId) { // Base Transaction Detail query var qry = GetGifts(); // Start Date Filter if (start.HasValue) { qry = qry.Where(t => t.Transaction.TransactionDateTime >= start.Value); } // End Date Filter if (end.HasValue) { qry = qry.Where(t => t.Transaction.TransactionDateTime < end.Value); } // Account Id Filter var distictAccountIds = accountIds.Where(i => i != 0).Distinct().ToList(); if (distictAccountIds.Any()) { qry = qry .Where(t => distictAccountIds.Contains(t.AccountId)); } // Currency Type Filter var distictCurrencyTypeIds = currencyTypeIds.Where(i => i != 0).Distinct().ToList(); if (distictCurrencyTypeIds.Any()) { qry = qry .Where(t => t.Transaction.FinancialPaymentDetail != null && t.Transaction.FinancialPaymentDetail.CurrencyTypeValueId.HasValue && distictCurrencyTypeIds.Contains(t.Transaction.FinancialPaymentDetail.CurrencyTypeValueId.Value)); } // Source Type Filter var distictSourceTypeIds = sourceTypeIds.Where(i => i != 0).Distinct().ToList(); if (distictSourceTypeIds.Any()) { qry = qry .Where(t => t.Transaction.SourceTypeValueId.HasValue && distictSourceTypeIds.Contains(t.Transaction.SourceTypeValueId.Value)); } // Amount Range Filter if (minAmount.HasValue || maxAmount.HasValue) { var givingIdQry = qry .GroupBy(d => d.Transaction.AuthorizedPersonAlias.Person.GivingId) .Select(d => new { d.Key, Total = d.Sum(t => t.Amount) }) .Where(s => (!minAmount.HasValue || s.Total >= minAmount.Value) && (!maxAmount.HasValue || s.Total <= maxAmount.Value)) .Select(s => s.Key); // put all the givingIds into a List instead of a subquery to prevent a timeout issue var givingIdList = givingIdQry.ToList(); qry = qry .Where(d => givingIdList.Contains(d.Transaction.AuthorizedPersonAlias.Person.GivingId)); } // Data View Filter if (dataViewId.HasValue) { var rockContext = (RockContext)this.Context; if (rockContext != null) { var personService = new PersonService(rockContext); var dataView = new DataViewService(rockContext).Get(dataViewId.Value); if (dataView != null) { var errorMessages = new List <string>(); ParameterExpression paramExpression = personService.ParameterExpression; Expression whereExpression = dataView.GetExpression(personService, paramExpression, out errorMessages); SortProperty sortProperty = null; var dataViewGivingIdQry = personService .Queryable().AsNoTracking() .Where(paramExpression, whereExpression, sortProperty) .Select(p => p.GivingId); qry = qry .Where(t => dataViewGivingIdQry.Contains(t.Transaction.AuthorizedPersonAlias.Person.GivingId)); } } } return(qry); }