/// <summary>
/// Returns Global Attributes from cache. If they are not already in cache, they
/// will be read and added to cache
/// </summary>
/// <returns></returns>
public static GlobalAttributesCache Read()
{
string cacheKey = GlobalAttributesCache.CacheKey();
ObjectCache cache = MemoryCache.Default;
GlobalAttributesCache globalAttributes = cache[cacheKey] as GlobalAttributesCache;
if (globalAttributes != null)
{
return(globalAttributes);
}
else
{
globalAttributes = new GlobalAttributesCache();
globalAttributes.Attributes = new List <AttributeCache>();
globalAttributes.AttributeValues = new Dictionary <string, KeyValuePair <string, string> >();
var attributeService = new Rock.Model.AttributeService();
var attributeValueService = new Rock.Model.AttributeValueService();
foreach (Rock.Model.Attribute attribute in attributeService.GetGlobalAttributes())
{
var attributeCache = AttributeCache.Read(attribute);
globalAttributes.Attributes.Add(attributeCache);
var attributeValue = attributeValueService.GetByAttributeIdAndEntityId(attribute.Id, null).FirstOrDefault();
string value = (attributeValue != null && !string.IsNullOrEmpty(attributeValue.Value)) ? attributeValue.Value : attributeCache.DefaultValue;
globalAttributes.AttributeValues.Add(attributeCache.Key, new KeyValuePair <string, string>(attributeCache.Name, value));
}
cache.Set(cacheKey, globalAttributes, new CacheItemPolicy());
return(globalAttributes);
}
}
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>
/// Adds the missing synced content channel items for all <see cref="MediaElement"/>
/// items in the folder.
/// </summary>
/// <param name="mediaFolderId">The media folder identifier.</param>
public static void AddMissingSyncedContentChannelItems(int mediaFolderId)
{
List <int> mediaElementIds;
using (var rockContext = new RockContext())
{
var mediaFolder = new MediaFolderService(rockContext).Get(mediaFolderId);
// If the folder wasn't found or syncing isn't enabled then exit early.
if (mediaFolder == null || !mediaFolder.IsContentChannelSyncEnabled)
{
return;
}
var contentChannelId = mediaFolder.ContentChannelId;
var attributeId = mediaFolder.ContentChannelAttributeId;
// If we don't have required information then exit early.
if (!contentChannelId.HasValue || !attributeId.HasValue)
{
return;
}
// Build a query of all attribute values for the given attribute
// that are not null or empty.
var attributeValueQuery = new AttributeValueService(rockContext).Queryable()
.Where(a => a.AttributeId == attributeId.Value && !string.IsNullOrEmpty(a.Value));
// Build a query of all content channel items for the channel.
var contentChannelItemQuery = new ContentChannelItemService(rockContext).Queryable()
.Where(i => i.ContentChannelId == contentChannelId.Value);
// Join the two so we end up just content channel items that
// have a non-null and non-empty attribute value. Finally
// select just the value so we get a list of MediaElement Guid
// values that have already been synced.
var syncedMediaElementValues = contentChannelItemQuery.Join(attributeValueQuery, i => i.Id, v => v.EntityId, (i, v) => v.Value);
// Our final query is to get all MediaElements that do not
// exist in the previous query. That gives us a final list
// of items that need to be synced still.
mediaElementIds = new MediaElementService(rockContext).Queryable()
.Where(e => e.MediaFolderId == mediaFolderId &&
!syncedMediaElementValues.Contains(e.Guid.ToString()))
.Select(e => e.Id)
.ToList();
}
// Add the content channel item for each media element.
foreach (var mediaElementId in mediaElementIds)
{
MediaElementService.AddSyncedContentChannelItem(mediaElementId);
}
}
/// <summary>
/// This method takes the attribute values of the original blocks, and creates copies of them that point to the copied blocks.
/// In addition, any block attribute value pointing to a page in the original page tree is now updated to point to the
/// corresponding page in the copied page tree.
/// </summary>
/// <param name="pageGuidDictionary">The dictionary containing the original page guids and the corresponding copied page guids.</param>
/// <param name="blockGuidDictionary">The dictionary containing the original block guids and the corresponding copied block guids.</param>
/// <param name="rockContext">The rock context.</param>
/// <param name="currentPersonAliasId">The current person alias identifier.</param>
private void GenerateBlockAttributeValues(Dictionary <Guid, Guid> pageGuidDictionary, Dictionary <Guid, Guid> blockGuidDictionary, RockContext rockContext, int?currentPersonAliasId = null)
{
var attributeValueService = new AttributeValueService(rockContext);
var pageService = new PageService(rockContext);
var blockService = new BlockService(rockContext);
var pageGuid = Rock.SystemGuid.EntityType.PAGE.AsGuid();
var blockGuid = Rock.SystemGuid.EntityType.BLOCK.AsGuid();
Dictionary <Guid, int> blockIntDictionary = blockService.Queryable()
.Where(p => blockGuidDictionary.Keys.Contains(p.Guid) || blockGuidDictionary.Values.Contains(p.Guid))
.ToDictionary(p => p.Guid, p => p.Id);
var attributeValues = attributeValueService.Queryable().Where(a =>
a.Attribute.EntityType.Guid == blockGuid && blockIntDictionary.Values.Contains(a.EntityId.Value))
.ToList();
foreach (var attributeValue in attributeValues)
{
var attribute = AttributeCache.Get(attributeValue.AttributeId);
var fieldType = attribute?.FieldType.Field as Field.FieldType;
var currentValue = attributeValue;
var newAttributeValue = attributeValue.Clone(false);
newAttributeValue.CreatedByPersonAlias = null;
newAttributeValue.CreatedByPersonAliasId = currentPersonAliasId;
newAttributeValue.CreatedDateTime = RockDateTime.Now;
newAttributeValue.ModifiedByPersonAlias = null;
newAttributeValue.ModifiedByPersonAliasId = currentPersonAliasId;
newAttributeValue.ModifiedDateTime = RockDateTime.Now;
newAttributeValue.Id = 0;
newAttributeValue.Guid = Guid.NewGuid();
newAttributeValue.EntityId = blockIntDictionary[blockGuidDictionary[blockIntDictionary.Where(d => d.Value == attributeValue.EntityId.Value).FirstOrDefault().Key]];
if (fieldType != null && currentValue != null && currentValue.Value != null)
{
newAttributeValue.Value = fieldType.GetCopyValue(currentValue.Value, rockContext);
}
if (attributeValue.Attribute.FieldType.Guid == Rock.SystemGuid.FieldType.PAGE_REFERENCE.AsGuid())
{
if (pageGuidDictionary.ContainsKey(attributeValue.Value.AsGuid()))
{
newAttributeValue.Value = pageGuidDictionary[attributeValue.Value.AsGuid()].ToString();
}
}
attributeValueService.Add(newAttributeValue);
}
rockContext.SaveChanges();
}
/// <summary>
/// Gets the root matrix attribute value that ties the matrix values to a person or other entity.
/// </summary>
/// <returns></returns>
private AttributeValue GetRootMatrixAttributeValue()
{
var rockContext = new RockContext();
var attributeMatrixService = new AttributeMatrixService(rockContext);
var attributeValueService = new AttributeValueService(rockContext);
var matrixGuidQuery = attributeMatrixService.Queryable().AsNoTracking().Where(am =>
am.AttributeMatrixItems.Any(ami => ami.Id == EntityId)
).Select(am => am.Guid.ToString());
var attributeValue = attributeValueService.Queryable().AsNoTracking().FirstOrDefault(av =>
matrixGuidQuery.Contains(av.Value)
);
return(attributeValue);
}
/// <summary>
/// Maps the activity ministry.
/// </summary>
/// <param name="tableData">The table data.</param>
/// <returns></returns>
private void MapActivityMinistry( IQueryable<Row> tableData )
{
int groupEntityTypeId = EntityTypeCache.Read( "Rock.Model.Group" ).Id;
var attributeService = new AttributeService();
// Add an Attribute for the unique F1 Ministry Id
var ministryAttributeId = attributeService.Queryable().Where( a => a.EntityTypeId == groupEntityTypeId
&& a.Key == "F1MinistryId" ).Select( a => a.Id ).FirstOrDefault();
if ( ministryAttributeId == 0 )
{
var newMinistryAttribute = new Rock.Model.Attribute();
newMinistryAttribute.Key = "F1MinistryId";
newMinistryAttribute.Name = "F1 Ministry Id";
newMinistryAttribute.FieldTypeId = IntegerFieldTypeId;
newMinistryAttribute.EntityTypeId = groupEntityTypeId;
newMinistryAttribute.EntityTypeQualifierValue = string.Empty;
newMinistryAttribute.EntityTypeQualifierColumn = string.Empty;
newMinistryAttribute.Description = "The FellowshipOne identifier for the ministry that was imported";
newMinistryAttribute.DefaultValue = string.Empty;
newMinistryAttribute.IsMultiValue = false;
newMinistryAttribute.IsRequired = false;
newMinistryAttribute.Order = 0;
attributeService.Add( newMinistryAttribute, ImportPersonAlias );
attributeService.Save( newMinistryAttribute, ImportPersonAlias );
ministryAttributeId = newMinistryAttribute.Id;
}
// Get previously imported Ministries
var importedMinistries = new AttributeValueService().GetByAttributeId( ministryAttributeId )
.Select( av => new { RLCId = av.Value.AsType<int?>(), LocationId = av.EntityId } )
.ToDictionary( t => t.RLCId, t => t.LocationId );
foreach ( var row in tableData )
{
int? ministryId = row["Ministry_ID"] as int?;
if ( ministryId != null && !importedMinistries.ContainsKey( ministryId ) )
{
// Activity_ID
// Ministry_Name
// Activity_Name
// Ministry_Active
// Activity_Active
}
}
}
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);
}
}
/// <summary>
/// Returns a <see cref="Rock.Model.Person"/> user preference value by preference setting's key.
/// </summary>
/// <param name="person">The <see cref="Rock.Model.Person"/> to retrieve the preference value for.</param>
/// <param name="key">A <see cref="System.String"/> representing the key name of the preference setting.</param>
/// <returns>A list of <see cref="System.String"/> containing the values associated with the user's preference setting.</returns>
public static List<string> GetUserPreference( Person person, string key )
{
int? PersonEntityTypeId = Rock.Web.Cache.EntityTypeCache.Read( Person.USER_VALUE_ENTITY ).Id;
var rockContext = new Rock.Data.RockContext();
var attributeService = new Model.AttributeService( rockContext );
var attribute = attributeService.Get( PersonEntityTypeId, string.Empty, string.Empty, key );
if (attribute != null)
{
var attributeValueService = new Model.AttributeValueService( rockContext );
var attributeValues = attributeValueService.GetByAttributeIdAndEntityId(attribute.Id, person.Id);
if (attributeValues != null && attributeValues.Count() > 0)
return attributeValues.Select( v => v.Value).ToList();
}
return null;
}
/// <summary>
/// Gets the root matrix attribute value that ties the matrix values to a person or other entity.
/// </summary>
/// <returns></returns>
private AttributeValue GetRootMatrixAttributeValue()
{
var rockContext = new RockContext();
var attributeMatrixService = new AttributeMatrixService(rockContext);
var attributeService = new AttributeService(rockContext);
var attributeValueService = new AttributeValueService(rockContext);
var matrixGuidQuery = attributeMatrixService.Queryable().AsNoTracking().Where(am =>
am.AttributeMatrixItems.Any(ami => ami.Id == EntityId))
.Select(am => am.Guid.ToString());
var matrixFieldType = FieldTypeCache.Get(SystemGuid.FieldType.MATRIX);
var attributeIdQuery = attributeService.Queryable().AsNoTracking().Where(a =>
a.FieldTypeId == matrixFieldType.Id)
.Select(a => a.Id);
var attributeValue = attributeValueService.Queryable().AsNoTracking().FirstOrDefault(av =>
attributeIdQuery.Contains(av.AttributeId) && matrixGuidQuery.Contains(av.Value));
return(attributeValue);
}
/// <summary>
/// Gets the Global Attribute values for the specified key.
/// </summary>
/// <param name="key">The key.</param>
/// <returns></returns>
public string GetValue( string key )
{
if ( AttributeValues.Keys.Contains( key ) )
{
return AttributeValues[key].Value;
}
else
{
var attributeCache = Attributes.FirstOrDefault(a => a.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
if ( attributeCache != null )
{
var attributeValue = new AttributeValueService().GetByAttributeIdAndEntityId( attributeCache.Id, null ).FirstOrDefault();
string value = ( attributeValue != null && !string.IsNullOrEmpty( attributeValue.Value ) ) ? attributeValue.Value : attributeCache.DefaultValue;
AttributeValues.Add( attributeCache.Key, new KeyValuePair<string, string>( attributeCache.Name, value ) );
return value;
}
return string.Empty;
}
}
/// <summary>
/// Returns the environment data as json.
/// </summary>
/// <returns>a JSON formatted string</returns>
public static string GetEnvDataAsJson( System.Web.HttpRequest request, string rockUrl )
{
var envData = new Dictionary<string, string>();
envData.Add( "AppRoot", rockUrl );
envData.Add( "Architecture", ( IntPtr.Size == 4 ) ? "32bit" : "64bit" );
envData.Add( "AspNetVersion", Environment.Version.ToString() );
envData.Add( "IisVersion", request.ServerVariables["SERVER_SOFTWARE"] );
envData.Add( "ServerOs", Environment.OSVersion.ToString() );
try { envData.Add( "SqlVersion", Rock.Data.DbService.ExecuteScaler( "SELECT SERVERPROPERTY('productversion')" ).ToString() ); }
catch {}
try
{
using ( var rockContext = new RockContext() )
{
var entityType = EntityTypeCache.Read( "Rock.Security.BackgroundCheck.ProtectMyMinistry", false, rockContext );
if ( entityType != null )
{
var pmmUserName = new AttributeValueService( rockContext )
.Queryable().AsNoTracking()
.Where( v =>
v.Attribute.EntityTypeId.HasValue &&
v.Attribute.EntityTypeId.Value == entityType.Id &&
v.Attribute.Key == "UserName" )
.Select( v => v.Value )
.FirstOrDefault();
if ( !string.IsNullOrWhiteSpace( pmmUserName ) )
{
envData.Add( "PMMUserName", pmmUserName );
}
}
}
}
catch { }
return envData.ToJson();
}
/// <summary>
/// Builds an expression for an attribute field
/// </summary>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="entityField">The property.</param>
/// <param name="values">The values.</param>
/// <returns></returns>
public Expression GetAttributeExpression( IService serviceInstance, ParameterExpression parameterExpression, EntityField entityField, List<string> values )
{
ComparisonType comparisonType = ComparisonType.EqualTo;
var service = new AttributeValueService( (RockContext)serviceInstance.Context );
var attributeValues = service.Queryable().Where( v =>
v.Attribute.Guid == entityField.AttributeGuid &&
v.EntityId.HasValue &&
v.Value != string.Empty );
ParameterExpression attributeValueParameterExpression = Expression.Parameter( typeof( AttributeValue ), "v" );
var filterExpression = entityField.FieldType.Field.AttributeFilterExpression( entityField.FieldConfig, values, attributeValueParameterExpression );
if ( filterExpression != null )
{
attributeValues = attributeValues.Where( attributeValueParameterExpression, filterExpression, null );
}
IQueryable<int> ids = attributeValues.Select( v => v.EntityId.Value );
if ( ids != null )
{
MemberExpression propertyExpression = Expression.Property( parameterExpression, "Id" );
ConstantExpression idsExpression = Expression.Constant( ids.AsQueryable(), typeof( IQueryable<int> ) );
Expression expression = Expression.Call( typeof( Queryable ), "Contains", new Type[] { typeof( int ) }, idsExpression, propertyExpression );
if ( comparisonType == ComparisonType.NotEqualTo ||
comparisonType == ComparisonType.DoesNotContain ||
comparisonType == ComparisonType.IsBlank )
{
return Expression.Not( expression );
}
else
{
return expression;
}
}
return null;
}
public void Execute(IJobExecutionContext context)
{
JobDataMap dataMap = context.JobDetail.JobDataMap;
string livePlatformUrl = dataMap.GetString("Address") ?? "http://live.newpointe.org/api/v1/events/current";
//Check ChurchOnline Platform API to see if there is a live event
using (WebClient wc = new WebClient())
{
LivePlatformUrlJson = wc.DownloadString(livePlatformUrl);
}
dynamic isServiceLive = JsonConvert.DeserializeObject(LivePlatformUrlJson);
string isLive = isServiceLive.response.item.isLive.ToString();
// specify which attribute key we want to work with
var attributeKey = "LiveService"; //production
var attributeValueService = new AttributeValueService(rockContext);
// specify NULL as the EntityId since this is a GlobalAttribute
var globalAttributeValue = attributeValueService.GetGlobalAttributeValue(attributeKey);
if (globalAttributeValue != null)
{
// save updated value to database
globalAttributeValue.Value = isLive;
rockContext.SaveChanges();
// flush the attributeCache for this attribute so it gets reloaded from the database
//Rock.Web.Cache.AttributeCache.Flush();
// flush the GlobalAttributeCache since this attribute is a GlobalAttribute
Rock.Web.Cache.GlobalAttributesCache.Flush();
}
}
/// <summary>
/// Binds the registrants grid.
/// </summary>
private void BindRegistrantsGrid()
{
int? instanceId = hfRegistrationInstanceId.Value.AsIntegerOrNull();
if ( instanceId.HasValue )
{
using ( var rockContext = new RockContext() )
{
// Start query for registrants
var qry = new RegistrationRegistrantService( rockContext )
.Queryable( "PersonAlias.Person.PhoneNumbers.NumberTypeValue,Fees.RegistrationTemplateFee,GroupMember.Group" ).AsNoTracking()
.Where( r =>
r.Registration.RegistrationInstanceId == instanceId.Value &&
r.PersonAlias != null &&
r.PersonAlias.Person != null );
// Filter by daterange
if ( drpRegistrantDateRange.LowerValue.HasValue )
{
qry = qry.Where( r =>
r.CreatedDateTime.HasValue &&
r.CreatedDateTime.Value >= drpRegistrantDateRange.LowerValue.Value );
}
if ( drpRegistrantDateRange.UpperValue.HasValue )
{
qry = qry.Where( r =>
r.CreatedDateTime.HasValue &&
r.CreatedDateTime.Value <= drpRegistrantDateRange.UpperValue.Value );
}
// Filter by first name
if ( !string.IsNullOrWhiteSpace( tbRegistrantFirstName.Text ) )
{
string rfname = tbRegistrantFirstName.Text;
qry = qry.Where( r =>
r.PersonAlias.Person.NickName.StartsWith( rfname ) ||
r.PersonAlias.Person.FirstName.StartsWith( rfname ) );
}
// Filter by last name
if ( !string.IsNullOrWhiteSpace( tbRegistrantLastName.Text ) )
{
string rlname = tbRegistrantLastName.Text;
qry = qry.Where( r =>
r.PersonAlias.Person.LastName.StartsWith( rlname ) );
}
bool preloadCampusValues = false;
var registrantAttributes = new List<AttributeCache>();
var personAttributes = new List<AttributeCache>();
var groupMemberAttributes = new List<AttributeCache>();
var registrantAttributeIds = new List<int>();
var personAttributesIds = new List<int>();
var groupMemberAttributesIds = new List<int>();
if ( RegistrantFields != null )
{
// Filter by any selected
foreach ( var personFieldType in RegistrantFields
.Where( f =>
f.FieldSource == RegistrationFieldSource.PersonField &&
f.PersonFieldType.HasValue )
.Select( f => f.PersonFieldType.Value ) )
{
switch ( personFieldType )
{
case RegistrationPersonFieldType.Campus:
{
preloadCampusValues = true;
var ddlCampus = phRegistrantFormFieldFilters.FindControl( "ddlCampus" ) as RockDropDownList;
if ( ddlCampus != null )
{
var campusId = ddlCampus.SelectedValue.AsIntegerOrNull();
if ( campusId.HasValue )
{
var familyGroupTypeGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
qry = qry.Where( r =>
r.PersonAlias.Person.Members.Any( m =>
m.Group.GroupType.Guid == familyGroupTypeGuid &&
m.Group.CampusId.HasValue &&
m.Group.CampusId.Value == campusId ) );
}
}
break;
}
case RegistrationPersonFieldType.Email:
{
var tbEmailFilter = phRegistrantFormFieldFilters.FindControl( "tbEmailFilter" ) as RockTextBox;
if ( tbEmailFilter != null && !string.IsNullOrWhiteSpace( tbEmailFilter.Text ) )
{
qry = qry.Where( r =>
r.PersonAlias.Person.Email != null &&
r.PersonAlias.Person.Email.Contains( tbEmailFilter.Text ) );
}
break;
}
case RegistrationPersonFieldType.Birthdate:
{
var drpBirthdateFilter = phRegistrantFormFieldFilters.FindControl( "drpBirthdateFilter" ) as DateRangePicker;
if ( drpBirthdateFilter != null )
{
if ( drpBirthdateFilter.LowerValue.HasValue )
{
qry = qry.Where( r =>
r.PersonAlias.Person.BirthDate.HasValue &&
r.PersonAlias.Person.BirthDate.Value >= drpBirthdateFilter.LowerValue.Value );
}
if ( drpBirthdateFilter.UpperValue.HasValue )
{
qry = qry.Where( r =>
r.PersonAlias.Person.BirthDate.HasValue &&
r.PersonAlias.Person.BirthDate.Value <= drpBirthdateFilter.UpperValue.Value );
}
}
break;
}
case RegistrationPersonFieldType.Gender:
{
var ddlGenderFilter = phRegistrantFormFieldFilters.FindControl( "ddlGenderFilter" ) as RockDropDownList;
if ( ddlGenderFilter != null )
{
var gender = ddlGenderFilter.SelectedValue.ConvertToEnumOrNull<Gender>();
if ( gender.HasValue )
{
qry = qry.Where( r =>
r.PersonAlias.Person.Gender == gender );
}
}
break;
}
case RegistrationPersonFieldType.MaritalStatus:
{
var ddlMaritalStatusFilter = phRegistrantFormFieldFilters.FindControl( "ddlMaritalStatusFilter" ) as RockDropDownList;
if ( ddlMaritalStatusFilter != null )
{
var maritalStatusId = ddlMaritalStatusFilter.SelectedValue.AsIntegerOrNull();
if ( maritalStatusId.HasValue )
{
qry = qry.Where( r =>
r.PersonAlias.Person.MaritalStatusValueId.HasValue &&
r.PersonAlias.Person.MaritalStatusValueId.Value == maritalStatusId.Value );
}
}
break;
}
case RegistrationPersonFieldType.MobilePhone:
{
var tbPhoneFilter = phRegistrantFormFieldFilters.FindControl( "tbPhoneFilter" ) as RockTextBox;
if ( tbPhoneFilter != null && !string.IsNullOrWhiteSpace( tbPhoneFilter.Text ) )
{
string numericPhone = tbPhoneFilter.Text.AsNumeric();
qry = qry.Where( r =>
r.PersonAlias.Person.PhoneNumbers != null &&
r.PersonAlias.Person.PhoneNumbers.Any( n => n.Number.Contains( numericPhone ) ) );
}
break;
}
}
}
// Get all the registrant attributes selected to be on grid
registrantAttributes = RegistrantFields
.Where( f =>
f.Attribute != null &&
f.FieldSource == RegistrationFieldSource.RegistrationAttribute )
.Select( f => f.Attribute )
.ToList();
registrantAttributeIds = registrantAttributes.Select( a => a.Id ).Distinct().ToList();
// Filter query by any configured registrant attribute filters
if ( registrantAttributes != null && registrantAttributes.Any() )
{
var attributeValueService = new AttributeValueService( rockContext );
var parameterExpression = attributeValueService.ParameterExpression;
foreach ( var attribute in registrantAttributes )
{
var filterControl = phRegistrantFormFieldFilters.FindControl( "filter_" + attribute.Id.ToString() );
if ( filterControl != null )
{
var filterValues = attribute.FieldType.Field.GetFilterValues( filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter );
var expression = attribute.FieldType.Field.AttributeFilterExpression( attribute.QualifierValues, filterValues, parameterExpression );
if ( expression != null )
{
var attributeValues = attributeValueService
.Queryable()
.Where( v => v.Attribute.Id == attribute.Id );
attributeValues = attributeValues.Where( parameterExpression, expression, null );
qry = qry
.Where( r => attributeValues.Select( v => v.EntityId ).Contains( r.Id ) );
}
}
}
}
// Get all the person attributes selected to be on grid
personAttributes = RegistrantFields
.Where( f =>
f.Attribute != null &&
f.FieldSource == RegistrationFieldSource.PersonAttribute )
.Select( f => f.Attribute )
.ToList();
personAttributesIds = personAttributes.Select( a => a.Id ).Distinct().ToList();
// Filter query by any configured person attribute filters
if ( personAttributes != null && personAttributes.Any() )
{
var attributeValueService = new AttributeValueService( rockContext );
var parameterExpression = attributeValueService.ParameterExpression;
foreach ( var attribute in personAttributes )
{
var filterControl = phRegistrantFormFieldFilters.FindControl( "filter_" + attribute.Id.ToString() );
if ( filterControl != null )
{
var filterValues = attribute.FieldType.Field.GetFilterValues( filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter );
var expression = attribute.FieldType.Field.AttributeFilterExpression( attribute.QualifierValues, filterValues, parameterExpression );
if ( expression != null )
{
var attributeValues = attributeValueService
.Queryable()
.Where( v => v.Attribute.Id == attribute.Id );
attributeValues = attributeValues.Where( parameterExpression, expression, null );
qry = qry
.Where( r => attributeValues.Select( v => v.EntityId ).Contains( r.PersonAlias.PersonId ) );
}
}
}
}
// Get all the group member attributes selected to be on grid
groupMemberAttributes = RegistrantFields
.Where( f =>
f.Attribute != null &&
f.FieldSource == RegistrationFieldSource.GroupMemberAttribute )
.Select( f => f.Attribute )
.ToList();
groupMemberAttributesIds = groupMemberAttributes.Select( a => a.Id ).Distinct().ToList();
// Filter query by any configured person attribute filters
if ( groupMemberAttributes != null && groupMemberAttributes.Any() )
{
var attributeValueService = new AttributeValueService( rockContext );
var parameterExpression = attributeValueService.ParameterExpression;
foreach ( var attribute in groupMemberAttributes )
{
var filterControl = phRegistrantFormFieldFilters.FindControl( "filter_" + attribute.Id.ToString() );
if ( filterControl != null )
{
var filterValues = attribute.FieldType.Field.GetFilterValues( filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter );
var expression = attribute.FieldType.Field.AttributeFilterExpression( attribute.QualifierValues, filterValues, parameterExpression );
if ( expression != null )
{
var attributeValues = attributeValueService
.Queryable()
.Where( v => v.Attribute.Id == attribute.Id );
attributeValues = attributeValues.Where( parameterExpression, expression, null );
qry = qry
.Where( r => r.GroupMemberId.HasValue &&
attributeValues.Select( v => v.EntityId ).Contains( r.GroupMemberId.Value ) );
}
}
}
}
}
// Sort the query
IOrderedQueryable<RegistrationRegistrant> orderedQry = null;
SortProperty sortProperty = gRegistrants.SortProperty;
if ( sortProperty != null )
{
orderedQry = qry.Sort( sortProperty );
}
else
{
orderedQry = qry
.OrderBy( r => r.PersonAlias.Person.LastName )
.ThenBy( r => r.PersonAlias.Person.NickName );
}
// Set the grids LinqDataSource which will run query and set results for current page
gRegistrants.SetLinqDataSource<RegistrationRegistrant>( orderedQry );
if ( RegistrantFields != null )
{
// Get the query results for the current page
var currentPageRegistrants = gRegistrants.DataSource as List<RegistrationRegistrant>;
if ( currentPageRegistrants != null )
{
// Get all the registrant ids in current page of query results
var registrantIds = currentPageRegistrants
.Select( r => r.Id )
.Distinct()
.ToList();
// Get all the person ids in current page of query results
var personIds = currentPageRegistrants
.Select( r => r.PersonAlias.PersonId )
.Distinct()
.ToList();
// Get all the group member ids and the group id in current page of query results
var groupMemberIds = new List<int>();
GroupLinks = new Dictionary<int,string>();
foreach( var groupMember in currentPageRegistrants
.Where( m =>
m.GroupMember != null &&
m.GroupMember.Group != null )
.Select( m => m.GroupMember ) )
{
groupMemberIds.Add( groupMember.Id );
GroupLinks.AddOrIgnore( groupMember.GroupId,
string.Format( "<a href='{0}'>{1}</a>",
LinkedPageUrl( "GroupDetailPage", new Dictionary<string, string> { { "GroupId", groupMember.GroupId.ToString() } } ),
groupMember.Group.Name ) );
}
// If the campus column was selected to be displayed on grid, preload all the people's
// campuses so that the databind does not need to query each row
if ( preloadCampusValues )
{
PersonCampusIds = new Dictionary<int, List<int>>();
Guid familyGroupTypeGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
foreach ( var personCampusList in new GroupMemberService( rockContext )
.Queryable().AsNoTracking()
.Where( m =>
m.Group.GroupType.Guid == familyGroupTypeGuid &&
personIds.Contains( m.PersonId ) )
.GroupBy( m => m.PersonId )
.Select( m => new
{
PersonId = m.Key,
CampusIds = m
.Where( g => g.Group.CampusId.HasValue )
.Select( g => g.Group.CampusId.Value )
.ToList()
} ) )
{
PersonCampusIds.Add( personCampusList.PersonId, personCampusList.CampusIds );
}
}
// If there are any attributes that were selected to be displayed, we're going
// to try and read all attribute values in one query and then put them into a
// custom grid ObjectList property so that the AttributeField columns don't need
// to do the LoadAttributes and querying of values for each row/column
if ( personAttributesIds.Any() || groupMemberAttributesIds.Any() || registrantAttributeIds.Any() )
{
// Query the attribute values for all rows and attributes
var attributeValues = new AttributeValueService( rockContext )
.Queryable( "Attribute" ).AsNoTracking()
.Where( v =>
v.EntityId.HasValue &&
(
(
personAttributesIds.Contains( v.AttributeId ) &&
personIds.Contains( v.EntityId.Value )
) ||
(
groupMemberAttributesIds.Contains( v.AttributeId ) &&
groupMemberIds.Contains( v.EntityId.Value )
) ||
(
registrantAttributeIds.Contains( v.AttributeId ) &&
registrantIds.Contains( v.EntityId.Value )
)
)
)
.ToList();
// Get the attributes to add to each row's object
var attributes = new Dictionary<string, AttributeCache>();
RegistrantFields
.Where( f => f.Attribute != null )
.Select( f => f.Attribute )
.ToList()
.ForEach( a => attributes
.Add( a.Id.ToString() + a.Key, a ) );
// Initialize the grid's object list
gRegistrants.ObjectList = new Dictionary<string, object>();
// Loop through each of the current page's registrants and build an attribute
// field object for storing attributes and the values for each of the registrants
foreach ( var registrant in currentPageRegistrants )
{
// Create a row attribute object
var attributeFieldObject = new AttributeFieldObject();
// Add the attributes to the attribute object
attributeFieldObject.Attributes = attributes;
// Add any person attribute values to object
attributeValues
.Where( v =>
personAttributesIds.Contains( v.AttributeId ) &&
v.EntityId.Value == registrant.PersonAlias.PersonId )
.ToList()
.ForEach( v => attributeFieldObject.AttributeValues
.Add( v.AttributeId.ToString() + v.Attribute.Key, v ) );
// Add any group member attribute values to object
if ( registrant.GroupMemberId.HasValue )
{
attributeValues
.Where( v =>
groupMemberAttributesIds.Contains( v.AttributeId ) &&
v.EntityId.Value == registrant.GroupMemberId.Value )
.ToList()
.ForEach( v => attributeFieldObject.AttributeValues
.Add( v.AttributeId.ToString() + v.Attribute.Key, v ) );
}
// Add any registrant attribute values to object
attributeValues
.Where( v =>
registrantAttributeIds.Contains( v.AttributeId ) &&
v.EntityId.Value == registrant.PersonAlias.PersonId )
.ToList()
.ForEach( v => attributeFieldObject.AttributeValues
.Add( v.AttributeId.ToString() + v.Attribute.Key, v ) );
// Add row attribute object to grid's object list
gRegistrants.ObjectList.Add( registrant.Id.ToString(), attributeFieldObject );
}
}
}
}
gRegistrants.DataBind();
}
}
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
var rockContext = new RockContext();
int entityTypeIdBlock = EntityTypeCache.Read( typeof( Rock.Model.Block ), true, rockContext ).Id;
string entityTypeQualifier = BlockTypeCache.Read( Rock.SystemGuid.BlockType.HTML_CONTENT.AsGuid(), rockContext ).Id.ToString();
var htmlContentService = new HtmlContentService( rockContext );
var attributeValueQry = new AttributeValueService( rockContext ).Queryable()
.Where( a => a.Attribute.Key == "RequireApproval" && a.Attribute.EntityTypeId == entityTypeIdBlock )
.Where( a => a.Attribute.EntityTypeQualifierColumn == "BlockTypeId" && a.Attribute.EntityTypeQualifierValue == entityTypeQualifier )
.Where( a => a.Value == "True" )
.Select( a => a.EntityId );
var qry = htmlContentService.Queryable().Where( a => attributeValueQry.Contains( a.BlockId ) );
// Filter by approved/unapproved
if ( ddlApprovedFilter.SelectedIndex > -1 )
{
if ( ddlApprovedFilter.SelectedValue.ToLower() == "unapproved" )
{
qry = qry.Where( a => a.IsApproved == false );
}
else if ( ddlApprovedFilter.SelectedValue.ToLower() == "approved" )
{
qry = qry.Where( a => a.IsApproved == true );
}
}
// Filter by the person that approved the content
if ( _canApprove )
{
int? personId = gContentListFilter.GetUserPreference( "Approved By" ).AsIntegerOrNull();
if ( personId.HasValue )
{
qry = qry.Where( a => a.ApprovedByPersonAliasId.HasValue && a.ApprovedByPersonAlias.PersonId == personId );
}
}
SortProperty sortProperty = gContentList.SortProperty;
if ( sortProperty != null )
{
qry = qry.Sort( sortProperty );
}
else
{
qry = qry.OrderByDescending( a => a.ModifiedDateTime );
}
var selectQry = qry.Select( a => new
{
a.Id,
SiteName = a.Block.PageId.HasValue ? a.Block.Page.Layout.Site.Name : a.Block.Layout.Site.Name,
PageName = a.Block.Page.InternalName,
a.ModifiedDateTime,
a.IsApproved,
ApprovedDateTime = a.IsApproved ? a.ApprovedDateTime : null,
ApprovedByPerson = a.IsApproved ? a.ApprovedByPersonAlias.Person : null,
BlockPageId = a.Block.PageId,
BlockLayoutId = a.Block.LayoutId,
} );
gContentList.EntityTypeId = EntityTypeCache.Read<HtmlContent>().Id;
// Filter by Site
if ( ddlSiteFilter.SelectedIndex > 0 )
{
if ( ddlSiteFilter.SelectedValue.ToLower() != "all" )
{
selectQry = selectQry.Where( h => h.SiteName == ddlSiteFilter.SelectedValue );
}
}
gContentList.DataSource = selectQry.ToList();
gContentList.DataBind();
}
/// <summary>
/// Loads the <see cref="P:IHasAttributes.Attributes" /> and <see cref="P:IHasAttributes.AttributeValues" /> of any <see cref="IHasAttributes" /> object
/// </summary>
/// <param name="entity">The item.</param>
/// <param name="rockContext">The rock context.</param>
public static void LoadAttributes( Rock.Attribute.IHasAttributes entity, RockContext rockContext )
{
if ( entity != null )
{
Dictionary<string, PropertyInfo> properties = new Dictionary<string, PropertyInfo>();
Type entityType = entity.GetType();
if ( entityType.Namespace == "System.Data.Entity.DynamicProxies" )
entityType = entityType.BaseType;
rockContext = rockContext ?? new RockContext();
// Check for group type attributes
var groupTypeIds = new List<int>();
if ( entity is GroupMember || entity is Group || entity is GroupType )
{
// Can't use GroupTypeCache here since it loads attributes and would result in a recursive stack overflow situation
var groupTypeService = new GroupTypeService( rockContext );
GroupType groupType = null;
if ( entity is GroupMember )
{
var group = ( (GroupMember)entity ).Group ?? new GroupService( rockContext )
.Queryable().AsNoTracking().FirstOrDefault(g => g.Id == ( (GroupMember)entity ).GroupId );
if ( group != null )
{
groupType = group.GroupType ?? groupTypeService
.Queryable().AsNoTracking().FirstOrDefault( t => t.Id == group.GroupTypeId );
}
}
else if ( entity is Group )
{
groupType = ( (Group)entity ).GroupType ?? groupTypeService
.Queryable().AsNoTracking().FirstOrDefault( t => t.Id == ( (Group)entity ).GroupTypeId );
}
else
{
groupType = ( (GroupType)entity );
}
while ( groupType != null )
{
groupTypeIds.Insert( 0, groupType.Id );
// Check for inherited group type id's
if ( groupType.InheritedGroupTypeId.HasValue )
{
groupType = groupType.InheritedGroupType ?? groupTypeService
.Queryable().AsNoTracking().FirstOrDefault( t => t.Id == ( groupType.InheritedGroupTypeId ?? 0 ) );
}
else
{
groupType = null;
}
}
}
foreach ( PropertyInfo propertyInfo in entityType.GetProperties() )
properties.Add( propertyInfo.Name.ToLower(), propertyInfo );
Rock.Model.AttributeService attributeService = new Rock.Model.AttributeService( rockContext );
Rock.Model.AttributeValueService attributeValueService = new Rock.Model.AttributeValueService( rockContext );
var inheritedAttributes = new Dictionary<int, List<Rock.Web.Cache.AttributeCache>>();
if ( groupTypeIds.Any() )
{
groupTypeIds.ForEach( g => inheritedAttributes.Add( g, new List<Rock.Web.Cache.AttributeCache>() ) );
}
else
{
inheritedAttributes.Add( 0, new List<Rock.Web.Cache.AttributeCache>() );
}
var attributes = new List<Rock.Web.Cache.AttributeCache>();
// Get all the attributes that apply to this entity type and this entity's properties match any attribute qualifiers
var entityTypeCache = Rock.Web.Cache.EntityTypeCache.Read( entityType);
if ( entityTypeCache != null )
{
int entityTypeId = entityTypeCache.Id;
foreach ( var attribute in attributeService.Queryable()
.AsNoTracking()
.Where( a => a.EntityTypeId == entityTypeCache.Id )
.Select( a => new
{
a.Id,
a.EntityTypeQualifierColumn,
a.EntityTypeQualifierValue
}
) )
{
// group type ids exist (entity is either GroupMember, Group, or GroupType) and qualifier is for a group type id
if ( groupTypeIds.Any() && (
( entity is GroupMember && string.Compare( attribute.EntityTypeQualifierColumn, "GroupTypeId", true ) == 0 ) ||
( entity is Group && string.Compare( attribute.EntityTypeQualifierColumn, "GroupTypeId", true ) == 0 ) ||
( entity is GroupType && string.Compare( attribute.EntityTypeQualifierColumn, "Id", true ) == 0 ) ) )
{
int groupTypeIdValue = int.MinValue;
if ( int.TryParse( attribute.EntityTypeQualifierValue, out groupTypeIdValue ) && groupTypeIds.Contains( groupTypeIdValue ) )
{
inheritedAttributes[groupTypeIdValue].Add( Rock.Web.Cache.AttributeCache.Read( attribute.Id ) );
}
}
else if ( string.IsNullOrEmpty( attribute.EntityTypeQualifierColumn ) ||
( properties.ContainsKey( attribute.EntityTypeQualifierColumn.ToLower() ) &&
( string.IsNullOrEmpty( attribute.EntityTypeQualifierValue ) ||
( properties[attribute.EntityTypeQualifierColumn.ToLower()].GetValue( entity, null ) ?? "" ).ToString() == attribute.EntityTypeQualifierValue ) ) )
{
attributes.Add( Rock.Web.Cache.AttributeCache.Read( attribute.Id ) );
}
}
}
var allAttributes = new List<Rock.Web.Cache.AttributeCache>();
foreach ( var attributeGroup in inheritedAttributes )
{
foreach ( var attribute in attributeGroup.Value )
{
allAttributes.Add( attribute );
}
}
foreach ( var attribute in attributes )
{
allAttributes.Add( attribute );
}
var attributeValues = new Dictionary<string, Rock.Model.AttributeValue>();
if ( allAttributes.Any() )
{
foreach ( var attribute in allAttributes )
{
// Add a placeholder for this item's value for each attribute
attributeValues.Add( attribute.Key, null );
}
// If loading attributes for a saved item, read the item's value(s) for each attribute
if ( !entityTypeCache.IsEntity || entity.Id != 0 )
{
List<int> attributeIds = allAttributes.Select( a => a.Id ).ToList();
foreach ( var attributeValue in attributeValueService.Queryable().AsNoTracking()
.Where( v => v.EntityId == entity.Id && attributeIds.Contains( v.AttributeId ) ) )
{
var attributeKey = AttributeCache.Read( attributeValue.AttributeId ).Key;
attributeValues[attributeKey] = attributeValue.Clone( false ) as Rock.Model.AttributeValue;
}
}
// Look for any attributes that don't have a value and create a default value entry
foreach ( var attribute in allAttributes )
{
if ( attributeValues[attribute.Key] == null )
{
var attributeValue = new Rock.Model.AttributeValue();
attributeValue.AttributeId = attribute.Id;
if ( entity.AttributeValueDefaults != null && entity.AttributeValueDefaults.ContainsKey( attribute.Name ) )
{
attributeValue.Value = entity.AttributeValueDefaults[attribute.Name];
}
else
{
attributeValue.Value = attribute.DefaultValue;
}
attributeValues[attribute.Key] = attributeValue;
}
else
{
if ( !String.IsNullOrWhiteSpace( attribute.DefaultValue ) &&
String.IsNullOrWhiteSpace( attributeValues[attribute.Key].Value ) )
{
attributeValues[attribute.Key].Value = attribute.DefaultValue;
}
}
}
}
entity.Attributes = new Dictionary<string, Web.Cache.AttributeCache>();
allAttributes.ForEach( a => entity.Attributes.Add( a.Key, a ) );
entity.AttributeValues = attributeValues;
}
}
protected void Page_Load(object sender, EventArgs e)
{
var shapePageReference = new Rock.Web.PageReference(GetAttributeValue("SHAPEAssessmentPage"));
var discPageReference = new Rock.Web.PageReference(GetAttributeValue("DISCAssessmentPage"));
if (!string.IsNullOrWhiteSpace(PageParameter("FormId")))
{
//Load the person based on the FormId
var personInUrl = PageParameter("FormId");
SelectedPerson = GetPersonFromForm(personInUrl);
PersonEncodedKey = SelectedPerson.UrlEncodedKey;
}
else if (!string.IsNullOrWhiteSpace(PageParameter("PersonId")))
{
//Load the person based on the PersonId
SelectedPerson = GetPersonFromId(PageParameter("PersonId"));
PersonEncodedKey = SelectedPerson.UrlEncodedKey;
}
else if (CurrentPerson != null)
{
//Load the person based on the currently logged in person
SelectedPerson = CurrentPerson;
PersonEncodedKey = SelectedPerson.UrlEncodedKey;
}
else
{
//Show Error Message
nbNoPerson.Visible = true;
Response.Redirect(shapePageReference.BuildUrl(), true);
return;
}
// Load the attributes
AttributeValueService attributeValueService = new AttributeValueService(rockContext);
DefinedValueService definedValueService = new DefinedValueService(rockContext);
string spiritualGift1 = "";
string spiritualGift2 = "";
string spiritualGift3 = "";
string spiritualGift4 = "";
string heartCategories = "";
string heartCauses = "";
string heartPassion = "";
string ability1 = "";
string ability2 = "";
string people = "";
string places = "";
string events = "";
var spiritualGift1AttributeValue =
attributeValueService
.Queryable()
.FirstOrDefault(a => a.Attribute.Key == "SpiritualGift1" && a.EntityId == SelectedPerson.Id);
// Redirect if they haven't taken the Assessment
if (spiritualGift1AttributeValue == null)
{
Response.Redirect(shapePageReference.BuildUrl(), true);
}
else
{
var spiritualGift2AttributeValue =
attributeValueService
.Queryable()
.FirstOrDefault(a => a.Attribute.Key == "SpiritualGift2" && a.EntityId == SelectedPerson.Id);
var spiritualGift3AttributeValue =
attributeValueService
.Queryable()
.FirstOrDefault(a => a.Attribute.Key == "SpiritualGift3" && a.EntityId == SelectedPerson.Id);
var spiritualGift4AttributeValue =
attributeValueService
.Queryable()
.FirstOrDefault(a => a.Attribute.Key == "SpiritualGift4" && a.EntityId == SelectedPerson.Id);
var ability1AttributeValue =
attributeValueService
.Queryable().FirstOrDefault(a => a.Attribute.Key == "Ability1" && a.EntityId == SelectedPerson.Id);
var ability2AttributeValue =
attributeValueService
.Queryable().FirstOrDefault(a => a.Attribute.Key == "Ability2" && a.EntityId == SelectedPerson.Id);
var peopleAttributeValue = attributeValueService
.Queryable()
.FirstOrDefault(a => a.Attribute.Key == "SHAPEPeople" && a.EntityId == SelectedPerson.Id);
var placesAttributeValue = attributeValueService
.Queryable()
.FirstOrDefault(a => a.Attribute.Key == "SHAPEPlaces" && a.EntityId == SelectedPerson.Id);
var eventsAttributeValue = attributeValueService
.Queryable()
.FirstOrDefault(a => a.Attribute.Key == "SHAPEEvents" && a.EntityId == SelectedPerson.Id);
var heartCategoriesAttributeValue = attributeValueService
.Queryable()
.FirstOrDefault(a => a.Attribute.Key == "HeartCategories" && a.EntityId == SelectedPerson.Id);
var heartCausesAttributeValue = attributeValueService
.Queryable()
.FirstOrDefault(a => a.Attribute.Key == "HeartCauses" && a.EntityId == SelectedPerson.Id);
var heartPassionAttributeValue = attributeValueService
.Queryable()
.FirstOrDefault(a => a.Attribute.Key == "HeartPassion" && a.EntityId == SelectedPerson.Id);
if (spiritualGift1AttributeValue.Value != null) spiritualGift1 = spiritualGift1AttributeValue.Value;
if (spiritualGift2AttributeValue.Value != null) spiritualGift2 = spiritualGift2AttributeValue.Value;
if (spiritualGift3AttributeValue.Value != null) spiritualGift3 = spiritualGift3AttributeValue.Value;
if (spiritualGift4AttributeValue.Value != null) spiritualGift4 = spiritualGift4AttributeValue.Value;
if (heartCategoriesAttributeValue.Value != null) heartCategories = heartCategoriesAttributeValue.Value;
if (heartCausesAttributeValue.Value != null) heartCauses = heartCausesAttributeValue.Value;
if (heartPassionAttributeValue.Value != null) heartPassion = heartPassionAttributeValue.Value;
if (ability1AttributeValue.Value != null) ability1 = ability1AttributeValue.Value;
if (ability2AttributeValue.Value != null) ability2 = ability2AttributeValue.Value;
if (peopleAttributeValue.Value != null) people = peopleAttributeValue.Value;
if (placesAttributeValue.Value != null) places = placesAttributeValue.Value;
if (eventsAttributeValue.Value != null) events = eventsAttributeValue.Value;
string spiritualGift1Guid;
string spiritualGift2Guid;
string spiritualGift3Guid;
string spiritualGift4Guid;
string ability1Guid;
string ability2Guid;
// Check to see if there are already values saved as an ID. If so, convert them to GUID
if (spiritualGift1.ToString().Length < 5)
{
if (spiritualGift1 != null) SpiritualGift1 = Int32.Parse(spiritualGift1);
if (spiritualGift2 != null) SpiritualGift2 = Int32.Parse(spiritualGift2);
if (spiritualGift3 != null) SpiritualGift3 = Int32.Parse(spiritualGift3);
if (spiritualGift4 != null) SpiritualGift4 = Int32.Parse(spiritualGift4);
if (ability1 != null) Ability1 = Int32.Parse(ability1);
if (ability2 != null) Ability2 = Int32.Parse(ability2);
var intsOfGifts =
definedValueService.GetByIds(new List<int>
{
SpiritualGift1,
SpiritualGift2,
SpiritualGift3,
SpiritualGift4,
Ability1,
Ability2
});
spiritualGift1Guid = intsOfGifts.ToList()[SpiritualGift1].Guid.ToString();
spiritualGift2Guid = intsOfGifts.ToList()[SpiritualGift2].Guid.ToString();
spiritualGift3Guid = intsOfGifts.ToList()[SpiritualGift3].Guid.ToString();
spiritualGift4Guid = intsOfGifts.ToList()[SpiritualGift4].Guid.ToString();
ability1Guid = intsOfGifts.ToList()[Ability1].Guid.ToString();
ability2Guid = intsOfGifts.ToList()[Ability2].Guid.ToString();
}
else
{
spiritualGift1Guid = spiritualGift1;
spiritualGift2Guid = spiritualGift2;
spiritualGift3Guid = spiritualGift3;
spiritualGift4Guid = spiritualGift4;
ability1Guid = ability1;
ability2Guid = ability2;
}
// Get all of the data about the assiciated gifts and ability categories
var shapeGift1Object = definedValueService.GetListByGuids(new List<Guid> { new Guid(spiritualGift1Guid) }).FirstOrDefault();
var shapeGift2Object = definedValueService.GetListByGuids(new List<Guid> { new Guid(spiritualGift2Guid) }).FirstOrDefault();
var shapeGift3Object = definedValueService.GetListByGuids(new List<Guid> { new Guid(spiritualGift3Guid) }).FirstOrDefault();
var shapeGift4Object = definedValueService.GetListByGuids(new List<Guid> { new Guid(spiritualGift4Guid) }).FirstOrDefault();
var ability1Object = definedValueService.GetListByGuids(new List<Guid> { new Guid(ability1Guid) }).FirstOrDefault();
var ability2Object = definedValueService.GetListByGuids(new List<Guid> { new Guid(ability2Guid) }).FirstOrDefault();
shapeGift1Object.LoadAttributes();
shapeGift2Object.LoadAttributes();
shapeGift3Object.LoadAttributes();
shapeGift4Object.LoadAttributes();
ability1Object.LoadAttributes();
ability2Object.LoadAttributes();
// Get heart choices Values from Guids
string heartCategoriesString = "";
if (!heartCategories.IsNullOrWhiteSpace())
{
string[] heartCategoryArray = heartCategories.Split(',');
foreach (string category in heartCategoryArray)
{
var definedValueObject =
definedValueService.Queryable().FirstOrDefault(a => a.Guid == new Guid(category));
if (category.Equals(heartCategoryArray.Last()))
{
heartCategoriesString += definedValueObject.Value;
}
else
{
heartCategoriesString += definedValueObject.Value + ", ";
}
}
}
// Get Volunteer Opportunities
string gift1AssociatedVolunteerOpportunities =
shapeGift1Object.GetAttributeValue("AssociatedVolunteerOpportunities");
string gift2AssociatedVolunteerOpportunities =
shapeGift2Object.GetAttributeValue("AssociatedVolunteerOpportunities");
string gift3AssociatedVolunteerOpportunities =
shapeGift3Object.GetAttributeValue("AssociatedVolunteerOpportunities");
string gift4AssociatedVolunteerOpportunities =
shapeGift4Object.GetAttributeValue("AssociatedVolunteerOpportunities");
string allAssociatedVolunteerOpportunities = gift1AssociatedVolunteerOpportunities + "," +
gift2AssociatedVolunteerOpportunities + "," +
gift3AssociatedVolunteerOpportunities + "," +
gift4AssociatedVolunteerOpportunities;
if (allAssociatedVolunteerOpportunities != ",,,")
{
List<int> associatedVolunteerOpportunitiesList =
allAssociatedVolunteerOpportunities.Split(',').Select(t => int.Parse(t)).ToList();
Dictionary<int, int> VolunteerOpportunities = new Dictionary<int, int>();
var i = 0;
var q = from x in associatedVolunteerOpportunitiesList
group x by x
into g
let count = g.Count()
orderby count descending
select new { Value = g.Key, Count = count };
foreach (var x in q)
{
VolunteerOpportunities.Add(i, x.Value);
i++;
}
ConnectionOpportunityService connectionOpportunityService = new ConnectionOpportunityService(rockContext);
List<ConnectionOpportunity> connectionOpportunityList = new List<ConnectionOpportunity>();
foreach (KeyValuePair<int, int> entry in VolunteerOpportunities.Take(4))
{
var connection = connectionOpportunityService.GetByIds(new List<int> { entry.Value }).FirstOrDefault();
// Only display connection if it is marked Active
if (connection.IsActive == true)
{
connectionOpportunityList.Add(connection);
}
}
rpVolunteerOpportunities.DataSource = connectionOpportunityList;
rpVolunteerOpportunities.DataBind();
}
//Get DISC Info
DiscService.AssessmentResults savedScores = DiscService.LoadSavedAssessmentResults(SelectedPerson);
if (!string.IsNullOrWhiteSpace(savedScores.PersonalityType))
{
ShowResults(savedScores);
DISCResults.Visible = true;
NoDISCResults.Visible = false;
}
else
{
discPageReference.Parameters = new System.Collections.Generic.Dictionary<string, string>();
discPageReference.Parameters.Add("rckipid", SelectedPerson.UrlEncodedKey);
Response.Redirect(discPageReference.BuildUrl(), true);
}
// Build the UI
lbPersonName.Text = SelectedPerson.FullName;
lbGift1Title.Text = shapeGift1Object.Value;
lbGift1BodyHTML.Text = shapeGift1Object.GetAttributeValue("HTMLDescription");
lbGift2Title.Text = shapeGift2Object.Value;
lbGift2BodyHTML.Text = shapeGift2Object.GetAttributeValue("HTMLDescription");
lbGift3Title.Text = shapeGift3Object.Value;
lbGift3BodyHTML.Text = shapeGift3Object.GetAttributeValue("HTMLDescription");
lbGift4Title.Text = shapeGift4Object.Value;
lbGift4BodyHTML.Text = shapeGift4Object.GetAttributeValue("HTMLDescription");
lbAbility1Title.Text = ability1Object.Value;
lbAbility1BodyHTML.Text = ability1Object.GetAttributeValue("HTMLDescription");
lbAbility2Title.Text = ability2Object.Value;
lbAbility2BodyHTML.Text = ability2Object.GetAttributeValue("HTMLDescription");
lbPeople.Text = people;
lbPlaces.Text = places;
lbEvents.Text = events;
lbHeartCategories.Text = heartCategoriesString;
lbHeartCauses.Text = heartCauses;
lbHeartPassion.Text = heartPassion;
if (spiritualGift1AttributeValue.ModifiedDateTime != null)
{
lbAssessmentDate.Text = spiritualGift1AttributeValue.ModifiedDateTime.Value.ToShortDateString();
}
else
{
lbAssessmentDate.Text = spiritualGift1AttributeValue.CreatedDateTime.Value.ToShortDateString();
}
// Show create account panel if this person doesn't have an account
if (SelectedPerson.Users.Count == 0)
{
pnlAccount.Visible = true;
}
}
}
/// <summary>
/// Binds the grid.
/// </summary>
private void ShowResults()
{
// Get the group types that we're interested in
Guid? groupTypeGuid = GetAttributeValue( "GroupType" ).AsGuidOrNull();
if ( !groupTypeGuid.HasValue )
{
ShowError( "A valid Group Type is required." );
return;
}
gGroups.Columns[1].Visible = GetAttributeValue( "ShowDescription" ).AsBoolean();
gGroups.Columns[2].Visible = GetAttributeValue( "ShowSchedule" ).AsBoolean();
gGroups.Columns[3].Visible = GetAttributeValue( "ShowCount" ).AsBoolean();
gGroups.Columns[4].Visible = GetAttributeValue( "ShowAge" ).AsBoolean();
bool showProximity = GetAttributeValue( "ShowProximity" ).AsBoolean();
gGroups.Columns[5].Visible = showProximity; // Distance
// Get query of groups of the selected group type
var rockContext = new RockContext();
var groupService = new GroupService( rockContext );
var groupQry = groupService
.Queryable( "GroupLocations.Location" )
.Where( g => g.IsActive && g.GroupType.Guid.Equals( groupTypeGuid.Value ) && g.IsPublic );
var groupParameterExpression = groupService.ParameterExpression;
var schedulePropertyExpression = Expression.Property( groupParameterExpression, "Schedule" );
var dowFilterControl = phFilterControls.FindControl( "filter_dow" );
if ( dowFilterControl != null )
{
var field = FieldTypeCache.Read( Rock.SystemGuid.FieldType.DAY_OF_WEEK ).Field;
var filterValues = field.GetFilterValues( dowFilterControl, null, Rock.Reporting.FilterMode.SimpleFilter );
var expression = field.PropertyFilterExpression( null, filterValues, schedulePropertyExpression, "WeeklyDayOfWeek", typeof( DayOfWeek? ) );
groupQry = groupQry.Where( groupParameterExpression, expression, null );
}
var timeFilterControl = phFilterControls.FindControl( "filter_time" );
if ( timeFilterControl != null )
{
var field = FieldTypeCache.Read( Rock.SystemGuid.FieldType.TIME ).Field;
var filterValues = field.GetFilterValues( timeFilterControl, null, Rock.Reporting.FilterMode.SimpleFilter );
var expression = field.PropertyFilterExpression( null, filterValues, schedulePropertyExpression, "WeeklyTimeOfDay", typeof( TimeSpan? ) );
groupQry = groupQry.Where( groupParameterExpression, expression, null );
}
// Filter query by any configured attribute filters
if ( AttributeFilters != null && AttributeFilters.Any() )
{
var attributeValueService = new AttributeValueService( rockContext );
var parameterExpression = attributeValueService.ParameterExpression;
foreach ( var attribute in AttributeFilters )
{
var filterControl = phFilterControls.FindControl( "filter_" + attribute.Id.ToString() );
if ( filterControl != null )
{
var filterValues = attribute.FieldType.Field.GetFilterValues( filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter );
var expression = attribute.FieldType.Field.AttributeFilterExpression( attribute.QualifierValues, filterValues, parameterExpression );
if ( expression != null )
{
var attributeValues = attributeValueService
.Queryable()
.Where( v => v.Attribute.Id == attribute.Id );
attributeValues = attributeValues.Where( parameterExpression, expression, null );
groupQry = groupQry.Where( w => attributeValues.Select( v => v.EntityId ).Contains( w.Id ) );
}
}
}
}
List<GroupLocation> fences = null;
List<Group> groups = null;
// Run query to get list of matching groups
SortProperty sortProperty = gGroups.SortProperty;
if ( sortProperty != null )
{
groups = groupQry.Sort( sortProperty ).ToList();
}
else
{
groups = groupQry.OrderBy( g => g.Name ).ToList();
}
int? fenceGroupTypeId = GetGroupTypeId( GetAttributeValue( "GeofencedGroupType" ).AsGuidOrNull() );
bool showMap = GetAttributeValue( "ShowMap" ).AsBoolean();
bool showFences = showMap && GetAttributeValue( "ShowFence" ).AsBoolean();
var distances = new Dictionary<int, double>();
// If we care where these groups are located...
if ( fenceGroupTypeId.HasValue || showMap || showProximity )
{
// Get the location for the address entered
Location personLocation = null;
if ( fenceGroupTypeId.HasValue || showProximity )
{
personLocation = new LocationService( rockContext )
.Get( acAddress.Street1, acAddress.Street2, acAddress.City,
acAddress.State, acAddress.PostalCode, acAddress.Country );
}
// If showing a map, and person's location was found, save a mapitem for this location
FinderMapItem personMapItem = null;
if ( showMap && personLocation != null && personLocation.GeoPoint != null )
{
var infoWindow = string.Format( @"
<div style='width:250px'>
<div class='clearfix'>
<strong>Your Location</strong>
<br/>{0}
</div>
</div>
", personLocation.FormattedHtmlAddress );
personMapItem = new FinderMapItem( personLocation );
personMapItem.Name = "Your Location";
personMapItem.InfoWindow = HttpUtility.HtmlEncode( infoWindow.Replace( Environment.NewLine, string.Empty ).Replace( "\n", string.Empty ).Replace( "\t", string.Empty ) );
}
// Get the locations, and optionally calculate the distance for each of the groups
var groupLocations = new List<GroupLocation>();
foreach ( var group in groups )
{
foreach ( var groupLocation in group.GroupLocations
.Where( gl => gl.Location.GeoPoint != null ) )
{
groupLocations.Add( groupLocation );
if ( showProximity && personLocation != null && personLocation.GeoPoint != null )
{
double meters = groupLocation.Location.GeoPoint.Distance( personLocation.GeoPoint ) ?? 0.0D;
double miles = meters * Location.MilesPerMeter;
// If this group already has a distance calculated, see if this location is closer and if so, use it instead
if ( distances.ContainsKey( group.Id ) )
{
if ( distances[group.Id] < miles )
{
distances[group.Id] = miles;
}
}
else
{
distances.Add( group.Id, miles );
}
}
}
}
// If groups should be limited by a geofence
var fenceMapItems = new List<MapItem>();
if ( fenceGroupTypeId.HasValue )
{
fences = new List<GroupLocation>();
if ( personLocation != null && personLocation.GeoPoint != null )
{
fences = new GroupLocationService( rockContext )
.Queryable( "Group,Location" )
.Where( gl =>
gl.Group.GroupTypeId == fenceGroupTypeId &&
gl.Location.GeoFence != null &&
personLocation.GeoPoint.Intersects( gl.Location.GeoFence ) )
.ToList();
}
// Limit the group locations to only those locations inside one of the fences
groupLocations = groupLocations
.Where( gl =>
fences.Any( f => gl.Location.GeoPoint.Intersects( f.Location.GeoFence ) ) )
.ToList();
// Limit the groups to the those that still contain a valid location
groups = groups
.Where( g =>
groupLocations.Any( gl => gl.GroupId == g.Id ) )
.ToList();
// If the map and fences should be displayed, create a map item for each fence
if ( showMap && showFences )
{
foreach ( var fence in fences )
{
var mapItem = new FinderMapItem( fence.Location );
mapItem.EntityTypeId = EntityTypeCache.Read( "Rock.Model.Group" ).Id;
mapItem.EntityId = fence.GroupId;
mapItem.Name = fence.Group.Name;
fenceMapItems.Add( mapItem );
}
}
}
// if not sorting by ColumnClick and SortByDistance, then sort the groups by distance
if ( gGroups.SortProperty == null && GetAttributeValue( "SortByDistance" ).AsBoolean() )
{
// only show groups with a known location, and sort those by distance
groups = groups.Where( a => distances.Select( b => b.Key ).Contains( a.Id ) ).ToList();
groups = groups.OrderBy( a => distances[a.Id] ).ThenBy( a => a.Name ).ToList();
}
// if limiting by PageSize, limit to the top X groups
int? pageSize = ddlPageSize.SelectedValue.AsIntegerOrNull();
if ( pageSize.HasValue && pageSize > 0 )
{
groups = groups.Take( pageSize.Value ).ToList();
}
// If a map is to be shown
if ( showMap && groups.Any() )
{
Template template = Template.Parse( GetAttributeValue( "MapInfo" ) );
bool showDebug = UserCanEdit && GetAttributeValue( "MapInfoDebug" ).AsBoolean();
lMapInfoDebug.Visible = showDebug;
// Add mapitems for all the remaining valid group locations
var groupMapItems = new List<MapItem>();
foreach ( var gl in groupLocations )
{
var group = groups.Where( g => g.Id == gl.GroupId ).FirstOrDefault();
if ( group != null )
{
// Resolve info window lava template
var linkedPageParams = new Dictionary<string, string> { { "GroupId", group.Id.ToString() } };
var mergeFields = new Dictionary<string, object>();
mergeFields.Add( "Group", gl.Group );
mergeFields.Add( "Location", gl.Location );
Dictionary<string, object> linkedPages = new Dictionary<string, object>();
linkedPages.Add( "GroupDetailPage", LinkedPageRoute( "GroupDetailPage" ) );
if ( _targetPersonGuid != Guid.Empty )
{
linkedPages.Add( "RegisterPage", LinkedPageUrl( "RegisterPage", _urlParms ) );
}
else
{
linkedPages.Add( "RegisterPage", LinkedPageUrl( "RegisterPage", null ) );
}
mergeFields.Add( "LinkedPages", linkedPages );
// add collection of allowed security actions
Dictionary<string, object> securityActions = new Dictionary<string, object>();
securityActions.Add( "View", group.IsAuthorized( Authorization.VIEW, CurrentPerson ) );
securityActions.Add( "Edit", group.IsAuthorized( Authorization.EDIT, CurrentPerson ) );
securityActions.Add( "Administrate", group.IsAuthorized( Authorization.ADMINISTRATE, CurrentPerson ) );
mergeFields.Add( "AllowedActions", securityActions );
string infoWindow = template.Render( Hash.FromDictionary( mergeFields ) );
if ( showDebug )
{
lMapInfoDebug.Text = mergeFields.lavaDebugInfo( null, "<span class='label label-info'>Lava used for the map window.</span>", "" );
showDebug = false;
}
// Add a map item for group
var mapItem = new FinderMapItem( gl.Location );
mapItem.EntityTypeId = EntityTypeCache.Read( "Rock.Model.Group" ).Id;
mapItem.EntityId = group.Id;
mapItem.Name = group.Name;
mapItem.InfoWindow = HttpUtility.HtmlEncode( infoWindow.Replace( Environment.NewLine, string.Empty ).Replace( "\n", string.Empty ).Replace( "\t", string.Empty ) );
groupMapItems.Add( mapItem );
}
}
// Show the map
Map( personMapItem, fenceMapItems, groupMapItems );
pnlMap.Visible = true;
}
else
{
pnlMap.Visible = false;
}
}
else
{
pnlMap.Visible = false;
}
// Should a lava output be displayed
if ( GetAttributeValue( "ShowLavaOutput" ).AsBoolean() )
{
string template = GetAttributeValue( "LavaOutput" );
var mergeFields = new Dictionary<string, object>();
if ( fences != null )
{
mergeFields.Add( "Fences", fences.Select( f => f.Group ).ToList() );
}
else
{
mergeFields.Add( "Fences", new Dictionary<string, object>() );
}
mergeFields.Add( "Groups", groups );
Dictionary<string, object> linkedPages = new Dictionary<string, object>();
linkedPages.Add( "GroupDetailPage", LinkedPageUrl( "GroupDetailPage", null ) );
if ( _targetPersonGuid != Guid.Empty )
{
linkedPages.Add( "RegisterPage", LinkedPageUrl( "RegisterPage", _urlParms ) );
}
else
{
linkedPages.Add( "RegisterPage", LinkedPageUrl( "RegisterPage", null ) );
}
mergeFields.Add( "LinkedPages", linkedPages );
lLavaOverview.Text = template.ResolveMergeFields( mergeFields );
bool showDebug = UserCanEdit && GetAttributeValue( "LavaOutputDebug" ).AsBoolean();
lLavaOutputDebug.Visible = showDebug;
if ( showDebug )
{
lLavaOutputDebug.Text = mergeFields.lavaDebugInfo( null, "<span class='label label-info'>Lava used for the summary info.</span>" );
}
pnlLavaOutput.Visible = true;
}
else
{
pnlLavaOutput.Visible = false;
}
// Should a grid be displayed
if ( GetAttributeValue( "ShowGrid" ).AsBoolean() )
{
pnlGrid.Visible = true;
// Save the groups into the grid's object list since it is not being bound to actual group objects
gGroups.ObjectList = new Dictionary<string, object>();
groups.ForEach( g => gGroups.ObjectList.Add( g.Id.ToString(), g ) );
// Bind the grid
gGroups.DataSource = groups.Select( g =>
{
var qryMembers = new GroupMemberService( rockContext ).Queryable().Where( a => a.GroupId == g.Id );
var groupType = GroupTypeCache.Read( g.GroupTypeId );
return new
{
Id = g.Id,
Name = g.Name,
GroupTypeName = groupType.Name,
GroupOrder = g.Order,
GroupTypeOrder = groupType.Order,
Description = g.Description,
IsSystem = g.IsSystem,
IsActive = g.IsActive,
GroupRole = string.Empty,
DateAdded = DateTime.MinValue,
Schedule = g.Schedule,
MemberCount = qryMembers.Count(),
AverageAge = Math.Round( qryMembers.Select( m => m.Person.BirthDate ).ToList().Select( a => Person.GetAge( a ) ).Average() ?? 0.0D ),
Distance = distances.Where( d => d.Key == g.Id )
.Select( d => d.Value ).FirstOrDefault()
};
} ).ToList();
gGroups.DataBind();
}
else
{
pnlGrid.Visible = false;
}
// Show the results
pnlResults.Visible = true;
}
/// <summary>
/// Binds the group members grid.
/// </summary>
protected void BindGroupMembersGrid()
{
if ( _group != null )
{
pnlGroupMembers.Visible = true;
lHeading.Text = string.Format( "{0} {1}", _group.GroupType.GroupTerm, _group.GroupType.GroupMemberTerm.Pluralize() );
if ( _group.GroupType.Roles.Any() )
{
nbRoleWarning.Visible = false;
rFilter.Visible = true;
gGroupMembers.Visible = true;
var rockContext = new RockContext();
GroupMemberService groupMemberService = new GroupMemberService( rockContext );
var qry = groupMemberService.Queryable( "Person,GroupRole", true ).AsNoTracking()
.Where( m => m.GroupId == _group.Id );
// Filter by First Name
string firstName = tbFirstName.Text;
if ( !string.IsNullOrWhiteSpace( firstName ) )
{
qry = qry.Where( m => m.Person.FirstName.StartsWith( firstName ) );
}
// Filter by Last Name
string lastName = tbLastName.Text;
if ( !string.IsNullOrWhiteSpace( lastName ) )
{
qry = qry.Where( m => m.Person.LastName.StartsWith( lastName ) );
}
// Filter by role
var validGroupTypeRoles = _group.GroupType.Roles.Select( r => r.Id ).ToList();
var roles = new List<int>();
foreach ( string role in cblRole.SelectedValues )
{
if ( !string.IsNullOrWhiteSpace( role ) )
{
int roleId = int.MinValue;
if ( int.TryParse( role, out roleId ) && validGroupTypeRoles.Contains( roleId ) )
{
roles.Add( roleId );
}
}
}
if ( roles.Any() )
{
qry = qry.Where( m => roles.Contains( m.GroupRoleId ) );
}
// Filter by Status
var statuses = new List<GroupMemberStatus>();
foreach ( string status in cblStatus.SelectedValues )
{
if ( !string.IsNullOrWhiteSpace( status ) )
{
statuses.Add( status.ConvertToEnum<GroupMemberStatus>() );
}
}
if ( statuses.Any() )
{
qry = qry.Where( m => statuses.Contains( m.GroupMemberStatus ) );
}
// Filter query by any configured attribute filters
if ( AvailableAttributes != null && AvailableAttributes.Any() )
{
var attributeValueService = new AttributeValueService( rockContext );
var parameterExpression = attributeValueService.ParameterExpression;
foreach ( var attribute in AvailableAttributes )
{
var filterControl = phAttributeFilters.FindControl( "filter_" + attribute.Id.ToString() );
if ( filterControl != null )
{
var filterValues = attribute.FieldType.Field.GetFilterValues( filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter );
var expression = attribute.FieldType.Field.AttributeFilterExpression( attribute.QualifierValues, filterValues, parameterExpression );
if ( expression != null )
{
var attributeValues = attributeValueService
.Queryable()
.Where( v => v.Attribute.Id == attribute.Id );
attributeValues = attributeValues.Where( parameterExpression, expression, null );
qry = qry.Where( w => attributeValues.Select( v => v.EntityId ).Contains( w.Id ) );
}
}
}
}
_inactiveStatus = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE );
SortProperty sortProperty = gGroupMembers.SortProperty;
bool hasGroupRequirements = new GroupRequirementService( rockContext ).Queryable().Where( a => a.GroupId == _group.Id ).Any();
// If there are group requirements that that member doesn't meet, show an icon in the grid
bool includeWarnings = false;
var groupMemberIdsThatLackGroupRequirements = new GroupService( rockContext ).GroupMembersNotMeetingRequirements( _group.Id, includeWarnings ).Select( a => a.Key.Id );
List<GroupMember> groupMembersList = null;
if ( sortProperty != null )
{
groupMembersList = qry.Sort( sortProperty ).ToList();
}
else
{
groupMembersList = qry.OrderBy( a => a.GroupRole.Order ).ThenBy( a => a.Person.LastName ).ThenBy( a => a.Person.FirstName ).ToList();
}
// Since we're not binding to actual group member list, but are using AttributeField columns,
// we need to save the workflows into the grid's object list
gGroupMembers.ObjectList = new Dictionary<string, object>();
groupMembersList.ForEach( m => gGroupMembers.ObjectList.Add( m.Id.ToString(), m ) );
gGroupMembers.EntityTypeId = EntityTypeCache.Read( Rock.SystemGuid.EntityType.GROUP_MEMBER.AsGuid() ).Id;
gGroupMembers.DataSource = groupMembersList.Select( m => new
{
m.Id,
m.Guid,
m.PersonId,
Name = m.Person.NickName + " " + m.Person.LastName
+ ( hasGroupRequirements && groupMemberIdsThatLackGroupRequirements.Contains( m.Id )
? " <i class='fa fa-exclamation-triangle text-warning'></i>"
: string.Empty )
+ ( !string.IsNullOrEmpty( m.Note )
? " <i class='fa fa-file-text-o text-info'></i>"
: string.Empty ),
GroupRole = m.GroupRole.Name,
m.GroupMemberStatus,
RecordStatusValueId = m.Person.RecordStatusValueId,
IsDeceased = m.Person.IsDeceased
} ).ToList();
gGroupMembers.DataBind();
}
else
{
nbRoleWarning.Text = string.Format(
"{0} cannot be added to this {1} because the '{2}' group type does not have any roles defined.",
_group.GroupType.GroupMemberTerm.Pluralize(),
_group.GroupType.GroupTerm,
_group.GroupType.Name );
nbRoleWarning.Visible = true;
rFilter.Visible = false;
gGroupMembers.Visible = false;
}
}
else
{
pnlGroupMembers.Visible = false;
}
}
private void Map()
{
string mapStylingFormat = @"
<style>
#map_wrapper {{
height: {0}px;
}}
#map_canvas {{
width: 100%;
height: 100%;
border-radius: 8px;
}}
</style>";
lMapStyling.Text = string.Format( mapStylingFormat, GetAttributeValue( "MapHeight" ) );
string settingGroupTypeId = GetAttributeValue( "GroupType" );
string queryStringGroupTypeId = PageParameter( "GroupTypeId" );
if ( ( string.IsNullOrWhiteSpace(settingGroupTypeId) && string.IsNullOrWhiteSpace(queryStringGroupTypeId) ) )
{
pnlMap.Visible = false;
lMessages.Text = "<div class='alert alert-warning'><strong>Group Mapper</strong> Please configure a group type to display as a block setting or pass a GroupTypeId as a query parameter.</div>";
}
else
{
var rockContext = new RockContext();
pnlMap.Visible = true;
int groupsMapped = 0;
int groupsWithNoGeo = 0;
StringBuilder sbGroupJson = new StringBuilder();
StringBuilder sbGroupsWithNoGeo = new StringBuilder();
Guid? groupType = null;
int groupTypeId = -1;
if ( !string.IsNullOrWhiteSpace( settingGroupTypeId ) )
{
groupType = new Guid( settingGroupTypeId );
}
else
{
if ( !string.IsNullOrWhiteSpace( queryStringGroupTypeId ) && Int32.TryParse( queryStringGroupTypeId, out groupTypeId ) )
{
groupType = new GroupTypeService( rockContext ).Get( groupTypeId ).Guid;
}
}
if ( groupType != null )
{
Template template = null;
if ( GetAttributeValue( "ShowMapInfoWindow" ).AsBoolean() )
{
template = Template.Parse( GetAttributeValue( "InfoWindowContents" ).Trim() );
}
else
{
template = Template.Parse( string.Empty );
}
var groupPageRef = new PageReference( GetAttributeValue( "GroupDetailPage" ) );
// create group detail link for use in map's info window
var personPageParams = new Dictionary<string, string>();
personPageParams.Add( "PersonId", string.Empty );
var personProfilePage = LinkedPageUrl( "PersonProfilePage", personPageParams );
var groupEntityType = EntityTypeCache.Read( typeof( Group ) );
var dynamicGroups = new List<dynamic>();
// Create query to get attribute values for selected attribute keys.
var attributeKeys = GetAttributeValue( "Attributes" ).SplitDelimitedValues().ToList();
var attributeValues = new AttributeValueService( rockContext ).Queryable( "Attribute" )
.Where( v =>
v.Attribute.EntityTypeId == groupEntityType.Id &&
attributeKeys.Contains( v.Attribute.Key ) );
GroupService groupService = new GroupService( rockContext );
var groups = groupService.Queryable()
.Where( g => g.GroupType.Guid == groupType )
.Select( g => new
{
Group = g,
GroupId = g.Id,
GroupName = g.Name,
GroupGuid = g.Guid,
GroupMemberTerm = g.GroupType.GroupMemberTerm,
GroupCampus = g.Campus.Name,
IsActive = g.IsActive,
GroupLocation = g.GroupLocations
.Where( l => l.Location.GeoPoint != null )
.Select( l => new
{
l.Location.Street1,
l.Location.Street2,
l.Location.City,
l.Location.State,
PostalCode = l.Location.PostalCode,
Latitude = l.Location.GeoPoint.Latitude,
Longitude = l.Location.GeoPoint.Longitude,
Name = l.GroupLocationTypeValue.Value
} ).FirstOrDefault(),
GroupMembers = g.Members,
AttributeValues = attributeValues
.Where( v => v.EntityId == g.Id )
} );
if ( GetAttributeValue( "IncludeInactiveGroups" ).AsBoolean() == false )
{
groups = groups.Where( g => g.IsActive == true );
}
// Create dynamic object to include attribute values
foreach ( var group in groups )
{
dynamic dynGroup = new ExpandoObject();
dynGroup.GroupId = group.GroupId;
dynGroup.GroupName = group.GroupName;
// create group detail link for use in map's info window
if ( groupPageRef.PageId > 0 )
{
var groupPageParams = new Dictionary<string, string>();
groupPageParams.Add( "GroupId", group.GroupId.ToString() );
groupPageRef.Parameters = groupPageParams;
dynGroup.GroupDetailPage = groupPageRef.BuildUrl();
}
else
{
dynGroup.GroupDetailPage = string.Empty;
}
dynGroup.PersonProfilePage = personProfilePage;
dynGroup.GroupMemberTerm = group.GroupMemberTerm;
dynGroup.GroupCampus = group.GroupCampus;
dynGroup.GroupLocation = group.GroupLocation;
var groupAttributes = new List<dynamic>();
foreach ( AttributeValue value in group.AttributeValues )
{
var attrCache = AttributeCache.Read( value.AttributeId );
var dictAttribute = new Dictionary<string, object>();
dictAttribute.Add( "Key", attrCache.Key );
dictAttribute.Add( "Name", attrCache.Name );
if ( attrCache != null )
{
dictAttribute.Add( "Value", attrCache.FieldType.Field.FormatValueAsHtml( null, value.Value, attrCache.QualifierValues, false ) );
}
else
{
dictAttribute.Add( "Value", value.Value );
}
groupAttributes.Add( dictAttribute );
}
dynGroup.Attributes = groupAttributes;
var groupMembers = new List<dynamic>();
foreach ( GroupMember member in group.GroupMembers )
{
var dictMember = new Dictionary<string, object>();
dictMember.Add( "Id", member.Person.Id );
dictMember.Add( "GuidP", member.Person.Guid );
dictMember.Add( "NickName", member.Person.NickName );
dictMember.Add( "LastName", member.Person.LastName );
dictMember.Add( "RoleName", member.GroupRole.Name );
dictMember.Add( "Email", member.Person.Email );
dictMember.Add( "PhotoGuid", member.Person.Photo != null ? member.Person.Photo.Guid : Guid.Empty );
var phoneTypes = new List<dynamic>();
foreach ( PhoneNumber p in member.Person.PhoneNumbers )
{
var dictPhoneNumber = new Dictionary<string, object>();
dictPhoneNumber.Add( "Name", p.NumberTypeValue.Value );
dictPhoneNumber.Add( "Number", p.ToString() );
phoneTypes.Add( dictPhoneNumber );
}
dictMember.Add( "PhoneTypes", phoneTypes );
groupMembers.Add( dictMember );
}
dynGroup.GroupMembers = groupMembers;
dynamicGroups.Add( dynGroup );
}
// enable showing debug info
if ( GetAttributeValue( "EnableDebug" ).AsBoolean() && IsUserAuthorized( Authorization.EDIT ) )
{
lDebug.Visible = true;
lDebug.Text = dynamicGroups.Take( 5 ).lavaDebugInfo();
}
else
{
lDebug.Visible = false;
lDebug.Text = string.Empty;
}
foreach ( var group in dynamicGroups )
{
if ( group.GroupLocation != null && group.GroupLocation.Latitude != null )
{
groupsMapped++;
var groupDict = group as IDictionary<string, object>;
string infoWindow = template.Render( Hash.FromDictionary( groupDict ) ).Replace( "\n", string.Empty );
sbGroupJson.Append( string.Format(
@"{{ ""name"":""{0}"" , ""latitude"":""{1}"", ""longitude"":""{2}"", ""infowindow"":""{3}"" }},",
HttpUtility.HtmlEncode( group.GroupName ),
group.GroupLocation.Latitude,
group.GroupLocation.Longitude,
HttpUtility.HtmlEncode( infoWindow ) ) );
}
else
{
groupsWithNoGeo++;
if ( !string.IsNullOrWhiteSpace( group.GroupDetailPage ) )
{
sbGroupsWithNoGeo.Append( string.Format( @"<li><a href='{0}'>{1}</a></li>", group.GroupDetailPage, group.GroupName ) );
}
else
{
sbGroupsWithNoGeo.Append( string.Format( @"<li>{0}</li>", group.GroupName ) );
}
}
}
string groupJson = sbGroupJson.ToString();
// remove last comma
if ( groupJson.Length > 0 )
{
groupJson = groupJson.Substring( 0, groupJson.Length - 1 );
}
// add styling to map
string styleCode = "null";
string markerColor = "FE7569";
DefinedValueCache dvcMapStyle = DefinedValueCache.Read( GetAttributeValue( "MapStyle" ).AsGuid() );
if ( dvcMapStyle != null )
{
styleCode = dvcMapStyle.GetAttributeValue( "DynamicMapStyle" );
var colors = dvcMapStyle.GetAttributeValue( "Colors" ).Split( new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries ).ToList();
if ( colors.Any() )
{
markerColor = colors.First().Replace( "#", "" );
}
}
// write script to page
string mapScriptFormat = @" <script>
Sys.Application.add_load(function () {{
var groupData = JSON.parse('{{ ""groups"" : [ {0} ]}}');
var showInfoWindow = {1};
var mapStyle = {2};
var pinColor = '{3}';
var pinImage = new google.maps.MarkerImage('http://chart.apis.google.com/chart?chst=d_map_pin_letter&chld=%E2%80%A2|' + pinColor,
new google.maps.Size(21, 34),
new google.maps.Point(0,0),
new google.maps.Point(10, 34));
var pinShadow = new google.maps.MarkerImage('http://chart.apis.google.com/chart?chst=d_map_pin_shadow',
new google.maps.Size(40, 37),
new google.maps.Point(0, 0),
new google.maps.Point(12, 35));
initializeMap();
function initializeMap() {{
console.log(mapStyle);
var map;
var bounds = new google.maps.LatLngBounds();
var mapOptions = {{
mapTypeId: 'roadmap',
styles: mapStyle
}};
// Display a map on the page
map = new google.maps.Map(document.getElementById('map_canvas'), mapOptions);
map.setTilt(45);
// Display multiple markers on a map
if (showInfoWindow) {{
var infoWindow = new google.maps.InfoWindow(), marker, i;
}}
// Loop through our array of markers & place each one on the map
$.each(groupData.groups, function (i, group) {{
var position = new google.maps.LatLng(group.latitude, group.longitude);
bounds.extend(position);
marker = new google.maps.Marker({{
position: position,
map: map,
title: htmlDecode(group.name),
icon: pinImage,
shadow: pinShadow
}});
// Allow each marker to have an info window
if (showInfoWindow) {{
google.maps.event.addListener(marker, 'click', (function (marker, i) {{
return function () {{
infoWindow.setContent(htmlDecode(groupData.groups[i].infowindow));
infoWindow.open(map, marker);
}}
}})(marker, i));
}}
map.fitBounds(bounds);
}});
// Override our map zoom level once our fitBounds function runs (Make sure it only runs once)
var boundsListener = google.maps.event.addListener((map), 'bounds_changed', function (event) {{
google.maps.event.removeListener(boundsListener);
}});
}}
function htmlDecode(input) {{
var e = document.createElement('div');
e.innerHTML = input;
return e.childNodes.length === 0 ? """" : e.childNodes[0].nodeValue;
}}
}});
</script>";
string mapScript = string.Format(
mapScriptFormat,
groupJson,
GetAttributeValue( "ShowMapInfoWindow" ).AsBoolean().ToString().ToLower(),
styleCode,
markerColor );
ScriptManager.RegisterStartupScript( pnlMap, pnlMap.GetType(), "group-mapper-script", mapScript, false );
if ( groupsMapped == 0 )
{
pnlMap.Visible = false;
lMessages.Text = @" <p>
<div class='alert alert-warning fade in'>No groups were able to be mapped. You may want to check your configuration.</div>
</p>";
}
else
{
// output any warnings
if ( groupsWithNoGeo > 0 )
{
string messagesFormat = @" <p>
<div class='alert alert-warning fade in'>Some groups could not be mapped.
<button type='button' class='close' data-dismiss='alert' aria-hidden='true'><i class='fa fa-times'></i></button>
<small><a data-toggle='collapse' data-parent='#accordion' href='#map-error-details'>Show Details</a></small>
<div id='map-error-details' class='collapse'>
<p class='margin-t-sm'>
<strong>Groups That Could Not Be Mapped</strong>
<ul>
{0}
</ul>
</p>
</div>
</div>
</p>";
lMessages.Text = string.Format( messagesFormat, sbGroupsWithNoGeo.ToString() );
}
}
}
else
{
pnlMap.Visible = false;
lMessages.Text = "<div class='alert alert-warning'><strong>Group Mapper</strong> Please configure a group type to display and a location type to use.</div>";
}
}
}
/// <summary>
/// Job that will run quick SQL queries on a schedule.
///
/// Called by the <see cref="IScheduler" /> when a
/// <see cref="ITrigger" /> fires that is associated with
/// the <see cref="IJob" />.
/// </summary>
public virtual void Execute( IJobExecutionContext context )
{
JobDataMap dataMap = context.JobDetail.JobDataMap;
Guid? entryWorkflowType = dataMap.GetString( "EraEntryWorkflow" ).AsGuidOrNull();
Guid? exitWorkflowType = dataMap.GetString( "EraExitWorkflow" ).AsGuidOrNull();
bool updateVisitDates = dataMap.GetBooleanValue( "SetVisitDates" );
var groupTypeList = dataMap.GetString( "GroupTypes" );
// configuration
//
// giving
int exitGivingCount = 1;
// attendance
int exitAttendanceCountShort = 1;
int exitAttendanceCountLong = 8;
// get era dataset from stored proc
var resultContext = new RockContext();
var eraAttribute = AttributeCache.Read( SystemGuid.Attribute.PERSON_ERA_CURRENTLY_AN_ERA.AsGuid() );
var eraStartAttribute = AttributeCache.Read( SystemGuid.Attribute.PERSON_ERA_START_DATE.AsGuid() );
var eraEndAttribute = AttributeCache.Read( SystemGuid.Attribute.PERSON_ERA_END_DATE.AsGuid() );
resultContext.Database.CommandTimeout = 3600;
var results = resultContext.Database.SqlQuery<EraResult>( "spCrm_FamilyAnalyticsEraDataset" ).ToList();
int personEntityTypeId = EntityTypeCache.Read( "Rock.Model.Person" ).Id;
int attributeEntityTypeId = EntityTypeCache.Read( "Rock.Model.Attribute" ).Id;
int eraAttributeId = AttributeCache.Read( SystemGuid.Attribute.PERSON_ERA_CURRENTLY_AN_ERA.AsGuid() ).Id;
int personAnalyticsCategoryId = CategoryCache.Read( SystemGuid.Category.HISTORY_PERSON_ANALYTICS.AsGuid() ).Id;
foreach (var result in results )
{
// create new rock context for each family (https://weblog.west-wind.com/posts/2014/Dec/21/Gotcha-Entity-Framework-gets-slow-in-long-Iteration-Loops)
RockContext updateContext = new RockContext();
var attributeValueService = new AttributeValueService( updateContext );
var historyService = new HistoryService( updateContext );
// if era ensure it still meets requirements
if ( result.IsEra )
{
if (result.ExitGiftCountDuration < exitGivingCount && result.ExitAttendanceCountDurationShort < exitAttendanceCountShort && result.ExitAttendanceCountDurationLong < exitAttendanceCountLong )
{
// exit era (delete attribute value from each person in family)
var family = new GroupService( updateContext ).Queryable( "Members, Members.Person" ).AsNoTracking().Where( m => m.Id == result.FamilyId ).FirstOrDefault();
if ( family != null ) {
foreach ( var person in family.Members.Select( m => m.Person ) ) {
// remove the era flag
var eraAttributeValue = attributeValueService.Queryable().Where( v => v.AttributeId == eraAttribute.Id && v.EntityId == person.Id ).FirstOrDefault();
if ( eraAttributeValue != null )
{
attributeValueService.Delete( eraAttributeValue );
}
// set end date
var eraEndAttributeValue = attributeValueService.Queryable().Where( v => v.AttributeId == eraEndAttribute.Id && v.EntityId == person.Id ).FirstOrDefault();
if ( eraEndAttributeValue == null )
{
eraEndAttributeValue = new AttributeValue();
eraEndAttributeValue.EntityId = person.Id;
eraEndAttributeValue.AttributeId = eraEndAttribute.Id;
attributeValueService.Add( eraEndAttributeValue );
}
eraEndAttributeValue.Value = RockDateTime.Now.ToString();
// add a history record
if ( personAnalyticsCategoryId != 0 && personEntityTypeId != 0 && attributeEntityTypeId != 0 && eraAttributeId != 0 )
{
History historyRecord = new History();
historyService.Add( historyRecord );
historyRecord.EntityTypeId = personEntityTypeId;
historyRecord.EntityId = person.Id;
historyRecord.CreatedDateTime = RockDateTime.Now;
historyRecord.CreatedByPersonAliasId = person.PrimaryAliasId;
historyRecord.Caption = "eRA";
historyRecord.Summary = "Exited eRA Status";
historyRecord.Verb = "EXITED";
historyRecord.RelatedEntityTypeId = attributeEntityTypeId;
historyRecord.RelatedEntityId = eraAttributeId;
historyRecord.CategoryId = personAnalyticsCategoryId;
}
updateContext.SaveChanges();
}
// launch exit workflow
if ( exitWorkflowType.HasValue )
{
LaunchWorkflow( exitWorkflowType.Value, family );
}
}
}
}
else
{
// entered era
var family = new GroupService( updateContext ).Queryable( "Members" ).AsNoTracking().Where( m => m.Id == result.FamilyId ).FirstOrDefault();
if ( family != null )
{
foreach ( var person in family.Members.Select( m => m.Person ) )
{
// set era attribute to true
var eraAttributeValue = attributeValueService.Queryable().Where( v => v.AttributeId == eraAttribute.Id && v.EntityId == person.Id ).FirstOrDefault();
if ( eraAttributeValue == null )
{
eraAttributeValue = new AttributeValue();
eraAttributeValue.EntityId = person.Id;
eraAttributeValue.AttributeId = eraAttribute.Id;
attributeValueService.Add( eraAttributeValue );
}
eraAttributeValue.Value = bool.TrueString;
// add start date
var eraStartAttributeValue = attributeValueService.Queryable().Where( v => v.AttributeId == eraStartAttribute.Id && v.EntityId == person.Id ).FirstOrDefault();
if (eraStartAttributeValue == null )
{
eraStartAttributeValue = new AttributeValue();
eraStartAttributeValue.EntityId = person.Id;
eraStartAttributeValue.AttributeId = eraStartAttribute.Id;
attributeValueService.Add( eraStartAttributeValue );
}
eraStartAttributeValue.Value = RockDateTime.Now.ToString();
// delete end date if it exists
var eraEndAttributeValue = attributeValueService.Queryable().Where( v => v.AttributeId == eraEndAttribute.Id && v.EntityId == person.Id ).FirstOrDefault();
if ( eraEndAttributeValue != null )
{
attributeValueService.Delete( eraEndAttributeValue );
}
// add a history record
if ( personAnalyticsCategoryId != 0 && personEntityTypeId != 0 && attributeEntityTypeId != 0 && eraAttributeId != 0 )
{
History historyRecord = new History();
historyService.Add( historyRecord );
historyRecord.EntityTypeId = personEntityTypeId;
historyRecord.EntityId = person.Id;
historyRecord.CreatedDateTime = RockDateTime.Now;
historyRecord.CreatedByPersonAliasId = person.PrimaryAliasId;
historyRecord.Caption = "eRA";
historyRecord.Summary = "Entered eRA Status";
historyRecord.Verb = "ENTERED";
historyRecord.RelatedEntityTypeId = attributeEntityTypeId;
historyRecord.RelatedEntityId = eraAttributeId;
historyRecord.CategoryId = personAnalyticsCategoryId;
}
updateContext.SaveChanges();
}
// launch entry workflow
if ( entryWorkflowType.HasValue )
{
LaunchWorkflow( entryWorkflowType.Value, family );
}
}
}
// update stats
}
// load giving attributes
resultContext.Database.ExecuteSqlCommand( "spCrm_FamilyAnalyticsGiving" );
// load attendance attributes
resultContext.Database.ExecuteSqlCommand( "spCrm_FamilyAnalyticsAttendance" );
// process history for group types
if (!string.IsNullOrWhiteSpace( groupTypeList ) )
{
string[] groupTypeGuids = groupTypeList.Split( ',' );
var inactiveRecordValue = DefinedValueCache.Read( SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE );
var groupTypeEntityTypeId = EntityTypeCache.Read( "Rock.Model.GroupType" ).Id;
foreach ( var groupTypeGuid in groupTypeGuids )
{
var groupType = GroupTypeCache.Read( groupTypeGuid.AsGuid() );
if ( groupType != null )
{
// if the person is in a group of that type and the last history record for that group type isn't START write a start
RockContext rockContext = new RockContext();
// get history for this group type
var historyRecords = new HistoryService( rockContext ).Queryable()
.Where( h =>
h.EntityTypeId == personEntityTypeId
&& h.RelatedEntityTypeId == groupTypeEntityTypeId
&& h.RelatedEntityId == groupType.Id
)
.GroupBy( h => h.EntityId )
.Select( g => g.OrderByDescending( h => h.CreatedDateTime ).Select( h => new { h.EntityId, h.Verb } ).FirstOrDefault() )
.ToList();
// get group member information
var groupMemberInfo = new GroupMemberService( rockContext ).Queryable()
.Where( m =>
m.Group.GroupTypeId == groupType.Id
&& m.GroupMemberStatus == GroupMemberStatus.Active
&& m.Group.IsActive
//&& m.Person.RecordStatusValueId != inactiveRecordValue.Id
)
.GroupBy( m => m.PersonId )
.Select( g => g.OrderBy( m => m.CreatedDateTime ).Select( m => new { m.PersonId, m.CreatedDateTime, PersonAliasId = m.Person.Aliases.Select( p => p.Id ).FirstOrDefault() } ).FirstOrDefault() )
.ToList();
var needsStartDate = groupMemberInfo.Where( m => !historyRecords.Any( h => h.EntityId == m.PersonId && h.Verb == "STARTED" ) );
foreach ( var startItem in needsStartDate )
{
using ( RockContext updateContext = new RockContext() )
{
var historyService = new HistoryService( updateContext );
History history = new History();
historyService.Add( history );
history.EntityTypeId = personEntityTypeId;
history.EntityId = startItem.PersonId;
history.RelatedEntityTypeId = groupTypeEntityTypeId;
history.RelatedEntityId = groupType.Id;
history.Caption = groupType.Name;
history.Summary = "Started Membership in Group Of Type";
history.Verb = "STARTED";
history.CreatedDateTime = startItem.CreatedDateTime;
history.CreatedByPersonAliasId = startItem.PersonAliasId;
history.CategoryId = personAnalyticsCategoryId;
updateContext.SaveChanges();
}
}
var needsStoppedDate = historyRecords.Where( h => h.Verb == "STARTED" && !groupMemberInfo.Any( m => m.PersonId == h.EntityId ) );
foreach ( var stopItem in needsStoppedDate )
{
using ( RockContext updateContext = new RockContext() )
{
var person = new PersonService( updateContext ).Get( stopItem.EntityId );
if ( person != null )
{
var historyService = new HistoryService( updateContext );
History history = new History();
historyService.Add( history );
history.EntityTypeId = personEntityTypeId;
history.EntityId = person.Id;
history.RelatedEntityTypeId = groupTypeEntityTypeId;
history.RelatedEntityId = groupType.Id;
history.Caption = groupType.Name;
history.Summary = "Stopped Membership in Group Of Type";
history.Verb = "STOPPED";
history.CreatedDateTime = RockDateTime.Now;
history.CreatedByPersonAliasId = person.PrimaryAliasId;
history.CategoryId = personAnalyticsCategoryId;
updateContext.SaveChanges();
}
}
}
}
}
}
// process visit dates
if ( updateVisitDates )
{
resultContext.Database.ExecuteSqlCommand( "spCrm_FamilyAnalyticsUpdateVisitDates" );
}
}
/// <summary>
/// Loads the <see cref="P:IHasAttributes.Attributes" /> and <see cref="P:IHasAttributes.AttributeValues" /> of any <see cref="IHasAttributes" /> object
/// </summary>
/// <param name="entity">The item.</param>
/// <param name="rockContext">The rock context.</param>
public static void LoadAttributes(Rock.Attribute.IHasAttributes entity, RockContext rockContext)
{
if (entity != null)
{
Dictionary <string, PropertyInfo> properties = new Dictionary <string, PropertyInfo>();
Type entityType = entity.GetType();
if (entityType.Namespace == "System.Data.Entity.DynamicProxies")
{
entityType = entityType.BaseType;
}
rockContext = rockContext ?? new RockContext();
// Check for group type attributes
var groupTypeIds = new List <int>();
if (entity is GroupMember || entity is Group || entity is GroupType)
{
// Can't use GroupTypeCache here since it loads attributes and would result in a recursive stack overflow situation
var groupTypeService = new GroupTypeService(rockContext);
GroupType groupType = null;
if (entity is GroupMember)
{
var group = ((GroupMember)entity).Group ?? new GroupService(rockContext)
.Queryable().AsNoTracking().FirstOrDefault(g => g.Id == ((GroupMember)entity).GroupId);
if (group != null)
{
groupType = group.GroupType ?? groupTypeService
.Queryable().AsNoTracking().FirstOrDefault(t => t.Id == group.GroupTypeId);
}
}
else if (entity is Group)
{
groupType = ((Group)entity).GroupType ?? groupTypeService
.Queryable().AsNoTracking().FirstOrDefault(t => t.Id == ((Group)entity).GroupTypeId);
}
else
{
groupType = ((GroupType)entity);
}
while (groupType != null)
{
groupTypeIds.Insert(0, groupType.Id);
// Check for inherited group type id's
if (groupType.InheritedGroupTypeId.HasValue)
{
groupType = groupType.InheritedGroupType ?? groupTypeService
.Queryable().AsNoTracking().FirstOrDefault(t => t.Id == (groupType.InheritedGroupTypeId ?? 0));
}
else
{
groupType = null;
}
}
}
foreach (PropertyInfo propertyInfo in entityType.GetProperties())
{
properties.Add(propertyInfo.Name.ToLower(), propertyInfo);
}
Rock.Model.AttributeService attributeService = new Rock.Model.AttributeService(rockContext);
Rock.Model.AttributeValueService attributeValueService = new Rock.Model.AttributeValueService(rockContext);
var inheritedAttributes = new Dictionary <int, List <Rock.Web.Cache.AttributeCache> >();
if (groupTypeIds.Any())
{
groupTypeIds.ForEach(g => inheritedAttributes.Add(g, new List <Rock.Web.Cache.AttributeCache>()));
}
else
{
inheritedAttributes.Add(0, new List <Rock.Web.Cache.AttributeCache>());
}
var attributes = new List <Rock.Web.Cache.AttributeCache>();
// Get all the attributes that apply to this entity type and this entity's properties match any attribute qualifiers
var entityTypeCache = Rock.Web.Cache.EntityTypeCache.Read(entityType);
if (entityTypeCache != null)
{
int entityTypeId = entityTypeCache.Id;
foreach (var attribute in attributeService.Queryable()
.AsNoTracking()
.Where(a => a.EntityTypeId == entityTypeCache.Id)
.Select(a => new
{
a.Id,
a.EntityTypeQualifierColumn,
a.EntityTypeQualifierValue
}
))
{
// group type ids exist (entity is either GroupMember, Group, or GroupType) and qualifier is for a group type id
if (groupTypeIds.Any() && (
(entity is GroupMember && string.Compare(attribute.EntityTypeQualifierColumn, "GroupTypeId", true) == 0) ||
(entity is Group && string.Compare(attribute.EntityTypeQualifierColumn, "GroupTypeId", true) == 0) ||
(entity is GroupType && string.Compare(attribute.EntityTypeQualifierColumn, "Id", true) == 0)))
{
int groupTypeIdValue = int.MinValue;
if (int.TryParse(attribute.EntityTypeQualifierValue, out groupTypeIdValue) && groupTypeIds.Contains(groupTypeIdValue))
{
inheritedAttributes[groupTypeIdValue].Add(Rock.Web.Cache.AttributeCache.Read(attribute.Id));
}
}
else if (string.IsNullOrEmpty(attribute.EntityTypeQualifierColumn) ||
(properties.ContainsKey(attribute.EntityTypeQualifierColumn.ToLower()) &&
(string.IsNullOrEmpty(attribute.EntityTypeQualifierValue) ||
(properties[attribute.EntityTypeQualifierColumn.ToLower()].GetValue(entity, null) ?? "").ToString() == attribute.EntityTypeQualifierValue)))
{
attributes.Add(Rock.Web.Cache.AttributeCache.Read(attribute.Id));
}
}
}
var allAttributes = new List <Rock.Web.Cache.AttributeCache>();
foreach (var attributeGroup in inheritedAttributes)
{
foreach (var attribute in attributeGroup.Value)
{
allAttributes.Add(attribute);
}
}
foreach (var attribute in attributes)
{
allAttributes.Add(attribute);
}
var attributeValues = new Dictionary <string, Rock.Model.AttributeValue>();
if (allAttributes.Any())
{
foreach (var attribute in allAttributes)
{
// Add a placeholder for this item's value for each attribute
attributeValues.Add(attribute.Key, null);
}
// If loading attributes for a saved item, read the item's value(s) for each attribute
if (!entityTypeCache.IsEntity || entity.Id != 0)
{
List <int> attributeIds = allAttributes.Select(a => a.Id).ToList();
foreach (var attributeValue in attributeValueService.Queryable().AsNoTracking()
.Where(v => v.EntityId == entity.Id && attributeIds.Contains(v.AttributeId)))
{
var attributeKey = AttributeCache.Read(attributeValue.AttributeId).Key;
attributeValues[attributeKey] = attributeValue.Clone(false) as Rock.Model.AttributeValue;
}
}
// Look for any attributes that don't have a value and create a default value entry
foreach (var attribute in allAttributes)
{
if (attributeValues[attribute.Key] == null)
{
var attributeValue = new Rock.Model.AttributeValue();
attributeValue.AttributeId = attribute.Id;
if (entity.AttributeValueDefaults != null && entity.AttributeValueDefaults.ContainsKey(attribute.Name))
{
attributeValue.Value = entity.AttributeValueDefaults[attribute.Name];
}
else
{
attributeValue.Value = attribute.DefaultValue;
}
attributeValues[attribute.Key] = attributeValue;
}
else
{
if (!String.IsNullOrWhiteSpace(attribute.DefaultValue) &&
String.IsNullOrWhiteSpace(attributeValues[attribute.Key].Value))
{
attributeValues[attribute.Key].Value = attribute.DefaultValue;
}
}
}
}
entity.Attributes = new Dictionary <string, Web.Cache.AttributeCache>();
allAttributes.ForEach(a => entity.Attributes.Add(a.Key, a));
entity.AttributeValues = attributeValues;
}
}
protected void CalulateMetrics(int CampusId)
{
// specify which attribute key we want to work with
var attributeKeyCompositeUseGlobalValue = "CompositeUseGlobalValue";
var attributeKeyCompositeGoalMultiplier = "CompositeGoalMultiplier";
var attributeValueService = new AttributeValueService(rockContext);
// specify NULL as the EntityId since this is a GlobalAttribute
var compositeUseGlobalValue = attributeValueService.GetGlobalAttributeValue(attributeKeyCompositeUseGlobalValue);
var compositeGoalMultiplier = attributeValueService.GetGlobalAttributeValue(attributeKeyCompositeGoalMultiplier);
if (bool.Parse(compositeUseGlobalValue.ToString()) == true)
{
UseGlobalAttributeGoal = true;
GoalMultiplier = Convert.ToDouble(compositeGoalMultiplier.ToString());
}
//Set Last Sunday Date
DateTime now = DateTime.Now;
DateTime dt = DateTime.Now.StartOfWeek(DayOfWeek.Sunday);
SundayDate = dt.ToShortDateString();
SundayDateSQLFormatted = dt.Date.ToString("yyyy-MM-dd");
DateTime lastTuesday = DateTime.Now.AddDays(-1);
while (lastTuesday.DayOfWeek != DayOfWeek.Wednesday)
lastTuesday = lastTuesday.AddDays(-1);
DateTime lastWednesday = DateTime.Now.AddDays(-1);
while (lastWednesday.DayOfWeek != DayOfWeek.Wednesday)
lastWednesday = lastWednesday.AddDays(-1);
FinancialStartDate = lastTuesday.AddDays(-7).ToString("yyyy-MM-dd");
FinancialEndDate = lastWednesday.ToString("yyyy-MM-dd");
FinancialStartDateLastWeek = lastTuesday.AddDays(-14).ToString("yyyy-MM-dd");
FinancialEndDateLastWeek = lastWednesday.AddDays(-7).ToString("yyyy-MM-dd");
sMonth = DateTime.Now.Month.ToString();
sYear = DateTime.Now.Year.ToString();
int iMonth = Int32.Parse(sMonth);
int iYear = Int32.Parse(sYear);
int lastDayOfCurrentMonth = DateTime.DaysInMonth(iYear, iMonth);
int lastDayOfLastMonth = DateTime.DaysInMonth(iYear, iMonth - 1);
DateTime fiscalYearStartDate = new DateTime(iYear, 9, 1);
DateTime fiscalYearEndDate = new DateTime(iYear + 1, 8, 31);
DateTime lastFiscalYearStartDate = new DateTime(iYear - 1, 9, 1);
DateTime lastFiscalYearEndDate = new DateTime(iYear, 8, 31);
DateTime start2020 = new DateTime(2020, 1, 1);
DateTime end2020 = new DateTime(2020, 12, 31);
if (iMonth < 9)
{
fiscalYearStartDate = fiscalYearStartDate.AddYears(-1);
fiscalYearEndDate = fiscalYearEndDate.AddYears(-1);
lastFiscalYearStartDate = lastFiscalYearStartDate.AddYears(-1);
lastFiscalYearEndDate = lastFiscalYearEndDate.AddYears(-1);
}
DateTime periodEndDate = new DateTime(iYear, iMonth - 1, lastDayOfLastMonth);
DateTime lastPeriodEndDate = new DateTime(iYear - 1, iMonth - 1, lastDayOfLastMonth);
FiscalYearStartDate = fiscalYearStartDate.ToShortDateString();
FiscalYearEndDate = fiscalYearEndDate.ToShortDateString();
PeriodStartDate = fiscalYearStartDate.ToShortDateString();
PeriodEndDate = periodEndDate.ToShortDateString();
LastPeriodStartDate = lastFiscalYearStartDate.ToShortDateString();
LastPeriodEndDate = lastPeriodEndDate.ToShortDateString();
Last8WkStartDate = now.AddDays(-57).ToShortDateString();
Last8WkEndDate = now.ToShortDateString();
Last8WkStartDateLy = now.AddDays(-57).AddYears(-1).ToShortDateString();
Last8WkEndDateLy = now.AddYears(-1).ToShortDateString();
Last6WkStartDate = now.AddDays(-43).ToShortDateString();
Last6WkEndDate = now.ToShortDateString();
Last6WkStartDateLy = now.AddDays(-43).AddYears(-1).ToShortDateString();
Last6WkEndDateLy = now.AddYears(-1).ToShortDateString();
DateTime last6WkStartDate = now.AddDays(-43);
DateTime last6WkEndDate = now;
DateTime last6WkStartDateLy = now.AddDays(-43).AddYears(-1);
DateTime last6WkEndDateLy = now.AddYears(-1);
switch (iMonth)
{
case 09:
CurrentMonthInFiscalYear = 1;
GoalOffsetMultiplier = .083;
SecondaryGoalOffsetMultiplier = .89;
break;
case 10:
CurrentMonthInFiscalYear = 2;
GoalOffsetMultiplier = .167;
SecondaryGoalOffsetMultiplier = .90;
break;
case 11:
CurrentMonthInFiscalYear = 3;
GoalOffsetMultiplier = .25;
SecondaryGoalOffsetMultiplier = .91;
break;
case 12:
CurrentMonthInFiscalYear = 4;
GoalOffsetMultiplier = .333;
SecondaryGoalOffsetMultiplier = .92;
break;
case 01:
CurrentMonthInFiscalYear = 5;
GoalOffsetMultiplier = .417;
SecondaryGoalOffsetMultiplier = .93;
break;
case 02:
CurrentMonthInFiscalYear = 6;
GoalOffsetMultiplier = .5;
SecondaryGoalOffsetMultiplier = .94;
break;
case 03:
CurrentMonthInFiscalYear = 7;
GoalOffsetMultiplier = .583;
SecondaryGoalOffsetMultiplier = .95;
break;
case 04:
CurrentMonthInFiscalYear = 8;
GoalOffsetMultiplier = .667;
SecondaryGoalOffsetMultiplier = .96;
break;
case 05:
CurrentMonthInFiscalYear = 9;
GoalOffsetMultiplier = .75;
SecondaryGoalOffsetMultiplier = .97;
break;
case 06:
CurrentMonthInFiscalYear = 10;
GoalOffsetMultiplier = .883;
SecondaryGoalOffsetMultiplier = .98;
break;
case 07:
CurrentMonthInFiscalYear = 11;
GoalOffsetMultiplier = .917;
SecondaryGoalOffsetMultiplier = .99;
break;
case 08:
CurrentMonthInFiscalYear = 12;
GoalOffsetMultiplier = 1;
SecondaryGoalOffsetMultiplier = 1;
break;
}
//-------Attendance-------
//Auditorium
iAttendanceAud = Get6WkAttendanceAuditorium(CampusId, last6WkStartDate, last6WkEndDate);
iAttendanceAudLastYear = Get6WkAttendanceAuditorium(CampusId, last6WkStartDateLy, last6WkEndDateLy);
iAttendanceAudGoal2020 = GetMetrics(2, CampusId, start2020, end2020, 1);
//Kids
iAttendanceKids = Get6WkAttendanceKids(CampusId, last6WkStartDate, last6WkEndDate);
iAttendanceKidsLastYear = Get6WkAttendanceKids(CampusId, last6WkStartDateLy, last6WkEndDateLy);
iAttendanceChildGoal2020 = GetMetrics(3, CampusId, start2020, end2020, 1);
//Students
iAttendanceStudents = Get6WkAttendanceStudents(CampusId, last6WkStartDate, last6WkEndDate);
iAttendanceStudentsLastYear = Get6WkAttendanceStudents(CampusId, last6WkStartDateLy, last6WkEndDateLy);
iAttendanceStudentGoal2020 = GetMetrics(5, CampusId, start2020, end2020, 1);
//HighSchool
iAttendanceHighSchool = Get6WkAttendanceHighSchool(CampusId, last6WkStartDate, last6WkEndDate);
iAttendanceHighSchoolLastYear = Get6WkAttendanceHighSchool(CampusId, last6WkStartDateLy, last6WkEndDateLy);
iAttendanceStudentGoal2020 = GetMetrics(5, CampusId, start2020, end2020, 1);
if (UseGlobalAttributeGoal == true)
{
iAttendanceAudGoalCurrent = Convert.ToInt32((double?)iAttendanceAudLastYear * GoalMultiplier);
iAttendanceChildGoalCurrent = Convert.ToInt32((double?)iAttendanceKidsLastYear * GoalMultiplier);
iAttendanceStudentGoalCurrent = Convert.ToInt32((double?)iAttendanceStudentsLastYear * GoalMultiplier);
}
else
{
iAttendanceAudGoalCurrent = GetMetrics(2, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
iAttendanceChildGoalCurrent = GetMetrics(3, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
iAttendanceStudentGoalCurrent = GetMetrics(5, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
}
//All
iAttendanceAll = Get6WkAttendanceAll(CampusId, last6WkStartDate, last6WkEndDate);
iAttendanceAllLastYear = Get6WkAttendanceAll(CampusId, last6WkStartDateLy, last6WkEndDateLy);
iAttendanceAllGoalCurrent = iAttendanceAudGoalCurrent + iAttendanceChildGoalCurrent + iAttendanceStudentGoalCurrent;
iAttendanceAllGoal2020 = iAttendanceAudGoal2020 + iAttendanceChildGoal2020 + iAttendanceStudentGoal2020;
//Calculate attendance goal progress
iAttendanceAudGoalProgress = (double?)iAttendanceAud / ((double?)iAttendanceAudGoalCurrent * SecondaryGoalOffsetMultiplier) * 100;
iAttendanceChildGoalProgress = (double?)iAttendanceKids / ((double?)iAttendanceChildGoalCurrent * SecondaryGoalOffsetMultiplier) * 100;
iAttendanceStudentGoalProgress = (double?)iAttendanceStudents / ((double?)iAttendanceStudentGoalCurrent * SecondaryGoalOffsetMultiplier) * 100;
iAttendanceHighSchoolGoalProgress = (double?)iAttendanceHighSchool / ((double?)iAttendanceHighSchoolGoalCurrent * SecondaryGoalOffsetMultiplier) * 100;
iAttendanceAllGoalProgress = (double?)iAttendanceAll / ((double?)iAttendanceAllGoalCurrent * SecondaryGoalOffsetMultiplier) * 100;
//-------Baptisms-------
//YTD
iBaptisms = GetMetrics(11, CampusId, fiscalYearStartDate, periodEndDate, 0);
//LastYTD
iBaptismsLastYear = GetMetrics(11, CampusId, lastFiscalYearStartDate, lastPeriodEndDate, 0);
//Current Goal
iBaptismsGoalCurrent = GetMetrics(11, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
//2020 Goal
iBaptismsGoal2020 = GetMetrics(11, CampusId, start2020, end2020, 1);
//8Wk
iBaptisms8Wk = GetMetrics(11, CampusId, now.AddDays(-57), now, 0);
iBaptisms8WkLy = GetMetrics(11, CampusId, now.AddDays(-57).AddYears(-1), now.AddYears(-1), 0);
iBaptisms8WkProgress = (((double)iBaptisms8Wk - (double)iBaptisms8WkLy) / (double)iBaptisms8WkLy) * 100;
//-------Partners-------
//YTD
iPartners = GetMetricsLatest(20, CampusId, fiscalYearStartDate, periodEndDate, 0);
//LastYTD
iPartnersLastYear = GetMetricsLatest(20, CampusId, lastFiscalYearStartDate, lastPeriodEndDate, 0);
//Current Goal
iPartnersGoalCurrent = GetMetricsLatest(20, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
//2020 Goal
iPartnersGoal2020 = GetMetricsLatest(20, CampusId, start2020, end2020, 1);
//-------Commitments-------
//YTD
iCommitments = GetMetrics(12, CampusId, fiscalYearStartDate, periodEndDate, 0);
//LastYTD
iCommitmentsLastYear = GetMetrics(12, CampusId, lastFiscalYearStartDate, lastPeriodEndDate, 0);
//Current Goal
iCommitmentsGoalCurrent = GetMetrics(12, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
//2020 Goal
iCommitmentsGoal2020 = GetMetrics(12, CampusId, start2020, end2020, 1);
//8Wk
iCommitments8Wk = GetMetrics(12, CampusId, now.AddDays(-57), now, 0);
iCommitments8WkLy = GetMetrics(12, CampusId, now.AddDays(-57).AddYears(-1), now.AddYears(-1), 0);
//-------Recommitments-------
//YTD
iRecommitments = GetMetrics(13, CampusId, fiscalYearStartDate, periodEndDate, 0);
//LastYTD
iRecommitmentsLastYear = GetMetrics(13, CampusId, lastFiscalYearStartDate, lastPeriodEndDate, 0);
//Current Goal
iRecommitmentsGoalCurrent = GetMetrics(13, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
//2020 Goal
iRecommitmentsGoal2020 = GetMetrics(13, CampusId, start2020, end2020, 1);
//8Wk
iRecommitments8Wk = GetMetrics(13, CampusId, now.AddDays(-57), now, 0);
iRecommitments8WkLy = GetMetrics(13, CampusId, now.AddDays(-57).AddYears(-1), now.AddYears(-1), 0);
//-------Volunteers-------
//YTD
iVolunteers = GetMetricsLatest(16, CampusId, fiscalYearStartDate, periodEndDate, 0);
//LastYTD
iVolunteersLastYear = GetMetricsLatest(16, CampusId, lastFiscalYearStartDate, lastPeriodEndDate, 0);
//Current Goal
iVolunteersGoalCurrent = GetMetricsLatest(16, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
//2020 Goal
iVolunteersGoal2020 = GetMetricsLatest(16, CampusId, start2020, end2020, 1);
//-------SmallGroupParticipants-------
//YTD
iSmallGroupParticipants = GetMetricsLatest(17, CampusId, fiscalYearStartDate, periodEndDate, 0);
//LastYTD
iSmallGroupParticipantsLastYear = GetMetricsLatest(17, CampusId, lastFiscalYearStartDate, lastPeriodEndDate, 0);
//Current Goal
iSmallGroupParticipantsGoalCurrent = GetMetricsLatest(17, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
//2020 Goal
iSmallGroupParticipantsGoal2020 = GetMetricsLatest(17, CampusId, start2020, end2020, 1);
//-------SmallGroupLeaders-------
//YTD
iSmallGroupLeaders = GetMetricsLatest(18, CampusId, fiscalYearStartDate, periodEndDate, 0);
//LastYTD
iSmallGroupLeadersLastYear = GetMetricsLatest(18, CampusId, lastFiscalYearStartDate, lastPeriodEndDate, 0);
//Current Goal
iSmallGroupLeadersGoalCurrent = GetMetricsLatest(18, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
//2020 Goal
iSmallGroupLeadersGoal2020 = GetMetricsLatest(18, CampusId, start2020, end2020, 1);
//-------SmallGroups-------
//YTD
iSmallGroups = GetMetricsLatest(34, CampusId, fiscalYearStartDate, periodEndDate, 0);
//LastYTD
iSmallGroupsLastYear = GetMetricsLatest(34, CampusId, lastFiscalYearStartDate, lastPeriodEndDate, 0);
//Current Goal
iSmallGroupsGoalCurrent = GetMetricsLatest(34, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
//2020 Goal
iSmallGroupsGoal2020 = GetMetricsLatest(34, CampusId, start2020, end2020, 1);
//-------NewtoNewPointe-------
//YTD
iNewtoNewPointe = GetMetrics(21, CampusId, fiscalYearStartDate, periodEndDate, 0);
//LastYTD
iNewtoNewPointeLastYear = GetMetrics(21, CampusId, lastFiscalYearStartDate, lastPeriodEndDate, 0);
//Current Goal
iNewtoNewPointeGoalCurrent = GetMetrics(21, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
//2020 Goal
iNewtoNewPointeGoal2020 = GetMetrics(21, CampusId, start2020, end2020, 1);
//8Wk
iNewtoNewPointe8Wk = GetMetrics(21, CampusId, now.AddDays(-57), now, 0);
iNewtoNewPointe8WkLy = GetMetrics(21, CampusId, now.AddDays(-57).AddYears(-1), now.AddYears(-1), 0);
dNewtoNewPointe8WkProgress = (((double)iNewtoNewPointe8Wk - (double)iNewtoNewPointe8WkLy) / (double)iNewtoNewPointe8WkLy) * 100;
//-------DiscoverGroups-------
//YTD
iDiscoverGroups = GetMetrics(22, CampusId, fiscalYearStartDate, periodEndDate, 0);
//LastYTD
iDiscoverGroupsLastYear = GetMetrics(22, CampusId, lastFiscalYearStartDate, lastPeriodEndDate, 0);
//Current Goal
iDiscoverGroupsGoalCurrent = GetMetrics(22, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
//2020 Goal
iDiscoverGroupsGoal2020 = GetMetrics(2, CampusId, start2020, end2020, 1);
//8Wk
iDiscoverGroups8Wk = GetMetrics(22, CampusId, now.AddDays(-57), now, 0);
iDiscoverGroups8WkLy = GetMetrics(22, CampusId, now.AddDays(-57).AddYears(-1), now.AddYears(-1), 0);
dDiscoverGroups8WkProgress = (((double)iDiscoverGroups8Wk - (double)iDiscoverGroups8WkLy) / (double)iDiscoverGroups8WkLy) * 100;
//-------CampusGroups-------
//YTD
iCampusGroups = GetMetrics(24, CampusId, fiscalYearStartDate, periodEndDate, 0);
//LastYTD
iCampusGroupsLastYear = GetMetrics(24, CampusId, lastFiscalYearStartDate, lastPeriodEndDate, 0);
//Current Goal
iCampusGroupsGoalCurrent = GetMetrics(24, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
//2020 Goal
iCampusGroupsGoal2020 = GetMetrics(24, CampusId, start2020, end2020, 1);
//8Wk
iCampusGroups8Wk = GetMetrics(24, CampusId, now.AddDays(-57), now, 0);
iCampusGroups8WkLy = GetMetrics(24, CampusId, now.AddDays(-57).AddYears(-1), now.AddYears(-1), 0);
dCampusGroups8WkProgress = (((double)iCampusGroups8Wk - (double)iCampusGroups8WkLy) / (double)iCampusGroups8WkLy) * 100;
//-------NewHere-------
//YTD
iNewHere = GetMetrics(14, CampusId, fiscalYearStartDate, periodEndDate, 0);
//LastYTD
iNewHereLastYear = GetMetrics(14, CampusId, lastFiscalYearStartDate, lastPeriodEndDate, 0);
//Current Goal
iNewHereGoalCurrent = GetMetrics(14, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
//2020 Goal
iNewHereGoal2020 = GetMetrics(14, CampusId, start2020, end2020, 1);
//8Wk
iNewHere8Wk = GetMetrics(14, CampusId, now.AddDays(-57), now, 0);
iNewHere8WkLy = GetMetrics(14, CampusId, now.AddDays(-57).AddYears(-1), now.AddYears(-1), 0);
dNewHere8WkProgress = (((double)iNewHere8Wk - (double)iNewHere8WkLy) / (double)iNewHere8WkLy) * 100;
//-------Inactive Followups-------
//Total
iInactiveFollowup = GetMetrics(35, CampusId, fiscalYearStartDate, periodEndDate, 0);
//Completed
iInactiveFollowupComplete = GetMetrics(38, CampusId, fiscalYearStartDate, periodEndDate, 0);
//Inconplete
iInactiveFollowupIncomplete = iInactiveFollowup - iInactiveFollowupComplete;
//Progress
iInactiveFollowupProgress = (double)iInactiveFollowupComplete / (double)iInactiveFollowup * 100;
//-------Finances-------
expenses = .99;
giving = .95;
//TODO: need to make a method to get these as a double (not an int)
//Get Goals based on Global Attribute Multiplier or values stored in metrics table
if (UseGlobalAttributeGoal == true)
{
iBaptismsGoalCurrent = Convert.ToInt32((double?)iBaptismsLastYear * GoalMultiplier);
iPartnersGoalCurrent = Convert.ToInt32((double?)iPartnersLastYear * GoalMultiplier);
iCommitmentsGoalCurrent = Convert.ToInt32((double?)iCommitmentsLastYear * GoalMultiplier);
iRecommitmentsGoalCurrent = Convert.ToInt32((double?)iRecommitmentsLastYear * GoalMultiplier);
iVolunteersGoalCurrent = Convert.ToInt32((double?)iVolunteersLastYear * GoalMultiplier);
iSmallGroupParticipantsGoalCurrent = Convert.ToInt32((double?)iSmallGroupParticipantsLastYear * GoalMultiplier);
iSmallGroupLeadersGoalCurrent = Convert.ToInt32((double?)iSmallGroupLeadersLastYear * GoalMultiplier);
iNewtoNewPointeGoalCurrent = Convert.ToInt32((double?)iNewtoNewPointeLastYear * GoalMultiplier);
iDiscoverGroupsGoalCurrent = Convert.ToInt32((double?)iDiscoverGroupsLastYear * GoalMultiplier);
iCampusGroupsGoalCurrent = Convert.ToInt32((double?)iCampusGroupsLastYear * GoalMultiplier);
iNewHereGoalCurrent = Convert.ToInt32((double?)iNewHereLastYear * GoalMultiplier);
iSmallGroupsGoalCurrent = Convert.ToInt32((double?)iSmallGroupsLastYear * GoalMultiplier);
}
else
{
iBaptismsGoalCurrent = GetMetrics(11, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
iPartnersGoalCurrent = GetMetricsLatest(20, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
iCommitmentsGoalCurrent = GetMetrics(12, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
iRecommitmentsGoalCurrent = GetMetrics(13, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
iVolunteersGoalCurrent = GetMetricsLatest(16, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
iSmallGroupParticipantsGoalCurrent = GetMetricsLatest(17, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
iSmallGroupLeadersGoalCurrent = GetMetricsLatest(17, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
iNewtoNewPointeGoalCurrent = GetMetrics(21, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
iDiscoverGroupsGoalCurrent = GetMetrics(22, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
iCampusGroupsGoalCurrent = GetMetrics(24, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
iNewHereGoalCurrent = GetMetrics(14, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
iSmallGroupsGoalCurrent = GetMetrics(34, CampusId, lastFiscalYearStartDate, fiscalYearEndDate, 1);
}
//-------AllCommitments-------
//YTD
iAllCommitments = iCommitments + iRecommitments;
//LastYTD
iAllCommitmentsLastYear = iCommitmentsLastYear + iRecommitmentsLastYear;
//Current Goal
iAllCommitmentsGoalCurrent = iCommitmentsGoalCurrent + iRecommitmentsGoalCurrent;
//2020 Goal
iAllCommitmentsGoal2020 = iCommitmentsGoal2020 + iRecommitmentsGoal2020;
//Current Goal Progress
iAllCommitmentsGoalProgress = ((double)iCommitments + (double)iRecommitments) / (((double)iCommitmentsGoalCurrent + (double)iRecommitmentsGoalCurrent) * GoalOffsetMultiplier) * 100;
//8Wk
iAllCommitments8Wk = iCommitments8Wk + iRecommitments8Wk;
iAllCommitments8WkLy = iCommitments8WkLy + iRecommitments8WkLy;
dAllCommitments8WkProgress = (((double)iAllCommitments8Wk - (double)iAllCommitments8WkLy) / (double)iAllCommitments8WkLy) * 100;
// Caculate the progress toeards the goals
iBaptismsGoalProgress = (double)iBaptisms / ((double)iBaptismsGoalCurrent * GoalOffsetMultiplier) * 100;
iPartnersGoalProgress = (double)iPartners / ((double)iPartnersGoalCurrent * GoalOffsetMultiplier) * 100;
iCommitmentsGoalProgress = (double)iCommitments / ((double)iCommitmentsGoalCurrent * GoalOffsetMultiplier) * 100;
iRecommitmentsGoalProgress = (double)iRecommitments / ((double)iRecommitmentsGoalCurrent * GoalOffsetMultiplier) * 100;
iVolunteersGoalProgress = (double)iVolunteers / ((double)iVolunteersGoalCurrent * GoalOffsetMultiplier) * 100;
iSmallGroupParticipantsGoalProgress = (double)iSmallGroupParticipants / ((double)iSmallGroupParticipantsGoalCurrent * GoalOffsetMultiplier) * 100;
iSmallGroupLeadersGoalProgress = (double)iSmallGroupLeaders / ((double)iSmallGroupLeadersGoalCurrent * GoalOffsetMultiplier) * 100;
iNewtoNewPointeGoalProgress = (double)iNewtoNewPointe / ((double)iNewtoNewPointeGoalCurrent * GoalOffsetMultiplier) * 100;
iDiscoverGroupsGoalProgress = (double)iDiscoverGroups / ((double)iDiscoverGroupsGoalCurrent * GoalOffsetMultiplier) * 100;
iCampusGroupsGoalProgress = (double)iCampusGroups / ((double)iCampusGroupsGoalCurrent * GoalOffsetMultiplier) * 100;
iNewHereGoalProgress = (double)iNewHere / ((double)iNewHereGoalCurrent * GoalOffsetMultiplier) * 100;
iSmallGroupsGoalProgress = (double)iSmallGroups / ((double)iSmallGroupsGoalCurrent * GoalOffsetMultiplier) * 100;
//Calculate the Composite Score
CompositeScore = CalculateCompositeScore();
//Save to the database
if (CompositeScore > 0 && CompositeScore < 1000)
{
MetricValueService metricValueService = new MetricValueService(rockContext);
MetricValue metricValue;
metricValue = new MetricValue();
metricValueService.Add(metricValue);
metricValue.MetricId = 39;
metricValue.Metric = metricValue.Metric ?? new MetricService(rockContext).Get(metricValue.MetricId);
metricValue.MetricValueType = (MetricValueType)0;
metricValue.XValue = null;
metricValue.YValue = (decimal)CompositeScore;
metricValue.Note = "";
metricValue.MetricValueDateTime = dt;
metricValue.EntityId = CampusId;
rockContext.SaveChanges();
}
}
/// <summary>
/// Binds the group placement grid.
/// </summary>
/// <param name="isExporting">if set to <c>true</c> [is exporting].</param>
private void BindGroupPlacementGrid( bool isExporting = false )
{
int? groupId = gpGroupPlacementParentGroup.SelectedValueAsInt();
int? instanceId = hfRegistrationInstanceId.Value.AsIntegerOrNull();
if ( instanceId.HasValue )
{
using ( var rockContext = new RockContext() )
{
// Start query for registrants
var qry = new RegistrationRegistrantService( rockContext )
.Queryable( "PersonAlias.Person.PhoneNumbers.NumberTypeValue,Fees.RegistrationTemplateFee,GroupMember.Group" ).AsNoTracking()
.Where( r =>
r.Registration.RegistrationInstanceId == instanceId.Value &&
r.PersonAlias != null &&
r.PersonAlias.Person != null );
if ( groupId.HasValue )
{
var validGroupIds = new GroupService( rockContext ).GetAllDescendents( groupId.Value )
.Select( g => g.Id )
.ToList();
var existingPeopleInGroups = new GroupMemberService( rockContext )
.Queryable().AsNoTracking()
.Where( m => validGroupIds.Contains( m.GroupId ) )
.Select( m => m.PersonId )
.ToList();
qry = qry.Where( r => !existingPeopleInGroups.Contains( r.PersonAlias.PersonId ) );
}
bool preloadCampusValues = false;
var registrantAttributeIds = new List<int>();
var personAttributesIds = new List<int>();
var groupMemberAttributesIds = new List<int>();
if ( RegistrantFields != null )
{
// Check if campus is used
preloadCampusValues = RegistrantFields
.Any( f =>
f.FieldSource == RegistrationFieldSource.PersonField &&
f.PersonFieldType.HasValue &&
f.PersonFieldType.Value == RegistrationPersonFieldType.Campus );
// Get all the registrant attributes selected
var registrantAttributes = RegistrantFields
.Where( f =>
f.Attribute != null &&
f.FieldSource == RegistrationFieldSource.RegistrationAttribute )
.Select( f => f.Attribute )
.ToList();
registrantAttributeIds = registrantAttributes.Select( a => a.Id ).Distinct().ToList();
// Get all the person attributes selected
var personAttributes = RegistrantFields
.Where( f =>
f.Attribute != null &&
f.FieldSource == RegistrationFieldSource.PersonAttribute )
.Select( f => f.Attribute )
.ToList();
personAttributesIds = personAttributes.Select( a => a.Id ).Distinct().ToList();
// Get all the group member attributes selected to be on grid
var groupMemberAttributes = RegistrantFields
.Where( f =>
f.Attribute != null &&
f.FieldSource == RegistrationFieldSource.GroupMemberAttribute )
.Select( f => f.Attribute )
.ToList();
groupMemberAttributesIds = groupMemberAttributes.Select( a => a.Id ).Distinct().ToList();
}
// Sort the query
IOrderedQueryable<RegistrationRegistrant> orderedQry = null;
SortProperty sortProperty = gGroupPlacements.SortProperty;
if ( sortProperty != null )
{
orderedQry = qry.Sort( sortProperty );
}
else
{
orderedQry = qry
.OrderBy( r => r.PersonAlias.Person.LastName )
.ThenBy( r => r.PersonAlias.Person.NickName );
}
// Set the grids LinqDataSource which will run query and set results for current page
gGroupPlacements.SetLinqDataSource<RegistrationRegistrant>( orderedQry );
if ( RegistrantFields != null )
{
// Get the query results for the current page
var currentPageRegistrants = gGroupPlacements.DataSource as List<RegistrationRegistrant>;
if ( currentPageRegistrants != null )
{
// Get all the registrant ids in current page of query results
var registrantIds = currentPageRegistrants
.Select( r => r.Id )
.Distinct()
.ToList();
// Get all the person ids in current page of query results
var personIds = currentPageRegistrants
.Select( r => r.PersonAlias.PersonId )
.Distinct()
.ToList();
// Get all the group member ids and the group id in current page of query results
var groupMemberIds = new List<int>();
GroupLinks = new Dictionary<int, string>();
foreach ( var groupMember in currentPageRegistrants
.Where( m =>
m.GroupMember != null &&
m.GroupMember.Group != null )
.Select( m => m.GroupMember ) )
{
groupMemberIds.Add( groupMember.Id );
GroupLinks.AddOrIgnore( groupMember.GroupId,
isExporting ? groupMember.Group.Name :
string.Format( "<a href='{0}'>{1}</a>",
LinkedPageUrl( "GroupDetailPage", new Dictionary<string, string> { { "GroupId", groupMember.GroupId.ToString() } } ),
groupMember.Group.Name ) );
}
// If the campus column was selected to be displayed on grid, preload all the people's
// campuses so that the databind does not need to query each row
if ( preloadCampusValues )
{
PersonCampusIds = new Dictionary<int, List<int>>();
Guid familyGroupTypeGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
foreach ( var personCampusList in new GroupMemberService( rockContext )
.Queryable().AsNoTracking()
.Where( m =>
m.Group.GroupType.Guid == familyGroupTypeGuid &&
personIds.Contains( m.PersonId ) )
.GroupBy( m => m.PersonId )
.Select( m => new
{
PersonId = m.Key,
CampusIds = m
.Where( g => g.Group.CampusId.HasValue )
.Select( g => g.Group.CampusId.Value )
.ToList()
} ) )
{
PersonCampusIds.Add( personCampusList.PersonId, personCampusList.CampusIds );
}
}
// If there are any attributes that were selected to be displayed, we're going
// to try and read all attribute values in one query and then put them into a
// custom grid ObjectList property so that the AttributeField columns don't need
// to do the LoadAttributes and querying of values for each row/column
if ( personAttributesIds.Any() || groupMemberAttributesIds.Any() || registrantAttributeIds.Any() )
{
// Query the attribute values for all rows and attributes
var attributeValues = new AttributeValueService( rockContext )
.Queryable( "Attribute" ).AsNoTracking()
.Where( v =>
v.EntityId.HasValue &&
(
(
personAttributesIds.Contains( v.AttributeId ) &&
personIds.Contains( v.EntityId.Value )
) ||
(
groupMemberAttributesIds.Contains( v.AttributeId ) &&
groupMemberIds.Contains( v.EntityId.Value )
) ||
(
registrantAttributeIds.Contains( v.AttributeId ) &&
registrantIds.Contains( v.EntityId.Value )
)
)
)
.ToList();
// Get the attributes to add to each row's object
var attributes = new Dictionary<string, AttributeCache>();
RegistrantFields
.Where( f => f.Attribute != null )
.Select( f => f.Attribute )
.ToList()
.ForEach( a => attributes
.Add( a.Id.ToString() + a.Key, a ) );
// Initialize the grid's object list
gGroupPlacements.ObjectList = new Dictionary<string, object>();
// Loop through each of the current page's registrants and build an attribute
// field object for storing attributes and the values for each of the registrants
foreach ( var registrant in currentPageRegistrants )
{
// Create a row attribute object
var attributeFieldObject = new AttributeFieldObject();
// Add the attributes to the attribute object
attributeFieldObject.Attributes = attributes;
// Add any person attribute values to object
attributeValues
.Where( v =>
personAttributesIds.Contains( v.AttributeId ) &&
v.EntityId.Value == registrant.PersonAlias.PersonId )
.ToList()
.ForEach( v => attributeFieldObject.AttributeValues
.Add( v.AttributeId.ToString() + v.Attribute.Key, new AttributeValueCache( v ) ) );
// Add any group member attribute values to object
if ( registrant.GroupMemberId.HasValue )
{
attributeValues
.Where( v =>
groupMemberAttributesIds.Contains( v.AttributeId ) &&
v.EntityId.Value == registrant.GroupMemberId.Value )
.ToList()
.ForEach( v => attributeFieldObject.AttributeValues
.Add( v.AttributeId.ToString() + v.Attribute.Key, new AttributeValueCache( v ) ) );
}
// Add any registrant attribute values to object
attributeValues
.Where( v =>
registrantAttributeIds.Contains( v.AttributeId ) &&
v.EntityId.Value == registrant.Id )
.ToList()
.ForEach( v => attributeFieldObject.AttributeValues
.Add( v.AttributeId.ToString() + v.Attribute.Key, new AttributeValueCache( v ) ) );
// Add row attribute object to grid's object list
gGroupPlacements.ObjectList.Add( registrant.Id.ToString(), attributeFieldObject );
}
}
}
}
gGroupPlacements.DataBind();
}
}
}
/// <summary>
/// Handles adding families from the given XML element snippet
/// </summary>
/// <param name="elemFamilies">The xml element containing all the families.</param>
/// <param name="rockContext">The rock context.</param>
private void AddFamilies( XElement elemFamilies, RockContext rockContext )
{
if ( elemFamilies == null )
{
return;
}
// Persist the storage type's settings specific to the photo binary file type
var settings = new Dictionary<string, string>();
if ( _personImageBinaryFileType.Attributes == null )
{
_personImageBinaryFileType.LoadAttributes();
}
foreach ( var attributeValue in _personImageBinaryFileType.AttributeValues )
{
settings.Add( attributeValue.Key, attributeValue.Value.Value );
}
_personImageBinaryFileTypeSettings = settings.ToJson();
bool fabricateAttendance = GetAttributeValue( "FabricateAttendance" ).AsBoolean();
GroupService groupService = new GroupService( rockContext );
var allFamilies = rockContext.Groups;
List<Group> allGroups = new List<Group>();
var attendanceData = new Dictionary<Guid, List<Attendance>>();
// Next create the family along with its members and related data
foreach ( var elemFamily in elemFamilies.Elements( "family" ) )
{
Guid guid = elemFamily.Attribute( "guid" ).Value.Trim().AsGuid();
var familyMembers = BuildFamilyMembersFromXml( elemFamily.Element( "members" ), rockContext );
// Call replica of groupService's SaveNewFamily method in an attempt to speed things up
Group family = CreateNewFamily( familyMembers, campusId: 1 );
family.Guid = guid;
// add the family to the context's list of groups
allFamilies.Add( family );
// add the families address(es)
AddFamilyAddresses( groupService, family, elemFamily.Element( "addresses" ), rockContext );
// add their attendance data
if ( fabricateAttendance )
{
AddFamilyAttendance( family, elemFamily, rockContext, attendanceData );
}
allGroups.Add( family );
_stopwatch.Stop();
AppendFormat( "{0:00}:{1:00}.{2:00} added {3}<br/>", _stopwatch.Elapsed.Minutes, _stopwatch.Elapsed.Seconds, _stopwatch.Elapsed.Milliseconds / 10, family.Name );
_stopwatch.Start();
}
rockContext.ChangeTracker.DetectChanges();
rockContext.SaveChanges( disablePrePostProcessing: true );
// Now save each person's attributevalues (who had them defined in the XML)
// and add each person's ID to a dictionary for use later.
_stopwatch.Stop();
AppendFormat( "{0:00}:{1:00}.{2:00} saving attributes for everyone...<br/>", _stopwatch.Elapsed.Minutes, _stopwatch.Elapsed.Seconds, _stopwatch.Elapsed.Milliseconds / 10 );
_stopwatch.Start();
AttributeValueService attributeValueService = new AttributeValueService( rockContext );
foreach ( var gm in allGroups.SelectMany( g => g.Members ) )
{
// Put the person's id into the people dictionary for later use.
if ( !_peopleDictionary.ContainsKey( gm.Person.Guid ) )
{
_peopleDictionary.Add( gm.Person.Guid, gm.Person.Id );
}
// Only save if the person had attributes, otherwise it will error.
if ( _personWithAttributes.ContainsKey( gm.Person.Guid ) )
{
foreach ( var attributeCache in gm.Person.Attributes.Select( a => a.Value ) )
{
var newValue = gm.Person.AttributeValues[attributeCache.Key];
if ( newValue != null )
{
var attributeValue = new AttributeValue();
attributeValue.AttributeId = newValue.AttributeId;
attributeValue.EntityId = gm.Person.Id;
attributeValue.Value = newValue.Value;
rockContext.AttributeValues.Add( attributeValue );
}
}
}
}
rockContext.ChangeTracker.DetectChanges();
rockContext.SaveChanges( disablePrePostProcessing: true );
_stopwatch.Stop();
AppendFormat( "{0:00}:{1:00}.{2:00} attributes saved<br/>", _stopwatch.Elapsed.Minutes, _stopwatch.Elapsed.Seconds, _stopwatch.Elapsed.Milliseconds / 10 );
_stopwatch.Start();
// Create person alias records for each person manually since we set disablePrePostProcessing=true on save
PersonService personService = new PersonService( rockContext );
foreach ( var person in personService.Queryable( "Aliases", true )
.Where( p =>
_peopleDictionary.Keys.Contains( p.Guid ) &&
!p.Aliases.Any() ) )
{
person.Aliases.Add( new PersonAlias { AliasPersonId = person.Id, AliasPersonGuid = person.Guid } );
}
rockContext.ChangeTracker.DetectChanges();
rockContext.SaveChanges( disablePrePostProcessing: true );
_stopwatch.Stop();
AppendFormat( "{0:00}:{1:00}.{2:00} added person aliases<br/>", _stopwatch.Elapsed.Minutes, _stopwatch.Elapsed.Seconds, _stopwatch.Elapsed.Milliseconds / 10 );
_stopwatch.Start();
// Put the person alias ids into the people alias dictionary for later use.
PersonAliasService personAliasService = new PersonAliasService( rockContext );
foreach ( var personAlias in personAliasService.Queryable( "Person" )
.Where( a =>
_peopleDictionary.Keys.Contains( a.Person.Guid ) &&
a.PersonId == a.AliasPersonId ) )
{
_peopleAliasDictionary.Add( personAlias.Person.Guid, personAlias.Id );
}
// Now that person aliases have been saved, save the attendance records
var attendanceService = new AttendanceService( rockContext );
var attendanceGuids = attendanceData.Select( a => a.Key ).ToList();
foreach ( var aliasKeyValue in _peopleAliasDictionary
.Where( a => attendanceGuids.Contains( a.Key )) )
{
foreach ( var attendance in attendanceData[aliasKeyValue.Key] )
{
attendance.PersonAliasId = aliasKeyValue.Value;
attendanceService.Add( attendance );
}
}
rockContext.ChangeTracker.DetectChanges();
rockContext.SaveChanges( disablePrePostProcessing: true );
_stopwatch.Stop();
AppendFormat( "{0:00}:{1:00}.{2:00} added attendance records<br/>", _stopwatch.Elapsed.Minutes, _stopwatch.Elapsed.Seconds, _stopwatch.Elapsed.Milliseconds / 10 );
_stopwatch.Start();
// Now re-process the family section looking for any giving data.
// We do this last because we need the personAliases that were just added.
// Persist the storage type's settings specific to the contribution binary file type
settings = new Dictionary<string, string>();
if ( _checkImageBinaryFileType.Attributes == null )
{
_checkImageBinaryFileType.LoadAttributes();
}
foreach ( var attributeValue in _checkImageBinaryFileType.AttributeValues )
{
settings.Add( attributeValue.Key, attributeValue.Value.Value );
}
_checkImageBinaryFileTypeSettings = settings.ToJson();
foreach ( var elemFamily in elemFamilies.Elements( "family" ) )
{
// add the families giving data
if ( GetAttributeValue( "EnableGiving" ).AsBoolean() )
{
// Support multiple giving elements per family
foreach ( var elementGiving in elemFamily.Elements( "giving" ) )
{
AddFamilyGiving( elementGiving, elemFamily.Attribute( "name" ).Value, rockContext );
}
}
}
if ( GetAttributeValue( "EnableGiving" ).AsBoolean() )
{
// Now add the batches to the service to be persisted
var financialBatchService = new FinancialBatchService( rockContext );
foreach ( var financialBatch in _contributionBatches )
{
financialBatchService.Add( financialBatch.Value );
}
}
rockContext.ChangeTracker.DetectChanges();
rockContext.SaveChanges( disablePrePostProcessing: true );
}
/// <summary>
/// Generic method to delete the members of a group and then the group.
/// </summary>
/// <param name="group">The group.</param>
/// <param name="rockContext">The rock context.</param>
/// <exception cref="System.InvalidOperationException">Unable to delete group: + group.Name</exception>
private void DeleteGroupAndMemberData( Group group, RockContext rockContext )
{
GroupService groupService = new GroupService( rockContext );
// delete addresses
GroupLocationService groupLocationService = new GroupLocationService( rockContext );
if ( group.GroupLocations.Count > 0 )
{
foreach ( var groupLocations in group.GroupLocations.ToList() )
{
group.GroupLocations.Remove( groupLocations );
groupLocationService.Delete( groupLocations );
}
}
// delete members
var groupMemberService = new GroupMemberService( rockContext );
var members = group.Members;
foreach ( var member in members.ToList() )
{
group.Members.Remove( member );
groupMemberService.Delete( member );
}
// delete attribute values
group.LoadAttributes( rockContext );
if ( group.AttributeValues != null )
{
var attributeValueService = new AttributeValueService( rockContext );
foreach ( var entry in group.AttributeValues )
{
var attributeValue = attributeValueService.GetByAttributeIdAndEntityId( entry.Value.AttributeId, group.Id );
if ( attributeValue != null )
{
attributeValueService.Delete( attributeValue );
}
}
}
// now delete the group
if ( groupService.Delete( group ) )
{
// ok
}
else
{
throw new InvalidOperationException( "Unable to delete group: " + group.Name );
}
}
private void GetData()
{
var rockContext = new RockContext();
var itemService = new ContentChannelItemService(rockContext);
int personId = CurrentPerson != null ? CurrentPerson.Id : 0;
// Get all of the content channels
var allChannels = new ContentChannelService( rockContext ).Queryable( "ContentChannelType" )
.OrderBy( w => w.Name )
.ToList();
// Create variable for storing authorized channels and the count of active items
var channelCounts = new Dictionary<int, int>();
foreach ( var channel in allChannels )
{
if ( channel.IsAuthorized( Authorization.VIEW, CurrentPerson))
{
channelCounts.Add( channel.Id, 0);
}
}
// Get the pending approval item counts for each channel (if the channel requires approval)
itemService.Queryable()
.Where( i =>
channelCounts.Keys.Contains( i.ContentChannelId ) &&
i.Status == ContentChannelItemStatus.PendingApproval && i.ContentChannel.RequiresApproval )
.GroupBy( i => i.ContentChannelId )
.Select( i => new {
Id = i.Key,
Count = i.Count()
})
.ToList()
.ForEach( i => channelCounts[i.Id] = i.Count );
// Create a query to return channel, the count of items, and the selected class
var qry = allChannels
.Where( c => channelCounts.Keys.Contains( c.Id ) )
.Select( c => new
{
Channel = c,
Count = channelCounts[c.Id],
Class = ( SelectedChannelId.HasValue && SelectedChannelId.Value == c.Id ) ? "active" : ""
} );
// If displaying active only, update query to exclude those content channels without any items
if ( tglStatus.Checked )
{
qry = qry.Where( c => c.Count > 0 );
}
var contentChannels = qry.ToList();
rptChannels.DataSource = contentChannels;
rptChannels.DataBind();
ContentChannel selectedChannel = null;
if ( SelectedChannelId.HasValue )
{
selectedChannel = allChannels
.Where( w =>
w.Id == SelectedChannelId.Value &&
channelCounts.Keys.Contains( SelectedChannelId.Value ) )
.FirstOrDefault();
}
if ( selectedChannel != null && contentChannels.Count > 0 )
{
// show the content item panel
divItemPanel.Visible = true;
BindAttributes( selectedChannel );
AddDynamicControls( selectedChannel );
var itemQry = itemService.Queryable()
.Where( i => i.ContentChannelId == selectedChannel.Id );
var drp = new DateRangePicker();
drp.DelimitedValues = gfFilter.GetUserPreference( "Date Range" );
if ( drp.LowerValue.HasValue )
{
if ( selectedChannel.ContentChannelType.DateRangeType == ContentChannelDateType.SingleDate )
{
itemQry = itemQry.Where( i => i.StartDateTime >= drp.LowerValue.Value );
}
else
{
itemQry = itemQry.Where( i => i.ExpireDateTime.HasValue && i.ExpireDateTime.Value >= drp.LowerValue.Value );
}
}
if ( drp.UpperValue.HasValue )
{
DateTime upperDate = drp.UpperValue.Value.Date.AddDays( 1 );
itemQry = itemQry.Where( i => i.StartDateTime <= upperDate );
}
var status = gfFilter.GetUserPreference( "Status" ).ConvertToEnumOrNull<ContentChannelItemStatus>();
if ( status.HasValue )
{
itemQry = itemQry.Where( i => i.Status == status );
}
string title = gfFilter.GetUserPreference( "Title" );
if (!string.IsNullOrWhiteSpace(title))
{
itemQry = itemQry.Where( i => i.Title.Contains( title ) );
}
// Filter query by any configured attribute filters
if ( AvailableAttributes != null && AvailableAttributes.Any() )
{
var attributeValueService = new AttributeValueService( rockContext );
var parameterExpression = attributeValueService.ParameterExpression;
foreach ( var attribute in AvailableAttributes )
{
var filterControl = phAttributeFilters.FindControl( "filter_" + attribute.Id.ToString() );
if ( filterControl != null )
{
var filterValues = attribute.FieldType.Field.GetFilterValues( filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter );
var expression = attribute.FieldType.Field.AttributeFilterExpression( attribute.QualifierValues, filterValues, parameterExpression );
if ( expression != null )
{
var attributeValues = attributeValueService
.Queryable()
.Where( v => v.Attribute.Id == attribute.Id );
attributeValues = attributeValues.Where( parameterExpression, expression, null );
itemQry = itemQry.Where( w => attributeValues.Select( v => v.EntityId ).Contains( w.Id ) );
}
}
}
}
var items = new List<ContentChannelItem>();
foreach ( var item in itemQry.ToList() )
{
if ( item.IsAuthorized( Rock.Security.Authorization.VIEW, CurrentPerson ) )
{
items.Add( item );
}
}
SortProperty sortProperty = gContentChannelItems.SortProperty;
if ( sortProperty != null )
{
items = items.AsQueryable().Sort( sortProperty ).ToList();
}
else
{
items = items.OrderByDescending( p => p.StartDateTime ).ToList();
}
gContentChannelItems.ObjectList = new Dictionary<string, object>();
items.ForEach( i => gContentChannelItems.ObjectList.Add( i.Id.ToString(), i ) );
gContentChannelItems.DataSource = items.Select( i => new
{
i.Id,
i.Guid,
i.Title,
i.StartDateTime,
i.ExpireDateTime,
i.Priority,
Status = DisplayStatus( i.Status ),
Occurrences = i.EventItemOccurrences.Any()
} ).ToList();
gContentChannelItems.DataBind();
lContentChannelItems.Text = selectedChannel.Name + " Items";
}
else
{
divItemPanel.Visible = false;
}
}
/// <summary>
/// Handles the SaveClick event of the dlgSearch 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 dlgSearch_SaveClick( object sender, EventArgs e )
{
using ( var rockContext = new RockContext() )
{
var connectionRequestService = new ConnectionRequestService( rockContext );
var connectionRequest = connectionRequestService.Get( hfConnectionRequestId.ValueAsInt() );
if ( connectionRequest != null &&
connectionRequest.ConnectionOpportunity != null &&
connectionRequest.ConnectionOpportunity.ConnectionType != null )
{
var qrySearch = connectionRequest.ConnectionOpportunity.ConnectionType.ConnectionOpportunities.ToList();
if ( !string.IsNullOrWhiteSpace( tbSearchName.Text ) )
{
var searchTerms = tbSearchName.Text.ToLower().SplitDelimitedValues( true );
qrySearch = qrySearch.Where( o => searchTerms.Any( t => t.Contains( o.Name.ToLower() ) || o.Name.ToLower().Contains( t ) ) ).ToList();
}
var searchCampuses = cblCampus.SelectedValuesAsInt;
if ( searchCampuses.Count > 0 )
{
qrySearch = qrySearch.Where( o => o.ConnectionOpportunityCampuses.Any( c => searchCampuses.Contains( c.CampusId ) ) ).ToList();
}
// Filter query by any configured attribute filters
if ( SearchAttributes != null && SearchAttributes.Any() )
{
var attributeValueService = new AttributeValueService( rockContext );
var parameterExpression = attributeValueService.ParameterExpression;
foreach ( var attribute in SearchAttributes )
{
var filterControl = phAttributeFilters.FindControl( "filter_" + attribute.Id.ToString() );
if ( filterControl != null )
{
var filterValues = attribute.FieldType.Field.GetFilterValues( filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter );
var expression = attribute.FieldType.Field.AttributeFilterExpression( attribute.QualifierValues, filterValues, parameterExpression );
if ( expression != null )
{
var attributeValues = attributeValueService
.Queryable()
.Where( v => v.Attribute.Id == attribute.Id );
attributeValues = attributeValues.Where( parameterExpression, expression, null );
qrySearch = qrySearch.Where( w => attributeValues.Select( v => v.EntityId ).Contains( w.Id ) ).ToList();
}
}
}
}
rptSearchResult.DataSource = qrySearch;
rptSearchResult.DataBind();
}
}
}
/// <summary>
/// Returns Global Attributes from cache. If they are not already in cache, they
/// will be read and added to cache
/// </summary>
/// <returns></returns>
public static GlobalAttributesCache Read( RockContext rockContext = null )
{
string cacheKey = GlobalAttributesCache.CacheKey();
ObjectCache cache = MemoryCache.Default;
GlobalAttributesCache globalAttributes = cache[cacheKey] as GlobalAttributesCache;
if ( globalAttributes != null )
{
return globalAttributes;
}
else
{
globalAttributes = new GlobalAttributesCache();
globalAttributes.Attributes = new List<AttributeCache>();
globalAttributes.AttributeValues = new Dictionary<string, KeyValuePair<string, string>>();
rockContext = rockContext ?? new RockContext();
var attributeService = new Rock.Model.AttributeService( rockContext );
var attributeValueService = new Rock.Model.AttributeValueService( rockContext );
foreach ( Rock.Model.Attribute attribute in attributeService.GetGlobalAttributes() )
{
var attributeCache = AttributeCache.Read( attribute );
globalAttributes.Attributes.Add( attributeCache );
var attributeValue = attributeValueService.GetByAttributeIdAndEntityId( attribute.Id, null ).FirstOrDefault();
string value = ( attributeValue != null && !string.IsNullOrEmpty( attributeValue.Value ) ) ? attributeValue.Value : attributeCache.DefaultValue;
globalAttributes.AttributeValues.Add( attributeCache.Key, new KeyValuePair<string, string>( attributeCache.Name, value ) );
}
cache.Set( cacheKey, globalAttributes, new CacheItemPolicy() );
return globalAttributes;
}
}
/// <summary>
/// Builds an expression for an attribute field
/// </summary>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="entityField">The property.</param>
/// <param name="values">The values.</param>
/// <returns></returns>
public static Expression GetAttributeExpression( IService serviceInstance, ParameterExpression parameterExpression, EntityField entityField, List<string> values )
{
var service = new AttributeValueService( (RockContext)serviceInstance.Context );
var attributeValues = service.Queryable().Where( v =>
v.EntityId.HasValue &&
v.Value != string.Empty );
if ( entityField.AttributeGuid.HasValue )
{
attributeValues = attributeValues.Where( v => v.Attribute.Guid == entityField.AttributeGuid );
}
else
{
attributeValues = attributeValues.Where( v => v.Attribute.Key == entityField.Name && v.Attribute.FieldTypeId == entityField.FieldType.Id );
}
ParameterExpression attributeValueParameterExpression = Expression.Parameter( typeof( AttributeValue ), "v" );
// Determine the appropriate comparison type to use for this Expression.
// Attribute Value records only exist for Entities that have a value specified for the Attribute.
// Therefore, if the specified comparison works by excluding certain values we must invert our filter logic:
// first we find the Attribute Values that match those values and then we exclude the associated Entities from the result set.
var comparisonType = ComparisonType.EqualTo;
ComparisonType evaluatedComparisonType = comparisonType;
if ( values.Count >= 2 )
{
string comparisonValue = values[0];
if ( comparisonValue != "0" )
{
comparisonType = comparisonValue.ConvertToEnum<ComparisonType>( ComparisonType.EqualTo );
}
switch ( comparisonType )
{
case ComparisonType.DoesNotContain:
evaluatedComparisonType = ComparisonType.Contains;
break;
case ComparisonType.IsBlank:
evaluatedComparisonType = ComparisonType.IsNotBlank;
break;
case ComparisonType.LessThan:
evaluatedComparisonType = ComparisonType.GreaterThanOrEqualTo;
break;
case ComparisonType.LessThanOrEqualTo:
evaluatedComparisonType = ComparisonType.GreaterThan;
break;
case ComparisonType.NotEqualTo:
evaluatedComparisonType = ComparisonType.EqualTo;
break;
default:
evaluatedComparisonType = comparisonType;
break;
}
values[0] = evaluatedComparisonType.ToString();
}
var filterExpression = entityField.FieldType.Field.AttributeFilterExpression( entityField.FieldConfig, values, attributeValueParameterExpression );
if ( filterExpression != null )
{
attributeValues = attributeValues.Where( attributeValueParameterExpression, filterExpression, null );
}
IQueryable<int> ids = attributeValues.Select( v => v.EntityId.Value );
MemberExpression propertyExpression = Expression.Property( parameterExpression, "Id" );
ConstantExpression idsExpression = Expression.Constant( ids.AsQueryable(), typeof( IQueryable<int> ) );
Expression expression = Expression.Call( typeof( Queryable ), "Contains", new Type[] { typeof( int ) }, idsExpression, propertyExpression );
// If we have used an inverted comparison type for the evaluation, invert the Expression so that it excludes the matching Entities.
if ( comparisonType != evaluatedComparisonType )
{
return Expression.Not( expression );
}
else
{
return expression;
}
}
/// <summary>
/// Sets the value.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="value">The value.</param>
/// <param name="saveValue">if set to <c>true</c> [save value].</param>
/// <param name="rockContext">The rock context.</param>
public void SetValue( string key, string value, bool saveValue, RockContext rockContext = null )
{
if ( saveValue )
{
if ( rockContext == null )
{
rockContext = new RockContext();
}
// Save new value
var attributeValueService = new AttributeValueService( rockContext );
var attributeValue = attributeValueService.GetGlobalAttributeValue( key );
if ( attributeValue == null )
{
var attributeService = new AttributeService( rockContext );
var attribute = attributeService.GetGlobalAttribute( key );
if ( attribute == null )
{
attribute = new Rock.Model.Attribute();
attribute.FieldTypeId = FieldTypeCache.Read( new Guid( SystemGuid.FieldType.TEXT ) ).Id;
attribute.EntityTypeQualifierColumn = string.Empty;
attribute.EntityTypeQualifierValue = string.Empty;
attribute.Key = key;
attribute.Name = key.SplitCase();
attributeService.Add( attribute );
rockContext.SaveChanges();
Attributes.Add( AttributeCache.Read( attribute.Id ) );
}
attributeValue = new AttributeValue();
attributeValueService.Add( attributeValue );
attributeValue.IsSystem = false;
attributeValue.AttributeId = attribute.Id;
if ( !AttributeValues.Keys.Contains( key ) )
{
AttributeValues.Add( key, new KeyValuePair<string, string>( attribute.Name, value ) );
}
}
attributeValue.Value = value;
rockContext.SaveChanges();
}
var attributeCache = Attributes.FirstOrDefault( a => a.Key.Equals( key, StringComparison.OrdinalIgnoreCase ) );
if ( attributeCache != null ) // (Should never be null)
{
if ( AttributeValues.Keys.Contains( key ) )
{
AttributeValues[key] = new KeyValuePair<string, string>( attributeCache.Name, value );
}
else
{
AttributeValues.Add( key, new KeyValuePair<string, string>( attributeCache.Name, value ) );
}
}
}
/// <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>();
var workflowActivityGuid = action.GetWorklowAttributeValue( GetAttributeValue( action, "Activity" ).AsGuid() ).AsGuid();
if ( workflowActivityGuid.IsEmpty() )
{
action.AddLogEntry( "Invalid Activity Property", true );
return false;
}
var attributeKey = GetAttributeValue( action, "WorkflowAttributeKey", true );
var attributeValue = GetAttributeValue( action, "WorkflowAttributeValue", true );
if ( string.IsNullOrWhiteSpace( attributeKey) || string.IsNullOrWhiteSpace(attributeValue) )
{
action.AddLogEntry( "Invalid Workflow Property", true );
return false;
}
var activityType = new WorkflowActivityTypeService( rockContext ).Queryable()
.Where( a => a.Guid.Equals( workflowActivityGuid ) ).FirstOrDefault();
if ( activityType == null )
{
action.AddLogEntry( "Invalid Activity Property", true );
return false;
}
var entityType = EntityTypeCache.Read( typeof( Rock.Model.Workflow ) );
var workflowIds = new AttributeValueService( rockContext )
.Queryable()
.AsNoTracking()
.Where( a => a.Attribute.Key == attributeKey && a.Value == attributeValue && a.Attribute.EntityTypeId == entityType.Id )
.Select(a => a.EntityId);
var workflows = new WorkflowService( rockContext )
.Queryable()
//.AsNoTracking()
.Where( w => w.WorkflowType.ActivityTypes.Any( a => a.Guid == activityType.Guid ) && workflowIds.Contains(w.Id) )
.ToList();
foreach (var workflow in workflows )
{
WorkflowActivity.Activate( activityType, workflow );
action.AddLogEntry( string.Format( "Activated new '{0}' activity in {1} {2}", activityType.ToString(), workflow.TypeName, workflow.WorkflowId ) );
}
return true;
}
/// <summary>
/// This method takes the attribute values of the original blocks, and creates copies of them that point to the copied blocks.
/// In addition, any block attribute value pointing to a page in the original page tree is now updated to point to the
/// corresponding page in the copied page tree.
/// </summary>
/// <param name="pageGuidDictionary">The dictionary containing the original page guids and the corresponding copied page guids.</param>
/// <param name="blockGuidDictionary">The dictionary containing the original block guids and the corresponding copied block guids.</param>
/// <param name="rockContext">The rock context.</param>
/// <param name="currentPersonAliasId">The current person alias identifier.</param>
private void GenerateBlockAttributeValues( Dictionary<Guid, Guid> pageGuidDictionary, Dictionary<Guid, Guid> blockGuidDictionary, RockContext rockContext, int? currentPersonAliasId = null )
{
var attributeValueService = new AttributeValueService( rockContext );
var pageService = new PageService( rockContext );
var blockService = new BlockService( rockContext );
var pageGuid = Rock.SystemGuid.EntityType.PAGE.AsGuid();
var blockGuid = Rock.SystemGuid.EntityType.BLOCK.AsGuid();
Dictionary<Guid, int> blockIntDictionary = blockService.Queryable()
.Where( p => blockGuidDictionary.Keys.Contains( p.Guid ) || blockGuidDictionary.Values.Contains( p.Guid ) )
.ToDictionary( p => p.Guid, p => p.Id );
var attributeValues = attributeValueService.Queryable().Where( a =>
a.Attribute.EntityType.Guid == blockGuid && blockIntDictionary.Values.Contains( a.EntityId.Value ) )
.ToList();
foreach ( var attributeValue in attributeValues )
{
var newAttributeValue = attributeValue.Clone( false );
newAttributeValue.CreatedByPersonAlias = null;
newAttributeValue.CreatedByPersonAliasId = currentPersonAliasId;
newAttributeValue.CreatedDateTime = RockDateTime.Now;
newAttributeValue.ModifiedByPersonAlias = null;
newAttributeValue.ModifiedByPersonAliasId = currentPersonAliasId;
newAttributeValue.ModifiedDateTime = RockDateTime.Now;
newAttributeValue.Id = 0;
newAttributeValue.Guid = Guid.NewGuid();
newAttributeValue.EntityId = blockIntDictionary[blockGuidDictionary[blockIntDictionary.Where( d => d.Value == attributeValue.EntityId.Value ).FirstOrDefault().Key]];
if ( attributeValue.Attribute.FieldType.Guid == Rock.SystemGuid.FieldType.PAGE_REFERENCE.AsGuid() )
{
if ( pageGuidDictionary.ContainsKey( attributeValue.Value.AsGuid() ) )
{
newAttributeValue.Value = pageGuidDictionary[attributeValue.Value.AsGuid()].ToString();
}
}
attributeValueService.Add( newAttributeValue );
}
rockContext.SaveChanges();
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
if ( _workflowType != null )
{
pnlWorkflowList.Visible = true;
if ( _workflowType != null )
{
var rockContext = new RockContext();
var workflowService = new WorkflowService( rockContext );
var qry = workflowService
.Queryable( "Activities.ActivityType,InitiatorPersonAlias.Person" ).AsNoTracking()
.Where( w => w.WorkflowTypeId.Equals( _workflowType.Id ) );
// Activated Date Range Filter
if ( drpActivated.LowerValue.HasValue )
{
qry = qry.Where( w => w.ActivatedDateTime >= drpActivated.LowerValue.Value );
}
if ( drpActivated.UpperValue.HasValue )
{
DateTime upperDate = drpActivated.UpperValue.Value.Date.AddDays( 1 );
qry = qry.Where( w => w.ActivatedDateTime.Value < upperDate );
}
// State Filter
List<string> states = cblState.SelectedValues;
if ( states.Count == 1 ) // Don't filter if none or both options are selected
{
if ( states[0] == "Active" )
{
qry = qry.Where( w => !w.CompletedDateTime.HasValue );
}
else
{
qry = qry.Where( w => w.CompletedDateTime.HasValue );
}
}
// Completed Date Range Filter
if ( drpCompleted.LowerValue.HasValue )
{
qry = qry.Where( w => w.CompletedDateTime.HasValue && w.CompletedDateTime.Value >= drpCompleted.LowerValue.Value );
}
if ( drpCompleted.UpperValue.HasValue )
{
DateTime upperDate = drpCompleted.UpperValue.Value.Date.AddDays( 1 );
qry = qry.Where( w => w.CompletedDateTime.HasValue && w.CompletedDateTime.Value < upperDate );
}
string name = tbName.Text;
if ( !string.IsNullOrWhiteSpace( name ) )
{
qry = qry.Where( w => w.Name.StartsWith( name ) );
}
int? personId = ppInitiator.SelectedValue;
if ( personId.HasValue )
{
qry = qry.Where( w => w.InitiatorPersonAlias.PersonId == personId.Value );
}
string status = tbStatus.Text;
if ( !string.IsNullOrWhiteSpace( status ) )
{
qry = qry.Where( w => w.Status.StartsWith( status ) );
}
// Filter query by any configured attribute filters
if ( AvailableAttributes != null && AvailableAttributes.Any() )
{
var attributeValueService = new AttributeValueService( rockContext );
var parameterExpression = attributeValueService.ParameterExpression;
foreach ( var attribute in AvailableAttributes )
{
var filterControl = phAttributeFilters.FindControl( "filter_" + attribute.Id.ToString() );
if ( filterControl != null )
{
var filterValues = attribute.FieldType.Field.GetFilterValues( filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter );
var expression = attribute.FieldType.Field.AttributeFilterExpression( attribute.QualifierValues, filterValues, parameterExpression );
if ( expression != null )
{
var attributeValues = attributeValueService
.Queryable()
.Where( v => v.Attribute.Id == attribute.Id );
attributeValues = attributeValues.Where( parameterExpression, expression, null );
qry = qry.Where( w => attributeValues.Select( v => v.EntityId ).Contains( w.Id ) );
}
}
}
}
IQueryable<Workflow> workflows = null;
var sortProperty = gWorkflows.SortProperty;
if ( sortProperty != null )
{
if ( sortProperty.Property == "Initiator" )
{
if ( sortProperty.Direction == SortDirection.Ascending )
{
workflows = qry
.OrderBy( w => w.InitiatorPersonAlias.Person.LastName )
.ThenBy( w => w.InitiatorPersonAlias.Person.NickName );
}
else
{
workflows = qry
.OrderByDescending( w => w.InitiatorPersonAlias.Person.LastName )
.ThenByDescending( w => w.InitiatorPersonAlias.Person.NickName );
}
}
else
{
workflows = qry.Sort( sortProperty );
}
}
else
{
workflows = qry.OrderByDescending( s => s.CreatedDateTime );
}
// Since we're not binding to actual workflow list, but are using AttributeField columns,
// we need to save the workflows into the grid's object list
var workflowObjectQry = workflows;
if ( gWorkflows.AllowPaging )
{
workflowObjectQry = workflowObjectQry.Skip( gWorkflows.PageIndex * gWorkflows.PageSize ).Take( gWorkflows.PageSize );
}
gWorkflows.ObjectList = workflowObjectQry.ToList().ToDictionary( k => k.Id.ToString(), v => v as object );
gWorkflows.EntityTypeId = EntityTypeCache.Read<Workflow>().Id;
var qryGrid = workflows.Select( w => new
{
w.Id,
w.Name,
Initiator = w.InitiatorPersonAlias.Person,
Activities = w.Activities.Where( a => a.ActivatedDateTime.HasValue && !a.CompletedDateTime.HasValue ).OrderBy( a => a.ActivityType.Order ).Select( a => a.ActivityType.Name ),
w.CreatedDateTime,
Status = w.Status,
IsCompleted = w.CompletedDateTime.HasValue
} );
gWorkflows.SetLinqDataSource( qryGrid );
gWorkflows.DataBind();
}
else
{
pnlWorkflowList.Visible = false;
}
}
}
/// <summary>
/// Updates the list.
/// </summary>
private void UpdateList()
{
using ( var rockContext = new RockContext() )
{
var searchSelections = new Dictionary<string, string>();
var connectionTypeId = GetAttributeValue( "ConnectionTypeId" ).AsInteger();
var connectionType = new ConnectionTypeService( rockContext ).Get( connectionTypeId );
var connectionOpportunityService = new ConnectionOpportunityService( rockContext );
var qrySearch = connectionOpportunityService.Queryable().Where( a => a.ConnectionTypeId == connectionTypeId && a.IsActive == true ).ToList();
if ( GetAttributeValue( "DisplayNameFilter" ).AsBoolean() )
{
if ( !string.IsNullOrWhiteSpace( tbSearchName.Text ) )
{
searchSelections.Add( "tbSearchName", tbSearchName.Text );
var searchTerms = tbSearchName.Text.ToLower().SplitDelimitedValues( true );
qrySearch = qrySearch.Where( o => searchTerms.Any( t => t.Contains( o.Name.ToLower() ) || o.Name.ToLower().Contains( t ) ) ).ToList();
}
}
if ( GetAttributeValue( "DisplayCampusFilter" ).AsBoolean() )
{
var searchCampuses = cblCampus.SelectedValuesAsInt;
if ( searchCampuses.Count > 0 )
{
searchSelections.Add( "cblCampus", searchCampuses.AsDelimited("|") );
qrySearch = qrySearch.Where( o => o.ConnectionOpportunityCampuses.Any( c => searchCampuses.Contains( c.CampusId ) ) ).ToList();
}
}
if ( GetAttributeValue( "DisplayAttributeFilters" ).AsBoolean() )
{
// Filter query by any configured attribute filters
if ( AvailableAttributes != null && AvailableAttributes.Any() )
{
var attributeValueService = new AttributeValueService( rockContext );
var parameterExpression = attributeValueService.ParameterExpression;
foreach ( var attribute in AvailableAttributes )
{
string filterControlId = "filter_" + attribute.Id.ToString();
var filterControl = phAttributeFilters.FindControl( filterControlId );
if ( filterControl != null )
{
var filterValues = attribute.FieldType.Field.GetFilterValues( filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter );
var expression = attribute.FieldType.Field.AttributeFilterExpression( attribute.QualifierValues, filterValues, parameterExpression );
if ( expression != null )
{
searchSelections.Add( filterControlId, filterValues.ToJson() );
var attributeValues = attributeValueService
.Queryable()
.Where( v => v.Attribute.Id == attribute.Id );
attributeValues = attributeValues.Where( parameterExpression, expression, null );
qrySearch = qrySearch.Where( o => attributeValues.Select( v => v.EntityId ).Contains( o.Id ) ).ToList();
}
}
}
}
}
string sessionKey = string.Format( "ConnectionSearch_{0}", this.BlockId );
Session[sessionKey] = searchSelections;
var opportunities = qrySearch.OrderBy( s => s.PublicName ).ToList();
var mergeFields = new Dictionary<string, object>();
mergeFields.Add( "Opportunities", opportunities);
mergeFields.Add( "CurrentPerson", CurrentPerson );
var pageReference = new PageReference( GetAttributeValue( "DetailPage" ), null );
mergeFields.Add( "DetailPage", BuildDetailPageUrl(pageReference.BuildUrl()) );
lOutput.Text = GetAttributeValue( "LavaTemplate" ).ResolveMergeFields( mergeFields );
if ( GetAttributeValue( "SetPageTitle" ).AsBoolean() )
{
string pageTitle = "Connection";
RockPage.PageTitle = pageTitle;
RockPage.BrowserTitle = String.Format( "{0} | {1}", pageTitle, RockPage.Site.Name );
RockPage.Header.Title = String.Format( "{0} | {1}", pageTitle, RockPage.Site.Name );
}
// show debug info
if ( GetAttributeValue( "EnableDebug" ).AsBoolean() && IsUserAuthorized( Authorization.EDIT ) )
{
lDebug.Visible = true;
lDebug.Text = mergeFields.lavaDebugInfo();
}
}
}
/// <summary>
/// Gets a filter expression for an attribute value.
/// </summary>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="filterValues">The filter values.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <returns></returns>
public override Expression AttributeFilterExpression( Dictionary<string, ConfigurationValue> configurationValues, List<string> filterValues, ParameterExpression parameterExpression )
{
bool allowMultiple = configurationValues != null && configurationValues.ContainsKey( ALLOW_MULTIPLE_KEY ) && configurationValues[ALLOW_MULTIPLE_KEY].Value.AsBoolean();
List<string> selectedValues;
if ( allowMultiple || filterValues.Count != 1 )
{
ComparisonType comparisonType = filterValues[0].ConvertToEnum<ComparisonType>( ComparisonType.Contains );
// if it isn't either "Contains" or "Not Contains", just use the base AttributeFilterExpression
if ( !( new ComparisonType[] { ComparisonType.Contains, ComparisonType.DoesNotContain }).Contains(comparisonType))
{
return base.AttributeFilterExpression( configurationValues, filterValues, parameterExpression );
}
//// OR up the where clauses for each of the selected values
// and make sure to wrap commas around things so we don't collide with partial matches
// so it'll do something like this:
//
// WHERE ',' + Value + ',' like '%,bacon,%'
// OR ',' + Value + ',' like '%,lettuce,%'
// OR ',' + Value + ',' like '%,tomato,%'
if ( filterValues.Count > 1 )
{
selectedValues = filterValues[1].Split( new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries ).ToList();
}
else
{
selectedValues = new List<string>();
}
Expression comparison = null;
foreach ( var selectedValue in selectedValues )
{
var searchValue = "," + selectedValue + ",";
var qryToExtract = new AttributeValueService( new Data.RockContext() ).Queryable().Where( a => ( "," + a.Value + "," ).Contains( searchValue ) );
var valueExpression = FilterExpressionExtractor.Extract<AttributeValue>( qryToExtract, parameterExpression, "a" );
if ( comparisonType != ComparisonType.Contains )
{
valueExpression = Expression.Not( valueExpression );
}
if ( comparison == null )
{
comparison = valueExpression;
}
else
{
comparison = Expression.Or( comparison, valueExpression );
}
}
return comparison;
}
selectedValues = filterValues[0].Split( new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries ).ToList();
if ( selectedValues.Any() )
{
MemberExpression propertyExpression = Expression.Property( parameterExpression, "Value" );
ConstantExpression constantExpression = Expression.Constant( selectedValues, typeof( List<string> ) );
return Expression.Call( constantExpression, typeof( List<string> ).GetMethod( "Contains", new Type[] { typeof( string ) } ), propertyExpression );
}
return null;
}
/// <summary>
/// This method is called in the
/// <see cref="M:Rock.Data.Model`1.PreSaveChanges(Rock.Data.DbContext,System.Data.Entity.Infrastructure.DbEntityEntry,System.Data.Entity.EntityState)" />
/// method. Use it to populate <see cref="P:Rock.Data.Model`1.HistoryItems" /> if needed.
/// These history items are queued to be written into the database post save (so that they
/// are only written if the save actually occurs).
/// </summary>
/// <param name="dbContext">The database context.</param>
/// <param name="entry">The entry.</param>
/// <param name="state">The state.</param>
protected override void BuildHistoryItems(Data.DbContext dbContext, DbEntityEntry entry, EntityState state)
{
/*
* 12/18/2019 BJW
*
* We want to log the history of attribute values within a person matrix. Most of this logging occurs from
* the attribute value model. However, when a matrix item (row in the table) is deleted, the pre-save event
* of the attribute values is not called. Therefore, the delete event needs to be logged here. Additionally,
* when the matrix item is added, the history is much cleaner when added here so that all the values of the
* row are consolidated to one history item. Modified state is not possible to log here because the
* matrix item is not actually modified when its attributes change.
*
* Task: https://app.asana.com/0/1120115219297347/1136643182208595/f
*/
if (state != EntityState.Deleted && state != EntityState.Added)
{
return;
}
var rockContext = new RockContext();
var matrixId = AttributeMatrixId != default ?
AttributeMatrixId :
entry.OriginalValues["AttributeMatrixId"].ToStringSafe().AsIntegerOrNull();
var matrix = AttributeMatrix;
if (matrix == null && matrixId.HasValue)
{
var matrixService = new AttributeMatrixService(rockContext);
matrix = matrixService.Queryable().AsNoTracking().FirstOrDefault(am => am.Id == matrixId);
}
if (matrix == null)
{
return;
}
// The root attribute matrix attribute value is linked to the matrix by the guid as the attribute value
var matrixGuidString = matrix.Guid.ToString();
var personEntityTypeId = EntityTypeCache.Get(typeof(Person)).Id;
var attributeValueService = new AttributeValueService(rockContext);
var rootAttributeValue = attributeValueService.Queryable().AsNoTracking().FirstOrDefault(av =>
av.Value.Equals(matrixGuidString, System.StringComparison.OrdinalIgnoreCase) &&
av.Attribute.EntityTypeId == personEntityTypeId
);
if (rootAttributeValue?.EntityId == null)
{
return;
}
var rootAttributeCache = AttributeCache.Get(rootAttributeValue.AttributeId);
if (rootAttributeCache == null)
{
return;
}
// Evaluate the history changes
var historyChangeList = new History.HistoryChangeList();
if (AttributeValues == null || !AttributeValues.Any())
{
this.LoadAttributes();
}
var isDelete = state == EntityState.Deleted;
foreach (var attributeValue in AttributeValues.Values)
{
var attributeCache = AttributeCache.Get(attributeValue.AttributeId);
var formattedOldValue = isDelete ? GetHistoryFormattedValue(attributeValue.Value, attributeCache) : string.Empty;
var formattedNewValue = isDelete ? string.Empty : GetHistoryFormattedValue(attributeValue.Value, attributeCache);
History.EvaluateChange(historyChangeList, attributeCache.Name, formattedOldValue, formattedNewValue, attributeCache.FieldType.Field.IsSensitive());
}
if (!historyChangeList.Any())
{
historyChangeList.AddChange(
isDelete ? History.HistoryVerb.Delete : History.HistoryVerb.Add,
History.HistoryChangeType.Record,
$"{rootAttributeCache.Name} Item");
}
HistoryItems = HistoryService.GetChanges(
typeof(Person),
SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
rootAttributeValue.EntityId.Value,
historyChangeList,
rootAttributeCache.Name,
typeof(Attribute),
rootAttributeCache.Id,
dbContext.GetCurrentPersonAlias()?.Id,
dbContext.SourceOfChange);
}
