/// <summary>
/// Copies the properties from another EntitySetItem object to this EntitySetItem object
/// </summary>
/// <param name="target">The target.</param>
/// <param name="source">The source.</param>
public static void CopyPropertiesFrom(this EntitySetItem target, EntitySetItem source)
{
target.Id = source.Id;
target.EntityId = source.EntityId;
target.EntitySetId = source.EntitySetId;
target.Order = source.Order;
target.CreatedDateTime = source.CreatedDateTime;
target.ModifiedDateTime = source.ModifiedDateTime;
target.CreatedByPersonAliasId = source.CreatedByPersonAliasId;
target.ModifiedByPersonAliasId = source.ModifiedByPersonAliasId;
target.Guid = source.Guid;
target.ForeignId = source.ForeignId;
}
/// <summary>
/// Clones this EntitySetItem object to a new EntitySetItem object
/// </summary>
/// <param name="source">The source.</param>
/// <param name="deepCopy">if set to <c>true</c> a deep copy is made. If false, only the basic entity properties are copied.</param>
/// <returns></returns>
public static EntitySetItem Clone(this EntitySetItem source, bool deepCopy)
{
if (deepCopy)
{
return(source.Clone() as EntitySetItem);
}
else
{
var target = new EntitySetItem();
target.CopyPropertiesFrom(source);
return(target);
}
}
/// <summary>
/// creates or updates the entity set on the basis of campaign connection configuration, and returns the Id of the entitySetId
/// </summary>
/// <param name="campaignConfiguration">The campaign configuration.</param>
/// <returns></returns>
public static int GetEntitySet(CampaignItem campaignConfiguration)
{
var rockContext = new RockContext();
var connectionOpportunityService = new ConnectionOpportunityService(rockContext);
var connectionRequestService = new ConnectionRequestService(rockContext);
var entitySetService = new Rock.Model.EntitySetService(rockContext);
var connectionOpportunity = connectionOpportunityService.Get(campaignConfiguration.OpportunityGuid);
// list of person on the basis of Dataview result and optout group.
var filteredPersonIds = GetFilteredPersonIds(campaignConfiguration, rockContext);
// get the last connection datetime.
var lastConnectionDateTime = RockDateTime.Now.AddDays(-campaignConfiguration.DaysBetweenConnection);
// if DaysBetweenConnection is 0 then check for connection request for any time period.
if (campaignConfiguration.DaysBetweenConnection == default(int))
{
lastConnectionDateTime = DateTime.MinValue;
}
// list of person that has active connection request OR has connection closed in the past number of days between connection.
var excludedPersonIds = connectionRequestService
.Queryable()
.Where(a =>
a.ConnectionOpportunityId == connectionOpportunity.Id && (
a.ConnectionState == ConnectionState.Active ||
a.ConnectionState == ConnectionState.FutureFollowUp ||
((a.ConnectionState == ConnectionState.Connected || a.ConnectionState == ConnectionState.Inactive) && a.ModifiedDateTime > lastConnectionDateTime)))
.Select(a => a.PersonAlias.PersonId)
.ToList();
// filtered list of person removing all the personIds found in excludedPersonIds List
filteredPersonIds = filteredPersonIds.Where(a => !excludedPersonIds.Contains(a)).ToList();
// get the ordered list of personIds based on the oldest previous connection request and connection opportunity
/* 2020-05-06 MDP
* If there are many filteredPersonIds, we'll get a SQL Exception, so let's get *all* the Connected connection Requests first,
* and then use C# to filter.
*/
var orderedLastCompletedRequestForPerson = connectionRequestService
.Queryable()
.Where(a => a.ConnectionOpportunityId == connectionOpportunity.Id &&
a.ConnectionState == ConnectionState.Connected)
.GroupBy(a => a.PersonAlias.PersonId)
.Select(a => new
{
PersonId = a.Key,
LastConnectionDateTime = a.OrderByDescending(b => b.ModifiedDateTime).Select(b => b.ModifiedDateTime).FirstOrDefault()
})
.OrderBy(a => a.LastConnectionDateTime)
.Select(a => a.PersonId).ToList();
// Use C# to filter persons so we can avoid a SQL Exception
orderedLastCompletedRequestForPerson = orderedLastCompletedRequestForPerson.Where(a => filteredPersonIds.Contains(a)).ToList();
var random = new Random();
//// get the final ordered list of personIds based on the oldest previous connection request and
//// connection opportunity otherwise order randomly for the person who don't have any previous connection request.
var orderedPersonIds = filteredPersonIds
.OrderBy(a =>
{
var index = orderedLastCompletedRequestForPerson.IndexOf(a);
if (index == -1)
{
return(random.Next(orderedLastCompletedRequestForPerson.Count, int.MaxValue));
}
else
{
return(index);
}
}).ToList();
EntitySet entitySet = null;
if (campaignConfiguration.EntitySetId != default(int))
{
entitySet = entitySetService.Get(campaignConfiguration.EntitySetId);
}
List <Rock.Model.EntitySetItem> entitySetItems = new List <Rock.Model.EntitySetItem>();
var personEntityTypeId = EntityTypeCache.Get <Rock.Model.Person>().Id;
if (entitySet == null || entitySet.EntityTypeId != personEntityTypeId)
{
entitySet = new Rock.Model.EntitySet();
entitySet.EntityTypeId = personEntityTypeId;
entitySet.ExpireDateTime = null;
entitySetService.Add(entitySet);
}
else
{
var entitySetItemQry = new EntitySetItemService(rockContext)
.Queryable().AsNoTracking()
.Where(i => i.EntitySetId == entitySet.Id);
rockContext.BulkDelete(entitySetItemQry);
}
// Update the EntitySet name
entitySet.Name = campaignConfiguration.Name;
var orderIndex = 0;
foreach (var personId in orderedPersonIds)
{
try
{
var item = new Rock.Model.EntitySetItem();
item.Order = orderIndex++;
item.EntityId = personId;
entitySetItems.Add(item);
}
catch
{
// ignore
}
}
rockContext.SaveChanges();
entitySetItems.ForEach(a =>
{
a.EntitySetId = entitySet.Id;
});
rockContext.BulkInsert(entitySetItems);
return(entitySet.Id);
}
/// <summary>
/// Handles the Click event of the btnProcessWaitlist control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private void btnProcessWaitlist_Click( object sender, EventArgs e )
{
// create entity set with selected individuals
var keys = gWaitList.SelectedKeys.ToList();
if ( keys.Any() )
{
var entitySet = new Rock.Model.EntitySet();
entitySet.EntityTypeId = Rock.Web.Cache.EntityTypeCache.Read<Rock.Model.RegistrationRegistrant>().Id;
entitySet.ExpireDateTime = RockDateTime.Now.AddMinutes( 20 );
foreach ( var key in keys )
{
try
{
var item = new Rock.Model.EntitySetItem();
item.EntityId = (int)key;
entitySet.Items.Add( item );
}
catch
{
// ignore
}
}
if ( entitySet.Items.Any() )
{
var rockContext = new RockContext();
var service = new Rock.Model.EntitySetService( rockContext );
service.Add( entitySet );
rockContext.SaveChanges();
// redirect to the waitlist page
Dictionary<string, string> queryParms = new Dictionary<string, string>();
queryParms.Add( "WaitListSetId", entitySet.Id.ToString() );
NavigateToLinkedPage( "WaitListProcessPage", queryParms );
}
}
}