/// <summary>
        /// Показать окно предпросмотра отчета
        /// </summary>
        /// <param name="reportController">Контроллер</param>
        /// <param name="reportContainerHandle">Дескриптор</param>
        /// <param name="parametersObject">Объект параметров</param>
        /// <param name="criteria">Критерий</param>
        /// <param name="canApplyCriteria">Можно ли применить критерий</param>
        /// <param name="sortProperty">Сортировка</param>
        /// <param name="canApplySortProperty">Можно ли применить сортировку</param>
        /// <param name="showViewParameters">Объект DevExpress.ExpressApp.ShowViewParameters</param>
        public static void ShowPreview(this ReportServiceController reportController, string reportContainerHandle, ReportParametersObjectBase parametersObject, CriteriaOperator criteria, bool canApplyCriteria, SortProperty[] sortProperty, bool canApplySortProperty, ShowViewParameters showViewParameters)
        {
            var objectSpace = ReportDataProvider.ReportObjectSpaceProvider.CreateObjectSpace(typeof(ReportDataV2));
            Audit.ReportTrail.LogOperation(objectSpace, reportContainerHandle, parametersObject);

            var type = reportController.GetType().BaseType;
            var method = type.GetMethod("ShowReportPreview", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, new Type[] { typeof(string), typeof(ReportParametersObjectBase), typeof(CriteriaOperator), typeof(bool), typeof(SortProperty[]), typeof(bool), typeof(ShowViewParameters) }, null);

            if (method != null)
            {
                method.Invoke(reportController, new object[] { reportContainerHandle, parametersObject, criteria, canApplyCriteria, sortProperty, canApplySortProperty, showViewParameters });
            }
        }
示例#2
0
        /// <summary>
        /// Binds the grid.
        /// </summary>
        private void BindGrid()
        {
            using (var rockContext = new RockContext())
            {
                var qry = new BackgroundCheckService(rockContext)
                          .Queryable("PersonAlias.Person").AsNoTracking()
                          .Where(g =>
                                 g.PersonAlias != null &&
                                 g.PersonAlias.Person != null)
                          .Where(g =>
                                 g.ForeignId == 1);

                // FirstName
                string firstName = fRequest.GetUserPreference("First Name");
                if (!string.IsNullOrWhiteSpace(firstName))
                {
                    qry = qry.Where(t =>
                                    t.PersonAlias.Person.FirstName.StartsWith(firstName) ||
                                    t.PersonAlias.Person.NickName.StartsWith(firstName));
                }

                // LastName
                string lastName = fRequest.GetUserPreference("Last Name");
                if (!string.IsNullOrWhiteSpace(lastName))
                {
                    qry = qry.Where(t =>
                                    t.PersonAlias.Person.LastName.StartsWith(lastName));
                }

                // Request Date Range
                var drpRequestDates = new DateRangePicker();
                drpRequestDates.DelimitedValues = fRequest.GetUserPreference("Request Date Range");
                if (drpRequestDates.LowerValue.HasValue)
                {
                    qry = qry.Where(t => t.RequestDate >= drpRequestDates.LowerValue.Value);
                }

                if (drpRequestDates.UpperValue.HasValue)
                {
                    DateTime upperDate = drpRequestDates.UpperValue.Value.Date.AddDays(1);
                    qry = qry.Where(t => t.RequestDate < upperDate);
                }

                // Response Date Range
                var drpResponseDates = new DateRangePicker();
                drpResponseDates.DelimitedValues = fRequest.GetUserPreference("Response Date Range");
                if (drpResponseDates.LowerValue.HasValue)
                {
                    qry = qry.Where(t => t.ResponseDate >= drpResponseDates.LowerValue.Value);
                }

                if (drpResponseDates.UpperValue.HasValue)
                {
                    DateTime upperDate = drpResponseDates.UpperValue.Value.Date.AddDays(1);
                    qry = qry.Where(t => t.ResponseDate < upperDate);
                }

                // Record Found
                string recordFound = fRequest.GetUserPreference("Record Found");
                if (!string.IsNullOrWhiteSpace(recordFound))
                {
                    if (recordFound == "Yes")
                    {
                        qry = qry.Where(t =>
                                        t.RecordFound.HasValue &&
                                        t.RecordFound.Value);
                    }
                    else if (recordFound == "No")
                    {
                        qry = qry.Where(t =>
                                        t.RecordFound.HasValue &&
                                        !t.RecordFound.Value);
                    }
                }

                List <Rock.Model.BackgroundCheck> items = null;
                SortProperty sortProperty = gRequest.SortProperty;
                if (sortProperty != null)
                {
                    if (sortProperty.Property == "Name")
                    {
                        if (sortProperty.Direction == SortDirection.Descending)
                        {
                            items = qry.OrderByDescending(q => q.PersonAlias.Person.LastName).ThenBy(q => q.PersonAlias.Person.FirstName).ToList();
                        }
                        else
                        {
                            items = qry.OrderBy(q => q.PersonAlias.Person.LastName).ThenBy(q => q.PersonAlias.Person.FirstName).ToList();
                        }
                    }
                    else
                    {
                        items = qry.Sort(sortProperty).ToList();
                    }
                }
                else
                {
                    items = qry.OrderByDescending(d => d.RequestDate).ToList();
                }

                gRequest.DataSource = items.Select(b => new BackgroundCheckRow
                {
                    Name             = b.PersonAlias.Person.LastName + ", " + b.PersonAlias.Person.NickName,
                    Id               = b.Id,
                    PersonId         = b.PersonAlias.PersonId,
                    HasWorkflow      = b.WorkflowId.HasValue,
                    RequestDate      = b.RequestDate,
                    ResponseDate     = b.ResponseDate,
                    RecordFound      = b.RecordFound,
                    RecordFoundLabel = b.RecordFound.HasValue ? (
                        b.RecordFound.Value ?
                        "<span class='label label-warning'>Yes</span>" :
                        "<span class='label label-success'>No</span>") :
                                       string.Empty,
                    HasResponseData      = !string.IsNullOrWhiteSpace(b.ResponseData),
                    ResponseDocumentText = b.ResponseDocumentId.HasValue ? "<i class='fa fa-file-pdf-o fa-lg'></i>" : "",
                    ResponseDocumentId   = b.ResponseDocumentId ?? 0
                }).ToList();

                gRequest.DataBind();
            }
        }
示例#3
0
        private void BindPOGrid()
        {
            ConfigurePOGrid();

            DataTable dt = new DataTable();

            dt.Columns.AddRange(new DataColumn[] {
                new DataColumn("PurchaseOrderID", typeof(int)),
                new DataColumn("VendorName", typeof(string)),
                new DataColumn("POType", typeof(string)),
                new DataColumn("Status", typeof(string)),
                new DataColumn("ItemDetails", typeof(int)),
                new DataColumn("TotalPayments", typeof(string)),
                new DataColumn("NoteCount", typeof(int)),
                new DataColumn("AttachmentCount", typeof(int))
            });

            SortProperty sortProperty = dgPurchaseOrders.SortProperty;

            if (GetUserPreferences(PersonSettingKeyPrefix).Count() > 0)
            {
                var POListItems = PurchaseOrder.GetPurchaseOrderList(BuildFilter());


                // Check User Preferences to see if we have a pre-existing sort property
                if (sortProperty == null)
                {
                    sortProperty           = new SortProperty();
                    sortProperty.Direction = GetUserPreference(string.Format("{0}_Sort_Direction", PersonSettingKeyPrefix)) == "ASC" ? SortDirection.Ascending : SortDirection.Descending;
                    sortProperty.Property  = GetUserPreference(string.Format("{0}_Sort_Column", PersonSettingKeyPrefix));
                    if (string.IsNullOrEmpty(sortProperty.Property))
                    {
                        sortProperty.Property = "PurchaseOrderID";
                    }
                }
                if (sortProperty != null)
                {
                    try
                    {
                        if (sortProperty.Direction == SortDirection.Ascending)
                        {
                            POListItems = POListItems.OrderBy(r => r.GetType().GetProperty(sortProperty.Property).GetValue(r)).ToList();
                        }
                        else
                        {
                            POListItems = POListItems.OrderByDescending(r => r.GetType().GetProperty(sortProperty.Property).GetValue(r)).ToList();
                        }
                        SetUserPreference(string.Format("{0}_Sort_Direction", PersonSettingKeyPrefix), sortProperty.DirectionString);
                        SetUserPreference(string.Format("{0}_Sort_Column", PersonSettingKeyPrefix), sortProperty.Property);
                    } catch (NullReferenceException)
                    {
                        // Just eat this exception
                    }
                }
                else
                {
                    POListItems = POListItems.OrderByDescending(p => p.PurchaseOrderID).ToList();
                }

                foreach (var po in POListItems)
                {
                    DataRow dr = dt.NewRow();
                    dr["PurchaseOrderID"] = po.PurchaseOrderID;
                    dr["VendorName"]      = po.VendorName;
                    dr["POType"]          = po.POType;
                    dr["Status"]          = po.Status;
                    dr["ItemDetails"]     = po.ItemDetailCount;
                    dr["TotalPayments"]   = string.Format("{0:c}", po.TotalPayments);
                    dr["NoteCount"]       = po.NoteCount;
                    dr["AttachmentCount"] = po.AttachmentCount;

                    dt.Rows.Add(dr);
                }
            }

            dgPurchaseOrders.DataSource = dt;
            dgPurchaseOrders.DataBind();

            if (sortProperty != null)
            {
                foreach (var column in dgPurchaseOrders.Columns)
                {
                    var dcf = column as DataControlField;
                    if (dcf != null && dcf.SortExpression == sortProperty.Property)
                    {
                        dgPurchaseOrders.HeaderRow.Cells[dgPurchaseOrders.Columns.IndexOf(dcf)].AddCssClass(sortProperty.Direction.ToString().ToLower());
                        break;
                    }
                }
                if (dgPurchaseOrders.SortProperty == null)
                {
                    dgPurchaseOrders.Sort(sortProperty.Property, sortProperty.Direction);
                }
            }
        }
        /// <summary>
        /// Binds the group members grid.
        /// </summary>
        protected void BindGroupMembersGrid(bool selectAll = false)
        {
            if (_group != null)
            {
                pnlGroupMembers.Visible = true;

                lHeading.Text = string.Format("{0} {1}", _group.GroupType.GroupTerm, _group.GroupType.GroupMemberTerm.Pluralize());

                if (_group.GroupType.Roles.Any())
                {
                    nbRoleWarning.Visible = false;
                    rFilter.Visible       = true;
                    gGroupMembers.Visible = true;

                    var rockContext = new RockContext();

                    GroupMemberService groupMemberService = new GroupMemberService(rockContext);
                    var qry = groupMemberService.Queryable("Person,GroupRole", true).AsNoTracking()
                              .Where(m => m.GroupId == _group.Id);

                    // Filter by First Name
                    string firstName = tbFirstName.Text;
                    if (!string.IsNullOrWhiteSpace(firstName))
                    {
                        qry = qry.Where(m => m.Person.FirstName.StartsWith(firstName));
                    }

                    // Filter by Last Name
                    string lastName = tbLastName.Text;
                    if (!string.IsNullOrWhiteSpace(lastName))
                    {
                        qry = qry.Where(m => m.Person.LastName.StartsWith(lastName));
                    }

                    // Filter by role
                    var validGroupTypeRoles = _group.GroupType.Roles.Select(r => r.Id).ToList();
                    var roles = new List <int>();
                    foreach (string role in cblRole.SelectedValues)
                    {
                        if (!string.IsNullOrWhiteSpace(role))
                        {
                            int roleId = int.MinValue;
                            if (int.TryParse(role, out roleId) && validGroupTypeRoles.Contains(roleId))
                            {
                                roles.Add(roleId);
                            }
                        }
                    }

                    if (roles.Any())
                    {
                        qry = qry.Where(m => roles.Contains(m.GroupRoleId));
                    }

                    // Filter by Status
                    var statuses = new List <GroupMemberStatus>();
                    foreach (string status in cblStatus.SelectedValues)
                    {
                        if (!string.IsNullOrWhiteSpace(status))
                        {
                            statuses.Add(status.ConvertToEnum <GroupMemberStatus>());
                        }
                    }

                    if (statuses.Any())
                    {
                        qry = qry.Where(m => statuses.Contains(m.GroupMemberStatus));
                    }

                    // Filter query by any configured attribute filters
                    if (AvailableAttributes != null && AvailableAttributes.Any())
                    {
                        var attributeValueService = new AttributeValueService(rockContext);
                        var parameterExpression   = attributeValueService.ParameterExpression;

                        foreach (var attribute in AvailableAttributes)
                        {
                            var filterControl = phAttributeFilters.FindControl("filter_" + attribute.Id.ToString());
                            if (filterControl != null)
                            {
                                var filterValues = attribute.FieldType.Field.GetFilterValues(filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter);
                                var expression   = attribute.FieldType.Field.AttributeFilterExpression(attribute.QualifierValues, filterValues, parameterExpression);
                                if (expression != null)
                                {
                                    var attributeValues = attributeValueService
                                                          .Queryable()
                                                          .Where(v => v.Attribute.Id == attribute.Id);

                                    attributeValues = attributeValues.Where(parameterExpression, expression, null);

                                    qry = qry.Where(w => attributeValues.Select(v => v.EntityId).Contains(w.Id));
                                }
                            }
                        }
                    }

                    _inactiveStatus = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE);

                    SortProperty sortProperty = gGroupMembers.SortProperty;

                    bool hasGroupRequirements = new GroupRequirementService(rockContext).Queryable().Where(a => a.GroupId == _group.Id).Any();

                    // If there are group requirements that that member doesn't meet, show an icon in the grid
                    bool includeWarnings = false;
                    var  groupMemberIdsThatLackGroupRequirements = new GroupService(rockContext).GroupMembersNotMeetingRequirements(_group.Id, includeWarnings).Select(a => a.Key.Id);

                    List <GroupMember> groupMembersList = null;

                    if (sortProperty != null)
                    {
                        groupMembersList = qry.Sort(sortProperty).ToList();
                    }
                    else
                    {
                        groupMembersList = qry.OrderBy(a => a.GroupRole.Order).ThenBy(a => a.Person.LastName).ThenBy(a => a.Person.FirstName).ToList();
                    }

                    // Since we're not binding to actual group member list, but are using AttributeField columns,
                    // we need to save the workflows into the grid's object list
                    gGroupMembers.ObjectList = new Dictionary <string, object>();
                    groupMembersList.ForEach(m => gGroupMembers.ObjectList.Add(m.Id.ToString(), m));
                    gGroupMembers.EntityTypeId = EntityTypeCache.Read(Rock.SystemGuid.EntityType.GROUP_MEMBER.AsGuid()).Id;

                    var homePhoneType = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME);
                    var cellPhoneType = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_MOBILE);

                    // If exporting to Excel, the selectAll option will be true, and home location should be calculated
                    var homeLocations = new Dictionary <int, Location>();
                    if (selectAll)
                    {
                        foreach (var m in groupMembersList)
                        {
                            homeLocations.Add(m.Id, m.Person.GetHomeLocation(rockContext));
                        }
                    }

                    gGroupMembers.DataSource = groupMembersList
                                               .ToList().Select(m => new
                    {
                        m.Id,
                        m.Guid,
                        m.PersonId,
                        Name = m.Person.NickName + " " + m.Person.LastName
                               + (hasGroupRequirements && groupMemberIdsThatLackGroupRequirements.Contains(m.Id)
                                ? " <i class='fa fa-exclamation-triangle text-warning'></i>"
                                : string.Empty)
                               + (!string.IsNullOrEmpty(m.Note)
                            ? " <i class='fa fa-file-text-o text-info'></i>"
                            : string.Empty),
                        Email     = m.Person.Email,
                        HomePhone = homePhoneType != null ?
                                    m.Person.PhoneNumbers
                                    .Where(p => p.NumberTypeValueId.HasValue && p.NumberTypeValueId.Value == homePhoneType.Id)
                                    .Select(p => p.NumberFormatted)
                                    .FirstOrDefault() : string.Empty,
                        CellPhone = cellPhoneType != null ?
                                    m.Person.PhoneNumbers
                                    .Where(p => p.NumberTypeValueId.HasValue && p.NumberTypeValueId.Value == cellPhoneType.Id)
                                    .Select(p => p.NumberFormatted)
                                    .FirstOrDefault() : string.Empty,
                        HomeAddress = homeLocations.ContainsKey(m.Id) && homeLocations[m.Id] != null ?
                                      homeLocations[m.Id].FormattedAddress : string.Empty,
                        Latitude = homeLocations.ContainsKey(m.Id) && homeLocations[m.Id] != null ?
                                   homeLocations[m.Id].Latitude : (double?)null,
                        Longitude = homeLocations.ContainsKey(m.Id) && homeLocations[m.Id] != null ?
                                    homeLocations[m.Id].Longitude : (double?)null,
                        GroupRole = m.GroupRole.Name,
                        m.GroupMemberStatus,
                        RecordStatusValueId = m.Person.RecordStatusValueId,
                        IsDeceased          = m.Person.IsDeceased
                    }).ToList();
                    gGroupMembers.DataBind();
                }
                else
                {
                    nbRoleWarning.Text = string.Format(
                        "{0} cannot be added to this {1} because the '{2}' group type does not have any roles defined.",
                        _group.GroupType.GroupMemberTerm.Pluralize(),
                        _group.GroupType.GroupTerm,
                        _group.GroupType.Name);

                    nbRoleWarning.Visible = true;
                    rFilter.Visible       = false;
                    gGroupMembers.Visible = false;
                }
            }
            else
            {
                pnlGroupMembers.Visible = false;
            }
        }
示例#5
0
        /// <summary>
        /// Binds the group members grid.
        /// </summary>
        protected void BindInstancesGrid()
        {
            if (_template != null)
            {
                pnlInstances.Visible = true;

                lHeading.Text = string.Format("{0} Instances", _template.Name);

                var rockContext = new RockContext();

                RegistrationInstanceService instanceService = new RegistrationInstanceService(rockContext);
                var qry = instanceService.Queryable().AsNoTracking()
                          .Where(i => i.RegistrationTemplateId == _template.Id);

                // Date Range
                var drp = new DateRangePicker();
                drp.DelimitedValues = rFilter.GetUserPreference("Date Range");
                if (drp.LowerValue.HasValue)
                {
                    qry = qry.Where(i => i.StartDateTime >= drp.LowerValue.Value);
                }

                if (drp.UpperValue.HasValue)
                {
                    DateTime upperDate = drp.UpperValue.Value.Date.AddDays(1);
                    qry = qry.Where(i => i.StartDateTime < upperDate);
                }

                string statusFilter = rFilter.GetUserPreference("Active Status");
                if (!string.IsNullOrWhiteSpace(statusFilter))
                {
                    if (statusFilter == "inactive")
                    {
                        qry = qry.Where(i => i.IsActive == false);
                    }
                    else
                    {
                        qry = qry.Where(i => i.IsActive == true);
                    }
                }

                SortProperty sortProperty = gInstances.SortProperty;
                if (sortProperty != null)
                {
                    qry = qry.Sort(sortProperty);
                }
                else
                {
                    qry = qry.OrderByDescending(a => a.StartDateTime);
                }

                var instanceQry = qry.Select(i => new
                {
                    i.Id,
                    i.Guid,
                    i.Name,
                    i.StartDateTime,
                    i.EndDateTime,
                    i.IsActive,
                    Details     = string.Empty,
                    Registrants = i.Registrations.SelectMany(r => r.Registrants).Count()
                });

                gInstances.SetLinqDataSource(instanceQry);
                gInstances.DataBind();
            }
            else
            {
                pnlInstances.Visible = false;
            }
        }
示例#6
0
        /// <summary>
        /// Binds the grid.
        /// </summary>
        private void BindGrid()
        {
            var rockContext = new RockContext();

            var groupMemberService            = new GroupMemberService(rockContext);
            var groupService                  = new GroupService(rockContext);
            var groupTypeService              = new GroupTypeService(rockContext);
            var attributeService              = new AttributeService(rockContext);
            var attributeValueService         = new AttributeValueService(rockContext);
            var personService                 = new PersonService(rockContext);
            var personAliasService            = new PersonAliasService(rockContext);
            var entityTypeService             = new EntityTypeService(rockContext);
            var registrationRegistrantService = new RegistrationRegistrantService(rockContext);
            var eiogmService                  = new EventItemOccurrenceGroupMapService(rockContext);
            var groupLocationService          = new GroupLocationService(rockContext);
            var locationService               = new LocationService(rockContext);
            var signatureDocumentServce       = new SignatureDocumentService(rockContext);
            var phoneNumberService            = new PhoneNumberService(rockContext);

            int[] signatureDocumentIds = { };
            if (!string.IsNullOrWhiteSpace(GetAttributeValue("SignatureDocumentTemplates")))
            {
                signatureDocumentIds = Array.ConvertAll(GetAttributeValue("SignatureDocumentTemplates").Split(','), int.Parse);
            }

            int[] registrationInstanceIds = { };
            if (!string.IsNullOrWhiteSpace(GetAttributeValue("RegistrationInstances")))
            {
                registrationInstanceIds = Array.ConvertAll(GetAttributeValue("RegistrationInstances").Split(','), int.Parse);
            }

            Guid bbGroup = GetAttributeValue("Group").AsGuid();
            var  group   = new GroupService(rockContext).Get(bbGroup);

            Guid hsmGroupTypeGuid = GetAttributeValue("MSMGroupType").AsGuid();
            int? hsmGroupTypeId   = groupTypeService.Queryable().Where(gt => gt.Guid == hsmGroupTypeGuid).Select(gt => gt.Id).FirstOrDefault();

            int entityTypeId = entityTypeService.Queryable().Where(et => et.Name == typeof(Rock.Model.Group).FullName).FirstOrDefault().Id;

            var registrationTemplateIds = eiogmService.Queryable().Where(r => r.GroupId == group.Id).Select(m => m.RegistrationInstance.RegistrationTemplateId.ToString()).ToList();

            hlGroup.NavigateUrl = "/group/" + group.Id;

            var attributeIds = attributeService.Queryable()
                               .Where(a => (a.EntityTypeQualifierColumn == "GroupId" && a.EntityTypeQualifierValue == group.Id.ToString()) ||
                                      (a.EntityTypeQualifierColumn == "GroupTypeId" && a.EntityTypeQualifierValue == group.GroupTypeId.ToString()) ||
                                      (a.EntityTypeQualifierColumn == "RegistrationTemplateId" && registrationTemplateIds.Contains(a.EntityTypeQualifierValue)))
                               .Select(a => a.Id).ToList();

            var gmTmpqry = groupMemberService.Queryable()
                           .Where(gm => (gm.GroupId == group.Id));

            var qry = gmTmpqry
                      .Join(personAliasService.Queryable(),
                            obj => obj.PersonId,
                            pa => pa.PersonId,
                            (obj, pa) => new { GroupMember = obj, PersonAlias = pa }
                            )
                      .Join(registrationRegistrantService.Queryable(),
                            obj => obj.PersonAlias.Id,
                            rr => rr.PersonAliasId,
                            (obj, rr) => new { GroupMember = obj.GroupMember, Person = obj.GroupMember.Person, RegistrationRegistrant = rr })
                      .GroupJoin(attributeValueService.Queryable(),
                                 obj => new { PersonId = (int?)obj.Person.Id, AttributeId = 739 },
                                 av => new { PersonId = av.EntityId, av.AttributeId },
                                 (obj, av) => new { GroupMember = obj.GroupMember, Person = obj.Person, RegistrationRegistrant = obj.RegistrationRegistrant, School = av.Select(s => s.Value).FirstOrDefault() })
                      .GroupJoin(attributeValueService.Queryable(),
                                 obj => obj.GroupMember.Id,
                                 av => av.EntityId.Value,
                                 (obj, avs) => new { GroupMember = obj.GroupMember, Person = obj.Person, RegistrationRegistrant = obj.RegistrationRegistrant, GroupMemberAttributeValues = avs.Where(av => attributeIds.Contains(av.AttributeId)), School = obj.School /*, Location = obj.Location */ })
                      .GroupJoin(attributeValueService.Queryable(),
                                 obj => obj.RegistrationRegistrant.Id,
                                 av => av.EntityId.Value,
                                 (obj, avs) => new { GroupMember = obj.GroupMember, Person = obj.Person, RegistrationRegistrant = obj.RegistrationRegistrant, GroupMemberAttributeValues = obj.GroupMemberAttributeValues, RegistrationAttributeValues = avs.Where(av => attributeIds.Contains(av.AttributeId)), School = obj.School /*, Location = obj.Location */ })
                      .Where(obj => registrationInstanceIds.Contains(obj.RegistrationRegistrant.Registration.RegistrationInstanceId));

            var qry2 = gmTmpqry
                       .GroupJoin(
                groupMemberService.Queryable()
                .Join(groupService.Queryable(),
                      gm => new { Id = gm.GroupId, GroupTypeId = 10 },
                      g => new { g.Id, g.GroupTypeId },
                      (gm, g) => new { GroupMember = gm, Group = g })
                .Join(groupLocationService.Queryable(),
                      obj => new { GroupId = obj.Group.Id, GroupLocationTypeValueId = (int?)19 },
                      gl => new { gl.GroupId, gl.GroupLocationTypeValueId },
                      (g, gl) => new { GroupMember = g.GroupMember, GroupLocation = gl })
                .Join(locationService.Queryable(),
                      obj => obj.GroupLocation.LocationId,
                      l => l.Id,
                      (obj, l) => new { GroupMember = obj.GroupMember, Location = l }),
                gm => gm.PersonId,
                glgm => glgm.GroupMember.PersonId,
                (obj, l) => new { GroupMember = obj, Location = l.Select(loc => loc.Location).FirstOrDefault() }
                )
                       .GroupJoin(signatureDocumentServce.Queryable()
                                  .Join(personAliasService.Queryable(),
                                        sd => sd.AppliesToPersonAliasId,
                                        pa => pa.Id,
                                        (sd, pa) => new { SignatureDocument = sd, Alias = pa }),
                                  obj => obj.GroupMember.PersonId,
                                  sd => sd.Alias.PersonId,
                                  (obj, sds) => new { GroupMember = obj.GroupMember, Location = obj.Location, SignatureDocuments = sds })
                       .GroupJoin(phoneNumberService.Queryable(),
                                  obj => obj.GroupMember.PersonId,
                                  p => p.PersonId,
                                  (obj, pn) => new { GroupMember = obj.GroupMember, Location = obj.Location, SignatureDocuments = obj.SignatureDocuments, PhoneNumbers = pn });


            if (!String.IsNullOrWhiteSpace(GetUserPreference(string.Format("{0}PersonName", keyPrefix))))
            {
                string personName = GetUserPreference(string.Format("{0}PersonName", keyPrefix)).ToLower();
                qry = qry.ToList().Where(q => q.GroupMember.Person.FullName.ToLower().Contains(personName)).AsQueryable();
            }
            decimal?lowerVal = GetUserPreference(string.Format("{0}BalanceOwedLower", keyPrefix)).AsDecimalOrNull();
            decimal?upperVal = GetUserPreference(string.Format("{0}BalanceOwedUpper", keyPrefix)).AsDecimalOrNull();

            if (lowerVal != null && upperVal != null)
            {
                qry = qry.ToList().Where(q => q.RegistrationRegistrant.Registration.BalanceDue >= lowerVal && q.RegistrationRegistrant.Registration.BalanceDue <= upperVal).AsQueryable();
            }
            else if (lowerVal != null)
            {
                qry = qry.ToList().Where(q => q.RegistrationRegistrant.Registration.BalanceDue >= lowerVal).AsQueryable();
            }
            else if (upperVal != null)
            {
                qry = qry.ToList().Where(q => q.RegistrationRegistrant.Registration.BalanceDue <= upperVal).AsQueryable();
            }
            else if (!string.IsNullOrEmpty(cmpCampus.SelectedValue))
            {
                CampusCache campus = CampusCache.Read(cmpCampus.SelectedCampusId.Value);
                qry = qry.ToList().Where(q => q.RegistrationAttributeValues.Where(ra => ra.AttributeKey == "Whichcampus" && ra.Value.Contains(campus.Name.Replace(" ", ""))).Any()).AsQueryable();
            }

            var stopwatch = new Stopwatch();

            stopwatch.Start();
            var tmp  = qry.ToList();
            var tmp2 = qry2.ToList();

            lStats.Text = "Query Runtime: " + stopwatch.Elapsed;
            stopwatch.Reset();

            stopwatch.Start();

            var newQry = tmp.Select(g => new
            {
                Id                    = g.GroupMember.Id,
                RegisteredBy          = new ModelValue <Person>(g.RegistrationRegistrant.Registration.PersonAlias.Person),
                Registrant            = new ModelValue <Person>(g.Person),
                Age                   = g.Person.Age,
                GraduationYear        = g.Person.GraduationYear,
                RegistrationId        = g.RegistrationRegistrant.RegistrationId,
                Group                 = new ModelValue <Rock.Model.Group>((Rock.Model.Group)g.GroupMember.Group),
                DOB                   = g.Person.BirthDate.HasValue ? g.Person.BirthDate.Value.ToShortDateString() : "",
                Address               = new ModelValue <Rock.Model.Location>((Rock.Model.Location)tmp2.Where(gm => gm.GroupMember.Id == g.GroupMember.Id).Select(gm => gm.Location).FirstOrDefault()),
                Email                 = g.Person.Email,
                Gender                = g.Person.Gender,         // (B & B Registration)
                GraduationYearProfile = g.Person.GraduationYear, // (Person Profile)
                HomePhone             = tmp2.Where(gm => gm.GroupMember.Id == g.GroupMember.Id).SelectMany(gm => gm.PhoneNumbers).Where(pn => pn.NumberTypeValue.Guid == Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME.AsGuid()).Select(pn => pn.NumberFormatted).FirstOrDefault(),
                CellPhone             = tmp2.Where(gm => gm.GroupMember.Id == g.GroupMember.Id).SelectMany(gm => gm.PhoneNumbers).Where(pn => pn.NumberTypeValue.Guid == Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_MOBILE.AsGuid()).Select(pn => pn.NumberFormatted).FirstOrDefault(),
                GroupMemberData       = new Func <GroupMemberAttributes>(() =>
                {
                    GroupMemberAttributes gma = new GroupMemberAttributes(g.GroupMember, g.Person, g.GroupMemberAttributeValues);
                    return(gma);
                })(),
                RegistrantData = new Func <RegistrantAttributes>(() =>
                {
                    RegistrantAttributes row = new RegistrantAttributes(g.RegistrationRegistrant, g.RegistrationAttributeValues);
                    return(row);
                })(),
                School              = string.IsNullOrEmpty(g.School)?"":DefinedValueCache.Read(g.School.AsGuid()) != null?DefinedValueCache.Read(g.School.AsGuid()).Value:"",
                LegalRelease        = tmp2.Where(gm => gm.GroupMember.Id == g.GroupMember.Id).SelectMany(gm => gm.SignatureDocuments).OrderByDescending(sd => sd.SignatureDocument.CreatedDateTime).Where(sd => signatureDocumentIds.Contains(sd.SignatureDocument.SignatureDocumentTemplateId)).Select(sd => sd.SignatureDocument.SignatureDocumentTemplate.Name + " (" + sd.SignatureDocument.Status.ToString() + ")").FirstOrDefault(),
                Departure           = g.GroupMemberAttributeValues.Where(av => av.AttributeKey == "Departure").Select(av => av.Value).FirstOrDefault(),
                Campus              = group.Campus,                                                                                                        //
                Role                = group.ParentGroup.GroupType.Name.Contains("Serving") || group.Name.ToLower().Contains("leader")? "Leader":"Student", //
                MSMGroup            = String.Join(", ", groupMemberService.Queryable().Where(gm => gm.PersonId == g.GroupMember.PersonId && gm.Group.GroupTypeId == hsmGroupTypeId && gm.GroupMemberStatus == GroupMemberStatus.Active).Select(gm => gm.Group.Name).ToList()),
                Person              = g.Person,
                AddressStreet       = tmp2.Where(gm => gm.GroupMember.Id == g.GroupMember.Id).Select(gm => gm.Location != null?gm.Location.Street1:"").FirstOrDefault(),
                AddressCityStateZip = tmp2.Where(gm => gm.GroupMember.Id == g.GroupMember.Id).Select(gm => gm.Location != null ? gm.Location.City + ", " + gm.Location.State + " " + gm.Location.PostalCode : "").FirstOrDefault(),

                RegistrantName = g.Person.FullName,
            }).OrderBy(w => w.Registrant.Model.LastName).ToList().AsQueryable();

            lStats.Text += "<br />Object Build Runtime: " + stopwatch.Elapsed;

            stopwatch.Stop();
            gReport.GetRecipientMergeFields += GReport_GetRecipientMergeFields;
            var mergeFields = new List <String>();

            mergeFields.Add("Id");
            mergeFields.Add("RegisteredBy");
            mergeFields.Add("Group");
            mergeFields.Add("Registrant");
            mergeFields.Add("Age");
            mergeFields.Add("GraduationYear");
            mergeFields.Add("DOB");
            mergeFields.Add("Address");
            mergeFields.Add("Email");
            mergeFields.Add("Gender");
            mergeFields.Add("GraduationYearProfile");
            mergeFields.Add("HomePhone");
            mergeFields.Add("CellPhone");
            mergeFields.Add("GroupMemberData");
            mergeFields.Add("RegistrantData");
            mergeFields.Add("LegalRelease");
            mergeFields.Add("Departure");
            mergeFields.Add("Campus");
            mergeFields.Add("Role");
            mergeFields.Add("MSMGroup");
            gReport.CommunicateMergeFields = mergeFields;

            /*
             * if (!String.IsNullOrWhiteSpace(GetUserPreference(string.Format("{0}POA", keyPrefix))))
             * {
             *  string poa = GetUserPreference(string.Format("{0}POA", keyPrefix));
             *  if (poa == "[Blank]")
             *  {
             *      poa = "";
             *  }
             *  newQry = newQry.Where(q => q.GroupMemberData.POA == poa);
             * }
             */

            SortProperty sortProperty = gReport.SortProperty;

            if (sortProperty != null)
            {
                gReport.SetLinqDataSource(newQry.Sort(sortProperty));
            }
            else
            {
                gReport.SetLinqDataSource(newQry.OrderBy(p => p.Registrant.Model.LastName));
            }
            gReport.DataBind();
        }
示例#7
0
        /// <summary>
        /// Gets the data to display.
        /// </summary>
        private void GetData()
        {
            var rockContext = new RockContext();
            var itemService = new ContentChannelItemService(rockContext);

            // Get all of the content channels
            var contentChannelsQry = new ContentChannelService(rockContext).Queryable("ContentChannelType").AsNoTracking();

            List <Guid> contentChannelGuidsFilter      = GetAttributeValue(AttributeKey.ContentChannelsFilter).SplitDelimitedValues().AsGuidList();
            List <Guid> contentChannelTypeGuidsInclude = GetAttributeValue(AttributeKey.ContentChannelTypesInclude).SplitDelimitedValues().AsGuidList();
            List <Guid> contentChannelTypeGuidsExclude = GetAttributeValue(AttributeKey.ContentChannelTypesExclude).SplitDelimitedValues().AsGuidList();

            if (contentChannelGuidsFilter.Any())
            {
                // if contentChannelGuidsFilter is specified, only get those content channels.
                // NOTE: This take precedence over all the other Include/Exclude settings.
                contentChannelsQry = contentChannelsQry.Where(a => contentChannelGuidsFilter.Contains(a.Guid));
            }
            else if (contentChannelTypeGuidsInclude.Any())
            {
                // if contentChannelTypeGuidsInclude is specified, only get contentChannelTypes that are in the contentChannelTypeGuidsInclude
                // NOTE: no need to factor in contentChannelTypeGuidsExclude since included would take precedence and the excluded ones would already not be included
                contentChannelsQry = contentChannelsQry.Where(a => contentChannelTypeGuidsInclude.Contains(a.ContentChannelType.Guid) || a.ContentChannelType.ShowInChannelList);
            }
            else if (contentChannelTypeGuidsExclude.Any())
            {
                contentChannelsQry = contentChannelsQry.Where(a => !contentChannelTypeGuidsExclude.Contains(a.ContentChannelType.Guid) && a.ContentChannelType.ShowInChannelList);
            }
            else
            {
                contentChannelsQry = contentChannelsQry.Where(a => a.ContentChannelType.ShowInChannelList);
            }


            if (GetAttributeValue(AttributeKey.ShowCategoryFilter).AsBoolean())
            {
                var categoryId         = ddlCategory.SelectedValueAsId();
                var parentCategoryGuid = GetAttributeValue(AttributeKey.ParentCategory).AsGuidOrNull();
                if (ddlCategory.Visible && categoryId.HasValue)
                {
                    contentChannelsQry = contentChannelsQry.Where(a => a.Categories.Any(c => c.Id == categoryId));
                }
                else if (parentCategoryGuid.HasValue)
                {
                    var parentCategoryId = CategoryCache.GetId(parentCategoryGuid.Value);
                    contentChannelsQry = contentChannelsQry.Where(a => a.Categories.Any(c => c.ParentCategoryId == parentCategoryId));
                }
            }

            var contentChannelsList = contentChannelsQry.OrderBy(w => w.Name).ToList();

            // Create variable for storing authorized channels and the count of active items
            var channelCounts = new Dictionary <int, int>();

            foreach (var channel in contentChannelsList)
            {
                if (channel.IsAuthorized(Authorization.VIEW, CurrentPerson))
                {
                    channelCounts.Add(channel.Id, 0);
                }
            }

            // Get the pending approval item counts for each channel (if the channel requires approval)
            itemService.Queryable()
            .Where(i =>
                   channelCounts.Keys.Contains(i.ContentChannelId) &&
                   i.Status == ContentChannelItemStatus.PendingApproval && i.ContentChannel.RequiresApproval)
            .GroupBy(i => i.ContentChannelId)
            .Select(i => new
            {
                Id    = i.Key,
                Count = i.Count()
            })
            .ToList()
            .ForEach(i => channelCounts[i.Id] = i.Count);

            // Create a query to return channel, the count of items, and the selected class
            var qry = contentChannelsList
                      .Where(c => channelCounts.Keys.Contains(c.Id))
                      .Select(c => new
            {
                Channel = c,
                Count   = channelCounts[c.Id],
                Class   = (SelectedChannelId.HasValue && SelectedChannelId.Value == c.Id) ? "active" : ""
            });

            // If displaying active only, update query to exclude those content channels without any items
            if (tglStatus.Checked)
            {
                qry = qry.Where(c => c.Count > 0);
            }

            var contentChannels = qry.ToList();

            rptChannels.DataSource = contentChannels;
            rptChannels.DataBind();

            ContentChannel selectedChannel = null;

            if (SelectedChannelId.HasValue)
            {
                selectedChannel = contentChannelsList
                                  .Where(w =>
                                         w.Id == SelectedChannelId.Value &&
                                         channelCounts.Keys.Contains(SelectedChannelId.Value))
                                  .FirstOrDefault();
            }

            if (selectedChannel != null && contentChannels.Count > 0)
            {
                // show the content item panel
                divItemPanel.Visible = true;

                BindAttributes(selectedChannel);
                AddDynamicControls(selectedChannel);

                bool isFiltered = false;
                var  items      = GetItems(rockContext, selectedChannel, out isFiltered);

                var reorderFieldColumn = gContentChannelItems.ColumnsOfType <ReorderField>().FirstOrDefault();

                if (selectedChannel.ItemsManuallyOrdered && !isFiltered)
                {
                    if (reorderFieldColumn != null)
                    {
                        reorderFieldColumn.Visible = true;
                    }

                    gContentChannelItems.AllowSorting = false;
                }
                else
                {
                    if (reorderFieldColumn != null)
                    {
                        reorderFieldColumn.Visible = false;
                    }

                    gContentChannelItems.AllowSorting = true;

                    SortProperty sortProperty = gContentChannelItems.SortProperty;
                    if (sortProperty != null)
                    {
                        items = items.AsQueryable().Sort(sortProperty).ToList();
                    }
                    else
                    {
                        items = items.OrderByDescending(p => p.StartDateTime).ToList();
                    }
                }

                // Find any possible tags for the items
                var itemTags = new Dictionary <Guid, string>();
                if (selectedChannel.IsTaggingEnabled)
                {
                    itemTags = items.ToDictionary(i => i.Guid, v => "");
                    var entityTypeId = EntityTypeCache.Get(Rock.SystemGuid.EntityType.CONTENT_CHANNEL_ITEM.AsGuid()).Id;
                    var testedTags   = new Dictionary <int, string>();

                    foreach (var taggedItem in new TaggedItemService(rockContext)
                             .Queryable().AsNoTracking()
                             .Where(i =>
                                    i.EntityTypeId == entityTypeId &&
                                    itemTags.Keys.Contains(i.EntityGuid))
                             .OrderBy(i => i.Tag.Name))
                    {
                        if (!testedTags.ContainsKey(taggedItem.TagId))
                        {
                            testedTags.Add(taggedItem.TagId, taggedItem.Tag.IsAuthorized(Authorization.VIEW, CurrentPerson) ? taggedItem.Tag.Name : string.Empty);
                        }

                        if (testedTags[taggedItem.TagId].IsNotNullOrWhiteSpace())
                        {
                            itemTags[taggedItem.EntityGuid] += string.Format("<span class='tag'>{0}</span>", testedTags[taggedItem.TagId]);
                        }
                    }
                }

                gContentChannelItems.ObjectList = new Dictionary <string, object>();
                items.ForEach(i => gContentChannelItems.ObjectList.Add(i.Id.ToString(), i));

                var gridList = items.Select(i => new
                {
                    i.Id,
                    i.Guid,
                    i.Title,
                    i.StartDateTime,
                    i.ExpireDateTime,
                    i.Priority,
                    Status              = DisplayStatus(i.Status),
                    Tags                = itemTags.GetValueOrNull(i.Guid),
                    Occurrences         = i.EventItemOccurrences.Any(),
                    CreatedByPersonName = i.CreatedByPersonAlias != null ? String.Format("<a href={0}>{1}</a>", ResolveRockUrl(string.Format("~/Person/{0}", i.CreatedByPersonAlias.PersonId)), i.CreatedByPersonName) : String.Empty
                }).ToList();

                // only show the Event Occurrences item if any of the displayed content channel items have any occurrences (and the block setting is enabled)
                var eventOccurrencesColumn = gContentChannelItems.ColumnsWithDataField("Occurrences").FirstOrDefault();
                eventOccurrencesColumn.Visible = gridList.Any(a => a.Occurrences == true);

                gContentChannelItems.DataSource = gridList;
                gContentChannelItems.DataBind();

                lContentChannelItems.Text = selectedChannel.Name + " Items";
            }
            else
            {
                divItemPanel.Visible = false;
            }
        }
示例#8
0
        public XPCursor GetCursor(int pagesize)
        {
            SortingCollection sortingCollection = Sorting;
            var sortProperties = new SortProperty[Sorting.Count];
            for (int i = 0; i < sortProperties.Length; i++)
                sortProperties[i] = sortingCollection[i];

            var xpCursor = new XPCursor(Session, ObjectType, Criteria, sortProperties) {PageSize = pagesize};
            return xpCursor;
        }
        /// <summary>
        /// Binds the group members grid.
        /// </summary>
        protected void BindGrid()
        {
            if (_group != null)
            {
                lHeading.Text = _group.Name;

                DateTime?  fromDateTime = drpDates.LowerValue;
                DateTime?  toDateTime   = drpDates.UpperValue;
                List <int> locationIds  = new List <int>();
                List <int> scheduleIds  = new List <int>();

                // Location Filter
                if (ddlLocation.Visible)
                {
                    string locValue = ddlLocation.SelectedValue;
                    if (locValue.StartsWith("P"))
                    {
                        int?parentLocationId = locValue.Substring(1).AsIntegerOrNull();
                        if (parentLocationId.HasValue)
                        {
                            locationIds = new LocationService(_rockContext)
                                          .GetAllDescendents(parentLocationId.Value)
                                          .Select(l => l.Id)
                                          .ToList();
                        }
                    }
                    else
                    {
                        int?locationId = locValue.AsIntegerOrNull();
                        if (locationId.HasValue)
                        {
                            locationIds.Add(locationId.Value);
                        }
                    }
                }

                // Schedule Filter
                if (ddlSchedule.Visible && ddlSchedule.SelectedValue != "0")
                {
                    scheduleIds.Add(ddlSchedule.SelectedValueAsInt() ?? 0);
                }

                var qry = new ScheduleService(_rockContext)
                          .GetGroupOccurrences(_group, fromDateTime, toDateTime, locationIds, scheduleIds, true, bddlCampus.SelectedValueAsInt())
                          .AsQueryable();

                SortProperty sortProperty             = gOccurrences.SortProperty;
                List <ScheduleOccurrence> occurrences = null;
                if (sortProperty != null)
                {
                    occurrences = qry.Sort(sortProperty).ToList();
                }
                else
                {
                    occurrences = qry.OrderByDescending(a => a.Date).ThenByDescending(a => a.StartTime).ToList();
                }

                gOccurrences.DataSource = occurrences;
                gOccurrences.DataBind();
            }
        }
        /// <summary>
        /// Binds the grid.
        /// </summary>
        private void BindGrid()
        {
            var personAliasEntityType = EntityTypeCache.Read("Rock.Model.PersonAlias");

            if (personAliasEntityType != null && CurrentPersonAlias != null)
            {
                var rockContext = new RockContext();

                // PersonAlias query for joining the followed entity id to
                var personAliasQry = new PersonAliasService(rockContext).Queryable();

                // Get all the people that the current person currently follows
                var followedPersonIds = new FollowingService(rockContext).Queryable()
                                        .Where(f =>
                                               f.EntityTypeId == personAliasEntityType.Id &&
                                               f.PersonAliasId == CurrentPersonAlias.Id)
                                        .Join(personAliasQry, s => s.EntityId, p => p.Id, (s, p) => p.PersonId)
                                        .Distinct();

                // Get all the person suggestions for the current person that they are not already following
                var qry = new FollowingSuggestedService(rockContext)
                          .Queryable("SuggestionType")
                          .Where(s =>
                                 s.SuggestionType != null &&
                                 s.EntityTypeId == personAliasEntityType.Id &&
                                 s.PersonAliasId == CurrentPersonAlias.Id)
                          .Join(personAliasQry, s => s.EntityId, p => p.Id, (s, p) => new { s, p })
                          .Where(j => !followedPersonIds.Contains(j.p.PersonId))
                          .Select(j => new
                {
                    j.s.Id,
                    j.s.LastPromotedDateTime,
                    j.s.StatusChangedDateTime,
                    j.s.SuggestionType.ReasonNote,
                    j.s.Status,
                    Person   = j.p.Person,
                    LastName = j.p.Person.LastName,
                    NickName = j.p.Person.NickName
                });

                // Sort the result
                SortProperty sortProperty = gSuggestions.SortProperty;
                if (sortProperty == null)
                {
                    sortProperty = new SortProperty(new GridViewSortEventArgs("LastName,NickName", SortDirection.Ascending));
                }

                // Bind grid to the query
                gSuggestions.DataSource = qry.Sort(sortProperty)
                                          .Select(s => new
                {
                    s.Id,
                    s.LastPromotedDateTime,
                    s.StatusChangedDateTime,
                    s.ReasonNote,
                    s.Status,
                    StatusLabel = s.Status == FollowingSuggestedStatus.Ignored ?
                                  "<span class='label label-warning'>Ignored</span>" :
                                  "<span class='label label-success'>Suggested</span>",
                    s.Person,
                    s.LastName,
                    s.NickName
                })
                                          .ToList();

                gSuggestions.DataBind();
            }
        }
示例#11
0
        /// <summary>
        /// Binds the grid.
        /// </summary>
        private void BindGrid()
        {
            var queryable = new FinancialTransactionService().Queryable();

            // Set up the selection filter
            if (_batch != null)
            {
                // If transactions are for a batch, the filter is hidden so only check the batch id
                queryable = queryable.Where(t => t.BatchId.HasValue && t.BatchId.Value == _batch.Id);
            }
            else
            {
                // otherwise set the selection based on filter settings
                if (_person != null)
                {
                    queryable = queryable.Where(t => t.AuthorizedPersonId == _person.Id);
                }

                // Date Range
                var drp = new DateRangePicker();
                drp.DelimitedValues = rFilter.GetUserPreference("Date Range");
                if (drp.LowerValue.HasValue)
                {
                    queryable = queryable.Where(t => t.TransactionDateTime >= drp.LowerValue.Value);
                }
                if (drp.UpperValue.HasValue)
                {
                    DateTime upperDate = drp.UpperValue.Value.Date.AddDays(1);
                    queryable = queryable.Where(t => t.TransactionDateTime < upperDate);
                }

                // Amount Range
                var nre = new NumberRangeEditor();
                nre.DelimitedValues = rFilter.GetUserPreference("Amount Range");
                if (nre.LowerValue.HasValue)
                {
                    queryable = queryable.Where(t => t.Amount >= nre.LowerValue.Value);
                }
                if (nre.UpperValue.HasValue)
                {
                    queryable = queryable.Where(t => t.Amount <= nre.UpperValue.Value);
                }

                // Transaction Code
                string transactionCode = rFilter.GetUserPreference("Transaction Code");
                if (!string.IsNullOrWhiteSpace(transactionCode))
                {
                    queryable = queryable.Where(t => t.TransactionCode == transactionCode.Trim());
                }

                // Account Id
                int accountId = int.MinValue;
                if (int.TryParse(rFilter.GetUserPreference("Account"), out accountId))
                {
                    queryable = queryable.Where(t => t.TransactionDetails.Any(d => d.AccountId == accountId));
                }

                // Transaction Type
                int transactionTypeId = int.MinValue;
                if (int.TryParse(rFilter.GetUserPreference("Transaction Type"), out transactionTypeId))
                {
                    queryable = queryable.Where(t => t.TransactionTypeValueId == transactionTypeId);
                }

                // Currency Type
                int currencyTypeId = int.MinValue;
                if (int.TryParse(rFilter.GetUserPreference("Currency Type"), out currencyTypeId))
                {
                    queryable = queryable.Where(t => t.CurrencyTypeValueId == currencyTypeId);
                }

                // Credit Card Type
                int creditCardTypeId = int.MinValue;
                if (int.TryParse(rFilter.GetUserPreference("Credit Card Type"), out creditCardTypeId))
                {
                    queryable = queryable.Where(t => t.CreditCardTypeValueId == creditCardTypeId);
                }

                // Source Type
                int sourceTypeId = int.MinValue;
                if (int.TryParse(rFilter.GetUserPreference("Source Type"), out sourceTypeId))
                {
                    queryable = queryable.Where(t => t.SourceTypeValueId == sourceTypeId);
                }
            }

            SortProperty sortProperty = rGridTransactions.SortProperty;

            if (sortProperty != null)
            {
                queryable = queryable.Sort(sortProperty);
            }
            else
            {
                queryable = queryable.OrderBy(t => t.TransactionDateTime);
            }

            rGridTransactions.DataSource = queryable.AsNoTracking().ToList();
            rGridTransactions.DataBind();
        }
        /// <summary>
        /// Вызов приватного метода ReportServiceController.ShowReportPreview()
        /// Public Morozov
        /// </summary>
        /// <param name="reportContainerHandle"></param>
        /// <param name="parametersObject"></param>
        /// <param name="criteria"></param>
        /// <param name="canApplyCriteria"></param>
        /// <param name="sortProperty"></param>
        /// <param name="canApplySortProperty"></param>
        /// <param name="showViewParameters"></param>
        private void ShowReportPreview(string reportContainerHandle, ReportParametersObjectBase parametersObject, CriteriaOperator criteria, bool canApplyCriteria, SortProperty[] sortProperty, bool canApplySortProperty, ShowViewParameters showViewParameters)
        {
            var reportController = Frame.GetController<ReportServiceController>();
            Guard.ArgumentNotNull(reportController, "reportController");

            reportController.ShowPreview(reportContainerHandle, parametersObject, criteria, canApplyCriteria, sortProperty, canApplySortProperty, showViewParameters);
        }
    /// <summary>
    /// Übernimmt die Sortiereinstellungen und sortiert die Daten.
    /// </summary>
    /// <param name="sortProp"></param>
    /// <param name="sortDirectionAsc"></param>
    public void Sort(SortProperty sortProp, bool sortDirectionAsc)
    {
      this.sortProperty = sortProp;
      this.sortDirectionAsc = sortDirectionAsc;
      // Das Sortieren der Verzeichnisse ist noch nicht implementiert.
      SortFiles();

      // Sortierkriterien an die Unterverzeichnisse weitergeben.
      if (this.subDirectories != null)
      {
        foreach (DirectoryWrapper dir in this.subDirectories)
          dir.Sort(sortProp, sortDirectionAsc);
      }
    }
示例#14
0
        /// <summary>
        /// Binds the group members grid.
        /// </summary>
        protected void BindGroupMembersGrid()
        {
            if (_group != null)
            {
                pnlGroupMembers.Visible = true;

                lHeading.Text = string.Format("{0} {1}", _group.GroupType.GroupTerm, _group.GroupType.GroupMemberTerm.Pluralize());

                if (_group.GroupType.Roles.Any())
                {
                    nbRoleWarning.Visible = false;
                    rFilter.Visible       = true;
                    gGroupMembers.Visible = true;

                    var rockContext = new RockContext();

                    GroupMemberService groupMemberService = new GroupMemberService(rockContext);
                    var qry = groupMemberService.Queryable("Person,GroupRole", true)
                              .Where(m => m.GroupId == _group.Id);

                    // Filter by First Name
                    string firstName = tbFirstName.Text;
                    if (!string.IsNullOrWhiteSpace(firstName))
                    {
                        qry = qry.Where(m => m.Person.FirstName.StartsWith(firstName));
                    }

                    // Filter by Last Name
                    string lastName = tbLastName.Text;
                    if (!string.IsNullOrWhiteSpace(lastName))
                    {
                        qry = qry.Where(m => m.Person.LastName.StartsWith(lastName));
                    }

                    // Filter by role
                    var validGroupTypeRoles = _group.GroupType.Roles.Select(r => r.Id).ToList();
                    var roles = new List <int>();
                    foreach (string role in cblRole.SelectedValues)
                    {
                        if (!string.IsNullOrWhiteSpace(role))
                        {
                            int roleId = int.MinValue;
                            if (int.TryParse(role, out roleId) && validGroupTypeRoles.Contains(roleId))
                            {
                                roles.Add(roleId);
                            }
                        }
                    }
                    if (roles.Any())
                    {
                        qry = qry.Where(m => roles.Contains(m.GroupRoleId));
                    }

                    // Filter by Status
                    var statuses = new List <GroupMemberStatus>();
                    foreach (string status in cblStatus.SelectedValues)
                    {
                        if (!string.IsNullOrWhiteSpace(status))
                        {
                            statuses.Add(status.ConvertToEnum <GroupMemberStatus>());
                        }
                    }
                    if (statuses.Any())
                    {
                        qry = qry.Where(m => statuses.Contains(m.GroupMemberStatus));
                    }

                    // Filter query by any configured attribute filters
                    if (AvailableAttributes != null && AvailableAttributes.Any())
                    {
                        var attributeValueService = new AttributeValueService(rockContext);
                        var parameterExpression   = attributeValueService.ParameterExpression;

                        foreach (var attribute in AvailableAttributes)
                        {
                            var filterControl = phAttributeFilters.FindControl("filter_" + attribute.Id.ToString());
                            if (filterControl != null)
                            {
                                var filterValues = attribute.FieldType.Field.GetFilterValues(filterControl, attribute.QualifierValues);
                                var expression   = attribute.FieldType.Field.AttributeFilterExpression(attribute.QualifierValues, filterValues, parameterExpression);
                                if (expression != null)
                                {
                                    var attributeValues = attributeValueService
                                                          .Queryable()
                                                          .Where(v => v.Attribute.Id == attribute.Id);

                                    attributeValues = attributeValues.Where(parameterExpression, expression, null);

                                    qry = qry.Where(w => attributeValues.Select(v => v.EntityId).Contains(w.Id));
                                }
                            }
                        }
                    }


                    _inactiveStatus = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE);

                    SortProperty sortProperty = gGroupMembers.SortProperty;

                    List <GroupMember> groupMembers = null;

                    if (sortProperty != null)
                    {
                        groupMembers = qry.Sort(sortProperty).ToList();
                    }
                    else
                    {
                        groupMembers = qry.OrderBy(a => a.GroupRole.Order).ThenBy(a => a.Person.LastName).ThenBy(a => a.Person.FirstName).ToList();
                    }

                    // Since we're not binding to actual group member list, but are using AttributeField columns,
                    // we need to save the workflows into the grid's object list
                    gGroupMembers.ObjectList = new Dictionary <string, object>();
                    groupMembers.ForEach(m => gGroupMembers.ObjectList.Add(m.Id.ToString(), m));

                    gGroupMembers.DataSource = groupMembers.Select(m => new
                    {
                        m.Id,
                        m.Guid,
                        m.PersonId,
                        Name      = m.Person.NickName + " " + m.Person.LastName,
                        GroupRole = m.GroupRole.Name,
                        m.GroupMemberStatus
                    }).ToList();

                    gGroupMembers.DataBind();
                }
                else
                {
                    nbRoleWarning.Text = string.Format(
                        "{0} cannot be added to this {1} because the '{2}' group type does not have any roles defined.",
                        _group.GroupType.GroupMemberTerm.Pluralize(),
                        _group.GroupType.GroupTerm,
                        _group.GroupType.Name);

                    nbRoleWarning.Visible = true;
                    rFilter.Visible       = false;
                    gGroupMembers.Visible = false;
                }
            }
            else
            {
                pnlGroupMembers.Visible = false;
            }
        }
示例#15
0
        private IQueryable <CommunionData> getQuery <T>()
        {
            using (var rockContext = new RockContext())
            {
                var workflowService       = new WorkflowService(rockContext);
                var attributeService      = new AttributeService(rockContext);
                var attributeValueService = new AttributeValueService(rockContext);
                var personAliasService    = new PersonAliasService(rockContext);
                var personService         = new PersonService(rockContext);
                var definedValueService   = new DefinedValueService(rockContext);

                Guid hospitalWorkflow             = GetAttributeValue("HospitalAdmissionWorkflow").AsGuid();
                Guid nursingHomeAdmissionWorkflow = GetAttributeValue("NursingHomeResidentWorkflow").AsGuid();
                Guid homeBoundPersonWorkflow      = GetAttributeValue("HomeboundPersonWorkflow").AsGuid();
                Guid hospitalList    = GetAttributeValue("HospitalList").AsGuid();
                Guid nursingHomeList = GetAttributeValue("NursingHomeList").AsGuid();

                var workflowTypesIdAsStrings = new WorkflowTypeService(rockContext).Queryable()
                                               .Where(wt =>
                                                      wt.Guid == hospitalWorkflow ||
                                                      wt.Guid == nursingHomeAdmissionWorkflow ||
                                                      wt.Guid == homeBoundPersonWorkflow
                                                      )
                                               .ToList()
                                               .Select(wf => wf.Id.ToString())
                                               .ToList();

                var attributeIds = attributeService.Queryable()
                                   .Where(a => a.EntityTypeQualifierColumn == "WorkflowTypeId" && workflowTypesIdAsStrings.Contains(a.EntityTypeQualifierValue))
                                   .Select(a => a.Id).ToList();

                var wfTmpqry = workflowService.Queryable().AsNoTracking()
                               .Where(w => (
                                          w.WorkflowType.Guid == hospitalWorkflow ||
                                          w.WorkflowType.Guid == nursingHomeAdmissionWorkflow ||
                                          w.WorkflowType.Guid == homeBoundPersonWorkflow
                                          ) && (w.Status == "Active"));

                var tqry = wfTmpqry.Join(attributeValueService.Queryable(),
                                         obj => obj.Id,
                                         av => av.EntityId.Value,
                                         (obj, av) => new { Workflow = obj, AttributeValue = av })
                           .Where(a => attributeIds.Contains(a.AttributeValue.AttributeId))
                           .GroupBy(obj => obj.Workflow)
                           .Select(obj => new { Workflow = obj.Key, AttributeValues = obj.Select(a => a.AttributeValue) });
                var qry = tqry.ToList();


                List <DefinedValue> facilities = definedValueService.Queryable().Where(dv => dv.DefinedType.Guid == hospitalList || dv.DefinedType.Guid == nursingHomeList).ToList();
                facilities.ForEach(h =>
                {
                    h.LoadAttributes();
                });

                var newQry = qry.Select(w => new CommunionData
                {
                    Campus = new Func <Campus>(() =>
                    {
                        Campus campus = null;
                        AttributeValue personAliasAV = w.AttributeValues.AsQueryable().Where(av => av.AttributeKey == "PersonToVisit" || av.AttributeKey == "HomeboundPerson").FirstOrDefault();
                        if (personAliasAV != null)
                        {
                            PersonAlias pa = personAliasService.Get(personAliasAV.Value.AsGuid());
                            if (pa != null)
                            {
                                campus = pa.Person.GetCampus();
                            }
                        }
                        if (campus == null)
                        {
                            campus = new Campus()
                            {
                                Name = "Unknown"
                            };
                        }
                        return(campus);
                    })(),
                    Person      = GetPerson(personAliasService, w.AttributeValues),
                    Age         = GetPerson(personAliasService, w.AttributeValues).Age,
                    Description = w.AttributeValues.AsQueryable().Where(av => av.AttributeKey == "VisitationRequestDescription" || av.AttributeKey == "HomeboundResidentDescription").Select(av => av.ValueFormatted).FirstOrDefault(),
                    Location    = new Func <string>(() =>
                    {
                        return(w.AttributeValues.AsQueryable().Where(av => av.AttributeKey == "NursingHome" || av.AttributeKey == "Hospital").Select(av => av.ValueFormatted).DefaultIfEmpty("Home").FirstOrDefault());
                    })(),
                    Address        = GetLocation(personService, w.AttributeValues, facilities).Street1 + " " + GetLocation(personService, w.AttributeValues, facilities).Street2,
                    City           = GetLocation(personService, w.AttributeValues, facilities).City,
                    State          = GetLocation(personService, w.AttributeValues, facilities).State,
                    PostalCode     = GetLocation(personService, w.AttributeValues, facilities).PostalCode,
                    FacilityNumber = GetFacilityNumber(personService, w.AttributeValues, facilities),
                    Room           = w.AttributeValues.AsQueryable().Where(av => av.AttributeKey == "Room").Select(av => av.ValueFormatted).FirstOrDefault(),
                    AdmitDate      = w.AttributeValues.AsQueryable().Where(av => av.AttributeKey == "AdmitDate" || av.AttributeKey == "StartDate").Select(av => av.ValueFormatted).FirstOrDefault(),
                    Status         = w.Workflow.Status,
                    Communion      = w.AttributeValues.AsQueryable().Where(av => av.AttributeKey == "Communion").FirstOrDefault().ValueFormatted
                })
                             .Where(o => o.Communion.AsBoolean() && !o.Person.IsDeceased)
                             .OrderBy(a => a.PostalCode)
                             .ThenBy(a => a.Address)
                             .ToList()
                             .AsQueryable();


                List <COMMUNION_STATES> states = cblState.Items.Cast <ListItem>().Where(i => i.Selected).Select(i => ( COMMUNION_STATES )int.Parse(i.Value)).ToList();

                if (states.Count > 0)
                {
                    newQry = newQry.Where(o => (states.Contains(COMMUNION_STATES.KY) && o.State == "KY") ||
                                          (states.Contains(COMMUNION_STATES.IN) && o.State == "IN") ||
                                          ((states.Contains(COMMUNION_STATES.Other) && o.State != "IN" && o.State != "KY")));
                }
                List <int> campuses = cpCampus.Items.Cast <ListItem>().Where(i => i.Selected).Select(i => int.Parse(i.Value)).ToList();

                if (campuses.Count > 0)
                {
                    newQry = newQry.Where(o => campuses.Contains(o.Campus.Id));
                }


                //AddGridColumns( newQry.FirstOrDefault() );

                SortProperty sortProperty = gReport.SortProperty;
                if (sortProperty != null)
                {
                    newQry = newQry.Sort(sortProperty);
                }

                return(newQry);
            }
        }
示例#16
0
        private void BindRequisitionGrid()
        {
            ConfigureRequisitionGrid();
            List <RequisitionListItem> Requisitions = GetRequisitions();

            SortProperty sortProperty = dgRequisitions.SortProperty;

            // Check User Preferences to see if we have a pre-existing sort property
            if (sortProperty == null)
            {
                sortProperty           = new SortProperty();
                sortProperty.Direction = GetUserPreference(string.Format("{0}_Sort_Direction", PersonSettingsKeyPrefix)) == "ASC"? SortDirection.Ascending: SortDirection.Descending;
                sortProperty.Property  = GetUserPreference(string.Format("{0}_Sort_Column", PersonSettingsKeyPrefix));
                if (string.IsNullOrEmpty(sortProperty.Property))
                {
                    sortProperty.Property = "DateSubmitted";
                }
            }
            if (sortProperty != null)
            {
                if (sortProperty.Property == "DateSubmitted")
                {
                    if (sortProperty.Direction == SortDirection.Ascending)
                    {
                        Requisitions = Requisitions.OrderBy(r => r.DateSubmitted).ThenBy(r => r.DateCreated).ToList();
                    }
                    else
                    {
                        Requisitions = Requisitions.OrderByDescending(r => r.DateSubmitted).ThenByDescending(r => r.DateCreated).ToList();
                    }
                }
                else
                {
                    if (sortProperty.Direction == SortDirection.Ascending)
                    {
                        Requisitions = Requisitions.OrderBy(r => r.GetType().GetProperty(sortProperty.Property).GetValue(r)).ToList();
                    }
                    else
                    {
                        Requisitions = Requisitions.OrderByDescending(r => r.GetType().GetProperty(sortProperty.Property).GetValue(r)).ToList();
                    }
                }
                SetUserPreference(string.Format("{0}_Sort_Direction", PersonSettingsKeyPrefix), sortProperty.DirectionString);
                SetUserPreference(string.Format("{0}_Sort_Column", PersonSettingsKeyPrefix), sortProperty.Property);
            }
            else
            {
                Requisitions = Requisitions.OrderByDescending(r => r.DateSubmitted).ThenByDescending(r => r.DateCreated).ToList();
            }

            DataTable dt = new DataTable("Requisitions");

            dt.Columns.AddRange(
                new DataColumn[] {
                new DataColumn("RequisitionID", typeof(int)),
                new DataColumn("Title", typeof(string)),
                new DataColumn("RequesterID", typeof(int)),
                new DataColumn("Requester_Last_First", typeof(string)),
                new DataColumn("Status", typeof(string)),
                new DataColumn("RequisitionType", typeof(string)),
                new DataColumn("ItemCount", typeof(int)),
                new DataColumn("NoteCount", typeof(int)),
                new DataColumn("AttachmentCount", typeof(int)),
                new DataColumn("DateSubmitted", typeof(DateTime)),
                new DataColumn("IsExpedited", typeof(bool)),
                new DataColumn("IsApproved", typeof(bool)),
                new DataColumn("IsAccepted", typeof(bool))
            });

            var statuses       = Requisition.GetStatuses(true);
            int submittedOrder = statuses.Where(s => s.Value == "Submitted to Purchasing").Select(s => s.Order).FirstOrDefault();

            foreach (RequisitionListItem item in Requisitions)
            {
                DataRow dr = dt.NewRow();

                dr["RequisitionID"]        = item.RequisitionID;
                dr["Title"]                = item.Title;
                dr["RequesterID"]          = item.RequesterID;
                dr["Requester_Last_First"] = item.RequesterLastFirst;
                dr["Status"]               = item.Status;
                dr["RequisitionType"]      = item.RequisitionType;
                dr["ItemCount"]            = item.ItemCount;
                dr["NoteCount"]            = item.NoteCount;
                dr["AttachmentCount"]      = item.AttachmentCount;
                if (item.DateSubmitted != null && statuses.Where(s => s.Value == item.Status).Select(s => s.Order).FirstOrDefault() >= submittedOrder)
                {
                    dr["DateSubmitted"] = item.DateSubmitted;
                }
                else
                {
                    dr["DateSubmitted"] = item.DateCreated;
                }
                dr["IsExpedited"] = item.IsExpedited;
                dr["IsApproved"]  = item.IsApproved;
                dr["IsAccepted"]  = item.IsAccepted;

                dt.Rows.Add(dr);
            }


            dgRequisitions.DataSource = dt;
            dgRequisitions.DataBind();
            if (sortProperty != null)
            {
                foreach (var column in dgRequisitions.Columns)
                {
                    var dcf = column as DataControlField;
                    if (dcf != null && dcf.SortExpression == sortProperty.Property)
                    {
                        dgRequisitions.HeaderRow.Cells[dgRequisitions.Columns.IndexOf(dcf)].AddCssClass(sortProperty.Direction.ToString().ToLower());
                        break;
                    }
                }
                if (dgRequisitions.SortProperty == null)
                {
                    dgRequisitions.Sort(sortProperty.Property, sortProperty.Direction);
                }
            }
        }
        /// <summary>
        /// Binds the grid.
        /// </summary>
        private void BindGrid()
        {
            if (CurrentPersonAlias != null)
            {
                var rockContext = new RockContext();

                int personAliasEntityTypeId = EntityTypeCache.Read("Rock.Model.PersonAlias").Id;
                var personAliasIds          = new FollowingService(rockContext).Queryable()
                                              .Where(f =>
                                                     f.EntityTypeId == personAliasEntityTypeId &&
                                                     f.PersonAliasId == CurrentPersonAlias.Id)
                                              .Select(f => f.EntityId)
                                              .Distinct()
                                              .ToList();

                var qry = new PersonAliasService(rockContext).Queryable()
                          .Where(p => personAliasIds.Contains(p.Id))
                          .Select(p => p.Person)
                          .Distinct();

                // Sort
                SortProperty sortProperty = gFollowings.SortProperty;
                if (sortProperty == null)
                {
                    sortProperty = new SortProperty(new GridViewSortEventArgs("LastName,NickName", SortDirection.Ascending));
                }

                Guid homePhoneGuid = Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME.AsGuid();
                Guid cellPhoneGuid = Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_MOBILE.AsGuid();
                Guid adultGuid     = Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid();
                Guid marriedGuid   = Rock.SystemGuid.DefinedValue.PERSON_MARITAL_STATUS_MARRIED.AsGuid();

                gFollowings.DataSource = qry.Sort(sortProperty)
                                         .Select(p => new
                {
                    Person = p,
                    p.Id,
                    p.LastName,
                    p.NickName,
                    p.BirthDate,
                    p.Email,
                    HomePhone = p.PhoneNumbers
                                .Where(n => n.NumberTypeValue.Guid.Equals(homePhoneGuid))
                                .Select(n => n.NumberFormatted)
                                .FirstOrDefault(),
                    CellPhone = p.PhoneNumbers
                                .Where(n => n.NumberTypeValue.Guid.Equals(cellPhoneGuid))
                                .Select(n => n.NumberFormatted)
                                .FirstOrDefault(),
                    Spouse = p.Members
                             .Where(m =>
                                    p.MaritalStatusValue.Guid.Equals(marriedGuid) &&
                                    m.GroupRole.Guid.Equals(adultGuid))
                             .SelectMany(m => m.Group.Members)
                             .Where(m =>
                                    m.PersonId != p.Id &&
                                    m.GroupRole.Guid.Equals(adultGuid) &&
                                    m.Person.MaritalStatusValue.Guid.Equals(marriedGuid))
                             .Select(s => s.Person)
                             .FirstOrDefault()
                }).ToList();

                gFollowings.DataBind();
            }
        }
示例#18
0
 void IBindingList.ApplySort(PropertyDescriptor memberDescriptor, ListSortDirection direction)
 {
     sorting.Clear();
     SortProperty sortProperty = new SortProperty(memberDescriptor.Name, (direction == ListSortDirection.Ascending) ? SortingDirection.Ascending : SortingDirection.Descending);
     sorting.Add(sortProperty);
     ClearObjects();
     RaiseListChangedEvent(new ListChangedEventArgs(ListChangedType.Reset, 0));
 }
        /// <summary>
        /// Binds the grid.
        /// </summary>
        protected void BindGrid()
        {
            var attendanceService = new AttendanceService(new RockContext());
            var attendanceQuery   = attendanceService.Queryable();

            if (_person != null)
            {
                attendanceQuery = attendanceQuery.Where(a => a.PersonId == _person.Id);
            }
            else if (_group != null)
            {
                attendanceQuery = attendanceQuery.Where(a => a.GroupId == _group.Id);
            }

            var attendanceList = attendanceQuery.ToList();
            var qry            = attendanceList.AsQueryable()
                                 .Select(a => new
            {
                Location      = a.Location,
                Schedule      = a.Schedule,
                FullName      = a.Person.FullName,
                Group         = a.Group,
                StartDateTime = a.StartDateTime,
                EndDateTime   = a.EndDateTime
            });

            // Filter by Date Range
            var drp = new DateRangePicker();

            drp.DelimitedValues = rFilter.GetUserPreference("Date Range");
            if (drp.LowerValue.HasValue)
            {
                qry = qry.Where(t => t.StartDateTime >= drp.LowerValue.Value);
            }
            if (drp.UpperValue.HasValue)
            {
                DateTime upperDate = drp.UpperValue.Value.Date.AddDays(1);
                qry = qry.Where(t => t.EndDateTime < upperDate);
            }

            // Filter by Person
            if (ddlPeople.SelectedIndex > 0)
            {
                if (ddlPeople.SelectedValue.ToLower() != "all")
                {
                    qry = qry.Where(h => h.FullName == ddlPeople.SelectedValue);
                }
            }

            // Filter by Group
            if (ddlGroups.SelectedIndex > 0)
            {
                if (ddlGroups.SelectedValue.ToLower() != "all")
                {
                    qry = qry.Where(h => h.Group.Name == ddlGroups.SelectedValue);
                }
            }

            // Filter by Schedule
            if (ddlSchedules.SelectedIndex > 0)
            {
                if (ddlSchedules.SelectedValue.ToLower() != "all")
                {
                    qry = qry.Where(h => h.Schedule.Name == ddlSchedules.SelectedValue);
                }
            }

            SortProperty sortProperty = gHistory.SortProperty;

            if (sortProperty != null)
            {
                qry = qry.Sort(sortProperty);
            }
            else
            {
                qry = qry.OrderByDescending(p => p.StartDateTime);
            }

            gHistory.DataSource = qry.ToList();
            gHistory.DataBind();
        }
示例#20
0
        private List <MedicalItem> GetMedicalItems(bool overrideHideDistributed = false)
        {
            RockContext                rockContext                = new RockContext();
            GroupService               groupService               = new GroupService(rockContext);
            AttributeMatrixService     attributeMatrixService     = new AttributeMatrixService(rockContext);
            AttributeValueService      attributeValueService      = new AttributeValueService(rockContext);
            AttributeMatrixItemService attributeMatrixItemService = new AttributeMatrixItemService(rockContext);
            NoteService                noteService                = new NoteService(rockContext);

            var groupIdStrings = GetAttributeValue("GroupIds").SplitDelimitedValues();
            var groupIds       = new List <int>();

            foreach (var id in groupIdStrings)
            {
                groupIds.Add(id.AsInteger());
            }

            var groups = groupService.GetByIds(groupIds);

            if (cpCampus.SelectedCampusId != null && cpCampus.SelectedCampusId != 0)
            {
                groups = groups.Where(g => g.CampusId == cpCampus.SelectedCampusId);
            }

            var groupTypeIds = groups.ToList().Select(g => g.GroupTypeId.ToString()).Distinct();

            var personEntityid      = EntityTypeCache.GetId <Rock.Model.Person>().Value;
            var groupMemberEntityid = EntityTypeCache.GetId <Rock.Model.GroupMember>().Value;
            var key = GetAttributeValue("MedicationMatrixKey");

            var days       = GetAttributeValue(AttributeKey.Days).AsIntegerOrNull() ?? 14;
            var cutoffDate = Rock.RockDateTime.Today.AddDays(-days);

            var lastMedicationCheckinAttribute = AttributeCache.Get(Constants.PERSON_ATTRIBUTE_LASTMEDICATIONCHECKIN.AsGuid());


            var allowedPersonIds = attributeValueService.GetByAttributeId(lastMedicationCheckinAttribute.Id)
                                   .Where(av => av.ValueAsDateTime != null && av.ValueAsDateTime >= cutoffDate)
                                   .Select(av => av.EntityId);

            var groupMembers = groups
                               .SelectMany(g => g.Members)
                               .Where(gm => allowedPersonIds.Contains(gm.PersonId));

            AttributeService attributeService = new AttributeService(rockContext);

            List <int> attributeIds = attributeService.Queryable()
                                      .Where(a =>
                                             a.EntityTypeId == personEntityid &&
                                             a.Key == key)
                                      .Select(a => a.Id).ToList();

            if (attributeIds == null)
            {
                nbAlert.Visible = true;
                nbAlert.Text    = "Medication attribute not found";
                return(null);
            }

            List <int> filterAttributeIds = null;
            var        filterAttributeKey = GetAttributeValue("GroupMemberAttributeFilter");

            if (!string.IsNullOrWhiteSpace(filterAttributeKey))
            {
                filterAttributeIds = attributeService.Queryable()
                                     .Where(a =>
                                            (groupIdStrings.Contains(a.EntityTypeQualifierValue) || groupTypeIds.Contains(a.EntityTypeQualifierValue)) &&
                                            a.Key == filterAttributeKey &&
                                            a.EntityTypeId == groupMemberEntityid)
                                     .Select(a => a.Id).ToList();
            }

            var attributeMatrixItemEntityId = EntityTypeCache.GetId <AttributeMatrixItem>();

            var qry = groupMembers
                      .Join(
                attributeValueService.Queryable().Where(av => attributeIds.Contains(av.AttributeId)),
                m => m.PersonId,
                av => av.EntityId.Value,
                (m, av) => new { Person = m.Person, Member = m, AttributeValue = av.Value }
                )
                      .Join(
                attributeMatrixService.Queryable(),
                m => m.AttributeValue,
                am => am.Guid.ToString(),
                (m, am) => new { Person = m.Person, Member = m.Member, AttributeMatrix = am }
                )
                      .Join(
                attributeMatrixItemService.Queryable(),
                m => m.AttributeMatrix.Id,
                ami => ami.AttributeMatrixId,
                (m, ami) => new { Person = m.Person, Member = m.Member, AttributeMatrixItem = ami, TemplateId = ami.AttributeMatrix.AttributeMatrixTemplateId }
                )
                      .Join(
                attributeService.Queryable(),
                m => new { TemplateIdString = m.TemplateId.ToString(), EntityTypeId = attributeMatrixItemEntityId },
                a => new { TemplateIdString = a.EntityTypeQualifierValue, EntityTypeId = a.EntityTypeId },
                (m, a) => new { Person = m.Person, Member = m.Member, AttributeMatrixItem = m.AttributeMatrixItem, Attribute = a }
                )
                      .Join(
                attributeValueService.Queryable(),
                m => new { EntityId = m.AttributeMatrixItem.Id, AttributeId = m.Attribute.Id },
                av => new { EntityId = av.EntityId ?? 0, AttributeId = av.AttributeId },
                (m, av) => new { Person = m.Person, Member = m.Member, Attribute = m.Attribute, AttributeValue = av, MatrixItemId = m.AttributeMatrixItem.Id, FilterValue = "" }
                );

            if (filterAttributeIds != null && pnlAttribute.Visible && !string.IsNullOrWhiteSpace(ddlAttribute.SelectedValue))
            {
                var filterValue = ddlAttribute.SelectedValue;
                qry = qry
                      .Join(
                    attributeValueService.Queryable().Where(av => filterAttributeIds.Contains(av.AttributeId)),
                    m => new { Id = m.Member.Id, Value = filterValue },
                    av => new { Id = av.EntityId ?? 0, Value = av.Value },
                    (m, av) => new { Person = m.Person, Member = m.Member, Attribute = m.Attribute, AttributeValue = m.AttributeValue, MatrixItemId = m.MatrixItemId, FilterValue = av.Value });
            }
            var members = qry.ToList().GroupBy(a => a.Person).ToList();

            var firstDay = (dpDate.SelectedDate ?? Rock.RockDateTime.Today).Date;
            var nextday  = firstDay.AddDays(1);

            var personIds = members.Select(m => m.Key.Id);
            var attributeMatrixEntityTypeId = EntityTypeCache.GetId <AttributeMatrixItem>().Value;

            var noteType = NoteTypeCache.Get(GetAttributeValue("NoteType").AsGuid());

            if (noteType == null)
            {
                return(new List <MedicalItem>());
            }

            var noteItems = noteService.Queryable()
                            .Where(n => n.NoteTypeId == noteType.Id)
                            .Where(n => personIds.Contains(n.EntityId ?? 0))
                            .Where(h => h.CreatedDateTime >= firstDay && h.CreatedDateTime < nextday)
                            .Where(h => h.ForeignId != null)
                            .ToList();

            foreach (var member in members)
            {
                if (!string.IsNullOrWhiteSpace(tbName.Text) &&
                    !member.Key.FullName.ToLower().Contains(tbName.Text.ToLower()) &&
                    !member.Key.FullNameReversed.ToLower().Contains(tbName.Text.ToLower()))
                {
                    continue;
                }

                var medicines = member.GroupBy(m => m.MatrixItemId);
                foreach (var medicine in medicines)
                {
                    var scheduleAtt = medicine.FirstOrDefault(m => m.Attribute.Key == "Schedule");
                    if (scheduleAtt == null || scheduleAtt.AttributeValue.Value == null)
                    {
                        continue;
                    }
                    var schedules = scheduleAtt.AttributeValue.Value.SplitDelimitedValues();
                    foreach (var schedule in schedules)
                    {
                        if (ddlSchedule.SelectedValue != "" && ddlSchedule.SelectedValue.AsGuid() != schedule.AsGuid())
                        {
                            continue;
                        }

                        var medicalItem = new MedicalItem()
                        {
                            Person          = member.Key.FullNameReversed,
                            GroupMemberId   = member.Key.Id,
                            GroupMember     = member.Key.Members.FirstOrDefault(),
                            PersonId        = member.Key.Id,
                            FilterAttribute = member.FirstOrDefault().FilterValue,
                        };

                        if (!string.IsNullOrWhiteSpace(schedule))
                        {
                            var dv = DefinedValueCache.Get(schedule.AsGuid());
                            if (dv != null)
                            {
                                medicalItem.Schedule     = dv.Value;
                                medicalItem.ScheduleGuid = dv.Guid;
                            }
                        }

                        var medAtt = medicine.FirstOrDefault(m => m.Attribute.Key == "Medication");
                        if (medAtt != null)
                        {
                            medicalItem.Medication = medAtt.AttributeValue.Value;
                        }

                        var instructionAtt = medicine.FirstOrDefault(m => m.Attribute.Key == "Instructions");
                        if (instructionAtt != null)
                        {
                            medicalItem.Instructions = instructionAtt.AttributeValue.Value;
                        }
                        medicalItem.Key = string.Format("{0}|{1}|{2}", medicalItem.PersonId, medicine.Key, medicalItem.ScheduleGuid);

                        var notes = noteItems
                                    .Where(n => n.EntityId == medicalItem.PersonId && n.ForeignId == medicine.Key && n.ForeignGuid == medicalItem.ScheduleGuid);

                        if (notes.Any())
                        {
                            medicalItem.Distributed = true;
                            medicalItem.History     = string.Join("<br>", notes.Select(n => n.Text));
                        }

                        medicalItems.Add(medicalItem);
                    }
                }
                if (overrideHideDistributed == false && cbHideDistributed.Checked == true)
                {
                    medicalItems = medicalItems.Where(i => i.Distributed == false).ToList();
                }
            }

            SortProperty sortProperty = gGrid.SortProperty;

            if (sortProperty != null)
            {
                if (sortProperty.Property == "Person")
                {
                    if (sortProperty.Direction == SortDirection.Ascending)
                    {
                        medicalItems = medicalItems.OrderBy(mi => mi.Person).ToList();
                    }
                    else
                    {
                        medicalItems = medicalItems.OrderByDescending(mi => mi.Person).ToList();
                    }
                }
            }
            else
            {
                medicalItems       = medicalItems.OrderBy(mi => mi.Person).ToList();
                gGrid.SortProperty = new SortProperty()
                {
                    Property = "Person"
                };
            }

            return(medicalItems);
        }
        /// <summary>
        /// Binds the grid.
        /// </summary>
        private void BindGrid()
        {
            BlockTypeService blockTypeService = new BlockTypeService(new RockContext());
            SortProperty     sortProperty     = gBlockTypes.SortProperty;

            var blockTypes = blockTypeService.Queryable();

            // Exclude system blocks if checked.
            if (!string.IsNullOrWhiteSpace(gfSettings.GetUserPreference("Exclude System")))
            {
                blockTypes = blockTypes.Where(b => b.IsSystem == false);
            }

            // Filter by Name
            string nameFilter = gfSettings.GetUserPreference("Name");

            if (!string.IsNullOrEmpty(nameFilter.Trim()))
            {
                blockTypes = blockTypes.Where(b => b.Name.Contains(nameFilter.Trim()));
            }

            // Filter by Path
            string path = gfSettings.GetUserPreference("Path");

            if (!string.IsNullOrEmpty(path.Trim()))
            {
                blockTypes = blockTypes.Where(b => b.Path.Contains(path.Trim()));
            }

            string category = gfSettings.GetUserPreference("Category");

            if (!string.IsNullOrWhiteSpace(category))
            {
                blockTypes = blockTypes.Where(b => b.Category == category);
            }

            var selectQry = blockTypes.Select(a =>
                                              new
            {
                a.Id,
                a.Name,
                a.Category,
                a.Description,
                a.Path,
                BlocksCount = a.Blocks.Count(),
                a.IsSystem
            });

            if (sortProperty != null)
            {
                if (sortProperty.Property == "Status")
                {
                    // special case:  See if the file exists and sort by that
                    if (sortProperty.Direction == System.Web.UI.WebControls.SortDirection.Ascending)
                    {
                        gBlockTypes.DataSource = selectQry.ToList().OrderBy(a => System.IO.File.Exists(Request.MapPath(a.Path))).ToList();
                    }
                    else
                    {
                        gBlockTypes.DataSource = selectQry.ToList().OrderBy(a => !System.IO.File.Exists(Request.MapPath(a.Path))).ToList();
                    }
                }
                else
                {
                    gBlockTypes.DataSource = selectQry.Sort(sortProperty).ToList();
                }
            }
            else
            {
                gBlockTypes.DataSource = selectQry.OrderBy(b => b.Name).ToList();
            }

            gBlockTypes.DataBind();
        }
示例#22
0
        /// <summary>
        /// Binds the grid.
        /// </summary>
        private void BindGrid()
        {
            if (_entity != null)
            {
                var entityTypeCache = EntityTypeCache.Get(_entity.GetType(), false);
                if (entityTypeCache != null)
                {
                    var rockContext    = new RockContext();
                    var historyService = new HistoryService(rockContext);
                    IQueryable <History> qry;

                    if (entityTypeCache.Id == EntityTypeCache.GetId <Rock.Model.Person>())
                    {
                        // If this is History for a Person, also include any History for any of their Families
                        int?       groupEntityTypeId = EntityTypeCache.GetId <Rock.Model.Group>();
                        List <int> familyIds         = (_entity as Person).GetFamilies().Select(a => a.Id).ToList();

                        qry = historyService.Queryable().Include(a => a.CreatedByPersonAlias.Person)
                              .Where(h =>
                                     (h.EntityTypeId == entityTypeCache.Id && h.EntityId == _entity.Id) ||
                                     (h.EntityTypeId == groupEntityTypeId && familyIds.Contains(h.EntityId)));

                        // as per issue #1594, if relatedEntityType is an Attribute then check View Authorization
                        var attributeEntity     = EntityTypeCache.Get(Rock.SystemGuid.EntityType.ATTRIBUTE.AsGuid());
                        var personAttributes    = new AttributeService(rockContext).GetByEntityTypeId(entityTypeCache.Id).ToList().Select(a => AttributeCache.Get(a));
                        var allowedAttributeIds = personAttributes.Where(a => a.IsAuthorized(Rock.Security.Authorization.VIEW, CurrentPerson)).Select(a => a.Id).ToList();
                        qry = qry.Where(a => (a.RelatedEntityTypeId == attributeEntity.Id) ? allowedAttributeIds.Contains(a.RelatedEntityId.Value) : true);
                    }
                    else
                    {
                        qry = historyService.Queryable().Include(a => a.CreatedByPersonAlias.Person)
                              .Where(h =>
                                     (h.EntityTypeId == entityTypeCache.Id && h.EntityId == _entity.Id));
                    }

                    var historyCategories  = new CategoryService(rockContext).GetByEntityTypeId(EntityTypeCache.GetId <Rock.Model.History>()).ToList().Select(a => CategoryCache.Get(a));
                    var allowedCategoryIds = historyCategories.Where(a => a.IsAuthorized(Rock.Security.Authorization.VIEW, CurrentPerson)).Select(a => a.Id).ToList();

                    qry = qry.Where(a => allowedCategoryIds.Contains(a.CategoryId));

                    int?categoryId = gfSettings.GetUserPreference("Category").AsIntegerOrNull();
                    if (categoryId.HasValue)
                    {
                        qry = qry.Where(a => a.CategoryId == categoryId.Value);
                    }

                    int?personId = gfSettings.GetUserPreference("Who").AsIntegerOrNull();
                    if (personId.HasValue)
                    {
                        qry = qry.Where(h => h.CreatedByPersonAlias.PersonId == personId.Value);
                    }

                    var drp = new DateRangePicker();
                    drp.DelimitedValues = gfSettings.GetUserPreference("Date Range");
                    if (drp.LowerValue.HasValue)
                    {
                        qry = qry.Where(h => h.CreatedDateTime >= drp.LowerValue.Value);
                    }
                    if (drp.UpperValue.HasValue)
                    {
                        DateTime upperDate = drp.UpperValue.Value.Date.AddDays(1);
                        qry = qry.Where(h => h.CreatedDateTime < upperDate);
                    }

                    // Combine history records that were saved at the same time
                    var historySummaryList = historyService.GetHistorySummary(qry);

                    string summary = gfSettings.GetUserPreference("Summary Contains");
                    if (!string.IsNullOrWhiteSpace(summary))
                    {
                        historySummaryList = historySummaryList.Where(h => h.HistoryList.Any(x => x.SummaryHtml.IndexOf(summary, StringComparison.OrdinalIgnoreCase) >= 0)).ToList();
                    }

                    SortProperty sortProperty = gHistory.SortProperty;
                    if (sortProperty != null)
                    {
                        historySummaryList = historySummaryList.AsQueryable().Sort(sortProperty).ToList();
                    }
                    else
                    {
                        historySummaryList = historySummaryList.OrderByDescending(t => t.CreatedDateTime).ToList();
                    }

                    gHistory.DataSource   = historySummaryList;
                    gHistory.EntityTypeId = EntityTypeCache.Get <History>().Id;
                    gHistory.DataBind();
                }
            }
        }
        /// <summary>
        /// Binds the event calendar items grid.
        /// </summary>
        protected void BindEventCalendarItemsGrid()
        {
            if (_eventCalendar != null)
            {
                pnlEventCalendarItems.Visible = true;

                var rockContext = new RockContext();

                EventCalendarItemService eventCalendarItemService = new EventCalendarItemService(rockContext);
                var qry = eventCalendarItemService
                          .Queryable("EventCalendar,EventItem.EventItemAudiences,EventItem.EventItemOccurrences.Schedule")
                          .Where(m =>
                                 m.EventItem != null &&
                                 m.EventCalendarId == _eventCalendar.Id);

                // Filter by Status
                string statusFilter = ddlStatus.SelectedValue;
                if (statusFilter == "Active")
                {
                    qry = qry
                          .Where(m => m.EventItem.IsActive);
                }
                else if (statusFilter == "Inactive")
                {
                    qry = qry
                          .Where(m => !m.EventItem.IsActive);
                }

                // Filter by Approval Status
                string approvalStatusFilter = ddlApprovalStatus.SelectedValue;
                if (approvalStatusFilter == "Approved")
                {
                    qry = qry
                          .Where(m => m.EventItem.IsApproved);
                }
                else if (approvalStatusFilter == "Not Approved")
                {
                    qry = qry
                          .Where(m => !m.EventItem.IsApproved);
                }

                // Filter by Campus
                List <int> campusIds = cblCampus.SelectedValuesAsInt;
                if (campusIds.Any())
                {
                    qry = qry
                          .Where(i =>
                                 i.EventItem.EventItemOccurrences
                                 .Any(c =>
                                      !c.CampusId.HasValue ||
                                      campusIds.Contains(c.CampusId.Value)));
                }

                // Filter query by any configured attribute filters
                if (AvailableAttributes != null && AvailableAttributes.Any())
                {
                    var attributeValueService = new AttributeValueService(rockContext);
                    var parameterExpression   = attributeValueService.ParameterExpression;

                    foreach (var attribute in AvailableAttributes)
                    {
                        var filterControl = phAttributeFilters.FindControl("filter_" + attribute.Id.ToString());
                        if (filterControl != null)
                        {
                            var filterValues = attribute.FieldType.Field.GetFilterValues(filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter);
                            var expression   = attribute.FieldType.Field.AttributeFilterExpression(attribute.QualifierValues, filterValues, parameterExpression);
                            if (expression != null)
                            {
                                var attributeValues = attributeValueService
                                                      .Queryable()
                                                      .Where(v => v.Attribute.Id == attribute.Id);

                                attributeValues = attributeValues.Where(parameterExpression, expression, null);

                                qry = qry.Where(w => attributeValues.Select(v => v.EntityId).Contains(w.Id));
                            }
                        }
                    }
                }

                // Filter by Audience
                List <int> audiences = cblAudience.SelectedValuesAsInt;
                if (audiences.Any())
                {
                    qry = qry.Where(i => i.EventItem.EventItemAudiences
                                    .Any(c => audiences.Contains(c.DefinedValueId)));
                }

                SortProperty sortProperty = gEventCalendarItems.SortProperty;

                // Sort and query db
                List <EventCalendarItem> eventCalendarItems = null;
                if (sortProperty != null)
                {
                    // If sorting on date, wait until after checking to see if date range was specified
                    if (sortProperty.Property == "Date")
                    {
                        eventCalendarItems = qry.ToList();
                    }
                    else
                    {
                        eventCalendarItems = qry.Sort(sortProperty).ToList();
                    }
                }
                else
                {
                    eventCalendarItems = qry.OrderBy(a => a.EventItem.Name).ToList();
                }

                // Now that items have been loaded and ordered from db, calculate the next start date for each item
                var calendarItemsWithDates = eventCalendarItems
                                             .Select(i => new EventCalendarItemWithDates
                {
                    EventCalendarItem = i,
                    NextStartDateTime = i.EventItem.NextStartDateTime,
                })
                                             .ToList();

                var dateCol = gEventCalendarItems.Columns.OfType <BoundField>().Where(c => c.DataField == "Date").FirstOrDefault();

                // if a date range was specified, need to get all dates for items and filter based on any that have an occurrence withing the date range
                DateTime?lowerDateRange = drpDate.LowerValue;
                DateTime?upperDateRange = drpDate.UpperValue;
                if (lowerDateRange.HasValue || upperDateRange.HasValue)
                {
                    // If only one value was included, default the other to be a years difference
                    lowerDateRange = lowerDateRange ?? upperDateRange.Value.AddYears(-1).AddDays(1);
                    upperDateRange = upperDateRange ?? lowerDateRange.Value.AddYears(1).AddDays(-1);

                    // Get the start datetimes within the selected date range
                    calendarItemsWithDates.ForEach(i => i.StartDateTimes = i.EventCalendarItem.EventItem.GetStartTimes(lowerDateRange.Value, upperDateRange.Value.AddDays(1)));

                    // Filter out calendar items with no dates within range
                    calendarItemsWithDates = calendarItemsWithDates.Where(i => i.StartDateTimes.Any()).ToList();

                    // Update the Next Start Date to be the next date in range instead
                    dateCol.HeaderText = "Next Date In Range";
                    calendarItemsWithDates.ForEach(i => i.NextStartDateTime = i.StartDateTimes.Min());
                }
                else
                {
                    dateCol.HeaderText = "Next Start Date";
                }

                // Now sort on date if that is what was selected
                if (sortProperty != null && sortProperty.Property == "Date")
                {
                    if (sortProperty.Direction == SortDirection.Ascending)
                    {
                        calendarItemsWithDates = calendarItemsWithDates.OrderBy(a => a.NextStartDateTime).ToList();
                    }
                    else
                    {
                        calendarItemsWithDates = calendarItemsWithDates.OrderByDescending(a => a.NextStartDateTime).ToList();
                    }
                }

                // Save the calendar items to the grid's objectlist
                gEventCalendarItems.ObjectList = new Dictionary <string, object>();
                calendarItemsWithDates.ForEach(i => gEventCalendarItems.ObjectList.Add(i.EventCalendarItem.EventItem.Id.ToString(), i.EventCalendarItem));
                gEventCalendarItems.EntityTypeId = EntityTypeCache.Read("Rock.Model.EventCalendarItem").Id;

                gEventCalendarItems.DataSource = calendarItemsWithDates.Select(i => new
                {
                    Id          = i.EventCalendarItem.EventItem.Id,
                    Guid        = i.EventCalendarItem.EventItem.Guid,
                    Date        = i.NextStartDateTime.HasValue ? i.NextStartDateTime.Value.ToShortDateString() : "N/A",
                    Name        = i.EventCalendarItem.EventItem.Name,
                    Occurrences = campusIds.Any() ?
                                  i.EventCalendarItem.EventItem.EventItemOccurrences.Where(c => !c.CampusId.HasValue || campusIds.Contains(c.CampusId.Value)).Count() :
                                  i.EventCalendarItem.EventItem.EventItemOccurrences.Count(),
                    Calendar       = i.EventCalendarItem.EventItem.EventCalendarItems.ToList().Select(c => c.EventCalendar.Name).ToList().AsDelimited("<br>"),
                    Audience       = i.EventCalendarItem.EventItem.EventItemAudiences.ToList().Select(a => a.DefinedValue.Value).ToList().AsDelimited("<br>"),
                    Status         = i.EventCalendarItem.EventItem.IsActive ? "<span class='label label-success'>Active</span>" : "<span class='label label-default'>Inactive</span>",
                    ApprovalStatus = i.EventCalendarItem.EventItem.IsApproved ? "<span class='label label-info'>Approved</span>" : "<span class='label label-warning'>Not Approved</span>"
                }).ToList();

                gEventCalendarItems.DataBind();
            }
            else
            {
                pnlEventCalendarItems.Visible = false;
            }
        }
        /// <summary>
        /// Binds the registrations grid.
        /// </summary>
        private void BindRegistrationsGrid()
        {
            int?instanceId = this.RegistrationInstanceId;

            if (instanceId.HasValue && instanceId > 0)
            {
                using (var rockContext = new RockContext())
                {
                    var registrationEntityType = EntityTypeCache.Get(typeof(Rock.Model.Registration));

                    var instance = new RegistrationInstanceService(rockContext).Get(instanceId.Value);
                    if (instance != null)
                    {
                        decimal cost = instance.RegistrationTemplate.Cost;
                        if (instance.RegistrationTemplate.SetCostOnInstance ?? false)
                        {
                            cost = instance.Cost ?? 0.0m;
                        }

                        _instanceHasCost = cost > 0.0m;
                    }

                    var qry = new RegistrationService(rockContext)
                              .Queryable("PersonAlias.Person,Registrants.PersonAlias.Person,Registrants.Fees.RegistrationTemplateFee")
                              .AsNoTracking()
                              .Where(r =>
                                     r.RegistrationInstanceId == instanceId.Value &&
                                     !r.IsTemporary);

                    var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(sdrpRegistrationDateRange.DelimitedValues);

                    if (dateRange.Start.HasValue)
                    {
                        qry = qry.Where(r =>
                                        r.CreatedDateTime.HasValue &&
                                        r.CreatedDateTime.Value >= dateRange.Start.Value);
                    }

                    if (dateRange.End.HasValue)
                    {
                        qry = qry.Where(r =>
                                        r.CreatedDateTime.HasValue &&
                                        r.CreatedDateTime.Value < dateRange.End.Value);
                    }

                    if (!string.IsNullOrWhiteSpace(tbRegistrationRegisteredByFirstName.Text))
                    {
                        string pfname = tbRegistrationRegisteredByFirstName.Text;
                        qry = qry.Where(r =>
                                        r.FirstName.StartsWith(pfname) ||
                                        r.PersonAlias.Person.NickName.StartsWith(pfname) ||
                                        r.PersonAlias.Person.FirstName.StartsWith(pfname));
                    }

                    if (!string.IsNullOrWhiteSpace(tbRegistrationRegisteredByLastName.Text))
                    {
                        string plname = tbRegistrationRegisteredByLastName.Text;
                        qry = qry.Where(r =>
                                        r.LastName.StartsWith(plname) ||
                                        r.PersonAlias.Person.LastName.StartsWith(plname));
                    }

                    if (!string.IsNullOrWhiteSpace(tbRegistrationRegistrantFirstName.Text))
                    {
                        string rfname = tbRegistrationRegistrantFirstName.Text;
                        qry = qry.Where(r =>
                                        r.Registrants.Any(p =>
                                                          p.PersonAlias.Person.NickName.StartsWith(rfname) ||
                                                          p.PersonAlias.Person.FirstName.StartsWith(rfname)));
                    }

                    if (!string.IsNullOrWhiteSpace(tbRegistrationRegistrantLastName.Text))
                    {
                        string rlname = tbRegistrationRegistrantLastName.Text;
                        qry = qry.Where(r =>
                                        r.Registrants.Any(p =>
                                                          p.PersonAlias.Person.LastName.StartsWith(rlname)));
                    }

                    // If filtering on payment status, need to do some sub-querying...
                    if (ddlRegistrationPaymentStatus.SelectedValue != string.Empty && registrationEntityType != null)
                    {
                        // Get all the registrant costs
                        var rCosts = new Dictionary <int, decimal>();
                        qry.ToList()
                        .Select(r => new
                        {
                            RegistrationId = r.Id,
                            DiscountCosts  = r.Registrants.Sum(p => ( decimal? )p.DiscountedCost(r.DiscountPercentage, r.DiscountAmount)) ?? 0.0m,
                        }).ToList()
                        .ForEach(c =>
                                 rCosts.AddOrReplace(c.RegistrationId, c.DiscountCosts));

                        var rPayments = new Dictionary <int, decimal>();
                        new FinancialTransactionDetailService(rockContext)
                        .Queryable().AsNoTracking()
                        .Where(d =>
                               d.EntityTypeId.HasValue &&
                               d.EntityId.HasValue &&
                               d.EntityTypeId.Value == registrationEntityType.Id &&
                               rCosts.Keys.Contains(d.EntityId.Value))
                        .Select(d => new
                        {
                            RegistrationId = d.EntityId.Value,
                            Payment        = d.Amount
                        })
                        .ToList()
                        .GroupBy(d => d.RegistrationId)
                        .Select(d => new
                        {
                            RegistrationId = d.Key,
                            Payments       = d.Sum(p => p.Payment)
                        })
                        .ToList()
                        .ForEach(p => rPayments.AddOrReplace(p.RegistrationId, p.Payments));

                        var rPmtSummary = rCosts
                                          .Join(
                            rPayments,
                            c => c.Key,
                            p => p.Key,
                            (c, p) => new
                        {
                            RegistrationId = c.Key,
                            Costs          = c.Value,
                            Payments       = p.Value
                        })
                                          .ToList();

                        var ids = new List <int>();

                        if (ddlRegistrationPaymentStatus.SelectedValue == "Paid in Full")
                        {
                            ids = rPmtSummary
                                  .Where(r => r.Costs <= r.Payments)
                                  .Select(r => r.RegistrationId)
                                  .ToList();
                        }
                        else
                        {
                            ids = rPmtSummary
                                  .Where(r => r.Costs > r.Payments)
                                  .Select(r => r.RegistrationId)
                                  .ToList();
                        }

                        qry = qry.Where(r => ids.Contains(r.Id));
                    }

                    SortProperty sortProperty = gRegistrations.SortProperty;
                    if (sortProperty != null)
                    {
                        // If sorting by Total Cost or Balance Due, the database query needs to be run first without ordering,
                        // and then ordering needs to be done in memory since TotalCost and BalanceDue are not database fields.
                        if (sortProperty.Property == "TotalCost")
                        {
                            if (sortProperty.Direction == SortDirection.Ascending)
                            {
                                gRegistrations.SetLinqDataSource(qry.ToList().OrderBy(r => r.TotalCost).AsQueryable());
                            }
                            else
                            {
                                gRegistrations.SetLinqDataSource(qry.ToList().OrderByDescending(r => r.TotalCost).AsQueryable());
                            }
                        }
                        else if (sortProperty.Property == "BalanceDue")
                        {
                            if (sortProperty.Direction == SortDirection.Ascending)
                            {
                                gRegistrations.SetLinqDataSource(qry.ToList().OrderBy(r => r.BalanceDue).AsQueryable());
                            }
                            else
                            {
                                gRegistrations.SetLinqDataSource(qry.ToList().OrderByDescending(r => r.BalanceDue).AsQueryable());
                            }
                        }
                        else if (sortProperty.Property == "RegisteredBy")
                        {
                            // Sort by the Person name if we have it, otherwise the provided first and last name.
                            Func <Registration, string> sortBy = (r) =>
                            {
                                return(r.PersonAlias != null && r.PersonAlias.Person != null ? r.PersonAlias.Person.FullNameReversed : string.Format("{0}, {1}", r.LastName, r.FirstName));
                            };

                            if (sortProperty.Direction == SortDirection.Ascending)
                            {
                                gRegistrations.SetLinqDataSource(qry.ToList().OrderBy(sortBy).AsQueryable());
                            }
                            else
                            {
                                gRegistrations.SetLinqDataSource(qry.ToList().OrderByDescending(sortBy).AsQueryable());
                            }
                        }
                        else
                        {
                            gRegistrations.SetLinqDataSource(qry.Sort(sortProperty));
                        }
                    }
                    else
                    {
                        gRegistrations.SetLinqDataSource(qry.OrderByDescending(r => r.CreatedDateTime));
                    }

                    // Get all the payments for any registrations being displayed on the current page.
                    // This is used in the RowDataBound event but queried now so that each row does
                    // not have to query for the data.
                    var currentPageRegistrations = gRegistrations.DataSource as List <Registration>;
                    if (currentPageRegistrations != null && registrationEntityType != null)
                    {
                        var registrationIds = currentPageRegistrations
                                              .Select(r => r.Id)
                                              .ToList();

                        _registrationPayments = new FinancialTransactionDetailService(rockContext)
                                                .Queryable().AsNoTracking()
                                                .Where(d =>
                                                       d.EntityTypeId.HasValue &&
                                                       d.EntityId.HasValue &&
                                                       d.EntityTypeId.Value == registrationEntityType.Id &&
                                                       registrationIds.Contains(d.EntityId.Value))
                                                .ToList();
                    }

                    var discountCodeHeader = gRegistrations.GetColumnByHeaderText("Discount Code");
                    if (discountCodeHeader != null)
                    {
                        discountCodeHeader.Visible = GetAttributeValue(AttributeKey.DisplayDiscountCodes).AsBoolean();
                    }

                    gRegistrations.DataBind();
                }
            }
        }
        /// <summary>
        /// Binds the grid.
        /// </summary>
        private void BindGrid()
        {
            var rockContext = new RockContext();

            int    entityTypeIdBlock   = EntityTypeCache.Read(typeof(Rock.Model.Block), true, rockContext).Id;
            string entityTypeQualifier = BlockTypeCache.Read(Rock.SystemGuid.BlockType.HTML_CONTENT.AsGuid(), rockContext).Id.ToString();
            var    htmlContentService  = new HtmlContentService(rockContext);
            var    attributeValueQry   = new AttributeValueService(rockContext).Queryable()
                                         .Where(a => a.Attribute.Key == "RequireApproval" && a.Attribute.EntityTypeId == entityTypeIdBlock)
                                         .Where(a => a.Attribute.EntityTypeQualifierColumn == "BlockTypeId" && a.Attribute.EntityTypeQualifierValue == entityTypeQualifier)
                                         .Where(a => a.Value == "True")
                                         .Select(a => a.EntityId);

            var qry = htmlContentService.Queryable().Where(a => attributeValueQry.Contains(a.BlockId));

            // Filter by approved/unapproved
            if (ddlApprovedFilter.SelectedIndex > -1)
            {
                if (ddlApprovedFilter.SelectedValue.ToLower() == "unapproved")
                {
                    qry = qry.Where(a => a.IsApproved == false);
                }
                else if (ddlApprovedFilter.SelectedValue.ToLower() == "approved")
                {
                    qry = qry.Where(a => a.IsApproved == true);
                }
            }

            // Filter by the person that approved the content
            if (_canApprove)
            {
                int?personId = gContentListFilter.GetUserPreference("Approved By").AsIntegerOrNull();
                if (personId.HasValue)
                {
                    qry = qry.Where(a => a.ApprovedByPersonAliasId.HasValue && a.ApprovedByPersonAlias.PersonId == personId);
                }
            }

            SortProperty sortProperty = gContentList.SortProperty;

            if (sortProperty != null)
            {
                qry = qry.Sort(sortProperty);
            }
            else
            {
                qry = qry.OrderByDescending(a => a.ModifiedDateTime);
            }

            var selectQry = qry.Select(a => new
            {
                a.Id,
                SiteName = a.Block.PageId.HasValue ? a.Block.Page.Layout.Site.Name : a.Block.Layout.Site.Name,
                PageName = a.Block.Page.InternalName,
                a.ModifiedDateTime,
                a.IsApproved,
                ApprovedDateTime = a.IsApproved ? a.ApprovedDateTime : null,
                ApprovedByPerson = a.IsApproved ? a.ApprovedByPersonAlias.Person : null,
                BlockPageId      = a.Block.PageId,
                BlockLayoutId    = a.Block.LayoutId,
            });

            gContentList.EntityTypeId = EntityTypeCache.Read <HtmlContent>().Id;

            // Filter by Site
            if (ddlSiteFilter.SelectedIndex > 0)
            {
                if (ddlSiteFilter.SelectedValue.ToLower() != "all")
                {
                    selectQry = selectQry.Where(h => h.SiteName == ddlSiteFilter.SelectedValue);
                }
            }

            gContentList.DataSource = selectQry.ToList();
            gContentList.DataBind();
        }
示例#26
0
        /// <summary>
        /// Binds the grid.
        /// </summary>
        private void BindGrid()
        {
            var rockContext       = new RockContext();
            var recordTypeValueId = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_BUSINESS.AsGuid()).Id;

            var queryable = new PersonService(rockContext).Queryable()
                            .Where(q => q.RecordTypeValueId == recordTypeValueId);

            // Business Name Filter
            var businessName = gfBusinessFilter.GetUserPreference("Business Name");

            if (!string.IsNullOrWhiteSpace(businessName))
            {
                queryable = queryable.Where(a => a.LastName.Contains(businessName));
            }

            var    activeRecordStatusValueId = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_ACTIVE.AsGuid()).Id;
            string activeFilterValue         = gfBusinessFilter.GetUserPreference("Active Status");

            if (activeFilterValue == "inactive")
            {
                queryable = queryable.Where(b => b.RecordStatusValueId != activeRecordStatusValueId);
            }
            else if (activeFilterValue == "active")
            {
                queryable = queryable.Where(b => b.RecordStatusValueId == activeRecordStatusValueId);
            }

            SortProperty sortProperty = gBusinessList.SortProperty;

            if (sortProperty != null)
            {
                queryable = queryable.Sort(sortProperty);
            }
            else
            {
                queryable = queryable.OrderBy(q => q.LastName);
            }

            var groupMemberQuery = new GroupMemberService(rockContext).Queryable();

            var businessList = queryable.Select(b => new
            {
                Id = b.Id,
                b.LastName,
                BusinessName = b.LastName,
                PhoneNumber  = b.PhoneNumbers.FirstOrDefault().NumberFormatted,
                Email        = b.Email,
                Address      = b.Members
                               .Where(m => m.Group.GroupType.Guid.ToString() == Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY)
                               .SelectMany(m => m.Group.GroupLocations)
                               .FirstOrDefault()
                               .Location,
                Contacts = b.Members
                           .Where(m => m.Group.GroupType.Guid.ToString() == Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS)
                           .SelectMany(m => m.Group.Members)
                           .Where(p => p.GroupRole.Guid.ToString() == Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER && p.PersonId != b.Id)
                           .Select(p => p.Person.LastName + ", " + p.Person.NickName)
            });

            gBusinessList.EntityTypeId = EntityTypeCache.Read <Person>().Id;
            gBusinessList.DataSource   = businessList.ToList();
            gBusinessList.DataBind();
        }
        private List <ContentChannelItem> GetContent(List <string> errorMessages)
        {
            List <ContentChannelItem> items = null;

            // only load from the cache if a cacheDuration was specified
            if (ItemCacheDuration.HasValue && ItemCacheDuration.Value > 0)
            {
                items = GetCacheItem(CONTENT_CACHE_KEY) as List <ContentChannelItem>;
            }


            if (items == null)
            {
                Guid?channelGuid = GetAttributeValue("Channel").AsGuidOrNull();
                if (channelGuid.HasValue)
                {
                    var rockContext = new RockContext();
                    var service     = new ContentChannelItemService(rockContext);
                    var itemType    = typeof(Rock.Model.ContentChannelItem);

                    ParameterExpression paramExpression = service.ParameterExpression;

                    var contentChannel = new ContentChannelService(rockContext).Get(channelGuid.Value);
                    if (contentChannel != null)
                    {
                        var entityFields = HackEntityFields(contentChannel, rockContext);

                        items = new List <ContentChannelItem>();

                        var qry = service
                                  .Queryable("ContentChannel,ContentChannelType")
                                  .Where(i => i.ContentChannelId == contentChannel.Id);

                        if (contentChannel.RequiresApproval && !contentChannel.ContentChannelType.DisableStatus)
                        {
                            // Check for the configured status and limit query to those
                            var statuses = new List <ContentChannelItemStatus>();
                            foreach (string statusVal in (GetAttributeValue("Status") ?? "2").Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
                            {
                                var status = statusVal.ConvertToEnumOrNull <ContentChannelItemStatus>();
                                if (status != null)
                                {
                                    statuses.Add(status.Value);
                                }
                            }
                            if (statuses.Any())
                            {
                                qry = qry.Where(i => statuses.Contains(i.Status));
                            }
                        }

                        int?dataFilterId = GetAttributeValue("FilterId").AsIntegerOrNull();
                        if (dataFilterId.HasValue)
                        {
                            var        dataFilterService = new DataViewFilterService(rockContext);
                            var        dataFilter        = dataFilterService.Queryable("ChildFilters").FirstOrDefault(a => a.Id == dataFilterId.Value);
                            Expression whereExpression   = dataFilter != null?dataFilter.GetExpression(itemType, service, paramExpression, errorMessages) : null;

                            qry = qry.Where(paramExpression, whereExpression, null);
                        }

                        // All filtering has been added, now run query, check security and load attributes
                        foreach (var item in qry.ToList())
                        {
                            if (item.IsAuthorized(Authorization.VIEW, CurrentPerson))
                            {
                                item.LoadAttributes(rockContext);
                                items.Add(item);
                            }
                        }

                        // Order the items
                        SortProperty sortProperty = null;

                        string orderBy = GetAttributeValue("Order");
                        if (!string.IsNullOrWhiteSpace(orderBy))
                        {
                            var fieldDirection = new List <string>();
                            foreach (var itemPair in orderBy.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries).Select(a => a.Split('^')))
                            {
                                if (itemPair.Length == 2 && !string.IsNullOrWhiteSpace(itemPair[0]))
                                {
                                    var sortDirection = SortDirection.Ascending;
                                    if (!string.IsNullOrWhiteSpace(itemPair[1]))
                                    {
                                        sortDirection = itemPair[1].ConvertToEnum <SortDirection>(SortDirection.Ascending);
                                    }
                                    fieldDirection.Add(itemPair[0] + (sortDirection == SortDirection.Descending ? " desc" : ""));
                                }
                            }

                            sortProperty           = new SortProperty();
                            sortProperty.Direction = SortDirection.Ascending;
                            sortProperty.Property  = fieldDirection.AsDelimited(",");

                            string[] columns = sortProperty.Property.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                            var itemQry = items.AsQueryable();
                            IOrderedQueryable <ContentChannelItem> orderedQry = null;

                            for (int columnIndex = 0; columnIndex < columns.Length; columnIndex++)
                            {
                                string column = columns[columnIndex].Trim();

                                var direction = sortProperty.Direction;
                                if (column.ToLower().EndsWith(" desc"))
                                {
                                    column    = column.Left(column.Length - 5);
                                    direction = sortProperty.Direction == SortDirection.Ascending ? SortDirection.Descending : SortDirection.Ascending;
                                }

                                try
                                {
                                    if (column.StartsWith("Attribute:"))
                                    {
                                        string attributeKey = column.Substring(10);

                                        if (direction == SortDirection.Ascending)
                                        {
                                            orderedQry = (columnIndex == 0) ?
                                                         itemQry.OrderBy(i => i.AttributeValues.Where(v => v.Key == attributeKey).FirstOrDefault().Value.SortValue) :
                                                         orderedQry.ThenBy(i => i.AttributeValues.Where(v => v.Key == attributeKey).FirstOrDefault().Value.SortValue);
                                        }
                                        else
                                        {
                                            orderedQry = (columnIndex == 0) ?
                                                         itemQry.OrderByDescending(i => i.AttributeValues.Where(v => v.Key == attributeKey).FirstOrDefault().Value.SortValue) :
                                                         orderedQry.ThenByDescending(i => i.AttributeValues.Where(v => v.Key == attributeKey).FirstOrDefault().Value.SortValue);
                                        }
                                    }
                                    else
                                    {
                                        if (direction == SortDirection.Ascending)
                                        {
                                            orderedQry = (columnIndex == 0) ? itemQry.OrderBy(column) : orderedQry.ThenBy(column);
                                        }
                                        else
                                        {
                                            orderedQry = (columnIndex == 0) ? itemQry.OrderByDescending(column) : orderedQry.ThenByDescending(column);
                                        }
                                    }
                                }
                                catch { }
                            }

                            try
                            {
                                if (orderedQry != null)
                                {
                                    items = orderedQry.ToList();
                                }
                            }
                            catch { }
                        }

                        if (ItemCacheDuration.HasValue && ItemCacheDuration.Value > 0)
                        {
                            var cacheItemPolicy = new CacheItemPolicy {
                                AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(ItemCacheDuration.Value)
                            };
                            AddCacheItem(CONTENT_CACHE_KEY, items, cacheItemPolicy);
                        }
                    }
                }
            }

            return(items);
        }
        /// <summary>
        /// Binds the grid.
        /// </summary>
        private void BindGrid(bool isExporting = false)
        {
            int?personId      = null;
            int?givingGroupId = null;

            bool validRequest = false;

            if (TargetPerson != null)
            {
                personId      = TargetPerson.Id;
                givingGroupId = TargetPerson.GivingGroupId;
                validRequest  = true;
            }
            else
            {
                int personEntityTypeId = EntityTypeCache.Read("Rock.Model.Person").Id;
                if (!ContextTypesRequired.Any(e => e.Id == personEntityTypeId))
                {
                    validRequest = true;
                }
            }

            if (validRequest)
            {
                var rockContext = new RockContext();
                var qry         = new FinancialScheduledTransactionService(rockContext)
                                  .Queryable("ScheduledTransactionDetails,FinancialPaymentDetail.CurrencyTypeValue,FinancialPaymentDetail.CreditCardTypeValue")
                                  .AsNoTracking();

                // Valid Accounts
                var accountGuids = GetAttributeValue("Accounts").SplitDelimitedValues().AsGuidList();
                if (accountGuids.Any())
                {
                    qry = qry.Where(t => t.ScheduledTransactionDetails.Any(d => accountGuids.Contains(d.Account.Guid)));
                }

                // Amount Range
                var nre = new NumberRangeEditor();
                nre.DelimitedValues = gfSettings.GetUserPreference("Amount");
                if (nre.LowerValue.HasValue)
                {
                    qry = qry.Where(t => t.ScheduledTransactionDetails.Sum(d => d.Amount) >= nre.LowerValue.Value);
                }

                if (nre.UpperValue.HasValue)
                {
                    qry = qry.Where(t => t.ScheduledTransactionDetails.Sum(d => d.Amount) <= nre.UpperValue.Value);
                }

                // Frequency
                int?frequencyTypeId = gfSettings.GetUserPreference("Frequency").AsIntegerOrNull();
                if (frequencyTypeId.HasValue)
                {
                    qry = qry.Where(t => t.TransactionFrequencyValueId == frequencyTypeId.Value);
                }

                // Date Range
                var drp = new DateRangePicker();
                drp.DelimitedValues = gfSettings.GetUserPreference("Created");
                if (drp.LowerValue.HasValue)
                {
                    qry = qry.Where(t => t.CreatedDateTime >= drp.LowerValue.Value);
                }

                if (drp.UpperValue.HasValue)
                {
                    DateTime upperDate = drp.UpperValue.Value.Date.AddDays(1);
                    qry = qry.Where(t => t.CreatedDateTime < upperDate);
                }

                // Account Id
                int accountId = int.MinValue;
                if (int.TryParse(gfSettings.GetUserPreference("Account"), out accountId) && ddlAccount.Visible)
                {
                    qry = qry.Where(t => t.ScheduledTransactionDetails.Any(d => d.AccountId == accountId));
                }

                // Active only (no filter)
                if (string.IsNullOrWhiteSpace(gfSettings.GetUserPreference("Include Inactive")))
                {
                    qry = qry.Where(t => t.IsActive);
                }

                if (givingGroupId.HasValue)
                {
                    //  Person contributes with family
                    qry = qry.Where(t => t.AuthorizedPersonAlias.Person.GivingGroupId == givingGroupId);
                }
                else if (personId.HasValue)
                {
                    // Person contributes individually
                    qry = qry.Where(t => t.AuthorizedPersonAlias.PersonId == personId);
                }

                SortProperty sortProperty = gList.SortProperty;
                if (sortProperty != null)
                {
                    if (sortProperty.Property == "Amount")
                    {
                        if (sortProperty.Direction == SortDirection.Ascending)
                        {
                            qry = qry.OrderBy(t => t.ScheduledTransactionDetails.Sum(d => (decimal?)d.Amount) ?? 0.00M);
                        }
                        else
                        {
                            qry = qry.OrderByDescending(t => t.ScheduledTransactionDetails.Sum(d => (decimal?)d.Amount) ?? 0.0M);
                        }
                    }
                    else
                    {
                        qry = qry.Sort(sortProperty);
                    }
                }
                else
                {
                    qry = qry
                          .OrderBy(t => t.AuthorizedPersonAlias.Person.LastName)
                          .ThenBy(t => t.AuthorizedPersonAlias.Person.NickName)
                          .ThenByDescending(t => t.IsActive)
                          .ThenByDescending(t => t.StartDate);
                }

                _isExporting = isExporting;

                gList.SetLinqDataSource <FinancialScheduledTransaction>(qry);
                gList.DataBind();

                _isExporting = false;
            }
        }
示例#29
0
        /// <summary>
        /// Binds the grid.
        /// </summary>
        private void BindGrid()
        {
            int?metricId = hfMetricId.Value.AsIntegerOrNull();

            if (!metricId.HasValue)
            {
                return;
            }

            var                rockContext        = new RockContext();
            SortProperty       sortProperty       = gMetricValues.SortProperty;
            MetricValueService metricValueService = new MetricValueService(rockContext);
            var                qry = metricValueService.Queryable().Include(a => a.MetricValuePartitions);

            qry = qry.Where(a => a.MetricId == metricId);

            var metricValuePartitionsColumn = gMetricValues.Columns.OfType <RockLiteralField>().FirstOrDefault(a => a.ID == "lMetricValuePartitions");
            var metric = new MetricService(rockContext).Get(metricId ?? 0);

            metricValuePartitionsColumn.Visible = metric != null && metric.MetricPartitions.Any(a => a.EntityTypeId.HasValue);

            var drp = new DateRangePicker();

            drp.DelimitedValues = gfMetricValues.GetUserPreference("Date Range");
            if (drp.LowerValue.HasValue)
            {
                qry = qry.Where(a => a.MetricValueDateTime >= drp.LowerValue.Value);
            }

            if (drp.UpperValue.HasValue)
            {
                DateTime upperDate = drp.UpperValue.Value.Date.AddDays(1);
                qry = qry.Where(a => a.MetricValueDateTime < upperDate);
            }

            var metricValueType = gfMetricValues.GetUserPreference("Goal/Measure").ConvertToEnumOrNull <MetricValueType>();

            if (metricValueType.HasValue)
            {
                qry = qry.Where(a => a.MetricValueType == metricValueType.Value);
            }

            var entityTypeEntityUserPreference = gfMetricValues.GetUserPreference(this.EntityTypeEntityPreferenceKey) ?? string.Empty;

            var entityTypeEntityList = entityTypeEntityUserPreference.Split(',').Select(a => a.Split('|')).Where(a => a.Length == 2).Select(a =>
                                                                                                                                            new
            {
                EntityTypeId = a[0].AsIntegerOrNull(),
                EntityId     = a[1].AsIntegerOrNull()
            });

            foreach (var entityTypeEntity in entityTypeEntityList)
            {
                if (entityTypeEntity.EntityTypeId.HasValue && entityTypeEntity.EntityId.HasValue)
                {
                    qry = qry.Where(a => a.MetricValuePartitions.Any(x => x.MetricPartition.EntityTypeId == entityTypeEntity.EntityTypeId && x.EntityId == entityTypeEntity.EntityId));
                }
            }

            if (sortProperty != null)
            {
                qry = qry.Sort(sortProperty);
            }
            else
            {
                qry = qry.OrderByDescending(s => s.MetricValueDateTime).ThenBy(s => s.YValue).ThenBy(s => s.XValue).ThenByDescending(s => s.ModifiedDateTime);
            }

            gMetricValues.SetLinqDataSource(qry);

            gMetricValues.DataBind();
        }
        /// <summary>
        /// Binds the grid to a list of Prayer Requests.
        /// </summary>
        private void BindGrid()
        {
            PrayerRequestService prayerRequestService = new PrayerRequestService(new RockContext());
            SortProperty         sortProperty         = gPrayerRequests.SortProperty;

            var prayerRequests = prayerRequestService.Queryable().Select(a =>
                                                                         new
            {
                a.Id,
                FullName     = a.FirstName + " " + a.LastName,
                CategoryName = a.Category.Name,
                EnteredDate  = a.EnteredDateTime,
                a.ExpirationDate,
                a.Text,
                a.FlagCount,
                a.IsApproved,
                a.CategoryId,
                CategoryParentCategoryId = a.Category.ParentCategoryId,
                a.IsUrgent,
                a.IsPublic,
                a.IsActive,
                a.AllowComments
            });

            // Filter by prayer category if one is selected...
            int selectedPrayerCategoryID = catpPrayerCategoryFilter.SelectedValue.AsInteger(false) ?? All.Id;

            if (selectedPrayerCategoryID != All.Id && selectedPrayerCategoryID != None.Id)
            {
                prayerRequests = prayerRequests.Where(c => c.CategoryId == selectedPrayerCategoryID ||
                                                      c.CategoryParentCategoryId == selectedPrayerCategoryID);
            }

            // Filter by approved/unapproved
            if (ddlApprovedFilter.SelectedIndex > -1)
            {
                if (ddlApprovedFilter.SelectedValue == "unapproved")
                {
                    prayerRequests = prayerRequests.Where(a => a.IsApproved == false || !a.IsApproved.HasValue);
                }
                else if (ddlApprovedFilter.SelectedValue == "approved")
                {
                    prayerRequests = prayerRequests.Where(a => a.IsApproved == true);
                }
            }

            // Filter by urgent/non-urgent
            if (ddlUrgentFilter.SelectedIndex > -1)
            {
                if (ddlUrgentFilter.SelectedValue == "non-urgent")
                {
                    prayerRequests = prayerRequests.Where(a => a.IsUrgent == false || !a.IsUrgent.HasValue);
                }
                else if (ddlUrgentFilter.SelectedValue == "urgent")
                {
                    prayerRequests = prayerRequests.Where(a => a.IsUrgent == true);
                }
            }

            // Filter by public/non-public
            if (ddlPublicFilter.SelectedIndex > -1)
            {
                if (ddlPublicFilter.SelectedValue == "non-public")
                {
                    prayerRequests = prayerRequests.Where(a => a.IsPublic == false || !a.IsPublic.HasValue);
                }
                else if (ddlPublicFilter.SelectedValue == "public")
                {
                    prayerRequests = prayerRequests.Where(a => a.IsPublic == true);
                }
            }

            // Filter by active/inactive
            if (ddlActiveFilter.SelectedIndex > -1)
            {
                if (ddlActiveFilter.SelectedValue == "inactive")
                {
                    prayerRequests = prayerRequests.Where(a => a.IsActive == false || !a.IsActive.HasValue);
                }
                else if (ddlActiveFilter.SelectedValue == "active")
                {
                    prayerRequests = prayerRequests.Where(a => a.IsActive == true);
                }
            }

            // Filter by active/inactive
            if (ddlAllowCommentsFilter.SelectedIndex > -1)
            {
                if (ddlAllowCommentsFilter.SelectedValue == "unallow")
                {
                    prayerRequests = prayerRequests.Where(a => a.AllowComments == false || !a.AllowComments.HasValue);
                }
                else if (ddlAllowCommentsFilter.SelectedValue == "allow")
                {
                    prayerRequests = prayerRequests.Where(a => a.AllowComments == true);
                }
            }

            // Filter by Date Range
            if (drpDateRange.LowerValue.HasValue)
            {
                DateTime startDate = drpDateRange.LowerValue.Value.Date;
                prayerRequests = prayerRequests.Where(a => a.EnteredDate >= startDate);
            }

            if (drpDateRange.UpperValue.HasValue)
            {
                // Add one day in order to include everything up to the end of the selected datetime.
                var endDate = drpDateRange.UpperValue.Value.AddDays(1);
                prayerRequests = prayerRequests.Where(a => a.EnteredDate < endDate);
            }

            // Don't show expired prayer requests.
            // TODO save users filter setting?
            if (!cbShowExpired.Checked)
            {
                prayerRequests = prayerRequests.Where(a => RockDateTime.Today <= a.ExpirationDate);
            }

            // Sort by the given property otherwise sort by the EnteredDate (and Id)
            // (this is a hack because the Date field alone doesn't sort in the descending direction well)
            if (sortProperty != null)
            {
                gPrayerRequests.DataSource = prayerRequests.Sort(sortProperty).ToList();
            }
            else
            {
                // TODO Figure out how to tell Grid what Direction and Property it's sorting on
                //sortProperty.Direction = SortDirection.Ascending;
                //sortProperty.Property = "EnteredDate";
                gPrayerRequests.DataSource = prayerRequests.OrderByDescending(p => p.EnteredDate).ThenByDescending(p => p.Id).ToList();
            }

            gPrayerRequests.DataBind();
        }
示例#31
0
        /// <summary>
        /// Binds the grid.
        /// </summary>
        private void BindGrid()
        {
            if (Person != null)
            {
                var familyIds = families.Select(f => f.Key).ToList();
                var qry       = new HistoryService(new RockContext()).Queryable("CreatedByPersonAlias.Person")
                                .Where(h =>
                                       (h.EntityTypeId == personEntityTypeId && h.EntityId == Person.Id) ||
                                       (h.EntityTypeId == groupEntityTypeId && familyIds.Contains(h.EntityId)));

                int?categoryId = gfSettings.GetUserPreference("Category").AsIntegerOrNull();
                if (categoryId.HasValue)
                {
                    qry = qry.Where(a => a.CategoryId == categoryId.Value);
                }

                string summary = gfSettings.GetUserPreference("Summary Contains");
                if (!string.IsNullOrWhiteSpace(summary))
                {
                    qry = qry.Where(h => h.Summary.Contains(summary));
                }

                int personId = int.MinValue;
                if (int.TryParse(gfSettings.GetUserPreference("Who"), out personId))
                {
                    qry = qry.Where(h => h.CreatedByPersonAlias.PersonId == personId);
                }

                var drp = new DateRangePicker();
                drp.DelimitedValues = gfSettings.GetUserPreference("Date Range");
                if (drp.LowerValue.HasValue)
                {
                    qry = qry.Where(h => h.CreatedDateTime >= drp.LowerValue.Value);
                }
                if (drp.UpperValue.HasValue)
                {
                    DateTime upperDate = drp.UpperValue.Value.Date.AddDays(1);
                    qry = qry.Where(h => h.CreatedDateTime < upperDate);
                }

                SortProperty sortProperty = gHistory.SortProperty;
                if (sortProperty != null)
                {
                    qry = qry.Sort(sortProperty);
                }
                else
                {
                    qry = qry.OrderByDescending(t => t.CreatedDateTime);
                }

                // Combine history records that were saved at the same time
                var histories = new List <History>();
                foreach (var history in qry)
                {
                    var existingHistory = histories
                                          .Where(h =>
                                                 h.CreatedByPersonAliasId == history.CreatedByPersonAliasId &&
                                                 h.CreatedDateTime == history.CreatedDateTime &&
                                                 h.EntityTypeId == history.EntityTypeId &&
                                                 h.EntityId == history.EntityId &&
                                                 h.CategoryId == history.CategoryId &&
                                                 h.RelatedEntityTypeId == history.RelatedEntityTypeId &&
                                                 h.RelatedEntityId == history.RelatedEntityId).FirstOrDefault();
                    if (existingHistory != null)
                    {
                        existingHistory.Summary += "<br/>" + history.Summary;
                    }
                    else
                    {
                        histories.Add(history);
                    }
                }

                gHistory.DataSource = histories.Select(h => new
                {
                    Id                  = h.Id,
                    CategoryId          = h.CategoryId,
                    Category            = h.Category != null ? h.Category.Name : "",
                    EntityTypeId        = h.EntityTypeId,
                    EntityId            = h.EntityId,
                    Caption             = h.Caption ?? string.Empty,
                    Summary             = h.Summary,
                    RelatedEntityTypeId = h.RelatedEntityTypeId ?? 0,
                    RelatedEntityId     = h.RelatedEntityId ?? 0,
                    CreatedByPersonId   = h.CreatedByPersonAlias != null ? h.CreatedByPersonAlias.PersonId : 0,
                    PersonName          = h.CreatedByPersonAlias != null && h.CreatedByPersonAlias.Person != null ? h.CreatedByPersonAlias.Person.NickName + " " + h.CreatedByPersonAlias.Person.LastName : "",
                    CreatedDateTime     = h.CreatedDateTime
                }).ToList();

                gHistory.EntityTypeId = EntityTypeCache.Read <History>().Id;
                gHistory.DataBind();
            }
        }
        /// <summary>
        /// Binds the grid.
        /// </summary>
        private void BindGrid()
        {
            phSummary.Controls.Clear();
            rFilter.Visible = true;
            gList.Visible   = true;
            RockContext rockContext = new RockContext();
            BenevolenceRequestService benevolenceRequestService = new BenevolenceRequestService(rockContext);
            var qry = benevolenceRequestService.Queryable("BenevolenceResults,RequestedByPersonAlias,RequestedByPersonAlias.Person,CaseWorkerPersonAlias,CaseWorkerPersonAlias.Person");

            // Filter by Start Date
            DateTime?startDate = drpDate.LowerValue;

            if (startDate != null)
            {
                qry = qry.Where(b => b.RequestDateTime >= startDate);
            }

            // Filter by End Date
            DateTime?endDate = drpDate.UpperValue;

            if (endDate != null)
            {
                qry = qry.Where(b => b.RequestDateTime <= endDate);
            }

            // Filter by Campus
            if (cpCampus.SelectedCampusId.HasValue)
            {
                qry = qry.Where(b => b.CampusId == cpCampus.SelectedCampusId);
            }

            if (TargetPerson != null)
            {
                // show benevolence request for the target person and also for their family members
                var qryFamilyMembers = TargetPerson.GetFamilyMembers(true, rockContext);
                qry = qry.Where(a => a.RequestedByPersonAliasId.HasValue && qryFamilyMembers.Any(b => b.PersonId == a.RequestedByPersonAlias.PersonId));
            }
            else
            {
                // Filter by First Name
                string firstName = tbFirstName.Text;
                if (!string.IsNullOrWhiteSpace(firstName))
                {
                    qry = qry.Where(b => b.FirstName.StartsWith(firstName));
                }

                // Filter by Last Name
                string lastName = tbLastName.Text;
                if (!string.IsNullOrWhiteSpace(lastName))
                {
                    qry = qry.Where(b => b.LastName.StartsWith(lastName));
                }
            }

            // Filter by Government Id
            string governmentId = tbGovernmentId.Text;

            if (!string.IsNullOrWhiteSpace(governmentId))
            {
                qry = qry.Where(b => b.GovernmentId.StartsWith(governmentId));
            }

            // Filter by Case Worker
            int?caseWorkerPersonAliasId = ddlCaseWorker.SelectedItem.Value.AsIntegerOrNull();

            if (caseWorkerPersonAliasId != null)
            {
                qry = qry.Where(b => b.CaseWorkerPersonAliasId == caseWorkerPersonAliasId);
            }

            // Filter by Result
            int?resultTypeValueId = ddlResult.SelectedItem.Value.AsIntegerOrNull();

            if (resultTypeValueId != null)
            {
                qry = qry.Where(b => b.BenevolenceResults.Where(r => r.ResultTypeValueId == resultTypeValueId).Count() > 0);
            }

            // Filter by Request Status
            int?requestStatusValueId = ddlStatus.SelectedItem.Value.AsIntegerOrNull();

            if (requestStatusValueId != null)
            {
                qry = qry.Where(b => b.RequestStatusValueId == requestStatusValueId);
            }

            SortProperty sortProperty = gList.SortProperty;

            if (sortProperty != null)
            {
                if (sortProperty.Property == "TotalAmount")
                {
                    if (sortProperty.Direction == SortDirection.Descending)
                    {
                        qry = qry.OrderByDescending(a => a.BenevolenceResults.Sum(b => b.Amount));
                    }
                    else
                    {
                        qry = qry.OrderBy(a => a.BenevolenceResults.Sum(b => b.Amount));
                    }
                }
                else
                {
                    qry = qry.Sort(sortProperty);
                }
            }
            else
            {
                qry = qry.OrderByDescending(a => a.RequestDateTime).ThenByDescending(a => a.Id);
            }

            // Filter query by any configured attribute filters
            if (AvailableAttributes != null && AvailableAttributes.Any())
            {
                var attributeValueService = new AttributeValueService(rockContext);
                var parameterExpression   = attributeValueService.ParameterExpression;

                foreach (var attribute in AvailableAttributes)
                {
                    var filterControl = phAttributeFilters.FindControl("filter_" + attribute.Id.ToString());
                    if (filterControl != null)
                    {
                        var filterValues = attribute.FieldType.Field.GetFilterValues(filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter);
                        var expression   = attribute.FieldType.Field.AttributeFilterExpression(attribute.QualifierValues, filterValues, parameterExpression);
                        if (expression != null)
                        {
                            var attributeValues = attributeValueService
                                                  .Queryable()
                                                  .Where(v => v.Attribute.Id == attribute.Id);

                            attributeValues = attributeValues.Where(parameterExpression, expression, null);

                            qry = qry.Where(w => attributeValues.Select(v => v.EntityId).Contains(w.Id));
                        }
                    }
                }
            }

            gList.DataSource = qry.ToList();
            gList.DataBind();

            // Builds the Totals section
            var definedTypeCache = DefinedTypeCache.Read(new Guid(Rock.SystemGuid.DefinedType.BENEVOLENCE_RESULT_TYPE));
            Dictionary <string, decimal> resultTotals = new Dictionary <string, decimal>();
            decimal grandTotal = 0;

            foreach (BenevolenceRequest request in qry.ToList())
            {
                foreach (BenevolenceResult result in request.BenevolenceResults)
                {
                    if (result.Amount != null)
                    {
                        if (resultTotals.ContainsKey(result.ResultTypeValue.Value))
                        {
                            resultTotals[result.ResultTypeValue.Value] += result.Amount.Value;
                        }
                        else
                        {
                            resultTotals.Add(result.ResultTypeValue.Value, result.Amount.Value);
                        }

                        grandTotal += result.Amount.Value;
                    }
                }
            }

            foreach (KeyValuePair <string, decimal> keyValuePair in resultTotals)
            {
                phSummary.Controls.Add(new LiteralControl(string.Format("<div class='row'><div class='col-xs-8'>{0}: </div><div class='col-xs-4 text-right'>{1}{2:#,##0.00}</div></div>", keyValuePair.Key, GlobalAttributesCache.Value("CurrencySymbol"), keyValuePair.Value)));
            }

            phSummary.Controls.Add(new LiteralControl(string.Format("<div class='row'><div class='col-xs-8'><b>Total: </div><div class='col-xs-4 text-right'>{0}{1:#,##0.00}</b></div></div>", GlobalAttributesCache.Value("CurrencySymbol"), grandTotal)));
        }
        /// <summary>
        /// Binds the grid.
        /// </summary>
        protected void BindGrid()
        {
            var showProfilesViewed = GetAttributeValue("SeeProfilesViewed").AsBoolean();
            var rockContext        = new RockContext();

            var personViewedService = new PersonViewedService(rockContext);
            var personService       = new PersonService(rockContext);

            if (showProfilesViewed)
            {
                // This grid should show the profiles viewed by this person.
                pnlViewed.Visible   = true;
                pnlViewedBy.Visible = false;

                if (personId.HasValue)
                {
                    var viewedList = personViewedService.Queryable()
                                     .Where(p => p.ViewerPersonAlias != null && p.ViewerPersonAlias.PersonId == personId)
                                     .GroupBy(p => p.TargetPersonAlias.PersonId)
                                     .Select(p => new
                    {
                        TargetPersonId = p.Key,
                        FirstViewed    = p.Min(g => g.ViewDateTime),
                        LastViewed     = p.Max(g => g.ViewDateTime),
                        ViewedCount    = p.Count()
                    });

                    var pQry = personService.Queryable();

                    var qry = viewedList
                              .Join(pQry, v => v.TargetPersonId, p => p.Id, (v, p) => new
                    {
                        p.Id,
                        FullName = p.NickName + " " + p.LastName,
                        p.BirthDate,
                        p.Gender,
                        FirstViewedDate = v.FirstViewed,
                        LastViewedDate  = v.LastViewed,
                        ViewedCount     = v.ViewedCount
                    });

                    SortProperty sortProperty = gViewed.SortProperty;
                    if (sortProperty != null)
                    {
                        qry = qry.Sort(sortProperty);
                    }
                    else
                    {
                        qry = qry.OrderByDescending(q => q.LastViewedDate);
                    }

                    gViewed.EntityTypeId = EntityTypeCache.Read <PersonViewed>().Id;
                    gViewed.DataSource   = qry.ToList();
                    gViewed.DataBind();
                }
            }
            else
            {
                // This grid should show the profiles that have viewed this person.
                pnlViewed.Visible   = false;
                pnlViewedBy.Visible = true;

                if (personId.HasValue)
                {
                    var viewedList = personViewedService.Queryable()
                                     .Where(p => p.TargetPersonAlias != null && p.TargetPersonAlias.PersonId == personId)
                                     .GroupBy(p => p.ViewerPersonAlias.PersonId)
                                     .Select(p => new
                    {
                        ViewerPersonId = p.Key,
                        FirstViewed    = p.Min(g => g.ViewDateTime),
                        LastViewed     = p.Max(g => g.ViewDateTime),
                        ViewedCount    = p.Count()
                    });

                    var pQry = personService.Queryable();

                    var qry = viewedList
                              .Join(pQry, v => v.ViewerPersonId, p => p.Id, (v, p) => new
                    {
                        p.Id,
                        FullName = p.NickName + " " + p.LastName,
                        p.BirthDate,
                        p.Gender,
                        FirstViewedDate = v.FirstViewed,
                        LastViewedDate  = v.LastViewed,
                        ViewedCount     = v.ViewedCount
                    });

                    SortProperty sortProperty = gViewedBy.SortProperty;
                    if (sortProperty != null)
                    {
                        qry = qry.Sort(sortProperty);
                    }
                    else
                    {
                        qry = qry.OrderByDescending(q => q.LastViewedDate);
                    }

                    gViewedBy.EntityTypeId = EntityTypeCache.Read <Person>().Id;
                    gViewedBy.DataSource   = qry.ToList();
                    gViewedBy.DataBind();
                }
            }
        }
示例#34
0
    private void RefreshDataSource(int pageIndex, string searchText)
    {
        int totalPages = 0;

        ResourceListView.PageIndex    = 0;
        ResourceListView.TotalRecords = 0;
        ResourceListView.DataSource.Clear();
        if (!string.IsNullOrEmpty(searchText))
        {
            int totalRecords = 0;
            ResourceListView.PageSize = _pageSize;
            int             totalParsedRecords = totalParsedRecords = _pageSize * pageIndex;
            List <Resource> foundRestResource  = null;
            Dictionary <Guid, IEnumerable <string> > userPermissions = null;

            SortProperty sortProp = null;
            if (ResourceListView.SortDirection == System.Web.UI.WebControls.SortDirection.Ascending)
            {
                sortProp = new SortProperty(ResourceListView.SortExpression, Zentity.Platform.SortDirection.Ascending);
            }
            else
            {
                sortProp = new SortProperty(ResourceListView.SortExpression, Zentity.Platform.SortDirection.Descending);
            }

            //search resources and user permissions on the searched resources.
            using (ResourceDataAccess dataAccess = new ResourceDataAccess())
            {
                AuthenticatedToken token = this.Session[Constants.AuthenticationTokenKey] as AuthenticatedToken;
                if (token != null)
                {
                    foundRestResource = dataAccess.SearchResources(token, searchText, _pageSize, sortProp, totalParsedRecords,
                                                                   false, out totalRecords).ToList();
                    userPermissions = GetPermissions(token, foundRestResource);
                }
            }

            //Calculate total pages
            if (totalRecords > 0)
            {
                totalPages = Convert.ToInt32(Math.Ceiling((double)totalRecords / _pageSize));
            }

            // Update empty resource's title with default value.
            if (foundRestResource != null && foundRestResource.Count() > 0)
            {
                Utility.UpdateResourcesEmptyTitle(foundRestResource);
            }

            //Bind data to GridView
            ResourceListView.TotalRecords = totalRecords;
            ResourceListView.PageIndex    = pageIndex;

            foreach (Resource resource in foundRestResource)
            {
                ResourceListView.DataSource.Add(resource);
            }

            ResourceListView.UserPermissions = userPermissions;
            //Enable feed for this page.
            string searchString = GetSearchString();
            if (!string.IsNullOrEmpty(searchString))
            {
                ResourceListView.EnableFeed(searchString);
            }
            ResourceListView.DataBind();
        }
    }
        /// <summary>
        /// Binds the event calendar items grid.
        /// </summary>
        protected void BindConnectionOpportunitiesGrid()
        {
            if (_connectionType != null)
            {
                pnlConnectionOpportunities.Visible = true;

                rFilter.Visible = true;
                gConnectionOpportunities.Visible = true;

                var rockContext = new RockContext();

                ConnectionOpportunityService connectionOpportunityService = new ConnectionOpportunityService(rockContext);
                var qry = connectionOpportunityService.Queryable()
                          .Where(o => o.ConnectionTypeId == _connectionType.Id);

                // Filter by Active Only
                if (cbActive.Checked)
                {
                    qry = qry.Where(o => o.IsActive);
                }

                // Filter query by any configured attribute filters
                if (AvailableAttributes != null && AvailableAttributes.Any())
                {
                    var attributeValueService = new AttributeValueService(rockContext);
                    var parameterExpression   = attributeValueService.ParameterExpression;

                    foreach (var attribute in AvailableAttributes)
                    {
                        var filterControl = phAttributeFilters.FindControl("filter_" + attribute.Id.ToString());
                        if (filterControl != null)
                        {
                            var filterValues = attribute.FieldType.Field.GetFilterValues(filterControl, attribute.QualifierValues, Rock.Reporting.FilterMode.SimpleFilter);
                            var expression   = attribute.FieldType.Field.AttributeFilterExpression(attribute.QualifierValues, filterValues, parameterExpression);
                            if (expression != null)
                            {
                                var attributeValues = attributeValueService
                                                      .Queryable()
                                                      .Where(v => v.Attribute.Id == attribute.Id);

                                attributeValues = attributeValues.Where(parameterExpression, expression, null);

                                qry = qry.Where(w => attributeValues.Select(v => v.EntityId).Contains(w.Id));
                            }
                        }
                    }
                }
                SortProperty sortProperty = gConnectionOpportunities.SortProperty;

                List <ConnectionOpportunity> connectionOpportunities = null;
                if (sortProperty != null)
                {
                    connectionOpportunities = qry.Sort(sortProperty).ToList();
                }
                else
                {
                    connectionOpportunities = qry.ToList().OrderBy(a => a.Name).ToList();
                }

                gConnectionOpportunities.DataSource = connectionOpportunities;
                gConnectionOpportunities.DataBind();
            }
            else
            {
                pnlConnectionOpportunities.Visible = false;
            }
        }
示例#36
0
 public DBCollection(XPCollection collection)
     : this(collection.Session, collection.ObjectType, collection.Criteria)
 {
     var sortProperties = new SortProperty[collection.Sorting.Count];
     for (int i = 0; i < collection.Sorting.Count; i++)
     {
         SortProperty sortProperty = collection.Sorting[i];
         sortProperties[i] = new SortProperty(sortProperty.PropertyName, sortProperty.Direction);
     }
     Sorting = new SortingCollection(this, sortProperties);
 }
示例#37
0
        private void ImportLessons(Session uow, XElement xElement, 
            Dictionary <string,Lesson> lessonDic,
            Dictionary<string,Subject> subjectDic,
            Dictionary<string,TkbClass> classDic,
            Dictionary<string, TkbGroup> groupDic,
            Dictionary<string,TkbTeacher> teacherDic,
            StreamWriter fileStreamlog)
        {
            SortProperty sort = new SortProperty("LessonCode", SortingDirection.Descending);
            int nextcode = 0;
            using (XPCollection collection = new XPCollection(uow, typeof(Lesson), new BinaryOperator(
                "Semester.SemesterName", Semester.SemesterName), sort) { TopReturnedObjects = 1 })
            {
                if (collection.Count > 0)
                {
                    Lesson firstLesson = collection[0] as Lesson;
                    nextcode = firstLesson.LessonCode;
                }
            }
            int newcode=Convert.ToInt32(Semester.SemesterName+"0000"); //first lesson of semester
            if (newcode > nextcode)
                nextcode = newcode;
            foreach (XElement row in xElement.Elements())
            {
                string sid = "", classids = "", subjectid = "", teacherids = "", classroomids = "", groupids = "";
                string weeks = "", studentcoustudentidsnt = "", periodsperweek = "";
                int periodspercard = 0;

                foreach (XAttribute column in row.Attributes())
                {
                    switch (column.Name.LocalName)
                    {
                        case "id":
                            sid = column.Value;
                            break;
                        case "classids":
                            classids = column.Value;
                            break;
                        case "subjectid":
                            subjectid = column.Value;
                            break;
                        case "periodspercard":
                            periodspercard = int.Parse(column.Value);
                            break;
                        case "periodsperweek":
                            periodsperweek = column.Value;
                            break;
                        case "teacherids":
                            teacherids = column.Value;
                            break;
                        case "classroomids":
                            classroomids = column.Value;
                            break;
                        case "groupids":
                            groupids = column.Value;
                            break;
                        case "studentcoustudentidsnt":
                            studentcoustudentidsnt = column.Value;
                            break;
                        case "weeks":
                            weeks = column.Value;
                            break;
                        default:
                            break;
                    }
                }
                TkbLesson tkblesson = uow.FindObject<TkbLesson>(new BinaryOperator("ID", sid));
                if (tkblesson == null)
                {
                    tkblesson = new TkbLesson(uow)
                    {
                        Semester = uow.FindObject<Semester>(new BinaryOperator("Oid", this.Semester.Oid)),
                        ID = sid,
                        PeriodsPerCard = periodspercard,
                        PeriodsPerWeek = periodsperweek,
                        ClassroomIDs = classroomids,
                        GroupIDs = groupids,
                        StudentIDs = studentcoustudentidsnt,
                        Week = weeks,
                        Note = this.Note,
                        SubjectID = (subjectDic.ContainsKey(subjectid)?subjectDic[subjectid].SubjectCode:null)
                    };
                    tkblesson.NumExpectation = 0;
                    tkblesson.GroupIDs = "";
                    if (groupids != "")
                    {
                        foreach (string groupid in groupids.Split(','))
                        {
                            string groupname ="";
                            if (groupDic.ContainsKey(groupid))
                            {
                                if (groupDic[groupid].EntireClass)
                                {
                                    groupname = classDic.ContainsKey(groupDic[groupid].Classid) ?
                                        classDic[groupDic[groupid].Classid].Name :
                                        groupDic[groupid].Name;
                                }
                                else
                                {
                                    groupname = groupDic[groupid].Name;
                                }
                            }
                            else
                            {
                                groupname = groupid;
                            }

                            tkblesson.GroupIDs += (groupname!="" ? groupname  + "," : "");
                            tkblesson.NumExpectation += (groupDic.ContainsKey(groupid) ? groupDic[groupid].StudentCount : 0);
                        }
                        tkblesson.GroupIDs = tkblesson.GroupIDs.TrimEnd(',');
                    }

                    tkblesson.ClassIDs = "";
                    if (classids != "")
                    {
                        foreach (string classid in classids.Split(','))
                        {
                            tkblesson.ClassIDs += (classDic.ContainsKey(classid) ?  classDic[classid].Short + "," :"");
                        }
                        tkblesson.ClassIDs= tkblesson.ClassIDs.TrimEnd(',');
                    }
                    tkblesson.TeacherIDs = "";

                    if (teacherids != "")
                    {
                        foreach (string teacherid in teacherids.Split(','))
                        {

                            tkblesson.TeacherIDs += (teacherDic.ContainsKey(teacherid)? teacherDic[teacherid].Short + "," : "");
                        }
                        tkblesson.TeacherIDs = tkblesson.TeacherIDs.TrimEnd(',');
                    }
                    tkblesson.Save();

                    //fileStreamlog.WriteLine(String.Format("Create tkblesson: \"{0}\" successful on {1: dd-mm-yyyy HH:MM:ss}", tkblesson.ID + "-" + tkblesson.SubjectID, DateTime.Now));

                }
                else
                {
                    tkblesson.Semester = uow.FindObject<Semester>(new BinaryOperator("Oid", this.Semester.Oid));
                    tkblesson.ID = sid;
                    tkblesson.PeriodsPerCard = periodspercard;
                    tkblesson.PeriodsPerWeek = periodsperweek;
                    tkblesson.ClassroomIDs = classroomids;
                    tkblesson.StudentIDs = studentcoustudentidsnt;
                    tkblesson.Week = weeks;
                    tkblesson.Note = this.Note;
                    tkblesson.SubjectID = (subjectDic.ContainsKey(subjectid) ? subjectDic[subjectid].SubjectCode : "");

                    tkblesson.NumExpectation = 0;
                    tkblesson.GroupIDs = "";
                    if (groupids != "")
                    {
                        foreach (string groupid in groupids.Split(','))
                        {
                            string groupname = "";
                            if (groupDic.ContainsKey(groupid))
                            {
                                if (groupDic[groupid].EntireClass)
                                {
                                    groupname = classDic.ContainsKey(groupDic[groupid].Classid) ?
                                        classDic[groupDic[groupid].Classid].Name :
                                        groupDic[groupid].Name;
                                }
                                else
                                {
                                    groupname = groupDic[groupid].Name;
                                }
                            }
                            else
                            {
                                groupname = groupid;
                            }

                            tkblesson.GroupIDs += (groupname != "" ? groupname + "," : "");
                            tkblesson.NumExpectation += (groupDic.ContainsKey(groupid) ? groupDic[groupid].StudentCount : 0);
                        }
                        tkblesson.GroupIDs = tkblesson.GroupIDs.TrimEnd(',');
                    }

                    tkblesson.ClassIDs = "";
                    if (classids != "")
                    {
                        foreach (string classid in classids.Split(','))
                        {
                            tkblesson.ClassIDs += (classDic.ContainsKey(classid) ? classDic[classid].Short + "," : "");
                        }
                        tkblesson.ClassIDs = tkblesson.ClassIDs.TrimEnd(',');
                    }
                    tkblesson.TeacherIDs = "";
                    if (teacherids != "")
                    {
                        foreach (string teacherid in teacherids.Split(','))
                        {

                            tkblesson.TeacherIDs += (teacherDic.ContainsKey(teacherid) ? teacherDic[teacherid].Short + "," : "");
                        }
                        tkblesson.TeacherIDs = tkblesson.TeacherIDs.TrimEnd(',');
                    }
                    tkblesson.Save();

                    //fileStreamlog.WriteLine(String.Format("Update tkblesson: \"{0}\" successful on {1: dd-mm-yyyy HH:MM:ss}", tkblesson.ID, DateTime.Now));
                }

                Lesson lesson = new Lesson(uow)
                {
                    CanRegister = Active,
                    TkbLesson = tkblesson,
                    Semester = uow.FindObject<Semester>(new BinaryOperator("Oid", this.Semester.Oid)),
                    Subject = (subjectDic.ContainsKey(subjectid) ? subjectDic[subjectid] : null),
                    LessonNote = Note,
                    ClassIDs = tkblesson.GroupIDs,
                    NumExpectation = tkblesson.NumExpectation,
                    LessonCode = ++nextcode //tăng dần
                };
                foreach (string teacherCode in tkblesson.TeacherIDs.Split(','))
                {
                    Teacher teacher = uow.FindObject<Teacher>(new BinaryOperator("TeacherCode", teacherCode));
                    if (teacher !=null)
                        lesson.Teachers.Add(teacher);
                }
                lesson.Save();
                if (lesson.Subject != null)
                {
                    //fileStreamlog.WriteLine(String.Format("Create Lesson: \"{0}\" successfully on {1: dd-mm-yyyy HH:MM:ss}", lesson.Subject.SubjectCode + lesson.TkbLesson.Name, DateTime.Now));
                    fileStreamlog.WriteLine(String.Format("<TR><TD>LESSON</TD><TD>CREATE NEW</TD><TD>\"{0}\"</TD><TD> {1:dd-mm-yy HH:MM:ss}</TD><TD>OK</TD></TR>",
                      lesson.LessonCode.ToString() + "-" + lesson.Subject.SubjectCode +"-"+ lesson.ClassIDs, DateTime.Now));
                }
                else
                {
                    //fileStreamlog.WriteLine(String.Format("WARNING: Create Lesson: \"{0}\" without Lesson \"{1}\" successfully on {2: dd-mm-yyyy HH:MM:ss}", lesson.TkbLesson.Name, tkblesson.SubjectID, DateTime.Now));
                    fileStreamlog.WriteLine(String.Format("<TR><TD>LESSON</TD><TD>CREATE NEW</TD><TD>\"{0}\"</TD><TD> {1:dd-mm-yy HH:MM:ss}</TD><TD>WARNING</TD></TR>",
                      lesson.LessonCode.ToString() + "-" + lesson.TkbLesson.Name + "-"+lesson.TkbLesson.SubjectID + "-" + lesson.ClassIDs, DateTime.Now));
                }
                lessonDic.Add(sid, lesson);

            }

            //fileStreamlog.WriteLine(String.Format("Create {0} lesson successfully on {1: dd-mm-yyyy HH:MM:ss}", lessonDic.Count, DateTime.Now));
        }