/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The workflow action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
public override bool Execute(RockContext rockContext, Model.WorkflowAction action, Object entity, out List <string> errorMessages)
{
var checkInState = GetCheckInState(entity, out errorMessages);
if (checkInState == null)
{
return(false);
}
var family = checkInState.CheckIn.CurrentFamily;
if (family != null)
{
var remove = GetAttributeValue(action, "Remove").AsBoolean();
bool ageRequired = checkInState.CheckInType == null || checkInState.CheckInType.AgeRequired;
// get the Age Range
var ageRangeAttributeKey = string.Empty;
var ageRangeAttributeGuid = GetAttributeValue(action, "GroupAgeRangeAttribute").AsGuidOrNull();
if (ageRangeAttributeGuid.HasValue)
{
var attribute = AttributeCache.Get(ageRangeAttributeGuid.Value, rockContext);
if (attribute != null)
{
ageRangeAttributeKey = attribute.Key;
}
}
// get the admin-selected attribute key instead of using a hardcoded key
var birthdateRangeAttributeKey = string.Empty;
var birthdateRangeAttributeGuid = GetAttributeValue(action, "GroupBirthdateRangeAttribute").AsGuidOrNull();
if (birthdateRangeAttributeGuid.HasValue)
{
var attribute = AttributeCache.Get(birthdateRangeAttributeGuid.Value, rockContext);
if (attribute != null)
{
birthdateRangeAttributeKey = attribute.Key;
}
}
foreach (var person in family.People)
{
var ageAsDouble = person.Person.AgePrecise;
decimal? age = ageAsDouble.HasValue ? Convert.ToDecimal(ageAsDouble.Value) : (decimal?)null;
DateTime?birthdate = person.Person.BirthDate;
foreach (var groupType in person.GroupTypes.ToList())
{
foreach (var group in groupType.Groups.ToList())
{
bool?ageMatch = null;
bool?birthdayMatch = null;
// First check to see if age matches
if (!string.IsNullOrWhiteSpace(ageRangeAttributeKey))
{
var ageRange = group.Group.GetAttributeValue(ageRangeAttributeKey).ToStringSafe();
var ageRangePair = ageRange.Split(new char[] { ',' }, StringSplitOptions.None);
string minAgeValue = null;
string maxAgeValue = null;
if (ageRangePair.Length == 2)
{
minAgeValue = ageRangePair[0];
maxAgeValue = ageRangePair[1];
}
decimal?minAge = minAgeValue.AsDecimalOrNull();
decimal?maxAge = maxAgeValue.AsDecimalOrNull();
if (minAge.HasValue || maxAge.HasValue)
{
if (age.HasValue)
{
if (minAge.HasValue)
{
int groupMinAgePrecision = minAge.Value.GetDecimalPrecision();
decimal?personAgePrecise = age.Floor(groupMinAgePrecision);
if (personAgePrecise < minAge)
{
ageMatch = false;
}
}
if (maxAge.HasValue)
{
int groupMaxAgePrecision = maxAge.Value.GetDecimalPrecision();
decimal?personAgePrecise = age.Floor(groupMaxAgePrecision);
if (personAgePrecise > maxAge)
{
ageMatch = false;
}
}
if (!ageMatch.HasValue)
{
ageMatch = true;
}
}
else
{
if (ageRequired)
{
ageMatch = false;
}
}
}
}
if ((!ageMatch.HasValue || !ageMatch.Value) && !string.IsNullOrWhiteSpace(birthdateRangeAttributeKey))
{
var birthdateRange = group.Group.GetAttributeValue(birthdateRangeAttributeKey).ToStringSafe();
var birthdateRangePair = birthdateRange.Split(new char[] { ',' }, StringSplitOptions.None);
string minBirthdateValue = null;
string maxBirthdateValue = null;
if (birthdateRangePair.Length == 2)
{
minBirthdateValue = birthdateRangePair[0];
maxBirthdateValue = birthdateRangePair[1];
}
DateTime?minBirthdate = minBirthdateValue.AsDateTime();
DateTime?maxBirthdate = maxBirthdateValue.AsDateTime();
if (minBirthdate.HasValue || maxBirthdate.HasValue)
{
if (birthdate.HasValue)
{
if (minBirthdate.HasValue && birthdate.Value < minBirthdate.Value)
{
birthdayMatch = false;
}
if (maxBirthdate.HasValue && birthdate.Value > maxBirthdate.Value)
{
birthdayMatch = false;
}
if (!birthdayMatch.HasValue)
{
birthdayMatch = true;
}
}
else
{
if (ageRequired)
{
birthdayMatch = false;
}
}
}
}
if ((ageMatch.HasValue || birthdayMatch.HasValue) && !((ageMatch ?? false) || (birthdayMatch ?? false)))
{
if (remove)
{
groupType.Groups.Remove(group);
}
else
{
group.ExcludedByFilter = true;
}
}
}
}
}
}
return(true);
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
Guid? groupGuid = null;
Person person = null;
string attributeValue = string.Empty;
Guid groupRoleGuid = Guid.Empty;
string attributeKey = string.Empty;
// get the group attribute
Guid groupAttributeGuid = GetAttributeValue(action, "Group").AsGuid();
if (!groupAttributeGuid.IsEmpty())
{
groupGuid = action.GetWorklowAttributeValue(groupAttributeGuid).AsGuidOrNull();
if (!groupGuid.HasValue)
{
errorMessages.Add("The group could not be found!");
}
}
// get person alias guid
Guid personAliasGuid = Guid.Empty;
string personAttribute = GetAttributeValue(action, "Person");
Guid guid = personAttribute.AsGuid();
if (!guid.IsEmpty())
{
var attribute = AttributeCache.Read(guid, rockContext);
if (attribute != null)
{
string value = action.GetWorklowAttributeValue(guid);
personAliasGuid = value.AsGuid();
}
if (personAliasGuid != Guid.Empty)
{
person = new PersonAliasService(rockContext).Queryable().AsNoTracking()
.Where(p => p.Guid.Equals(personAliasGuid))
.Select(p => p.Person)
.FirstOrDefault();
}
else
{
errorMessages.Add("The person could not be found in the attribute!");
}
}
// get group member attribute value
attributeValue = GetAttributeValue(action, "AttributeValue");
guid = attributeValue.AsGuid();
if (guid.IsEmpty())
{
attributeValue = attributeValue.ResolveMergeFields(GetMergeFields(action));
}
else
{
var workflowAttributeValue = action.GetWorklowAttributeValue(guid);
if (workflowAttributeValue != null)
{
attributeValue = workflowAttributeValue;
}
}
// get optional role filter
groupRoleGuid = GetAttributeValue(action, "GroupRoleFilter").AsGuid();
// get attribute key
attributeKey = GetAttributeValue(action, "GroupMemberAttributeKey").Replace(" ", "");
// set attribute
if (groupGuid.HasValue && person != null)
{
var qry = new GroupMemberService(rockContext).Queryable()
.Where(m => m.Group.Guid == groupGuid && m.PersonId == person.Id);
if (groupRoleGuid != Guid.Empty)
{
qry = qry.Where(m => m.GroupRole.Guid == groupRoleGuid);
}
foreach (var groupMember in qry.ToList())
{
groupMember.LoadAttributes(rockContext);
if (groupMember.Attributes.ContainsKey(attributeKey))
{
var attribute = groupMember.Attributes[attributeKey];
Rock.Attribute.Helper.SaveAttributeValue(groupMember, attribute, attributeValue, rockContext);
}
else
{
action.AddLogEntry(string.Format("The group member attribute {0} does not exist!", attributeKey));
break;
}
}
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(true);
}
private void CreateControls(bool setValues)
{
fsAttributes.Controls.Clear();
string validationGroup = string.Format("vgAttributeValues_{0}", this.BlockId);
valSummaryTop.ValidationGroup = validationGroup;
btnSave.ValidationGroup = validationGroup;
hfAttributeOrder.Value = AttributeList.AsDelimited("|");
if (Person != null)
{
foreach (int attributeId in AttributeList)
{
var attribute = AttributeCache.Read(attributeId);
string attributeValue = Person.GetAttributeValue(attribute.Key);
string formattedValue = string.Empty;
if (ViewMode != VIEW_MODE_EDIT || !attribute.IsAuthorized(Authorization.EDIT, CurrentPerson))
{
if (ViewMode == VIEW_MODE_ORDER && _canAdministrate)
{
var div = new HtmlGenericControl("div");
fsAttributes.Controls.Add(div);
div.Attributes.Add("data-attribute-id", attribute.Id.ToString());
div.Attributes.Add("class", "form-group");
var a = new HtmlGenericControl("a");
div.Controls.Add(a);
var i = new HtmlGenericControl("i");
a.Controls.Add(i);
i.Attributes.Add("class", "fa fa-bars");
div.Controls.Add(new LiteralControl(" " + attribute.Name));
}
else
{
if (attribute.FieldType.Class == typeof(Rock.Field.Types.ImageFieldType).FullName)
{
formattedValue = attribute.FieldType.Field.FormatValueAsHtml(fsAttributes, attribute.EntityTypeId, Person.Id, attributeValue, attribute.QualifierValues, true);
}
else
{
formattedValue = attribute.FieldType.Field.FormatValueAsHtml(fsAttributes, attribute.EntityTypeId, Person.Id, attributeValue, attribute.QualifierValues, false);
}
if (!string.IsNullOrWhiteSpace(formattedValue))
{
if (attribute.FieldType.Class == typeof(Rock.Field.Types.MatrixFieldType).FullName)
{
fsAttributes.Controls.Add(new RockLiteral {
Label = attribute.Name, Text = formattedValue, CssClass = "matrix-attribute"
});
}
else
{
fsAttributes.Controls.Add(new RockLiteral {
Label = attribute.Name, Text = formattedValue
});
}
}
}
}
else
{
attribute.AddControl(fsAttributes.Controls, attributeValue, validationGroup, setValues, true);
}
}
}
pnlActions.Visible = (ViewMode != VIEW_MODE_VIEW);
}
/// <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>();
Group group = null;
Person person = null;
//
// Get the selected group from the configuration options.
//
var groupGuid = GetAttributeValue(action, "GroupExplicit").AsGuidOrNull();
if (!groupGuid.HasValue)
{
var guidGroupAttribute = GetAttributeValue(action, "Group").AsGuidOrNull();
if (guidGroupAttribute.HasValue)
{
var attributeGroup = AttributeCache.Get(guidGroupAttribute.Value, rockContext);
if (attributeGroup != null)
{
groupGuid = action.GetWorklowAttributeValue(guidGroupAttribute.Value).AsGuidOrNull();
}
}
}
if (groupGuid.HasValue)
{
group = new GroupService(rockContext).Get(groupGuid.Value);
}
if (group == null)
{
errorMessages.Add("No group was provided");
}
else
{
//
// Get the next person to be picked.
//
person = GetNextPerson(action, group.Id);
if (person == null)
{
errorMessages.Add("Group contains no valid members");
}
}
//
// Set the attribute value.
//
if (!errorMessages.Any())
{
//
// Set value of the selected attribute.
//
Guid selectAttributeGuid = GetAttributeValue(action, "Attribute").AsGuid();
if (!selectAttributeGuid.IsEmpty())
{
var selectedPersonAttribute = AttributeCache.Get(selectAttributeGuid, rockContext);
if (selectedPersonAttribute != null)
{
if (selectedPersonAttribute.FieldTypeId == FieldTypeCache.Get(Rock.SystemGuid.FieldType.TEXT.AsGuid(), rockContext).Id)
{
SetWorkflowAttributeValue(action, selectAttributeGuid, person.FullName);
}
else
{
SetWorkflowAttributeValue(action, selectAttributeGuid, person.PrimaryAlias.Guid.ToString());
}
}
}
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(true);
}
/// <summary>
/// Gets the group placement registrants.
/// </summary>
/// <param name="options">The options.</param>
/// <param name="currentPerson">The current person.</param>
/// <returns></returns>
public List <GroupPlacementRegistrant> GetGroupPlacementRegistrants(GetGroupPlacementRegistrantsParameters options, Person currentPerson)
{
var rockContext = this.Context as RockContext;
var registrationRegistrantService = new RegistrationRegistrantService(rockContext);
var registrationRegistrantQuery = registrationRegistrantService.Queryable();
registrationRegistrantQuery = registrationRegistrantQuery
.Where(a => a.Registration.RegistrationInstance.RegistrationTemplateId == options.RegistrationTemplateId);
if (options.RegistrationInstanceId.HasValue)
{
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.Registration.RegistrationInstanceId == options.RegistrationInstanceId.Value);
}
else if (options.RegistrationTemplateInstanceIds?.Any() == true)
{
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => options.RegistrationTemplateInstanceIds.Contains(a.Registration.RegistrationInstanceId));
}
if (options.RegistrantPersonDataViewFilterId.HasValue)
{
var dataFilter = new DataViewFilterService(rockContext).Get(options.RegistrantPersonDataViewFilterId.Value);
List <string> errorMessages = new List <string>();
var personService = new PersonService(rockContext);
var paramExpression = personService.ParameterExpression;
var personWhereExpression = dataFilter?.GetExpression(typeof(Person), personService, paramExpression, errorMessages);
if (personWhereExpression != null)
{
var personIdQry = personService.Queryable().Where(paramExpression, personWhereExpression, null).Select(x => x.Id);
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => personIdQry.Contains(a.PersonAlias.PersonId));
}
}
if (options.RegistrantId.HasValue)
{
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.Id == options.RegistrantId.Value);
}
Block registrationInstanceGroupPlacementBlock = new BlockService(rockContext).Get(options.BlockId);
if (registrationInstanceGroupPlacementBlock != null && currentPerson != null)
{
const string RegistrantAttributeFilter_RegistrationInstanceId = "RegistrantAttributeFilter_RegistrationInstanceId_{0}";
const string RegistrantAttributeFilter_RegistrationTemplateId = "RegistrantAttributeFilter_RegistrationTemplateId_{0}";
string userPreferenceKey;
if (options.RegistrationInstanceId.HasValue)
{
userPreferenceKey = PersonService.GetBlockUserPreferenceKeyPrefix(options.BlockId) + string.Format(RegistrantAttributeFilter_RegistrationInstanceId, options.RegistrationInstanceId);
}
else
{
userPreferenceKey = PersonService.GetBlockUserPreferenceKeyPrefix(options.BlockId) + string.Format(RegistrantAttributeFilter_RegistrationTemplateId, options.RegistrationTemplateId);
}
var attributeFilters = PersonService.GetUserPreference(currentPerson, userPreferenceKey).FromJsonOrNull <Dictionary <int, string> >() ?? new Dictionary <int, string>();
var parameterExpression = registrationRegistrantService.ParameterExpression;
Expression registrantWhereExpression = null;
foreach (var attributeFilter in attributeFilters)
{
var attribute = AttributeCache.Get(attributeFilter.Key);
var attributeFilterValues = attributeFilter.Value.FromJsonOrNull <List <string> >();
var entityField = EntityHelper.GetEntityFieldForAttribute(attribute);
if (entityField != null && attributeFilterValues != null)
{
var attributeWhereExpression = ExpressionHelper.GetAttributeExpression(registrationRegistrantService, parameterExpression, entityField, attributeFilterValues);
if (registrantWhereExpression == null)
{
registrantWhereExpression = attributeWhereExpression;
}
else
{
registrantWhereExpression = Expression.AndAlso(registrantWhereExpression, attributeWhereExpression);
}
}
}
if (registrantWhereExpression != null)
{
registrationRegistrantQuery = registrationRegistrantQuery.Where(parameterExpression, registrantWhereExpression);
}
}
var registrationTemplatePlacement = new RegistrationTemplatePlacementService(rockContext).Get(options.RegistrationTemplatePlacementId);
if (options.FilterFeeId.HasValue)
{
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.Fees.Any(f => f.RegistrationTemplateFeeId == options.FilterFeeId.Value));
}
if (options.FilterFeeOptionIds?.Any() == true)
{
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.Fees.Any(f => f.RegistrationTemplateFeeItemId.HasValue && options.FilterFeeOptionIds.Contains(f.RegistrationTemplateFeeItemId.Value)));
}
// don't include registrants that are on the waiting list
registrationRegistrantQuery = registrationRegistrantQuery.Where(a => a.OnWaitList == false);
registrationRegistrantQuery = registrationRegistrantQuery.OrderBy(a => a.PersonAlias.Person.LastName).ThenBy(a => a.PersonAlias.Person.NickName);
var registrationTemplatePlacementService = new RegistrationTemplatePlacementService(rockContext);
var registrationInstanceService = new RegistrationInstanceService(rockContext);
// get a queryable of PersonIds for the registration template shared groups so we can determine if the registrant has been placed
var registrationTemplatePlacementGroupsPersonIdQuery = registrationTemplatePlacementService.GetRegistrationTemplatePlacementPlacementGroups(registrationTemplatePlacement).SelectMany(a => a.Members).Select(a => a.PersonId);
// and also get a queryable of PersonIds for the registration instance placement groups so we can determine if the registrant has been placed
IQueryable <InstancePlacementGroupPersonId> allInstancesPlacementGroupInfoQuery = null;
if (!options.RegistrationInstanceId.HasValue && (options.RegistrationTemplateInstanceIds == null || !options.RegistrationTemplateInstanceIds.Any()))
{
// if neither RegistrationInstanceId or RegistrationTemplateInstanceIds was specified, use all of the RegistrationTemplates instances
options.RegistrationTemplateInstanceIds = new RegistrationTemplateService(rockContext).GetSelect(options.RegistrationTemplateId, s => s.Instances.Select(i => i.Id)).ToArray();
}
if (options.RegistrationInstanceId.HasValue)
{
allInstancesPlacementGroupInfoQuery =
registrationInstanceService.GetRegistrationInstancePlacementGroups(registrationInstanceService.Get(options.RegistrationInstanceId.Value))
.Where(a => a.GroupTypeId == registrationTemplatePlacement.GroupTypeId)
.SelectMany(a => a.Members).Select(a => a.PersonId)
.Select(s => new InstancePlacementGroupPersonId
{
PersonId = s,
RegistrationInstanceId = options.RegistrationInstanceId.Value
});
}
else if (options.RegistrationTemplateInstanceIds?.Any() == true)
{
foreach (var registrationInstanceId in options.RegistrationTemplateInstanceIds)
{
var instancePlacementGroupInfoQuery = registrationInstanceService.GetRegistrationInstancePlacementGroups(registrationInstanceService.Get(registrationInstanceId))
.Where(a => a.GroupTypeId == registrationTemplatePlacement.GroupTypeId)
.SelectMany(a => a.Members).Select(a => a.PersonId)
.Select(s => new InstancePlacementGroupPersonId
{
PersonId = s,
RegistrationInstanceId = registrationInstanceId
});
if (allInstancesPlacementGroupInfoQuery == null)
{
allInstancesPlacementGroupInfoQuery = instancePlacementGroupInfoQuery;
}
else
{
allInstancesPlacementGroupInfoQuery = allInstancesPlacementGroupInfoQuery.Union(instancePlacementGroupInfoQuery);
}
}
}
if (allInstancesPlacementGroupInfoQuery == null)
{
throw new ArgumentNullException("Registration Instance(s) must be specified");
}
// select in a way to avoid lazy loading
var registrationRegistrantPlacementQuery = registrationRegistrantQuery.Select(r => new
{
Registrant = r,
r.PersonAlias.Person,
r.Registration.RegistrationInstance,
// marked as AlreadyPlacedInGroup if the Registrant is a member of any of the registrant template placement group or the registration instance placement groups
AlreadyPlacedInGroup =
registrationTemplatePlacementGroupsPersonIdQuery.Contains(r.PersonAlias.PersonId) ||
allInstancesPlacementGroupInfoQuery.Any(x => x.RegistrationInstanceId == r.Registration.RegistrationInstanceId && x.PersonId == r.PersonAlias.PersonId)
});
var registrationRegistrantPlacementList = registrationRegistrantPlacementQuery.AsNoTracking().ToList();
var groupPlacementRegistrantList = registrationRegistrantPlacementList
.Select(x => new GroupPlacementRegistrant(x.Registrant, x.Person, x.AlreadyPlacedInGroup, x.RegistrationInstance, options))
.ToList();
return(groupPlacementRegistrantList.ToList());
}
/// <summary>
/// Binds the grid.
/// </summary>
/// <param name="report">The report.</param>
/// <param name="gReport">The g report.</param>
/// <param name="currentPerson">The current person.</param>
/// <param name="dataViewFilterOverrides">The data view filter overrides.</param>
/// <param name="databaseTimeoutSeconds">The database timeout seconds.</param>
/// <param name="isCommunication">if set to <c>true</c> [is communication].</param>
/// <param name="errorMessage">The error message.</param>
public static void BindGrid(Report report, Grid gReport, Person currentPerson, DataViewFilterOverrides dataViewFilterOverrides, int?databaseTimeoutSeconds, bool isCommunication, out string errorMessage)
{
errorMessage = null;
if (report != null)
{
var errors = new List <string>();
if (!report.EntityTypeId.HasValue)
{
gReport.Visible = false;
return;
}
var rockContext = new RockContext();
if (!report.IsAuthorized(Authorization.VIEW, currentPerson))
{
gReport.Visible = false;
return;
}
Type entityType = EntityTypeCache.Get(report.EntityTypeId.Value, rockContext).GetEntityType();
if (entityType == null)
{
errorMessage = string.Format("Unable to determine entityType for {0}", report.EntityType);
return;
}
gReport.EntityTypeId = report.EntityTypeId;
bool isPersonDataSet = report.EntityTypeId == EntityTypeCache.Get(typeof(Rock.Model.Person), true, rockContext).Id;
if (isPersonDataSet)
{
gReport.PersonIdField = "Id";
gReport.DataKeyNames = new string[] { "Id" };
}
else
{
gReport.PersonIdField = null;
}
if (report.EntityTypeId.HasValue)
{
gReport.RowItemText = EntityTypeCache.Get(report.EntityTypeId.Value, rockContext).FriendlyName;
}
List <EntityField> entityFields = Rock.Reporting.EntityHelper.GetEntityFields(entityType, true, false);
var selectedEntityFields = new Dictionary <int, EntityField>();
var selectedAttributes = new Dictionary <int, AttributeCache>();
var selectedComponents = new Dictionary <int, ReportField>();
// if there is a selectField, keep it to preserve which items are checked
var selectField = gReport.Columns.OfType <SelectField>().FirstOrDefault();
gReport.Columns.Clear();
int columnIndex = 0;
if (!string.IsNullOrWhiteSpace(gReport.PersonIdField))
{
// if we already had a selectField, use it (to preserve checkbox state)
gReport.Columns.Add(selectField ?? new SelectField());
columnIndex++;
}
var reportFieldSortExpressions = new Dictionary <Guid, string>();
gReport.CommunicateMergeFields = new List <string>();
gReport.CommunicationRecipientPersonIdFields = new List <string>();
foreach (var reportField in report.ReportFields.OrderBy(a => a.ColumnOrder))
{
bool mergeField = reportField.IsCommunicationMergeField.HasValue && reportField.IsCommunicationMergeField.Value;
bool recipientField = reportField.IsCommunicationRecipientField.HasValue && reportField.IsCommunicationRecipientField.Value;
columnIndex++;
if (reportField.ReportFieldType == ReportFieldType.Property)
{
var entityField = entityFields.FirstOrDefault(a => a.Name == reportField.Selection);
if (entityField != null)
{
selectedEntityFields.Add(columnIndex, entityField);
BoundField boundField = entityField.GetBoundFieldType();
boundField.DataField = string.Format("Entity_{0}_{1}", entityField.Name, columnIndex);
boundField.HeaderText = string.IsNullOrWhiteSpace(reportField.ColumnHeaderText) ? entityField.Title : reportField.ColumnHeaderText;
boundField.SortExpression = boundField.DataField;
reportFieldSortExpressions.AddOrReplace(reportField.Guid, boundField.SortExpression);
boundField.Visible = reportField.ShowInGrid;
gReport.Columns.Add(boundField);
if (mergeField)
{
gReport.CommunicateMergeFields.Add($"{boundField.DataField}|{boundField.HeaderText.RemoveSpecialCharacters()}");
}
if (recipientField)
{
gReport.CommunicationRecipientPersonIdFields.Add(boundField.DataField);
}
}
}
else if (reportField.ReportFieldType == ReportFieldType.Attribute)
{
Guid?attributeGuid = reportField.Selection.AsGuidOrNull();
if (attributeGuid.HasValue)
{
var attribute = AttributeCache.Get(attributeGuid.Value, rockContext);
if (attribute != null)
{
selectedAttributes.Add(columnIndex, attribute);
BoundField boundField;
if (attribute.FieldType.Guid.Equals(Rock.SystemGuid.FieldType.BOOLEAN.AsGuid()))
{
boundField = new BoolField();
}
else if (attribute.FieldType.Guid.Equals(Rock.SystemGuid.FieldType.DEFINED_VALUE.AsGuid()))
{
boundField = new DefinedValueField();
}
else
{
boundField = new CallbackField();
boundField.HtmlEncode = false;
(boundField as CallbackField).OnFormatDataValue += (sender, e) => {
string resultHtml = null;
if (e.DataValue != null)
{
bool condensed = true;
resultHtml = attribute.FieldType.Field.FormatValueAsHtml(gReport, e.DataValue.ToString(), attribute.QualifierValues, condensed);
}
e.FormattedValue = resultHtml ?? string.Empty;
};
}
boundField.DataField = string.Format("Attribute_{0}_{1}", attribute.Id, columnIndex);
boundField.HeaderText = string.IsNullOrWhiteSpace(reportField.ColumnHeaderText) ? attribute.Name : reportField.ColumnHeaderText;
boundField.SortExpression = boundField.DataField;
reportFieldSortExpressions.AddOrReplace(reportField.Guid, boundField.SortExpression);
if (attribute.FieldType.Guid.Equals(Rock.SystemGuid.FieldType.INTEGER.AsGuid()) ||
attribute.FieldType.Guid.Equals(Rock.SystemGuid.FieldType.DATE.AsGuid()) ||
attribute.FieldType.Guid.Equals(Rock.SystemGuid.FieldType.FILTER_DATE.AsGuid()))
{
boundField.HeaderStyle.HorizontalAlign = HorizontalAlign.Right;
boundField.ItemStyle.HorizontalAlign = HorizontalAlign.Right;
}
boundField.Visible = reportField.ShowInGrid;
gReport.Columns.Add(boundField);
if (mergeField)
{
gReport.CommunicateMergeFields.Add($"{boundField.DataField}|{boundField.HeaderText.RemoveSpecialCharacters()}");
}
if (recipientField)
{
gReport.CommunicationRecipientPersonIdFields.Add(boundField.DataField);
}
}
}
}
else if (reportField.ReportFieldType == ReportFieldType.DataSelectComponent)
{
selectedComponents.Add(columnIndex, reportField);
DataSelectComponent selectComponent = DataSelectContainer.GetComponent(reportField.DataSelectComponentEntityType.Name);
if (selectComponent != null)
{
try
{
DataControlField columnField = selectComponent.GetGridField(entityType, reportField.Selection ?? string.Empty);
string fieldId = $"{selectComponent.ColumnPropertyName}_{columnIndex}";
if (columnField is BoundField)
{
(columnField as BoundField).DataField = $"Data_{fieldId}";
var customSortProperties = selectComponent.SortProperties(reportField.Selection ?? string.Empty);
bool sortReversed = selectComponent.SortReversed(reportField.Selection ?? string.Empty);
if (customSortProperties != null)
{
if (customSortProperties == string.Empty)
{
// disable sorting if customSortExpression set to string.empty
columnField.SortExpression = string.Empty;
}
else
{
columnField.SortExpression = customSortProperties.Split(',').Select(a => string.Format("Sort_{0}_{1}", a, columnIndex)).ToList().AsDelimited(",");
}
}
else
{
// use default sorting if customSortExpression was null
columnField.SortExpression = (columnField as BoundField).DataField;
}
if (sortReversed == true && !string.IsNullOrWhiteSpace(columnField.SortExpression))
{
columnField.SortExpression = columnField.SortExpression + " DESC";
}
}
columnField.HeaderText = string.IsNullOrWhiteSpace(reportField.ColumnHeaderText) ? selectComponent.ColumnHeaderText : reportField.ColumnHeaderText;
if (!string.IsNullOrEmpty(columnField.SortExpression))
{
reportFieldSortExpressions.AddOrReplace(reportField.Guid, columnField.SortExpression);
}
columnField.Visible = reportField.ShowInGrid;
gReport.Columns.Add(columnField);
if (mergeField)
{
gReport.CommunicateMergeFields.Add($"Data_{fieldId}|{columnField.HeaderText.RemoveSpecialCharacters()}");
}
if (recipientField)
{
string fieldName = (selectComponent is IRecipientDataSelect) ? $"Recipient_{fieldId}" : $"Data_{fieldId}";
gReport.CommunicationRecipientPersonIdFields.Add(fieldName);
}
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, HttpContext.Current);
errors.Add(string.Format("{0} - {1}", selectComponent, ex.Message));
}
}
}
}
// if no fields are specified, show the default fields (Previewable/All) for the EntityType
var dataColumns = gReport.Columns.OfType <object>().Where(a => a.GetType() != typeof(SelectField));
if (dataColumns.Count() == 0)
{
// show either the Previewable Columns or all (if there are no previewable columns)
bool showAllColumns = !entityFields.Any(a => a.FieldKind == FieldKind.Property && a.IsPreviewable);
foreach (var entityField in entityFields.Where(a => a.FieldKind == FieldKind.Property))
{
columnIndex++;
selectedEntityFields.Add(columnIndex, entityField);
BoundField boundField = entityField.GetBoundFieldType();
boundField.DataField = string.Format("Entity_{0}_{1}", entityField.Name, columnIndex);
boundField.HeaderText = entityField.Name;
boundField.SortExpression = boundField.DataField;
boundField.Visible = showAllColumns || entityField.IsPreviewable;
gReport.Columns.Add(boundField);
}
}
try
{
gReport.Visible = true;
gReport.ExportFilename = report.Name;
SortProperty sortProperty = gReport.SortProperty;
if (sortProperty == null)
{
var reportSort = new SortProperty();
var sortColumns = new Dictionary <string, SortDirection>();
foreach (var reportField in report.ReportFields.Where(a => a.SortOrder.HasValue).OrderBy(a => a.SortOrder.Value))
{
if (reportFieldSortExpressions.ContainsKey(reportField.Guid))
{
var sortField = reportFieldSortExpressions[reportField.Guid];
if (!string.IsNullOrWhiteSpace(sortField))
{
sortColumns.Add(sortField, reportField.SortDirection);
}
}
}
if (sortColumns.Any())
{
reportSort.Property = sortColumns.Select(a => a.Key + (a.Value == SortDirection.Descending ? " desc" : string.Empty)).ToList().AsDelimited(",");
sortProperty = reportSort;
}
}
var qryErrors = new List <string>();
System.Data.Entity.DbContext reportDbContext;
dynamic qry = report.GetQueryable(entityType, selectedEntityFields, selectedAttributes, selectedComponents, sortProperty, dataViewFilterOverrides, databaseTimeoutSeconds ?? 180, isCommunication, out qryErrors, out reportDbContext);
errors.AddRange(qryErrors);
if (!string.IsNullOrEmpty(report.QueryHint) && reportDbContext is RockContext)
{
using (new QueryHintScope(reportDbContext as RockContext, report.QueryHint))
{
gReport.SetLinqDataSource(qry);
}
}
else
{
gReport.SetLinqDataSource(qry);
}
gReport.DataBind();
}
catch (Exception ex)
{
Exception exception = ex;
ExceptionLogService.LogException(ex, HttpContext.Current);
while (exception != null)
{
if (exception is System.Data.SqlClient.SqlException)
{
// if there was a SQL Server Timeout, have the warning be a friendly message about that.
if ((exception as System.Data.SqlClient.SqlException).Number == -2)
{
errorMessage = "This report did not complete in a timely manner. You can try again or adjust the timeout setting of this block.";
return;
}
else
{
errors.Add(exception.Message);
exception = exception.InnerException;
}
}
else
{
errors.Add(exception.Message);
exception = exception.InnerException;
}
}
}
if (errors.Any())
{
errorMessage = "WARNING: There was a problem with one or more of the report's data components...<br/><br/> " + errors.AsDelimited("<br/>");
}
}
}
private void SendEmail(RockContext rockContext, WorkflowAction action)
{
var mergeFields = GetMergeFields(action);
string to = GetAttributeValue(action, "To");
string fromValue = GetAttributeValue(action, "From");
string subject = GetAttributeValue(action, "Subject");
string body = GetAttributeValue(action, "Body");
bool createCommunicationRecord = GetAttributeValue(action, "SaveCommunicationHistory").AsBoolean();
string fromEmail = string.Empty;
string fromName = string.Empty;
Guid? fromGuid = fromValue.AsGuidOrNull();
if (fromGuid.HasValue)
{
var attribute = AttributeCache.Read(fromGuid.Value, rockContext);
if (attribute != null)
{
string fromAttributeValue = action.GetWorklowAttributeValue(fromGuid.Value);
if (!string.IsNullOrWhiteSpace(fromAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.PersonFieldType")
{
Guid personAliasGuid = fromAttributeValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
var person = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.Person)
.FirstOrDefault();
if (person != null && !string.IsNullOrWhiteSpace(person.Email))
{
fromEmail = person.Email;
fromName = person.FullName;
}
}
}
else
{
fromEmail = fromAttributeValue;
}
}
}
}
else
{
fromEmail = fromValue;
}
var metaData = new Dictionary <string, string>();
metaData.Add("workflow_action_guid", action.Guid.ToString());
Guid?guid = to.AsGuidOrNull();
if (guid.HasValue)
{
var attribute = AttributeCache.Read(guid.Value, rockContext);
if (attribute != null)
{
string toValue = action.GetWorklowAttributeValue(guid.Value);
if (!string.IsNullOrWhiteSpace(toValue))
{
switch (attribute.FieldType.Class)
{
case "Rock.Field.Types.TextFieldType":
{
Send(toValue, fromEmail, fromName, subject, body, mergeFields, rockContext, createCommunicationRecord, metaData);
break;
}
case "Rock.Field.Types.PersonFieldType":
{
Guid personAliasGuid = toValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
var person = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.Person)
.FirstOrDefault();
if (person == null)
{
action.AddLogEntry("Invalid Recipient: Person not found", true);
}
else if (string.IsNullOrWhiteSpace(person.Email))
{
action.AddLogEntry("Email was not sent: Recipient does not have an email address", true);
}
else if (!person.IsEmailActive)
{
action.AddLogEntry("Email was not sent: Recipient email is not active", true);
}
else if (person.EmailPreference == EmailPreference.DoNotEmail)
{
action.AddLogEntry("Email was not sent: Recipient has requested 'Do Not Email'", true);
}
else
{
var personDict = new Dictionary <string, object>(mergeFields);
personDict.Add("Person", person);
Send(person.Email, fromEmail, fromName, subject, body, personDict, rockContext, createCommunicationRecord, metaData);
}
}
break;
}
}
}
}
}
else
{
Send(to.ResolveMergeFields(mergeFields), fromEmail, fromName, subject, body, mergeFields, rockContext, createCommunicationRecord, metaData);
}
}
/// <summary>
/// Parses the where.
/// </summary>
/// <param name="whereClause">The where clause.</param>
/// <param name="type">The type.</param>
/// <param name="service">The service.</param>
/// <param name="parmExpression">The parm expression.</param>
/// <param name="entityType">Type of the entity.</param>
/// <param name="entityTypeCache">The entity type cache.</param>
/// <returns></returns>
private Expression ParseWhere(string whereClause, Type type, IService service, ParameterExpression parmExpression, Type entityType, EntityTypeCache entityTypeCache)
{
Expression returnExpression = null;
// find locations of and/or's
var expressionComponents = Regex.Split(whereClause, @"(\|\||&&)");
var currentExpressionComparisonType = ExpressionComparisonType.And;
foreach (var component in expressionComponents)
{
if (component == "||")
{
currentExpressionComparisonType = ExpressionComparisonType.Or;
continue;
}
if (component == "&&")
{
currentExpressionComparisonType = ExpressionComparisonType.And;
continue;
}
// parse the part to get the expression
string regexPattern = @"([a-zA-Z]+)|(==|<=|>=|<|!=|\^=|\*=|\*!|_=|_!|>|\$=|#=)|("".*""|\d+)";
var expressionParts = Regex.Matches(component, regexPattern)
.Cast <Match>()
.Select(m => m.Value)
.ToList();
if (expressionParts.Count == 3)
{
var property = expressionParts[0];
var operatorType = expressionParts[1];
var value = expressionParts[2].Replace("\"", "");
List <string> selectionParms = new List <string>();
selectionParms.Add(PropertyComparisonConversion(operatorType).ToString());
selectionParms.Add(value);
selectionParms.Add(property);
Expression expression = null;
if (entityType.GetProperty(property) != null)
{
var entityProperty = entityType.GetProperty(property);
expression = ExpressionHelper.PropertyFilterExpression(selectionParms, parmExpression, property, entityProperty.PropertyType);
}
else
{
AttributeCache filterAttribute = null;
Expression attributeWhereExpression = null;
var attributeKey = property;
// We would really love to further qualify this beyond the EntityType by including the
// EntityTypeQualifier and EntityTypeQualifierValue but we can't easily do that so, we
// will do that "Just in case..." code below (because this actually happened in our Spark
// environment.
// Also, there could be multiple attributes that have the same key (due to attribute qualifiers or just simply a duplicate key)
var entityAttributeListForAttributeKey = AttributeCache.GetByEntity(entityTypeCache.Id)
.SelectMany(a => a.AttributeIds)
.Select(a => AttributeCache.Get(a))
.Where(a => a != null && a.Key == attributeKey).ToList();
// Just in case this EntityType has multiple attributes with the same key, create a OR'd clause for each attribute that has this key
// NOTE: this could easily happen if doing an entity command against a DefinedValue, and the same attribute key is used in more than one defined type
foreach (var attribute in entityAttributeListForAttributeKey)
{
filterAttribute = attribute;
var attributeEntityField = EntityHelper.GetEntityFieldForAttribute(filterAttribute);
if (attributeWhereExpression == null)
{
attributeWhereExpression = ExpressionHelper.GetAttributeExpression(service, parmExpression, attributeEntityField, selectionParms);
}
else
{
attributeWhereExpression = Expression.OrElse(attributeWhereExpression, ExpressionHelper.GetAttributeExpression(service, parmExpression, attributeEntityField, selectionParms));
}
}
if (attributeWhereExpression != null)
{
expression = attributeWhereExpression;
}
}
if (returnExpression == null)
{
returnExpression = expression;
}
else
{
if (expression == null)
{
// unable to match to property or attribute, so just return what we got
return(returnExpression);
}
if (currentExpressionComparisonType == ExpressionComparisonType.And)
{
returnExpression = Expression.AndAlso(returnExpression, expression);
}
else
{
returnExpression = Expression.OrElse(returnExpression, expression);
}
}
}
else
{
// error in parsing expression
throw new Exception("Error in Where expression");
}
}
return(returnExpression);
}
/// <summary>
/// Builds the controls for the Fields placeholder.
/// </summary>
/// <param name="setValues">if set to <c>true</c> [set values].</param>
private void BuildFields(bool setValues)
{
phFields.Controls.Clear();
if (TemplateState.Forms == null)
{
return;
}
foreach (var form in TemplateState.Forms.OrderBy(f => f.Order))
{
if (form.Fields == null)
{
continue;
}
foreach (var field in form.Fields.OrderBy(f => f.Order))
{
if (field.FieldSource == RegistrationFieldSource.RegistrantAttribute)
{
if (field.AttributeId.HasValue)
{
object fieldValue = RegistrantState.FieldValues.ContainsKey(field.Id) ? RegistrantState.FieldValues[field.Id].FieldValue : null;
string value = setValues && fieldValue != null?fieldValue.ToString() : null;
var attribute = AttributeCache.Get(field.AttributeId.Value);
if ((setValues && value == null) || (value.IsNullOrWhiteSpace() && field.IsRequired == true))
{
// If the value was not set already, or if it is required and currently empty then use the default
// Intentionally leaving the possibility of saving an empty string as the value for non-required fields.
value = attribute.DefaultValue;
}
FieldVisibilityWrapper fieldVisibilityWrapper = new FieldVisibilityWrapper
{
ID = "_fieldVisibilityWrapper_attribute_" + attribute.Id.ToString(),
RegistrationTemplateFormFieldId = field.Id,
FieldVisibilityRules = field.FieldVisibilityRules
};
fieldVisibilityWrapper.EditValueUpdated += FieldVisibilityWrapper_EditValueUpdated;
phFields.Controls.Add(fieldVisibilityWrapper);
var editControl = attribute.AddControl(fieldVisibilityWrapper.Controls, value, BlockValidationGroup, setValues, true, field.IsRequired, null, field.Attribute.Description);
fieldVisibilityWrapper.EditControl = editControl;
bool hasDependantVisibilityRule = form.Fields.Any(a => a.FieldVisibilityRules.RuleList.Any(r => r.ComparedToRegistrationTemplateFormFieldGuid == field.Guid));
if (hasDependantVisibilityRule && attribute.FieldType.Field.HasChangeHandler(editControl))
{
attribute.FieldType.Field.AddChangeHandler(editControl, () =>
{
fieldVisibilityWrapper.TriggerEditValueUpdated(editControl, new FieldVisibilityWrapper.FieldEventArgs(attribute, editControl));
});
}
}
}
}
}
FieldVisibilityWrapper.ApplyFieldVisibilityRules(phFields);
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
// get person
int?personId = null;
string personAttributeValue = GetAttributeValue(action, "Person");
Guid? guidPersonAttribute = personAttributeValue.AsGuidOrNull();
if (guidPersonAttribute.HasValue)
{
var attributePerson = AttributeCache.Read(guidPersonAttribute.Value, rockContext);
if (attributePerson != null || attributePerson.FieldType.Class != "Rock.Field.Types.PersonFieldType")
{
string attributePersonValue = action.GetWorklowAttributeValue(guidPersonAttribute.Value);
if (!string.IsNullOrWhiteSpace(attributePersonValue))
{
Guid personAliasGuid = attributePersonValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
personId = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.PersonId)
.FirstOrDefault();
if (personId == null)
{
errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString()));
return(false);
}
}
}
}
}
if (personId == null)
{
errorMessages.Add("The attribute used to provide the person was invalid, or not of type 'Person'.");
return(false);
}
// determine the phone type to edit
DefinedValueCache phoneType = null;
var phoneTypeAttributeValue = action.GetWorklowAttributeValue(GetAttributeValue(action, "PhoneTypeAttribute").AsGuid());
if (phoneTypeAttributeValue != null)
{
phoneType = DefinedValueCache.Read(phoneTypeAttributeValue.AsGuid());
}
if (phoneType == null)
{
phoneType = DefinedValueCache.Read(GetAttributeValue(action, "PhoneType").AsGuid());
}
if (phoneType == null)
{
errorMessages.Add("The phone type to be updated was not selected.");
return(false);
}
// get the ignore blank setting
var ignoreBlanks = GetActionAttributeValue(action, "IgnoreBlankValues").AsBoolean(true);
// get the new phone number value
string phoneNumberValue = GetAttributeValue(action, "PhoneNumber");
Guid? phoneNumberValueGuid = phoneNumberValue.AsGuidOrNull();
if (phoneNumberValueGuid.HasValue)
{
phoneNumberValue = action.GetWorklowAttributeValue(phoneNumberValueGuid.Value);
}
else
{
phoneNumberValue = phoneNumberValue.ResolveMergeFields(GetMergeFields(action));
}
phoneNumberValue = PhoneNumber.CleanNumber(phoneNumberValue);
// gets value indicating if phone number is unlisted
string unlistedValue = GetAttributeValue(action, "Unlisted");
Guid? unlistedValueGuid = unlistedValue.AsGuidOrNull();
if (unlistedValueGuid.HasValue)
{
unlistedValue = action.GetWorklowAttributeValue(unlistedValueGuid.Value);
}
else
{
unlistedValue = unlistedValue.ResolveMergeFields(GetMergeFields(action));
}
bool?unlisted = unlistedValue.AsBooleanOrNull();
// gets value indicating if messaging should be enabled for phone number
string smsEnabledValue = GetAttributeValue(action, "MessagingEnabled");
Guid? smsEnabledValueGuid = smsEnabledValue.AsGuidOrNull();
if (smsEnabledValueGuid.HasValue)
{
smsEnabledValue = action.GetWorklowAttributeValue(smsEnabledValueGuid.Value);
}
else
{
smsEnabledValue = smsEnabledValue.ResolveMergeFields(GetMergeFields(action));
}
bool?smsEnabled = smsEnabledValue.AsBooleanOrNull();
bool updated = false;
var phoneNumberService = new PhoneNumberService(rockContext);
var phoneNumber = phoneNumberService.Queryable()
.Where(n =>
n.PersonId == personId.Value &&
n.NumberTypeValueId == phoneType.Id)
.FirstOrDefault();
string oldValue = string.Empty;
if (phoneNumber == null)
{
phoneNumber = new PhoneNumber {
NumberTypeValueId = phoneType.Id, PersonId = personId.Value
};
phoneNumberService.Add(phoneNumber);
updated = true;
}
else
{
oldValue = phoneNumber.NumberFormattedWithCountryCode;
}
if (!string.IsNullOrWhiteSpace(phoneNumberValue) || !ignoreBlanks)
{
updated = updated || phoneNumber.Number != phoneNumberValue;
phoneNumber.Number = phoneNumberValue;
}
if (unlisted.HasValue)
{
updated = updated || phoneNumber.IsUnlisted != unlisted.Value;
phoneNumber.IsUnlisted = unlisted.Value;
}
if (smsEnabled.HasValue)
{
updated = updated || phoneNumber.IsMessagingEnabled != smsEnabled.Value;
phoneNumber.IsMessagingEnabled = smsEnabled.Value;
}
if (updated)
{
var changes = new List <string>();
History.EvaluateChange(
changes,
string.Format("{0} Phone", phoneType.Value),
oldValue,
phoneNumber.NumberFormattedWithCountryCode);
if (changes.Any())
{
changes.Add(string.Format("<em>(Updated by the '{0}' workflow)</em>", action.ActionTypeCache.ActivityType.WorkflowType.Name));
HistoryService.SaveChanges(rockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), personId.Value, changes, false);
}
rockContext.SaveChanges();
if (action.Activity != null && action.Activity.Workflow != null)
{
var workflowType = action.Activity.Workflow.WorkflowTypeCache;
if (workflowType != null && workflowType.LoggingLevel == WorkflowLoggingLevel.Action)
{
var person = new PersonService(rockContext).Get(personId.Value);
action.AddLogEntry(string.Format("Updated {0} phone for {1} to {2}.", phoneType.Value, person.FullName, phoneNumber.NumberFormattedWithCountryCode));
}
}
}
return(true);
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click(object sender, EventArgs e)
{
if (RegistrantState != null)
{
RockContext rockContext = new RockContext();
var personService = new PersonService(rockContext);
var registrantService = new RegistrationRegistrantService(rockContext);
var registrantFeeService = new RegistrationRegistrantFeeService(rockContext);
var registrationTemplateFeeService = new RegistrationTemplateFeeService(rockContext);
var registrationTemplateFeeItemService = new RegistrationTemplateFeeItemService(rockContext);
RegistrationRegistrant registrant = null;
if (RegistrantState.Id > 0)
{
registrant = registrantService.Get(RegistrantState.Id);
}
var previousRegistrantPersonIds = registrantService.Queryable().Where(a => a.RegistrationId == RegistrantState.RegistrationId)
.Where(r => r.PersonAlias != null)
.Select(r => r.PersonAlias.PersonId)
.ToList();
bool newRegistrant = false;
var registrantChanges = new History.HistoryChangeList();
if (registrant == null)
{
newRegistrant = true;
registrant = new RegistrationRegistrant();
registrant.RegistrationId = RegistrantState.RegistrationId;
registrantService.Add(registrant);
registrantChanges.AddChange(History.HistoryVerb.Add, History.HistoryChangeType.Record, "Registrant");
}
if (!registrant.PersonAliasId.Equals(ppPerson.PersonAliasId))
{
string prevPerson = (registrant.PersonAlias != null && registrant.PersonAlias.Person != null) ?
registrant.PersonAlias.Person.FullName : string.Empty;
string newPerson = ppPerson.PersonName;
newRegistrant = true;
History.EvaluateChange(registrantChanges, "Person", prevPerson, newPerson);
}
int?personId = ppPerson.PersonId.Value;
registrant.PersonAliasId = ppPerson.PersonAliasId.Value;
// Get the name of registrant for history
string registrantName = "Unknown";
if (ppPerson.PersonId.HasValue)
{
var person = personService.Get(ppPerson.PersonId.Value);
if (person != null)
{
registrantName = person.FullName;
}
}
// set their status (wait list / registrant)
registrant.OnWaitList = !tglWaitList.Checked;
History.EvaluateChange(registrantChanges, "Cost", registrant.Cost, cbCost.Text.AsDecimal());
registrant.Cost = cbCost.Text.AsDecimal();
History.EvaluateChange(registrantChanges, "Discount Applies", registrant.DiscountApplies, cbDiscountApplies.Checked);
registrant.DiscountApplies = cbDiscountApplies.Checked;
if (!Page.IsValid)
{
return;
}
// Remove/delete any registrant fees that are no longer in UI with quantity
foreach (var dbFee in registrant.Fees.ToList())
{
if (!RegistrantState.FeeValues.Keys.Contains(dbFee.RegistrationTemplateFeeId) ||
RegistrantState.FeeValues[dbFee.RegistrationTemplateFeeId] == null ||
!RegistrantState.FeeValues[dbFee.RegistrationTemplateFeeId]
.Any(f =>
f.RegistrationTemplateFeeItemId == dbFee.RegistrationTemplateFeeItemId &&
f.Quantity > 0))
{
var feeOldValue = string.Format("'{0}' Fee (Quantity:{1:N0}, Cost:{2:C2}, Option:{3}",
dbFee.RegistrationTemplateFee.Name, dbFee.Quantity, dbFee.Cost, dbFee.Option);
registrantChanges.AddChange(History.HistoryVerb.Delete, History.HistoryChangeType.Record, "Fee").SetOldValue(feeOldValue);
registrant.Fees.Remove(dbFee);
registrantFeeService.Delete(dbFee);
}
}
// Add/Update any of the fees from UI
foreach (var uiFee in RegistrantState.FeeValues.Where(f => f.Value != null))
{
foreach (var uiFeeOption in uiFee.Value)
{
var dbFee = registrant.Fees
.Where(f =>
f.RegistrationTemplateFeeId == uiFee.Key &&
f.RegistrationTemplateFeeItemId == uiFeeOption.RegistrationTemplateFeeItemId)
.FirstOrDefault();
if (dbFee == null)
{
dbFee = new RegistrationRegistrantFee();
dbFee.RegistrationTemplateFeeId = uiFee.Key;
var registrationTemplateFeeItem = registrationTemplateFeeItemService.GetNoTracking(uiFeeOption.RegistrationTemplateFeeItemId);
if (registrationTemplateFeeItem != null)
{
dbFee.Option = registrationTemplateFeeItem.Name;
}
dbFee.RegistrationTemplateFeeItemId = uiFeeOption.RegistrationTemplateFeeItemId;
registrant.Fees.Add(dbFee);
}
var templateFee = dbFee.RegistrationTemplateFee;
if (templateFee == null)
{
templateFee = registrationTemplateFeeService.Get(uiFee.Key);
}
string feeName = templateFee != null ? templateFee.Name : "Fee";
if (!string.IsNullOrWhiteSpace(uiFeeOption.FeeLabel))
{
feeName = string.Format("{0} ({1})", feeName, uiFeeOption.FeeLabel);
}
if (dbFee.Id <= 0)
{
registrantChanges.AddChange(History.HistoryVerb.Add, History.HistoryChangeType.Record, "Fee").SetNewValue(feeName);
}
History.EvaluateChange(registrantChanges, feeName + " Quantity", dbFee.Quantity, uiFeeOption.Quantity);
dbFee.Quantity = uiFeeOption.Quantity;
History.EvaluateChange(registrantChanges, feeName + " Cost", dbFee.Cost, uiFeeOption.Cost);
dbFee.Cost = uiFeeOption.Cost;
}
}
if (TemplateState.RequiredSignatureDocumentTemplate != null)
{
var person = new PersonService(rockContext).Get(personId.Value);
var documentService = new SignatureDocumentService(rockContext);
var binaryFileService = new BinaryFileService(rockContext);
SignatureDocument document = null;
int?signatureDocumentId = hfSignedDocumentId.Value.AsIntegerOrNull();
int?binaryFileId = fuSignedDocument.BinaryFileId;
if (signatureDocumentId.HasValue)
{
document = documentService.Get(signatureDocumentId.Value);
}
if (document == null && binaryFileId.HasValue)
{
var instance = new RegistrationInstanceService(rockContext).Get(RegistrationInstanceId);
document = new SignatureDocument();
document.SignatureDocumentTemplateId = TemplateState.RequiredSignatureDocumentTemplate.Id;
document.AppliesToPersonAliasId = registrant.PersonAliasId.Value;
document.AssignedToPersonAliasId = registrant.PersonAliasId.Value;
document.Name = string.Format(
"{0}_{1}",
instance != null ? instance.Name : TemplateState.Name,
person != null ? person.FullName.RemoveSpecialCharacters() : string.Empty);
document.Status = SignatureDocumentStatus.Signed;
document.LastStatusDate = RockDateTime.Now;
documentService.Add(document);
}
if (document != null)
{
int?origBinaryFileId = document.BinaryFileId;
document.BinaryFileId = binaryFileId;
if (origBinaryFileId.HasValue && origBinaryFileId.Value != document.BinaryFileId)
{
// if a new the binaryFile was uploaded, mark the old one as Temporary so that it gets cleaned up
var oldBinaryFile = binaryFileService.Get(origBinaryFileId.Value);
if (oldBinaryFile != null && !oldBinaryFile.IsTemporary)
{
oldBinaryFile.IsTemporary = true;
}
}
// ensure the IsTemporary is set to false on binaryFile associated with this document
if (document.BinaryFileId.HasValue)
{
var binaryFile = binaryFileService.Get(document.BinaryFileId.Value);
if (binaryFile != null && binaryFile.IsTemporary)
{
binaryFile.IsTemporary = false;
}
}
}
}
if (!registrant.IsValid)
{
// Controls will render the error messages
return;
}
// use WrapTransaction since SaveAttributeValues does it's own RockContext.SaveChanges()
rockContext.WrapTransaction(() =>
{
rockContext.SaveChanges();
registrant.LoadAttributes();
foreach (var field in TemplateState.Forms
.SelectMany(f => f.Fields
.Where(t =>
t.FieldSource == RegistrationFieldSource.RegistrantAttribute &&
t.AttributeId.HasValue)))
{
var attribute = AttributeCache.Get(field.AttributeId.Value);
if (attribute != null)
{
string originalValue = registrant.GetAttributeValue(attribute.Key);
var fieldValue = RegistrantState.FieldValues
.Where(f => f.Key == field.Id)
.Select(f => f.Value.FieldValue)
.FirstOrDefault();
string newValue = fieldValue != null ? fieldValue.ToString() : string.Empty;
if ((originalValue ?? string.Empty).Trim() != (newValue ?? string.Empty).Trim())
{
string formattedOriginalValue = string.Empty;
if (!string.IsNullOrWhiteSpace(originalValue))
{
formattedOriginalValue = attribute.FieldType.Field.FormatValue(null, originalValue, attribute.QualifierValues, false);
}
string formattedNewValue = string.Empty;
if (!string.IsNullOrWhiteSpace(newValue))
{
formattedNewValue = attribute.FieldType.Field.FormatValue(null, newValue, attribute.QualifierValues, false);
}
History.EvaluateChange(registrantChanges, attribute.Name, formattedOriginalValue, formattedNewValue);
}
if (fieldValue != null)
{
registrant.SetAttributeValue(attribute.Key, fieldValue.ToString());
}
}
}
registrant.SaveAttributeValues(rockContext);
});
if (newRegistrant && TemplateState.GroupTypeId.HasValue && ppPerson.PersonId.HasValue)
{
using (var newRockContext = new RockContext())
{
var reloadedRegistrant = new RegistrationRegistrantService(newRockContext).Get(registrant.Id);
if (reloadedRegistrant != null &&
reloadedRegistrant.Registration != null &&
reloadedRegistrant.Registration.Group != null &&
reloadedRegistrant.Registration.Group.GroupTypeId == TemplateState.GroupTypeId.Value)
{
int?groupRoleId = TemplateState.GroupMemberRoleId.HasValue ?
TemplateState.GroupMemberRoleId.Value :
reloadedRegistrant.Registration.Group.GroupType.DefaultGroupRoleId;
if (groupRoleId.HasValue)
{
var groupMemberService = new GroupMemberService(newRockContext);
var groupMember = groupMemberService
.Queryable().AsNoTracking()
.Where(m =>
m.GroupId == reloadedRegistrant.Registration.Group.Id &&
m.PersonId == reloadedRegistrant.PersonId &&
m.GroupRoleId == groupRoleId.Value)
.FirstOrDefault();
if (groupMember == null)
{
groupMember = new GroupMember();
groupMember.GroupId = reloadedRegistrant.Registration.Group.Id;
groupMember.PersonId = ppPerson.PersonId.Value;
groupMember.GroupRoleId = groupRoleId.Value;
groupMember.GroupMemberStatus = TemplateState.GroupMemberStatus;
groupMemberService.Add(groupMember);
newRockContext.SaveChanges();
registrantChanges.AddChange(History.HistoryVerb.Add, History.HistoryChangeType.Record, string.Format("Registrant to {0} group", reloadedRegistrant.Registration.Group.Name));
}
else
{
registrantChanges.AddChange(History.HistoryVerb.Modify, History.HistoryChangeType.Record, string.Format("Registrant to existing person in {0} group", reloadedRegistrant.Registration.Group.Name));
}
if (reloadedRegistrant.GroupMemberId.HasValue && reloadedRegistrant.GroupMemberId.Value != groupMember.Id)
{
groupMemberService.Delete(reloadedRegistrant.GroupMember);
newRockContext.SaveChanges();
registrantChanges.AddChange(History.HistoryVerb.Delete, History.HistoryChangeType.Record, string.Format("Registrant to previous person in {0} group", reloadedRegistrant.Registration.Group.Name));
}
// Record this to the Person's and Registrants Notes and History...
reloadedRegistrant.GroupMemberId = groupMember.Id;
}
}
if (reloadedRegistrant.Registration.FirstName.IsNotNullOrWhiteSpace() && reloadedRegistrant.Registration.LastName.IsNotNullOrWhiteSpace())
{
reloadedRegistrant.Registration.SavePersonNotesAndHistory(reloadedRegistrant.Registration.FirstName, reloadedRegistrant.Registration.LastName, this.CurrentPersonAliasId, previousRegistrantPersonIds);
}
newRockContext.SaveChanges();
}
}
HistoryService.SaveChanges(
rockContext,
typeof(Registration),
Rock.SystemGuid.Category.HISTORY_EVENT_REGISTRATION.AsGuid(),
registrant.RegistrationId,
registrantChanges,
"Registrant: " + registrantName,
null,
null);
}
NavigateToRegistration();
}
/// <summary>
/// Loads Rock data that's used globally by the transform
/// </summary>
/// <param name="lookupContext">The lookup context.</param>
private static void LoadRockData(RockContext lookupContext = null)
{
lookupContext = lookupContext ?? new RockContext();
// initialize file providers
DatabaseProvider = new Database();
FileSystemProvider = new FileSystem();
// core-specified attribute guid for setting file root path
RootPathAttribute = AttributeCache.Get(new Guid("3CAFA34D-9208-439B-A046-CB727FB729DE"));
// core-specified blacklist files
FileTypeBlackList = (GlobalAttributesCache.Get().GetValue("ContentFiletypeBlacklist")
?? string.Empty).Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
// clean up blacklist
FileTypeBlackList = FileTypeBlackList.Select(a => a.ToLower().TrimStart(new char[] { '.', ' ' }));
FileTypes = new BinaryFileTypeService(lookupContext).Queryable().AsNoTracking().ToList();
// get all the types we'll be importing
var binaryTypeSettings = ConfigurationManager.GetSection("binaryFileTypes") as NameValueCollection;
// create any custom types defined in settings that don't exist yet
foreach (var typeKey in binaryTypeSettings.AllKeys)
{
if (!FileTypes.Any(f => f.Name == typeKey))
{
var newFileType = new BinaryFileType();
lookupContext.BinaryFileTypes.Add(newFileType);
newFileType.Name = typeKey;
newFileType.Description = typeKey;
newFileType.CacheToServerFileSystem = true;
var typeValue = binaryTypeSettings[typeKey];
if (typeValue != null)
{
// #TODO: support additional storage types (like AWS?)
newFileType.StorageEntityTypeId = typeValue.Equals("Database") ? DatabaseStorageTypeId : FileSystemStorageTypeId;
newFileType.Attributes = new Dictionary <string, AttributeCache>();
newFileType.AttributeValues = new Dictionary <string, AttributeValueCache>();
// save changes to binary type to get an ID
lookupContext.SaveChanges();
var newRootPath = new AttributeValue()
{
AttributeId = RootPathAttribute.Id,
EntityId = newFileType.Id,
Value = typeValue
};
newFileType.Attributes.Add(RootPathAttribute.Key, RootPathAttribute);
newFileType.AttributeValues.Add(RootPathAttribute.Key, new AttributeValueCache(newRootPath));
// save attribute values with the current type ID
lookupContext.AttributeValues.Add(newRootPath);
}
lookupContext.SaveChanges();
FileTypes.Add(newFileType);
}
}
// load attributes on file system types to get the default storage location
foreach (var type in FileTypes)
{
type.LoadAttributes(lookupContext);
if (type.StorageEntityTypeId == FileSystemStorageTypeId && binaryTypeSettings.AllKeys.Any(k => type.Name.Equals(k)))
{
// override the configured storage location since we can't handle relative paths
type.AttributeValues["RootPath"].Value = binaryTypeSettings[type.Name];
}
}
// get a list of all the imported people keys
var personAliasList = new PersonAliasService(lookupContext).Queryable().AsNoTracking().ToList();
ImportedPeople = personAliasList
.Where(pa => pa.ForeignKey != null)
.Select(pa =>
new PersonKeys()
{
PersonAliasId = pa.Id,
PersonId = pa.PersonId,
PersonForeignId = pa.ForeignId,
PersonForeignKey = pa.ForeignKey
}).ToList();
}
private void SaveTransaction(FinancialGateway financialGateway, GatewayComponent gateway, Person person, PaymentInfo paymentInfo, FinancialTransaction transaction, RockContext rockContext)
{
transaction.AuthorizedPersonAliasId = person.PrimaryAliasId;
if (RockTransactionEntry != null)
{
RockCheckBox cbGiveAnonymouslyControl = (( RockCheckBox )(RockTransactionEntry.FindControl("cbGiveAnonymously")));
if (cbGiveAnonymouslyControl != null)
{
transaction.ShowAsAnonymous = cbGiveAnonymouslyControl.Checked;
}
}
transaction.TransactionDateTime = RockDateTime.Now;
transaction.FinancialGatewayId = financialGateway.Id;
var txnType = DefinedValueCache.Read(this.GetAttributeValue("TransactionType").AsGuidOrNull() ?? Rock.SystemGuid.DefinedValue.TRANSACTION_TYPE_CONTRIBUTION.AsGuid());
transaction.TransactionTypeValueId = txnType.Id;
transaction.Summary = paymentInfo.Comment1;
if (transaction.FinancialPaymentDetail == null)
{
transaction.FinancialPaymentDetail = new FinancialPaymentDetail();
}
transaction.FinancialPaymentDetail.SetFromPaymentInfo(paymentInfo, gateway, rockContext);
Guid sourceGuid = Guid.Empty;
if (Guid.TryParse(GetAttributeValue("Source"), out sourceGuid))
{
var source = DefinedValueCache.Read(sourceGuid);
if (source != null)
{
transaction.SourceTypeValueId = source.Id;
}
}
var transactionEntity = this.GetTransactionEntity();
foreach (var account in GetSelectedAccounts().Where(a => a.Amount > 0))
{
var transactionDetail = new FinancialTransactionDetail();
transactionDetail.Amount = account.Amount;
transactionDetail.AccountId = account.Id;
if (transactionEntity != null)
{
transactionDetail.EntityTypeId = transactionEntity.TypeId;
transactionDetail.EntityId = transactionEntity.Id;
}
transaction.TransactionDetails.Add(transactionDetail);
}
var batchService = new FinancialBatchService(rockContext);
// Get the batch
var batch = batchService.Get(
GetAttributeValue("BatchNamePrefix"),
paymentInfo.CurrencyTypeValue,
paymentInfo.CreditCardTypeValue,
transaction.TransactionDateTime.Value,
financialGateway.GetBatchTimeOffset());
var batchChanges = new List <string>();
if (batch.Id == 0)
{
batchChanges.Add("Generated the batch");
History.EvaluateChange(batchChanges, "Batch Name", string.Empty, batch.Name);
History.EvaluateChange(batchChanges, "Status", null, batch.Status);
History.EvaluateChange(batchChanges, "Start Date/Time", null, batch.BatchStartDateTime);
History.EvaluateChange(batchChanges, "End Date/Time", null, batch.BatchEndDateTime);
}
decimal newControlAmount = batch.ControlAmount + transaction.TotalAmount;
History.EvaluateChange(batchChanges, "Control Amount", batch.ControlAmount.FormatAsCurrency(), newControlAmount.FormatAsCurrency());
batch.ControlAmount = newControlAmount;
transaction.BatchId = batch.Id;
transaction.LoadAttributes(rockContext);
var allowedTransactionAttributes = GetAttributeValue("AllowedTransactionAttributesFromURL").Split(',').AsGuidList().Select(x => AttributeCache.Read(x).Key);
foreach (KeyValuePair <string, AttributeValueCache> attr in transaction.AttributeValues)
{
if (PageParameters().ContainsKey("Attribute_" + attr.Key) && allowedTransactionAttributes.Contains(attr.Key))
{
attr.Value.Value = Server.UrlDecode(PageParameter("Attribute_" + attr.Key));
}
}
batch.Transactions.Add(transaction);
rockContext.SaveChanges();
transaction.SaveAttributeValues();
HistoryService.SaveChanges(
rockContext,
typeof(FinancialBatch),
Rock.SystemGuid.Category.HISTORY_FINANCIAL_BATCH.AsGuid(),
batch.Id,
batchChanges
);
SendReceipt(transaction.Id);
TransactionCode = transaction.TransactionCode;
}
private void OnDisposed(object sender, EventArgs eventArgs)
{
_ignoreTableSelectionChanged = true;
if (_fidField != null)
{
if (_featureLayer.DataSet.DataTable.Columns.Contains(_fidField))
_featureLayer.DataSet.DataTable.Columns.Remove(_fidField);
}
_selection = null;
_selectionIndices = null;
_selectedRows = null;
_attributeCache = null;
if (_featureLayer != null)
{
_featureLayer.SelectionChanged -= SelectedFeaturesChanged;
_featureLayer = null;
}
}
public override bool IsExcluded <TProperty, TContainer, TValue>(TProperty property, ref TContainer container)
{
return(AttributeCache <TValue> .HasAttribute <NonSerializedForPersistenceAttribute>() || base.IsExcluded <TProperty, TContainer, TValue>(property, ref container));
}
//Shows all rows (both selected and unselected)
private void ShowAllRows()
{
_showOnlySelectedRows = false;
if (_featureLayer.DataSet.AttributesPopulated)
{
_ignoreTableSelectionChanged = true;
_ignoreSelectionChanged = true;
dataGridView1.DataSource = _featureLayer.DataSet.DataTable;
foreach (int row in _selectedRows)
{
dataGridView1.Rows[row].Selected = true;
}
_ignoreTableSelectionChanged = false;
_ignoreSelectionChanged = false;
}
else
{
_attributeCache = new AttributeCache(_featureLayer.DataSet, 16);
dataGridView1.RowCount = _featureLayer.DrawnStates.Length;
}
Refresh();
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The workflow action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
var checkInState = GetCheckInState(entity, out errorMessages);
CheckInGroupType lastCheckinGroupType = null;
List <string> labelCodes = new List <string>();
List <int> childGroupIds;
List <CheckInLabel> checkInLabels = new List <CheckInLabel>();
var volAttributeGuid = GetAttributeValue(action, "VolunteerGroupAttribute");
string volAttributeKey = "";
if (!string.IsNullOrWhiteSpace(volAttributeGuid))
{
volAttributeKey = AttributeCache.Get(volAttributeGuid.AsGuid()).Key;
childGroupIds = checkInState.Kiosk.KioskGroupTypes
.SelectMany(g => g.KioskGroups)
.Where(g => !g.Group.GetAttributeValue(volAttributeKey).AsBoolean())
.Select(g => g.Group.Id).ToList();
}
else
{
childGroupIds = new List <int>();
}
if (checkInState != null)
{
var attendanceService = new AttendanceService(rockContext);
var globalAttributes = Rock.Web.Cache.GlobalAttributesCache.Get();
var globalMergeValues = Rock.Lava.LavaHelper.GetCommonMergeFields(null);
var groupMemberService = new GroupMemberService(rockContext);
foreach (var family in checkInState.CheckIn.Families.Where(f => f.Selected))
{
foreach (var person in family.People.Where(p => p.Selected))
{
if (person.GroupTypes.Where(gt => gt.Selected).SelectMany(gt => gt.Groups).Where(g => g.Selected && childGroupIds.Contains(g.Group.Id)).Any())
{
labelCodes.Add((person.SecurityCode) + "-" + LabelAge(person.Person));
}
if (string.IsNullOrEmpty(person.SecurityCode))
{
var lastAttendance = attendanceService.Queryable()
.Where(a => a.PersonAlias.PersonId == person.Person.Id && a.AttendanceCode != null)
.OrderByDescending(a => a.StartDateTime)
.FirstOrDefault();
if (lastAttendance != null)
{
person.SecurityCode = lastAttendance.AttendanceCode.Code;
}
}
var firstCheckinGroupType = person.GroupTypes.Where(g => g.Selected).FirstOrDefault();
if (firstCheckinGroupType != null)
{
List <Guid> labelGuids = new List <Guid>();
var mergeObjects = new Dictionary <string, object>();
foreach (var keyValue in globalMergeValues)
{
mergeObjects.Add(keyValue.Key, keyValue.Value);
}
mergeObjects.Add("Person", person);
mergeObjects.Add("GroupTypes", person.GroupTypes.Where(g => g.Selected).ToList());
List <Group> mergeGroups = new List <Group>();
List <Location> mergeLocations = new List <Location>();
List <Schedule> mergeSchedules = new List <Schedule>();
var sets = attendanceService
.Queryable().AsNoTracking().Where(a =>
a.PersonAlias.Person.Id == person.Person.Id &&
a.StartDateTime >= Rock.RockDateTime.Today &&
a.EndDateTime == null &&
a.Occurrence.Group != null &&
a.Occurrence.Schedule != null &&
a.Occurrence.Location != null
)
.Select(a =>
new
{
Group = a.Occurrence.Group,
Location = a.Occurrence.Location,
Schedule = a.Occurrence.Schedule,
AttendanceGuid = a.Guid
}
)
.ToList()
.OrderBy(a => a.Schedule.StartTimeOfDay);
//Load breakout group
var breakoutGroups = GetBreakoutGroups(person.Person, rockContext, action);
//Add in an empty object as a placeholder for our breakout group
mergeObjects.Add("BreakoutGroup", "");
//Add in GUID for QR code
if (sets.Any())
{
mergeObjects.Add("AttendanceGuid", sets.FirstOrDefault().AttendanceGuid.ToString());
}
foreach (var set in sets)
{
mergeGroups.Add(set.Group);
mergeLocations.Add(set.Location);
mergeSchedules.Add(set.Schedule);
//Add the breakout group mergefield
if (breakoutGroups.Any())
{
var breakoutGroup = breakoutGroups.Where(g => g.ScheduleId == set.Schedule.Id).FirstOrDefault();
if (breakoutGroup != null)
{
var breakoutGroupEntity = new GroupService(rockContext).Get(breakoutGroup.Id);
if (breakoutGroupEntity != null)
{
breakoutGroupEntity.LoadAttributes();
var letter = breakoutGroupEntity.GetAttributeValue("Letter");
if (!string.IsNullOrWhiteSpace(letter))
{
mergeObjects["BreakoutGroup"] = letter;
}
}
}
}
}
mergeObjects.Add("Groups", mergeGroups);
mergeObjects.Add("Locations", mergeLocations);
mergeObjects.Add("Schedules", mergeSchedules);
foreach (var groupType in person.GroupTypes.Where(g => g.Selected))
{
lastCheckinGroupType = groupType;
groupType.Labels = new List <CheckInLabel>();
GetGroupTypeLabels(groupType.GroupType, firstCheckinGroupType.Labels, mergeObjects, labelGuids);
var PrinterIPs = new Dictionary <int, string>();
foreach (var label in groupType.Labels)
{
label.PrintFrom = checkInState.Kiosk.Device.PrintFrom;
label.PrintTo = checkInState.Kiosk.Device.PrintToOverride;
if (label.PrintTo == PrintTo.Default)
{
label.PrintTo = groupType.GroupType.AttendancePrintTo;
}
if (label.PrintTo == PrintTo.Kiosk)
{
var device = checkInState.Kiosk.Device;
if (device != null)
{
label.PrinterDeviceId = device.PrinterDeviceId;
}
}
else if (label.PrintTo == PrintTo.Location)
{
// Should only be one
var group = groupType.Groups.Where(g => g.Selected).FirstOrDefault();
if (group != null)
{
var location = group.Locations.Where(l => l.Selected).FirstOrDefault();
if (location != null)
{
var device = location.Location.PrinterDevice;
if (device != null)
{
label.PrinterDeviceId = device.PrinterDeviceId;
}
}
}
}
if (label.PrinterDeviceId.HasValue)
{
if (PrinterIPs.ContainsKey(label.PrinterDeviceId.Value))
{
label.PrinterAddress = PrinterIPs[label.PrinterDeviceId.Value];
}
else
{
var printerDevice = new DeviceService(rockContext).Get(label.PrinterDeviceId.Value);
if (printerDevice != null)
{
PrinterIPs.Add(printerDevice.Id, printerDevice.IPAddress);
label.PrinterAddress = printerDevice.IPAddress;
}
}
}
checkInLabels.Add(label);
}
}
}
}
//Add in custom labels for parents
//This is the aggregate part
List <CheckInLabel> customLabels = new List <CheckInLabel>();
List <string> mergeCodes = (( string )GetAttributeValue(action, "MergeText")).Split(',').ToList();
while (labelCodes.Count > 0)
{
var mergeDict = new Dictionary <string, string>();
foreach (var mergeCode in mergeCodes)
{
if (labelCodes.Count > 0)
{
mergeDict.Add(mergeCode, labelCodes[0]);
labelCodes.RemoveAt(0);
}
else
{
mergeDict.Add(mergeCode, "");
}
}
mergeDict.Add("Date", Rock.RockDateTime.Today.DayOfWeek.ToString().Substring(0, 3) + " " + Rock.RockDateTime.Today.ToMonthDayString());
var labelCache = KioskLabel.Get(new Guid(GetAttributeValue(action, "AggregatedLabel")));
if (labelCache != null)
{
var checkInLabel = new CheckInLabel(labelCache, new Dictionary <string, object>());
checkInLabel.FileGuid = new Guid(GetAttributeValue(action, "AggregatedLabel"));
foreach (var keyValue in mergeDict)
{
if (checkInLabel.MergeFields.ContainsKey(keyValue.Key))
{
checkInLabel.MergeFields[keyValue.Key] = keyValue.Value;
}
else
{
checkInLabel.MergeFields.Add(keyValue.Key, keyValue.Value);
}
}
checkInLabel.PrintFrom = checkInState.Kiosk.Device.PrintFrom;
checkInLabel.PrintTo = checkInState.Kiosk.Device.PrintToOverride;
if (checkInLabel.PrintTo == PrintTo.Default)
{
checkInLabel.PrintTo = lastCheckinGroupType.GroupType.AttendancePrintTo;
}
if (checkInLabel.PrintTo == PrintTo.Kiosk)
{
var device = checkInState.Kiosk.Device;
if (device != null)
{
checkInLabel.PrinterDeviceId = device.PrinterDeviceId;
}
}
else if (checkInLabel.PrintTo == PrintTo.Location)
{
// Should only be one
var group = lastCheckinGroupType.Groups.Where(g => g.Selected).FirstOrDefault();
if (group != null)
{
var location = group.Locations.Where(l => l.Selected).FirstOrDefault();
if (location != null)
{
var device = location.Location.PrinterDevice;
if (device != null)
{
checkInLabel.PrinterDeviceId = device.PrinterDeviceId;
}
}
}
}
if (checkInLabel.PrinterDeviceId.HasValue)
{
var printerDevice = new DeviceService(rockContext).Get(checkInLabel.PrinterDeviceId.Value);
checkInLabel.PrinterAddress = printerDevice.IPAddress;
}
if (lastCheckinGroupType != null)
{
lastCheckinGroupType.Labels.Add(checkInLabel);
checkInLabels.Add(checkInLabel);
}
}
}
}
//For mobile check-in we need to serialize this data and save it in the database.
//This will mean that when it's time to finish checkin in
//All we will need to do is deserialize and pass the data to the printer
if (GetAttributeValue(action, "IsMobile").AsBoolean())
{
MobileCheckinRecordService mobileCheckinRecordService = new MobileCheckinRecordService(rockContext);
MobileCheckinRecord mobileCheckinRecord = mobileCheckinRecordService.Queryable()
.Where(r => r.Status == MobileCheckinStatus.Active)
.Where(r => r.CreatedDateTime > Rock.RockDateTime.Today)
.Where(r => r.UserName == checkInState.CheckIn.SearchValue)
.FirstOrDefault();
if (mobileCheckinRecord == null)
{
ExceptionLogService.LogException("Mobile Check-in failed to find mobile checkin record");
}
mobileCheckinRecord.SerializedCheckInState = JsonConvert.SerializeObject(checkInLabels);
rockContext.SaveChanges();
//Freshen cache (we're going to need it soon)
MobileCheckinRecordCache.Update(mobileCheckinRecord.Id);
}
return(true);
}
errorMessages.Add($"Attempted to run {this.GetType().GetFriendlyTypeName()} in check-in, but the check-in state was null.");
return(false);
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void btnSave_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{
if (ViewMode == VIEW_MODE_EDIT)
{
int personEntityTypeId = EntityTypeCache.Read(typeof(Person)).Id;
var rockContext = new RockContext();
var changes = new List <string>();
foreach (int attributeId in AttributeList)
{
var attribute = AttributeCache.Read(attributeId);
if (Person != null &&
attribute.IsAuthorized(Authorization.EDIT, CurrentPerson))
{
Control attributeControl = fsAttributes.FindControl(string.Format("attribute_field_{0}", attribute.Id));
if (attributeControl != null)
{
string originalValue = Person.GetAttributeValue(attribute.Key);
string newValue = attribute.FieldType.Field.GetEditValue(attributeControl, attribute.QualifierValues);
Rock.Attribute.Helper.SaveAttributeValue(Person, attribute, newValue, rockContext);
// Check for changes to write to history
if ((originalValue ?? string.Empty).Trim() != (newValue ?? string.Empty).Trim())
{
string formattedOriginalValue = string.Empty;
if (!string.IsNullOrWhiteSpace(originalValue))
{
formattedOriginalValue = attribute.FieldType.Field.FormatValue(null, originalValue, attribute.QualifierValues, false);
}
string formattedNewValue = string.Empty;
if (!string.IsNullOrWhiteSpace(newValue))
{
formattedNewValue = attribute.FieldType.Field.FormatValue(null, newValue, attribute.QualifierValues, false);
}
History.EvaluateChange(changes, attribute.Name, formattedOriginalValue, formattedNewValue, attribute.FieldType.Field.IsSensitive());
}
}
}
}
if (changes.Any())
{
HistoryService.SaveChanges(rockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
Person.Id, changes);
}
}
else if (ViewMode == VIEW_MODE_ORDER && _canAdministrate)
{
// Split and deliminate again to remove trailing delimiter
var attributeOrder = hfAttributeOrder.Value.SplitDelimitedValues().ToList().AsDelimited("|");
SetAttributeValue("AttributeOrder", attributeOrder);
SaveAttributeValues();
BindData();
}
ViewMode = VIEW_MODE_VIEW;
CreateControls(false);
}
}
public static bool HasAttribute <TType, TAttribute>()
where TAttribute : Attribute
{
return(AttributeCache <TType> .HasAttribute <TAttribute>());
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
// Determine which group to add the person to
Group group = null;
var guidGroupAttribute = GetAttributeValue(action, "Group").AsGuidOrNull();
if (guidGroupAttribute.HasValue)
{
var attributeGroup = AttributeCache.Read(guidGroupAttribute.Value, rockContext);
if (attributeGroup != null)
{
var groupGuid = action.GetWorklowAttributeValue(guidGroupAttribute.Value).AsGuidOrNull();
if (groupGuid.HasValue)
{
group = new GroupService(rockContext).Get(groupGuid.Value);
}
}
}
if (group == null)
{
errorMessages.Add("No group was provided");
}
// determine the person that will be added to the group
Person person = null;
// get the Attribute.Guid for this workflow's Person Attribute so that we can lookup the value
var guidPersonAttribute = GetAttributeValue(action, "Person").AsGuidOrNull();
if (guidPersonAttribute.HasValue)
{
var attributePerson = AttributeCache.Read(guidPersonAttribute.Value, rockContext);
if (attributePerson != null)
{
string attributePersonValue = action.GetWorklowAttributeValue(guidPersonAttribute.Value);
if (!string.IsNullOrWhiteSpace(attributePersonValue))
{
if (attributePerson.FieldType.Class == typeof(Rock.Field.Types.PersonFieldType).FullName)
{
Guid personAliasGuid = attributePersonValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
person = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.Person)
.FirstOrDefault();
}
}
else
{
errorMessages.Add("The attribute used to provide the person was not of type 'Person'.");
}
}
}
}
if (person == null)
{
errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString()));
}
// Add Person to Group
if (!errorMessages.Any())
{
var groupMemberService = new GroupMemberService(rockContext);
var groupMember = groupMemberService.Queryable().Where(m => m.GroupId == group.Id && m.PersonId == person.Id).FirstOrDefault();
if (groupMember != null)
{
groupMember.GroupMemberStatus = this.GetAttributeValue(action, "NewGroupMemberStatus").ConvertToEnum <GroupMemberStatus>(GroupMemberStatus.Active);
rockContext.SaveChanges();
}
else
{
// the person is not in the group provided
errorMessages.Add("The person is not in the group provided.");
}
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(true);
}
/// <summary>
/// Refresh the recipients list.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <returns></returns>
public void RefreshCommunicationRecipientList(RockContext rockContext)
{
if (!ListGroupId.HasValue)
{
return;
}
var emailMediumEntityType = EntityTypeCache.Get(SystemGuid.EntityType.COMMUNICATION_MEDIUM_EMAIL.AsGuid());
var smsMediumEntityType = EntityTypeCache.Get(SystemGuid.EntityType.COMMUNICATION_MEDIUM_SMS.AsGuid());
var preferredCommunicationTypeAttribute = AttributeCache.Get(SystemGuid.Attribute.GROUPMEMBER_COMMUNICATION_LIST_PREFERRED_COMMUNICATION_MEDIUM.AsGuid());
var segmentDataViewGuids = this.Segments.SplitDelimitedValues().AsGuidList();
var segmentDataViewIds = new DataViewService(rockContext).GetByGuids(segmentDataViewGuids).Select(a => a.Id).ToList();
var qryCommunicationListMembers = GetCommunicationListMembers(rockContext, ListGroupId, this.SegmentCriteria, segmentDataViewIds);
// NOTE: If this is scheduled communication, don't include Members that were added after the scheduled FutureSendDateTime
if (this.FutureSendDateTime.HasValue)
{
var memberAddedCutoffDate = this.FutureSendDateTime;
qryCommunicationListMembers = qryCommunicationListMembers.Where(a => (a.DateTimeAdded.HasValue && a.DateTimeAdded.Value < memberAddedCutoffDate) || (a.CreatedDateTime.HasValue && a.CreatedDateTime.Value < memberAddedCutoffDate));
}
var communicationRecipientService = new CommunicationRecipientService(rockContext);
var recipientsQry = GetRecipientsQry(rockContext);
// Get all the List member which is not part of communication recipients yet
var newMemberInList = qryCommunicationListMembers
.Where(a => !recipientsQry.Any(r => r.PersonAlias.PersonId == a.PersonId))
.AsNoTracking()
.ToList();
foreach (var newMember in newMemberInList)
{
var communicationRecipient = new CommunicationRecipient
{
PersonAliasId = newMember.Person.PrimaryAliasId.Value,
Status = CommunicationRecipientStatus.Pending,
CommunicationId = Id
};
switch (CommunicationType)
{
case CommunicationType.Email:
communicationRecipient.MediumEntityTypeId = emailMediumEntityType.Id;
break;
case CommunicationType.SMS:
communicationRecipient.MediumEntityTypeId = smsMediumEntityType.Id;
break;
case CommunicationType.RecipientPreference:
newMember.LoadAttributes();
if (preferredCommunicationTypeAttribute != null)
{
var recipientPreference = ( CommunicationType? )newMember
.GetAttributeValue(preferredCommunicationTypeAttribute.Key).AsIntegerOrNull();
switch (recipientPreference)
{
case CommunicationType.SMS:
communicationRecipient.MediumEntityTypeId = smsMediumEntityType.Id;
break;
case CommunicationType.Email:
communicationRecipient.MediumEntityTypeId = emailMediumEntityType.Id;
break;
default:
communicationRecipient.MediumEntityTypeId = emailMediumEntityType.Id;
break;
}
}
break;
default:
throw new Exception("Unexpected CommunicationType: " + CommunicationType.ConvertToString());
}
communicationRecipientService.Add(communicationRecipient);
}
// Get all pending communication recipents that are no longer part of the group list member, then delete them from the Recipients
var missingMemberInList = recipientsQry.Where(a => a.Status == CommunicationRecipientStatus.Pending)
.Where(a => !qryCommunicationListMembers.Any(r => r.PersonId == a.PersonAlias.PersonId))
.ToList();
foreach (var missingMember in missingMemberInList)
{
communicationRecipientService.Delete(missingMember);
}
rockContext.SaveChanges();
}
/// <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 mergeFields = GetMergeFields(action);
// Get the connection request
ConnectionRequest request = null;
Guid connectionRequestGuid = action.GetWorklowAttributeValue(GetAttributeValue(action, "ConnectionRequestAttribute").AsGuid()).AsGuid();
request = new ConnectionRequestService(rockContext).Get(connectionRequestGuid);
if (request == null)
{
errorMessages.Add("Invalid Connection Request Attribute or Value!");
return(false);
}
// Get the activity type
ConnectionActivityType activityType = null;
Guid activityTypeGuid = action.GetWorklowAttributeValue(GetAttributeValue(action, "ConnectionActivityTypeAttribute").AsGuid()).AsGuid();
activityType = new ConnectionActivityTypeService(rockContext).Get(activityTypeGuid);
if (activityType == null)
{
errorMessages.Add("Invalid Connection Activity Type Attribute or Value!");
return(false);
}
// Get the note
string noteValue = GetAttributeValue(action, "Note", true);
string note = string.Empty;
Guid? noteGuid = noteValue.AsGuidOrNull();
if (noteGuid.HasValue)
{
var attribute = AttributeCache.Get(noteGuid.Value, rockContext);
if (attribute != null)
{
note = action.GetWorklowAttributeValue(noteGuid.Value);
}
}
else
{
note = noteValue;
}
// Get the connector
int? personAliasId = null;
Guid?personAttributeGuid = GetAttributeValue(action, "PersonAttribute").AsGuidOrNull();
if (personAttributeGuid.HasValue)
{
Guid?personAliasGuid = action.GetWorklowAttributeValue(personAttributeGuid.Value).AsGuidOrNull();
if (personAliasGuid.HasValue)
{
var personAlias = new PersonAliasService(rockContext).Get(personAliasGuid.Value);
if (personAlias != null)
{
personAliasId = personAlias.Id;
}
}
}
// Add the activity
var activity = new ConnectionRequestActivity();
activity.ConnectionRequestId = request.Id;
activity.ConnectionActivityTypeId = activityType.Id;
activity.ConnectionOpportunityId = request.ConnectionOpportunityId;
activity.ConnectorPersonAliasId = personAliasId;
activity.Note = note.ResolveMergeFields(mergeFields);
new ConnectionRequestActivityService(rockContext).Add(activity);
rockContext.SaveChanges();
return(true);
}
/// <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");
int commandTimeout = dataMap.GetString("CommandTimeout").AsIntegerOrNull() ?? 3600;
// 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.Get(SystemGuid.Attribute.PERSON_ERA_CURRENTLY_AN_ERA.AsGuid());
var eraStartAttribute = AttributeCache.Get(SystemGuid.Attribute.PERSON_ERA_START_DATE.AsGuid());
var eraEndAttribute = AttributeCache.Get(SystemGuid.Attribute.PERSON_ERA_END_DATE.AsGuid());
if (eraAttribute == null || eraStartAttribute == null || eraEndAttribute == null)
{
throw new Exception("Family analytic attributes could not be found");
}
resultContext.Database.CommandTimeout = commandTimeout;
var results = resultContext.Database.SqlQuery <EraResult>("spCrm_FamilyAnalyticsEraDataset").ToList();
int personEntityTypeId = EntityTypeCache.Get("Rock.Model.Person").Id;
int attributeEntityTypeId = EntityTypeCache.Get("Rock.Model.Attribute").Id;
int eraAttributeId = eraAttribute.Id;
int personAnalyticsCategoryId = CategoryCache.Get(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();
updateContext.SourceOfChange = SOURCE_OF_CHANGE;
updateContext.Database.CommandTimeout = commandTimeout;
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.Verb = "EXITED";
historyRecord.ChangeType = History.HistoryChangeType.Attribute.ConvertToString();
historyRecord.ValueName = "eRA";
historyRecord.NewValue = "Exited";
historyRecord.RelatedEntityTypeId = attributeEntityTypeId;
historyRecord.RelatedEntityId = eraAttributeId;
historyRecord.CategoryId = personAnalyticsCategoryId;
historyRecord.SourceOfChange = SOURCE_OF_CHANGE;
}
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.Where(m => !m.Person.IsDeceased).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.Verb = "ENTERED";
historyRecord.ChangeType = History.HistoryChangeType.Attribute.ConvertToString();
historyRecord.RelatedEntityTypeId = attributeEntityTypeId;
historyRecord.RelatedEntityId = eraAttributeId;
historyRecord.CategoryId = personAnalyticsCategoryId;
historyRecord.SourceOfChange = SOURCE_OF_CHANGE;
}
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 visit dates
if (updateVisitDates)
{
resultContext.Database.ExecuteSqlCommand("spCrm_FamilyAnalyticsUpdateVisitDates");
}
}
/// <summary>
/// Get the next person for the action and group.
/// </summary>
/// <param name="action">The action that needs the next round robin person picked.</param>
/// <param name="groupId">The identifier of the group to load the next person from.</param>
/// <returns>A person object that represents the next person in the round robin selection process.</returns>
private Person GetNextPerson(WorkflowAction action, int groupId)
{
Person person = null;
//
// Lock so that only one thread can do this at a time. This is to ensure that
// we don't have two workflows processing at the same time and trying to get
// the next person in the round robin and overwriting each others changes.
//
lock ( _lockObject )
{
var attrKey = action.ActionType.Guid.ToString();
//
// Load attributes if we need to.
//
if (action.Activity.Workflow.WorkflowType.Attributes == null)
{
action.Activity.Workflow.WorkflowType.LoadAttributes();
}
//
// Check if we already have an attribute.
//
if (!action.Activity.Workflow.WorkflowType.Attributes.ContainsKey(attrKey))
{
var attribute = new Rock.Model.Attribute
{
EntityTypeId = action.Activity.Workflow.WorkflowType.TypeId,
Name = string.Format("Last Round Robin Person ({0})", action.ActionType.Name),
Key = attrKey,
FieldTypeId = FieldTypeCache.Get(Rock.SystemGuid.FieldType.TEXT.AsGuid()).Id
};
using (var newRockContext = new RockContext())
{
new AttributeService(newRockContext).Add(attribute);
newRockContext.SaveChanges();
AttributeCache.RemoveEntityAttributes();
}
action.Activity.Workflow.WorkflowType.Attributes.Add(attrKey, AttributeCache.Get(attribute));
var attributeValue = new AttributeValueCache
{
AttributeId = attribute.Id,
Value = string.Empty
};
action.Activity.Workflow.WorkflowType.AttributeValues.Add(attrKey, attributeValue);
}
//
// Get the last person selected.
//
var lastPersonId = action.Activity.Workflow.WorkflowType.GetAttributeValue(attrKey).AsIntegerOrNull();
var rockContext = new RockContext();
//
// Get the list of group members to pick from.
//
var groupMemberService = new GroupMemberService(rockContext);
var statuses = this.GetAttributeValue(action, "GroupMemberStatus")
.SplitDelimitedValues()
.Select(s => ( GroupMemberStatus )Enum.Parse(typeof(GroupMemberStatus), s))
.ToList();
var groupMembers = groupMemberService.Queryable()
.Where(m => m.GroupId == groupId && statuses.Contains(m.GroupMemberStatus))
.DistinctBy(m => m.PersonId)
.OrderBy(m => m.Person.LastName)
.ThenBy(m => m.Person.FirstName)
.ToList();
//
// Filter by the group role.
//
if (!string.IsNullOrWhiteSpace(GetAttributeValue(action, "GroupRole")))
{
var groupRole = new GroupTypeRoleService(rockContext).Get(GetAttributeValue(action, "GroupRole").AsGuid());
groupMembers = groupMembers.Where(m => m.GroupRoleId == groupRole.Id).ToList();
}
//
// Find the next person.
//
if (groupMembers.Count > 0)
{
int lastMemberIndex = -1;
//
// Find the index of the last person picked.
//
if (lastPersonId.HasValue)
{
var lastMember = groupMembers
.Where(m => !lastPersonId.HasValue || m.PersonId == lastPersonId)
.FirstOrDefault();
if (lastMember != null)
{
lastMemberIndex = groupMembers.IndexOf(lastMember);
}
}
//
// Pick either the next or the first person.
//
if (lastMemberIndex < 0 || (lastMemberIndex + 1) >= groupMembers.Count)
{
person = groupMembers.First().Person;
}
else
{
person = groupMembers[lastMemberIndex + 1].Person;
}
}
//
// Update the attribute value.
//
action.Activity.Workflow.WorkflowType.SetAttributeValue(attrKey, person != null ? person.Id.ToString() : string.Empty);
action.Activity.Workflow.WorkflowType.SaveAttributeValues(rockContext);
}
return(person);
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
// Determine the group
Group group = null;
var guidGroupAttribute = GetAttributeValue(action, "Group").AsGuidOrNull();
if (guidGroupAttribute.HasValue)
{
var attributeGroup = AttributeCache.Read(guidGroupAttribute.Value, rockContext);
if (attributeGroup != null)
{
var groupGuid = action.GetWorklowAttributeValue(guidGroupAttribute.Value).AsGuidOrNull();
if (groupGuid.HasValue)
{
group = new GroupService(rockContext).Get(groupGuid.Value);
}
}
}
if (group == null)
{
errorMessages.Add("No group was provided");
}
// determine the person
Person person = null;
// get the Attribute.Guid for this workflow's Person Attribute so that we can lookup the value
var guidPersonAttribute = GetAttributeValue(action, "Person").AsGuidOrNull();
if (guidPersonAttribute.HasValue)
{
var attributePerson = AttributeCache.Read(guidPersonAttribute.Value, rockContext);
if (attributePerson != null)
{
string attributePersonValue = action.GetWorklowAttributeValue(guidPersonAttribute.Value);
if (!string.IsNullOrWhiteSpace(attributePersonValue))
{
if (attributePerson.FieldType.Class == typeof(Rock.Field.Types.PersonFieldType).FullName)
{
Guid personAliasGuid = attributePersonValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
person = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.Person)
.FirstOrDefault();
}
}
else
{
errorMessages.Add("The attribute used to provide the person was not of type 'Person'.");
}
}
}
}
if (person == null)
{
errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString()));
}
// Add Person to Volunteer Tracking Table
if (!errorMessages.Any())
{
var groupMemberService = new GroupMemberService(rockContext);
var groupMember = groupMemberService.Queryable().FirstOrDefault(m => m.GroupId == group.Id && m.PersonId == person.Id);
if (groupMember != null)
{
var volunteerTrackingContext = new VolunteerTrackingContext();
var volunteerMembershipService = new VolunteerMembershipService(volunteerTrackingContext);
var oldVolunteerMembership = volunteerMembershipService.Queryable().FirstOrDefault(v => v.GroupId == groupMember.GroupId && v.PersonId == groupMember.PersonId && v.LeftGroupDateTime == null);
if (oldVolunteerMembership != null)
{
oldVolunteerMembership.LeftGroupDateTime = DateTime.Now;
}
var newVolunteerMembership = new VolunteerMembership
{
GroupId = groupMember.GroupId,
PersonId = groupMember.PersonId,
GroupRoleId = groupMember.GroupRoleId,
JoinedGroupDateTime = DateTime.Now
};
volunteerMembershipService.Add(newVolunteerMembership);
volunteerTrackingContext.SaveChanges();
}
else
{
// the person is not in the group provided
errorMessages.Add("The person is not in the group provided.");
}
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(true);
}
/// <summary>
/// Creates the child controls.
/// </summary>
/// <returns></returns>
public override Control[] CreateChildControls(Type entityType, FilterField filterControl, FilterMode filterMode)
{
var containerControl = new DynamicControlsPanel();
containerControl.ID = string.Format("{0}_containerControl", filterControl.ID);
containerControl.CssClass = "js-container-control";
filterControl.Controls.Add(containerControl);
// Create the field selection dropdown
var ddlEntityField = new RockDropDownList();
ddlEntityField.ID = string.Format("{0}_ddlProperty", filterControl.ID);
ddlEntityField.ClientIDMode = ClientIDMode.Predictable;
containerControl.Controls.Add(ddlEntityField);
// add Empty option first
ddlEntityField.Items.Add(new ListItem());
var rockBlock = filterControl.RockBlock();
var entityTypeCache = EntityTypeCache.Read(entityType, true);
this.entityFields = EntityHelper.GetEntityFields(entityType);
foreach (var entityField in this.entityFields.OrderBy(a => !a.IsPreviewable).ThenBy(a => a.FieldKind != FieldKind.Property).ThenBy(a => a.Title))
{
bool isAuthorized = true;
bool includeField = true;
if (entityField.FieldKind == FieldKind.Attribute && entityField.AttributeGuid.HasValue)
{
if (entityType == typeof(Rock.Model.Workflow) && !string.IsNullOrWhiteSpace(entityField.AttributeEntityTypeQualifierName))
{
// Workflows can contain tons of Qualified Attributes, so let the WorkflowAttributeFilter take care of those
includeField = false;
}
var attribute = AttributeCache.Read(entityField.AttributeGuid.Value);
if (includeField && attribute != null && rockBlock != null)
{
// only show the Attribute field in the drop down if they have VIEW Auth to it
isAuthorized = attribute.IsAuthorized(Rock.Security.Authorization.VIEW, rockBlock.CurrentPerson);
}
}
if (isAuthorized && includeField)
{
var listItem = new ListItem(entityField.Title, entityField.Name);
if (entityField.IsPreviewable)
{
listItem.Attributes["optiongroup"] = "Common";
}
else if (entityField.FieldKind == FieldKind.Attribute)
{
listItem.Attributes["optiongroup"] = string.Format("{0} Attributes", entityType.Name);
}
else
{
listItem.Attributes["optiongroup"] = string.Format("{0} Fields", entityType.Name);
}
ddlEntityField.Items.Add(listItem);
}
}
ddlEntityField.AutoPostBack = true;
// grab the currently selected value off of the request params since we are creating the controls after the Page Init
var selectedValue = ddlEntityField.Page.Request.Params[ddlEntityField.UniqueID];
if (selectedValue != null)
{
ddlEntityField.SelectedValue = selectedValue;
ddlEntityField_SelectedIndexChanged(ddlEntityField, new EventArgs());
}
ddlEntityField.SelectedIndexChanged += ddlEntityField_SelectedIndexChanged;
return(new Control[] { containerControl });
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
// get person
Person person = null;
string personAttributeValue = GetAttributeValue(action, "Person");
Guid? guidPersonAttribute = personAttributeValue.AsGuidOrNull();
if (guidPersonAttribute.HasValue)
{
var attributePerson = AttributeCache.Get(guidPersonAttribute.Value, rockContext);
if (attributePerson != null || attributePerson.FieldType.Class != "Rock.Field.Types.PersonFieldType")
{
string attributePersonValue = action.GetWorkflowAttributeValue(guidPersonAttribute.Value);
if (!string.IsNullOrWhiteSpace(attributePersonValue))
{
Guid personAliasGuid = attributePersonValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
person = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.Person)
.FirstOrDefault();
if (person == null)
{
errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString()));
return(false);
}
}
}
}
}
if (person == null)
{
errorMessages.Add("The attribute used to provide the person was invalid, or not of type 'Person'.");
return(false);
}
// determine the location type to edit
DefinedValueCache locationType = null;
var locationTypeAttributeValue = action.GetWorkflowAttributeValue(GetAttributeValue(action, "LocationTypeAttribute").AsGuid());
if (locationTypeAttributeValue != null)
{
locationType = DefinedValueCache.Get(locationTypeAttributeValue.AsGuid());
}
if (locationType == null)
{
locationType = DefinedValueCache.Get(GetAttributeValue(action, "LocationType").AsGuid());
}
if (locationType == null)
{
errorMessages.Add("The location type to be updated was not selected.");
return(false);
}
// get the new phone number value
Location location = null;
string locationValue = GetAttributeValue(action, "Location");
Guid? locationGuid = locationValue.AsGuidOrNull();
if (!locationGuid.HasValue || locationGuid.Value.IsEmpty())
{
string locationAttributeValue = GetAttributeValue(action, "LocationAttribute");
Guid? locationAttributeValueGuid = locationAttributeValue.AsGuidOrNull();
if (locationAttributeValueGuid.HasValue)
{
locationGuid = action.GetWorkflowAttributeValue(locationAttributeValueGuid.Value).AsGuidOrNull();
}
}
if (locationGuid.HasValue)
{
location = new LocationService(rockContext).Get(locationGuid.Value);
}
if (location == null)
{
errorMessages.Add("The location value could not be determined.");
return(false);
}
// gets value indicating if location is a mailing location
string mailingValue = GetAttributeValue(action, "IsMailing");
Guid? mailingValueGuid = mailingValue.AsGuidOrNull();
if (mailingValueGuid.HasValue)
{
mailingValue = action.GetWorkflowAttributeValue(mailingValueGuid.Value);
}
else
{
mailingValue = mailingValue.ResolveMergeFields(GetMergeFields(action));
}
bool?mailing = mailingValue.AsBooleanOrNull();
// gets value indicating if location is a mapped location
string mappedValue = GetAttributeValue(action, "IsMapped");
Guid? mappedValueGuid = mappedValue.AsGuidOrNull();
if (mappedValueGuid.HasValue)
{
mappedValue = action.GetWorkflowAttributeValue(mappedValueGuid.Value);
}
else
{
mappedValue = mappedValue.ResolveMergeFields(GetMergeFields(action));
}
bool?mapped = mappedValue.AsBooleanOrNull();
var savePreviousAddress = GetAttributeValue(action, "SavePreviousAddress").AsBoolean();
var locationService = new LocationService(rockContext);
locationService.Verify(location, false);
var groupLocationService = new GroupLocationService(rockContext);
foreach (var family in person.GetFamilies(rockContext).ToList())
{
bool locationUpdated = false;
if (savePreviousAddress)
{
// Get all existing addresses of the specified type
var groupLocations = family.GroupLocations.Where(l => l.GroupLocationTypeValueId == locationType.Id).ToList();
// Create a new address of the specified type, saving all existing addresses of that type as Previous Addresses
// Use the specified Is Mailing and Is Mapped values from the action's parameters if they are set,
// otherwise set them to true if any of the existing addresses of that type have those values set to true
GroupService.AddNewGroupAddress(rockContext, family, locationType.Guid.ToString(), location.Id, true,
$"the {action.ActionTypeCache.ActivityType.WorkflowType.Name} workflow",
mailing ?? groupLocations.Any(x => x.IsMailingLocation),
mapped ?? groupLocations.Any(x => x.IsMappedLocation));
}
else
{
var groupLocation = family.GroupLocations.FirstOrDefault(l => l.GroupLocationTypeValueId == locationType.Id);
string oldValue = string.Empty;
if (groupLocation == null)
{
groupLocation = new GroupLocation();
groupLocation.GroupId = family.Id;
groupLocation.GroupLocationTypeValueId = locationType.Id;
groupLocationService.Add(groupLocation);
}
else
{
oldValue = groupLocation.Location.ToString();
}
locationUpdated = oldValue != location.ToString();
groupLocation.Location = location;
if (mailing.HasValue)
{
if (((oldValue == string.Empty) ? null : groupLocation.IsMailingLocation.ToString()) != mailing.Value.ToString())
{
locationUpdated = true;
}
groupLocation.IsMailingLocation = mailing.Value;
}
if (mapped.HasValue)
{
if (((oldValue == string.Empty) ? null : groupLocation.IsMappedLocation.ToString()) != mapped.Value.ToString())
{
locationUpdated = true;
}
groupLocation.IsMappedLocation = mapped.Value;
}
}
if (locationUpdated)
{
var groupChanges = new History.HistoryChangeList();
groupChanges.AddChange(History.HistoryVerb.Modify, History.HistoryChangeType.Record, "Location").SourceOfChange = $"{action.ActionTypeCache.ActivityType.WorkflowType.Name} workflow";
foreach (var fm in family.Members)
{
HistoryService.SaveChanges(
rockContext,
typeof(Person),
Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
fm.PersonId,
groupChanges,
family.Name,
typeof(Group),
family.Id,
false,
null,
rockContext.SourceOfChange);
}
}
rockContext.SaveChanges();
action.AddLogEntry(string.Format("Updated the {0} location for {1} (family: {2}) to {3}", locationType.Value, person.FullName, family.Name, location.ToString()));
}
return(true);
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
// get person
Person person = null;
string personAttributeValue = GetAttributeValue(action, "Person");
Guid guidPersonAttribute = personAttributeValue.AsGuid();
if (!guidPersonAttribute.IsEmpty())
{
var attributePerson = AttributeCache.Get(guidPersonAttribute, rockContext);
if (attributePerson != null)
{
string attributePersonValue = action.GetWorklowAttributeValue(guidPersonAttribute);
if (!string.IsNullOrWhiteSpace(attributePersonValue))
{
if (attributePerson.FieldType.Class == "Rock.Field.Types.PersonFieldType")
{
Guid personAliasGuid = attributePersonValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
person = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.Person)
.FirstOrDefault();
if (person == null)
{
errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString()));
return(false);
}
}
}
else
{
errorMessages.Add("The attribute used to provide the person was not of type 'Person'.");
return(false);
}
}
}
}
if (person == null)
{
errorMessages.Add("The attribute used to provide the person was invalid, or not of type 'Person'.");
return(false);
}
// get value
string updateValue = GetAttributeValue(action, "Value");
Guid? valueGuid = updateValue.AsGuidOrNull();
if (valueGuid.HasValue)
{
updateValue = action.GetWorklowAttributeValue(valueGuid.Value);
}
else
{
updateValue = updateValue.ResolveMergeFields(GetMergeFields(action));
}
// determine the property to edit
var propertySelected = GetAttributeValue(action, "Property");
// get the ignore blank setting
var ignoreBlanks = GetActionAttributeValue(action, "IgnoreBlankValues").AsBoolean();
// update the person
switch (propertySelected)
{
case "Title":
{
var definedValueId = GetDefinedValueId(updateValue, SystemGuid.DefinedType.PERSON_TITLE.AsGuid(), rockContext);
if (ignoreBlanks == false || definedValueId.HasValue)
{
person.TitleValueId = definedValueId;
rockContext.SaveChanges();
}
break;
}
case "FirstName":
{
if (ignoreBlanks == false || !string.IsNullOrWhiteSpace(updateValue))
{
person.FirstName = updateValue;
rockContext.SaveChanges();
}
break;
}
case "NickName":
{
if (ignoreBlanks == false || !string.IsNullOrWhiteSpace(updateValue))
{
person.NickName = updateValue;
rockContext.SaveChanges();
}
break;
}
case "MiddleName":
{
if (ignoreBlanks == false || !string.IsNullOrWhiteSpace(updateValue))
{
person.MiddleName = updateValue;
rockContext.SaveChanges();
}
break;
}
case "LastName":
{
if (ignoreBlanks == false || !string.IsNullOrWhiteSpace(updateValue))
{
person.LastName = updateValue;
rockContext.SaveChanges();
}
break;
}
case "Suffix":
{
var definedValueId = GetDefinedValueId(updateValue, SystemGuid.DefinedType.PERSON_SUFFIX.AsGuid(), rockContext);
if (ignoreBlanks == false || definedValueId.HasValue)
{
person.SuffixValueId = definedValueId;
rockContext.SaveChanges();
}
break;
}
case "Birthdate":
{
var birthdate = updateValue.AsDateTime();
if (ignoreBlanks == false || birthdate.HasValue)
{
if (birthdate.HasValue)
{
person.BirthDay = birthdate.Value.Day;
person.BirthMonth = birthdate.Value.Month;
person.BirthYear = birthdate.Value.Year;
}
else
{
person.BirthDay = null;
person.BirthMonth = null;
person.BirthYear = null;
}
rockContext.SaveChanges();
}
break;
}
case "Photo":
{
// could be integer of binary file or a guid
var binaryFileId = updateValue.AsIntegerOrNull();
if (binaryFileId.HasValue)
{
person.PhotoId = binaryFileId;
rockContext.SaveChanges();
}
else
{
var binaryFileGuid = updateValue.AsGuidOrNull();
if (binaryFileGuid.HasValue)
{
binaryFileId = new BinaryFileService(rockContext).Queryable().Where(f => f.Guid == binaryFileGuid.Value).Select(f => f.Id).FirstOrDefault();
if (ignoreBlanks == false || binaryFileId.HasValue)
{
person.PhotoId = binaryFileId;
rockContext.SaveChanges();
}
}
}
break;
}
case "Gender":
{
var gender = updateValue.ConvertToEnumOrNull <Gender>();
if (ignoreBlanks == false || gender.HasValue)
{
if (!gender.HasValue)
{
gender = Gender.Unknown;
}
person.Gender = gender.Value;
rockContext.SaveChanges();
}
break;
}
case "MaritalStatus":
{
var definedValueId = GetDefinedValueId(updateValue, SystemGuid.DefinedType.PERSON_MARITAL_STATUS.AsGuid(), rockContext);
if (ignoreBlanks == false || definedValueId.HasValue)
{
person.MaritalStatusValueId = definedValueId;
rockContext.SaveChanges();
}
break;
}
case "AnniversaryDate":
{
var anniversarydate = updateValue.AsDateTime();
if (ignoreBlanks == false || anniversarydate.HasValue)
{
person.AnniversaryDate = anniversarydate;
rockContext.SaveChanges();
}
break;
}
case "CommunicationPreference":
{
var communicationPreference = updateValue.ConvertToEnumOrNull <CommunicationType>();
if (ignoreBlanks == false || communicationPreference.HasValue)
{
if (!communicationPreference.HasValue)
{
communicationPreference = CommunicationType.Email;
}
person.CommunicationPreference = communicationPreference.Value;
rockContext.SaveChanges();
}
break;
}
case "Email":
{
if (ignoreBlanks == false || !string.IsNullOrWhiteSpace(updateValue))
{
person.Email = updateValue;
rockContext.SaveChanges();
}
break;
}
case "IsEmailActive":
{
var updateAsBoolean = updateValue.AsBooleanOrNull();
if (ignoreBlanks == false || updateAsBoolean.HasValue)
{
if (!updateAsBoolean.HasValue)
{
updateAsBoolean = true; // default to true
}
person.IsEmailActive = updateAsBoolean.Value;
rockContext.SaveChanges();
}
break;
}
case "EmailNote":
{
if (ignoreBlanks == false || !string.IsNullOrWhiteSpace(updateValue))
{
person.EmailNote = updateValue;
rockContext.SaveChanges();
}
break;
}
case "EmailPreference":
{
var emailPreference = updateValue.ConvertToEnumOrNull <EmailPreference>();
if (ignoreBlanks == false || emailPreference.HasValue)
{
if (!emailPreference.HasValue)
{
emailPreference = EmailPreference.EmailAllowed;
}
person.EmailPreference = emailPreference.Value;
rockContext.SaveChanges();
}
break;
}
case "GraduationYear":
{
var updateAsInt = updateValue.AsIntegerOrNull();
if (ignoreBlanks == false || updateAsInt.HasValue)
{
person.GraduationYear = updateAsInt;
rockContext.SaveChanges();
}
break;
}
case "RecordStatus":
{
var definedValueId = GetDefinedValueId(updateValue, SystemGuid.DefinedType.PERSON_RECORD_STATUS.AsGuid(), rockContext);
if (ignoreBlanks == false || definedValueId.HasValue)
{
person.RecordStatusValueId = definedValueId;
rockContext.SaveChanges();
}
break;
}
case "RecordStatusReason":
{
var definedValueId = GetDefinedValueId(updateValue, SystemGuid.DefinedType.PERSON_RECORD_STATUS_REASON.AsGuid(), rockContext);
if (ignoreBlanks == false || definedValueId.HasValue)
{
person.RecordStatusReasonValueId = definedValueId;
rockContext.SaveChanges();
}
break;
}
case "InactiveReasonNote":
{
if (ignoreBlanks == false || !string.IsNullOrWhiteSpace(updateValue))
{
person.InactiveReasonNote = updateValue;
rockContext.SaveChanges();
}
break;
}
case "ConnectionStatus":
{
var definedValueId = GetDefinedValueId(updateValue, SystemGuid.DefinedType.PERSON_CONNECTION_STATUS.AsGuid(), rockContext);
if (ignoreBlanks == false || definedValueId.HasValue)
{
person.ConnectionStatusValueId = definedValueId;
rockContext.SaveChanges();
}
break;
}
case "IsDeceased":
{
var updateAsBoolean = updateValue.AsBooleanOrNull();
if (ignoreBlanks == false || updateAsBoolean.HasValue)
{
if (!updateAsBoolean.HasValue)
{
updateAsBoolean = false; // default to false
}
person.IsDeceased = updateAsBoolean.Value;
rockContext.SaveChanges();
}
break;
}
case "SystemNote":
{
if (ignoreBlanks == false || !string.IsNullOrWhiteSpace(updateValue))
{
person.SystemNote = updateValue;
rockContext.SaveChanges();
}
break;
}
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(true);
}
/// <summary>
/// Abstract method for sending a background request. Derived classes should implement
/// this method to initiate a background request. Because requests will be made through a
/// workflow, the workflow is passed to this method. It is up to the derived class to
/// evaluate/update any workflow attributes it needs
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="workflow">The Workflow initiating the request.</param>
/// <param name="personAttribute">The person attribute.</param>
/// <param name="ssnAttribute">The SSN attribute.</param>
/// <param name="requestTypeAttribute">The request type attribute.</param>
/// <param name="billingCodeAttribute">The billing code attribute.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns>
/// True/False value of whether the request was successfully sent or not
/// </returns>
public abstract bool SendRequest(RockContext rockContext, Rock.Model.Workflow workflow,
AttributeCache personAttribute, AttributeCache ssnAttribute, AttributeCache requestTypeAttribute,
AttributeCache billingCodeAttribute, out List <string> errorMessages);
//Limits the displayed rows only to rows which are selected
private void ShowOnlySelectedRows()
{
if (_featureLayer.DataSet.AttributesPopulated)
{
int numRows = _featureLayer.DataSet.DataTable.Rows.Count;
dataGridView1.SuspendLayout();
_selection = new DataTable();
_selection.Columns.AddRange(_featureLayer.DataSet.GetColumns());
if (!_selection.Columns.Contains(_fidField))
{
_selection.Columns.Add(_fidField, typeof(int));
}
if (_selectionIndices == null) _selectionIndices = new List<int>();
_selectionIndices.Clear();
for (int row = 0; row < numRows; row++)
{
if (!_featureLayer.DrawnStates[row].Selected) continue;
DataRow dr = _selection.NewRow();
dr.ItemArray = _featureLayer.DataSet.DataTable.Rows[row].ItemArray;
_selection.Rows.Add(dr);
_selectionIndices.Add(row);
}
dataGridView1.DataSource = _selection;
dataGridView1.SelectAll();
dataGridView1.ResumeLayout();
}
else
{
_attributeCache = new AttributeCache(_featureLayer.Selection, 16);
dataGridView1.Rows.Clear(); // without this setting rowCount takes a looooong time
dataGridView1.RowCount = _featureLayer.Selection.Count;
}
_showOnlySelectedRows = true;
Refresh();
}
public override bool Execute(RockContext rockContext, WorkflowAction action, object entity, out List <string> errorMessages)
{
AttributeMatrixService attributeMatrixService = new AttributeMatrixService(rockContext);
errorMessages = new List <string>();
// Get all the attribute values
var sourceMatrixAttributeGuid = action.GetWorkflowAttributeValue(GetActionAttributeValue(action, "SourceAttributeMatrix").AsGuid()).AsGuidOrNull();
var targetMatrixAttributeGuid = action.GetWorkflowAttributeValue(GetActionAttributeValue(action, "TargetAttributeMatrix").AsGuid()).AsGuidOrNull();
if (sourceMatrixAttributeGuid.HasValue)
{
// Load the source matrix
AttributeMatrix sourceMatrix = attributeMatrixService.Get(sourceMatrixAttributeGuid.Value);
AttributeMatrix targetMatrix = null;
if (targetMatrixAttributeGuid.HasValue)
{
// Just delete all the existing items and add new items from the source attribute
targetMatrix = attributeMatrixService.Get(targetMatrixAttributeGuid.Value);
targetMatrix.AttributeMatrixItems.Clear();
}
else
{
targetMatrix = new AttributeMatrix();
targetMatrix.AttributeMatrixItems = new List <AttributeMatrixItem>();
targetMatrix.AttributeMatrixTemplateId = sourceMatrix.AttributeMatrixTemplateId;
attributeMatrixService.Add(targetMatrix);
}
// Now copy all the items from the source to the target
foreach (var sourceItem in sourceMatrix.AttributeMatrixItems)
{
var targetItem = new AttributeMatrixItem();
sourceItem.LoadAttributes();
targetItem.AttributeMatrix = targetMatrix;
targetItem.LoadAttributes();
foreach (var attribute in sourceItem.AttributeValues)
{
targetItem.SetAttributeValue(attribute.Key, attribute.Value.Value);
}
targetMatrix.AttributeMatrixItems.Add(targetItem);
rockContext.SaveChanges(true);
targetItem.SaveAttributeValues(rockContext);
}
// Now store the target attribute
var targetAttribute = AttributeCache.Get(GetActionAttributeValue(action, "TargetAttributeMatrix").AsGuid(), rockContext);
if (targetAttribute.EntityTypeId == new Rock.Model.Workflow().TypeId)
{
action.Activity.Workflow.SetAttributeValue(targetAttribute.Key, targetMatrix.Guid.ToString());
}
else if (targetAttribute.EntityTypeId == new WorkflowActivity().TypeId)
{
action.Activity.SetAttributeValue(targetAttribute.Key, targetMatrix.Guid.ToString());
}
}
return(true);
}
private void FeatureLayerSetup()
{
if (_featureLayer == null) return;
if (_featureLayer.DataSet.NumRows() < 10000 && !_featureLayer.DataSet.AttributesPopulated)
{
_featureLayer.DataSet.FillAttributes();
}
if (_featureLayer.DataSet.AttributesPopulated)
{
dataGridView1.VirtualMode = false;
dataGridView1.AllowUserToOrderColumns = true;
dataGridView1.DataSource = _featureLayer.DataSet.DataTable;
if (_virtualHooked)
{
dataGridView1.CellValueNeeded -= DataGridView1CellValueNeeded;
dataGridView1.CellValuePushed -= dataGridView1_CellValuePushed;
dataGridView1.RowValidated -= dataGridView1_RowValidated;
}
AddFid(_featureLayer.DataSet.DataTable);
}
else
{
dataGridView1.VirtualMode = true;
dataGridView1.AllowUserToOrderColumns = false;
if (!_virtualHooked)
{
dataGridView1.CellValueNeeded += DataGridView1CellValueNeeded;
dataGridView1.CellValuePushed += dataGridView1_CellValuePushed;
dataGridView1.RowValidated += dataGridView1_RowValidated;
_virtualHooked = true;
}
_attributeCache = new AttributeCache(FeatureLayer.DataSet, 16);
foreach (var field in _featureLayer.DataSet.GetColumns())
{
dataGridView1.Columns.Add(field.ColumnName, field.ColumnName);
}
dataGridView1.RowCount = _featureLayer.DataSet.NumRows();
}
_featureLayer.SelectionChanged += SelectedFeaturesChanged;
}
/// <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>();
Guid? groupGuid = null;
Person person = null;
Group group = null;
string noteValue = string.Empty;
// get the group attribute
Guid groupAttributeGuid = GetAttributeValue(action, "Group").AsGuid();
if (!groupAttributeGuid.IsEmpty())
{
groupGuid = action.GetWorkflowAttributeValue(groupAttributeGuid).AsGuidOrNull();
if (groupGuid.HasValue)
{
group = new GroupService(rockContext).Get(groupGuid.Value);
if (group == null)
{
errorMessages.Add("The group provided does not exist.");
}
}
else
{
errorMessages.Add("Invalid group provided.");
}
}
// get person alias guid
Guid personAliasGuid = Guid.Empty;
string personAttribute = GetAttributeValue(action, "Person");
Guid guid = personAttribute.AsGuid();
if (!guid.IsEmpty())
{
var attribute = AttributeCache.Get(guid, rockContext);
if (attribute != null)
{
string value = action.GetWorkflowAttributeValue(guid);
personAliasGuid = value.AsGuid();
}
if (personAliasGuid != Guid.Empty)
{
person = new PersonAliasService(rockContext).Queryable()
.Where(p => p.Guid.Equals(personAliasGuid))
.Select(p => p.Person)
.FirstOrDefault();
if (person == null)
{
errorMessages.Add("The person could not be found.");
}
}
else
{
errorMessages.Add("Invalid person provided.");
}
}
// get group member note
noteValue = GetAttributeValue(action, "Note");
guid = noteValue.AsGuid();
if (guid.IsEmpty())
{
noteValue = noteValue.ResolveMergeFields(GetMergeFields(action));
}
else
{
var workflowAttributeValue = action.GetWorkflowAttributeValue(guid);
if (workflowAttributeValue != null)
{
noteValue = workflowAttributeValue;
}
}
// set note
if (group != null && person != null)
{
var groupMembers = new GroupMemberService(rockContext).Queryable()
.Where(m => m.Group.Guid == groupGuid && m.PersonId == person.Id).ToList();
if (groupMembers.Count() > 0)
{
foreach (var groupMember in groupMembers)
{
groupMember.Note = noteValue;
rockContext.SaveChanges();
}
}
else
{
errorMessages.Add(string.Format("{0} is not a member of the group {1}.", person.FullName, group.Name));
}
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(true);
}
/// <summary>
/// Returns
/// </summary>
private static bool SufficientValues(string fieldName, IAttributeSource source, int numValues)
{
ArrayList lst = new ArrayList();
AttributeCache ac = new AttributeCache(source, numValues);
foreach (Dictionary<string, object> dr in ac)
{
object val = dr[fieldName] ?? "[NULL]";
if (val.ToString() == string.Empty) val = "[NULL]";
if (lst.Contains(val)) continue;
lst.Add(val);
if (lst.Count > numValues) return true;
}
return false;
}
/// <summary>
/// Renders the specified context.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="result">The result.</param>
/// <exception cref="System.Exception">Your Lava command must contain at least one valid filter. If you configured a filter it's possible that the property or attribute you provided does not exist.</exception>
public override void Render(Context context, TextWriter result)
{
// first ensure that entity commands are allowed in the context
if (!this.IsAuthorized(context))
{
result.Write(string.Format(RockLavaBlockBase.NotAuthorizedMessage, this.Name));
base.Render(context, result);
return;
}
bool hasFilter = false;
// get a service for the entity based off it's friendly name
var entityTypes = EntityTypeCache.All();
var model = string.Empty;
if (_entityName == "business")
{
model = "Rock.Model.Person";
}
else
{
model = "Rock.Model." + _entityName;
}
// Check first to see if this is a core model
var entityTypeCache = entityTypes.Where(e => String.Equals(e.Name, model, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
// If not, look for first plug-in model that has same friendly name
if (entityTypeCache == null)
{
entityTypeCache = entityTypes
.Where(e =>
e.IsEntity &&
!e.Name.StartsWith("Rock.Model") &&
e.FriendlyName != null &&
e.FriendlyName.RemoveSpaces().ToLower() == _entityName)
.OrderBy(e => e.Id)
.FirstOrDefault();
}
// If still null check to see if this was a duplicate class and full class name was used as entity name
if (entityTypeCache == null)
{
model = _entityName.Replace('_', '.');
entityTypeCache = entityTypes.Where(e => String.Equals(e.Name, model, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
}
if (entityTypeCache != null)
{
Type entityType = entityTypeCache.GetEntityType();
if (entityType != null)
{
// Get the database context
var dbContext = Reflection.GetDbContextForEntityType(entityType); // TODO why not use RockContext here?
// Create an instance of the entity's service
IService serviceInstance = Reflection.GetServiceForEntityType(entityType, dbContext);
ParameterExpression paramExpression = Expression.Parameter(entityType, "x");
Expression queryExpression = null; // the base expression we'll use to build our query from
// Parse markup
var parms = ParseMarkup(_markup, context);
if (parms.Any(p => p.Key == "id"))
{
string propertyName = "Id";
List <string> selectionParms = new List <string>();
selectionParms.Add(PropertyComparisonConversion("==").ToString());
selectionParms.Add(parms["id"].ToString());
selectionParms.Add(propertyName);
var entityProperty = entityType.GetProperty(propertyName);
queryExpression = ExpressionHelper.PropertyFilterExpression(selectionParms, paramExpression, propertyName, entityProperty.PropertyType);
hasFilter = true;
}
else
{
// where clause expression
if (parms.Any(p => p.Key == "where"))
{
queryExpression = ParseWhere(parms["where"], entityType, serviceInstance, paramExpression, entityType, entityTypeCache);
if (queryExpression != null)
{
hasFilter = true;
}
}
// DataView expression
if (parms.Any(p => p.Key == "dataview"))
{
var dataViewId = parms["dataview"].AsIntegerOrNull();
if (dataViewId.HasValue)
{
var dataViewExpression = GetDataViewExpression(dataViewId.Value, serviceInstance, paramExpression, entityTypeCache);
if (queryExpression == null)
{
queryExpression = dataViewExpression;
hasFilter = true;
}
else
{
queryExpression = Expression.AndAlso(queryExpression, dataViewExpression);
}
}
}
// process dynamic filter expressions (from the query string)
if (parms.Any(p => p.Key == "dynamicparameters"))
{
var dynamicFilters = parms["dynamicparameters"].Split(',')
.Select(x => x.Trim())
.Where(x => !string.IsNullOrWhiteSpace(x))
.ToList();
foreach (var dynamicFilter in dynamicFilters)
{
var dynamicFilterValue = HttpContext.Current.Request[dynamicFilter];
var dynamicFilterExpression = GetDynamicFilterExpression(dynamicFilter, dynamicFilterValue, entityType, serviceInstance, paramExpression);
if (dynamicFilterExpression != null)
{
if (queryExpression == null)
{
queryExpression = dynamicFilterExpression;
hasFilter = true;
}
else
{
queryExpression = Expression.AndAlso(queryExpression, dynamicFilterExpression);
}
}
}
}
}
// Make the query from the expression
MethodInfo getMethod = serviceInstance.GetType().GetMethod("GetNoTracking", new Type[] { typeof(ParameterExpression), typeof(Expression), typeof(Rock.Web.UI.Controls.SortProperty), typeof(int?) });
if (getMethod != null)
{
// get a listing of ids and build it into the query expression
if (parms.Any(p => p.Key == "ids"))
{
List <int> value = parms["ids"].ToString().Split(',').Select(int.Parse).ToList();
MemberExpression propertyExpression = Expression.Property(paramExpression, "Id");
ConstantExpression constantExpression = Expression.Constant(value, typeof(List <int>));
Expression containsExpression = Expression.Call(constantExpression, typeof(List <int>).GetMethod("Contains", new Type[] { typeof(int) }), propertyExpression);
if (queryExpression != null)
{
queryExpression = Expression.AndAlso(queryExpression, containsExpression);
}
else
{
queryExpression = containsExpression;
}
hasFilter = true;
}
var getResult = getMethod.Invoke(serviceInstance, new object[] { paramExpression, queryExpression, null, null });
var queryResult = getResult as IQueryable <IEntity>;
// process entity specific filters
switch (_entityName)
{
case "person":
{
queryResult = PersonFilters((IQueryable <Person>)queryResult, parms);
break;
}
case "business":
{
queryResult = BusinessFilters((IQueryable <Person>)queryResult, parms);
break;
}
}
// if there was a dynamic expression add it now
if (parms.Any(p => p.Key == "expression"))
{
queryResult = queryResult.Where(parms["expression"]);
hasFilter = true;
}
var queryResultExpression = queryResult.Expression;
// add sort expressions
if (parms.Any(p => p.Key == "sort"))
{
string orderByMethod = "OrderBy";
foreach (var column in parms["sort"].Split(',').Select(x => x.Trim()).Where(x => !string.IsNullOrWhiteSpace(x)).ToList())
{
string propertyName;
var direction = SortDirection.Ascending;
if (column.EndsWith(" desc", StringComparison.OrdinalIgnoreCase))
{
direction = SortDirection.Descending;
propertyName = column.Left(column.Length - 5);
}
else
{
propertyName = column;
}
string methodName = direction == SortDirection.Descending ? orderByMethod + "Descending" : orderByMethod;
if (entityType.GetProperty(propertyName) != null)
{
// sorting a entity property
var memberExpression = Expression.Property(paramExpression, propertyName);
LambdaExpression sortSelector = Expression.Lambda(memberExpression, paramExpression);
queryResultExpression = Expression.Call(typeof(Queryable), methodName, new Type[] { queryResult.ElementType, sortSelector.ReturnType }, queryResultExpression, sortSelector);
}
else
{
// sorting on an attribute
// get attribute id
int?attributeId = null;
foreach (var id in AttributeCache.GetByEntity(entityTypeCache.Id).SelectMany(a => a.AttributeIds))
{
var attribute = AttributeCache.Get(id);
if (attribute.Key == propertyName)
{
attributeId = id;
break;
}
}
if (attributeId.HasValue)
{
// get AttributeValue queryable and parameter
if (dbContext is RockContext)
{
var attributeValues = new AttributeValueService(dbContext as RockContext).Queryable();
ParameterExpression attributeValueParameter = Expression.Parameter(typeof(AttributeValue), "v");
MemberExpression idExpression = Expression.Property(paramExpression, "Id");
var attributeExpression = Attribute.Helper.GetAttributeValueExpression(attributeValues, attributeValueParameter, idExpression, attributeId.Value);
LambdaExpression sortSelector = Expression.Lambda(attributeExpression, paramExpression);
queryResultExpression = Expression.Call(typeof(Queryable), methodName, new Type[] { queryResult.ElementType, sortSelector.ReturnType }, queryResultExpression, sortSelector);
}
else
{
throw new Exception(string.Format("The database context for type {0} does not support RockContext attribute value queries.", entityTypeCache.FriendlyName));
}
}
}
orderByMethod = "ThenBy";
}
}
// check to ensure we had some form of filter (otherwise we'll return all results in the table)
if (!hasFilter)
{
throw new Exception("Your Lava command must contain at least one valid filter. If you configured a filter it's possible that the property or attribute you provided does not exist.");
}
// reassemble the queryable with the sort expressions
queryResult = queryResult.Provider.CreateQuery(queryResultExpression) as IQueryable <IEntity>;
if (parms.GetValueOrNull("count").AsBoolean())
{
int countResult = queryResult.Count();
context.Scopes.Last()["count"] = countResult;
}
else
{
// Run security check on each result if enabled and entity is not a person (we do not check security on people)
if (parms["securityenabled"].AsBoolean() && _entityName != "person")
{
var items = queryResult.ToList();
var itemsSecured = new List <IEntity>();
Person person = GetCurrentPerson(context);
foreach (IEntity item in items)
{
ISecured itemSecured = item as ISecured;
if (itemSecured == null || itemSecured.IsAuthorized(Authorization.VIEW, person))
{
itemsSecured.Add(item);
}
}
queryResult = itemsSecured.AsQueryable();
}
// offset
if (parms.Any(p => p.Key == "offset"))
{
queryResult = queryResult.Skip(parms["offset"].AsInteger());
}
// limit, default to 1000
if (parms.Any(p => p.Key == "limit"))
{
queryResult = queryResult.Take(parms["limit"].AsInteger());
}
else
{
queryResult = queryResult.Take(1000);
}
var resultList = queryResult.ToList();
// if there is only one item to return set an alternative non-array based variable
if (resultList.Count == 1)
{
context.Scopes.Last()[_entityName] = resultList.FirstOrDefault();
}
context.Scopes.Last()[parms["iterator"]] = resultList;
}
}
}
}
else
{
result.Write(string.Format("Could not find a model for {0}.", _entityName));
base.Render(context, result);
}
base.Render(context, result);
}
