コード例 #1
0
ファイル: CategoryPicker.cs プロジェクト: ewin66/rockrms
        /// <summary>
        /// Sets the extra rest params.
        /// </summary>
        private void SetExtraRestParams()
        {
            string parms = "?getCategorizedItems=false";

            parms += string.Format("&entityTypeId={0}", EntityTypeId);

            if (!string.IsNullOrEmpty(EntityTypeQualifierColumn))
            {
                parms += string.Format("&entityQualifier={0}", EntityTypeQualifierColumn);

                if (!string.IsNullOrEmpty(EntityTypeQualifierValue))
                {
                    parms += string.Format("&entityQualifierValue={0}", EntityTypeQualifierValue);
                }
            }

            if (!string.IsNullOrEmpty(ExcludedCategoryIds))
            {
                parms += string.Format("&excludedCategoryIds={0}", ExcludedCategoryIds);
            }

            if (RootCategoryId.HasValue)
            {
                var rootCategory = CategoryCache.Get(RootCategoryId.Value);
                if (rootCategory.EntityTypeId == this.EntityTypeId)
                {
                    parms += string.Format("&rootCategoryId={0}", rootCategory.Id);
                }
            }

            ItemRestUrlExtraParams = parms;
        }
コード例 #2
0
        /// <summary>
        /// Rs the filter_ display filter value.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The e.</param>
        protected void rFilter_DisplayFilterValue(object sender, GridFilter.DisplayFilterValueArgs e)
        {
            switch (e.Key)
            {
            case "Category":
                var category = CategoryCache.Get(int.Parse(e.Value));
                e.Value = category != null ? category.Name : string.Empty;
                break;

            case "EntityType":
                var entityType = EntityTypeCache.Get(int.Parse(e.Value));
                e.Value = entityType != null ? entityType.FriendlyName : string.Empty;
                break;

            case "Owner":
                int?personId = e.Value.AsIntegerOrNull();
                if (personId.HasValue)
                {
                    var person = new PersonService(new RockContext()).Get(personId.Value);
                    if (person != null)
                    {
                        e.Value = person.FullNameReversed;
                    }
                    else
                    {
                        e.Value = string.Empty;
                    }
                }
                else
                {
                    e.Value = string.Empty;
                }
                break;
            }
        }
コード例 #3
0
        /// <summary>
        /// Handles the SaveClick event of the mdCategoryDetailConfig control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
        protected void mdCategoryDetailConfig_SaveClick(object sender, EventArgs e)
        {
            var selectedCategory = CategoryCache.Get(cpRootCategoryDetail.SelectedValue.AsInteger());

            this.SetAttributeValue(AttributeKey.RootCategory, selectedCategory != null ? selectedCategory.Guid.ToString() : string.Empty);

            var excludedCategoryIds   = cpExcludeCategoriesDetail.SelectedValuesAsInt();
            var excludedCategoryGuids = new List <Guid>();

            foreach (int excludedCategoryId in excludedCategoryIds)
            {
                var excludedCategory = CategoryCache.Get(excludedCategoryId);
                if (excludedCategory != null)
                {
                    excludedCategoryGuids.Add(excludedCategory.Guid);
                }
            }

            this.SetAttributeValue(AttributeKey.ExcludeCategories, excludedCategoryGuids.AsDelimited(","));

            this.SaveAttributeValues();

            mdCategoryDetailConfig.Visible = false;
            mdCategoryDetailConfig.Hide();
            Block_BlockUpdated(sender, e);
        }
コード例 #4
0
        /// <summary>
        /// Handles the RowDataBound event of the rGrid control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="GridViewRowEventArgs" /> instance containing the event data.</param>
        protected void rGrid_RowDataBound(object sender, GridViewRowEventArgs e)
        {
            if (e.Row.RowType == DataControlRowType.DataRow)
            {
                Literal lEntityType = e.Row.FindControl("lEntityType") as Literal;
                if (lEntityType != null)
                {
                    lEntityType.Text = "None (Global Attributes)";

                    int categoryId = (int)rGrid.DataKeys[e.Row.RowIndex].Value;
                    var category   = CategoryCache.Get(categoryId);

                    int entityTypeId = int.MinValue;
                    if (category != null &&
                        !string.IsNullOrWhiteSpace(category.EntityTypeQualifierValue) &&
                        int.TryParse(category.EntityTypeQualifierValue, out entityTypeId) &&
                        entityTypeId > 0)
                    {
                        var entityType = EntityTypeCache.Get(entityTypeId);
                        if (entityType != null)
                        {
                            lEntityType.Text = entityType.FriendlyName;
                        }
                    }
                }
            }
        }
コード例 #5
0
        public static void AddMoveHistory(RockContext rockContext, Location location, Attendance attendeeAttendance, bool isSubroom)
        {
            var moveSummary = string.Format("{0}</span> at <span class=\"field-name\">{1}", location.Name, Rock.RockDateTime.Now);

            if (isSubroom)
            {
                moveSummary += string.Format("</span> (a subroom of <span class=\"field-name\">{0})", location.ParentLocation.Name);
            }

            var changes = new History.HistoryChangeList();

            changes.AddCustom("Entry", History.HistoryChangeType.Record.ToString(), moveSummary.Truncate(250));
            changes.First().Caption             = "Moved To Location";
            changes.First().RelatedEntityTypeId = locationEntityTypeId;
            changes.First().RelatedEntityId     = location.Id;
            changes.First().RelatedData         = GetHostInfo();

            HistoryService.SaveChanges(
                rockContext,
                typeof(Rock.Model.Person),
                CategoryCache.Get(4).Guid,
                attendeeAttendance.PersonAlias.PersonId,
                changes,
                true
                );
        }
コード例 #6
0
        /// <summary>
        /// Adds the schedule columns.
        /// </summary>
        private void AddScheduleColumns()
        {
            ScheduleService scheduleService = new ScheduleService(new RockContext());

            // limit Schedules to ones that have a CheckInStartOffsetMinutes
            var scheduleQry = scheduleService.Queryable().Where(a => a.CheckInStartOffsetMinutes != null && a.IsActive);

            // limit Schedules to the Category from the Filter
            int scheduleCategoryId = CategoryCache.Get(Rock.SystemGuid.Category.SCHEDULE_SERVICE_TIMES.AsGuid()).Id;

            scheduleQry = scheduleQry.Where(a => a.CategoryId == scheduleCategoryId);

            // clear out any existing schedule columns just in case schedules been added/removed
            var scheduleList = scheduleQry.ToList().OrderBy(a => a.ToString()).ToList();

            var checkBoxEditableFields = gGroupLocationSchedule.Columns.OfType <CheckBoxEditableField>().ToList();

            foreach (var field in checkBoxEditableFields)
            {
                gGroupLocationSchedule.Columns.Remove(field);
            }

            foreach (var item in scheduleList)
            {
                string dataFieldName = string.Format("scheduleField_{0}", item.Id);

                CheckBoxEditableField field = new CheckBoxEditableField {
                    HeaderText = item.Name.Replace(" ", "<br/>"), DataField = dataFieldName
                };
                gGroupLocationSchedule.Columns.Add(field);
            }
        }
コード例 #7
0
ファイル: SchedulePicker.cs プロジェクト: marcoramzy/Rock
        /// <summary>
        /// Sets the value.
        /// </summary>
        /// <param name="schedule">The schedule.</param>
        public void SetValue(Schedule schedule)
        {
            if (schedule != null)
            {
                // If setting the value to an inactive schedule, enable the "Show Inactive Schedules" checkbox.
                if (AllowInactiveSelection && !schedule.IsActive)
                {
                    _cbShowInactiveSchedules.Checked = true;
                    SetExtraRestParams(true);
                }

                ItemId = schedule.Id.ToString();

                string parentCategoryIds = string.Empty;
                var    parentCategory    = schedule.CategoryId.HasValue ? CategoryCache.Get(schedule.CategoryId.Value) : null;
                while (parentCategory != null)
                {
                    parentCategoryIds = parentCategory.Id + "," + parentCategoryIds;
                    parentCategory    = parentCategory.ParentCategory;
                }

                InitialItemParentIds = parentCategoryIds.TrimEnd(new[] { ',' });
                ItemName             = schedule.Name;
            }
            else
            {
                ItemId   = Constants.None.IdValue;
                ItemName = Constants.None.TextHtml;
            }
        }
コード例 #8
0
ファイル: MergeTemplatePicker.cs プロジェクト: waldo2590/Rock
        /// <summary>
        /// Sets the value.
        /// </summary>
        /// <param name="mergeTemplate">The merge template.</param>
        public void SetValue(MergeTemplate mergeTemplate)
        {
            if (mergeTemplate != null)
            {
                ItemId = mergeTemplate.Id.ToString();

                var parentCategoryIds = new List <string>();
                var parentCategory    = CategoryCache.Get(mergeTemplate.CategoryId);
                while (parentCategory != null)
                {
                    if (!parentCategoryIds.Contains(parentCategory.Id.ToString()))
                    {
                        parentCategoryIds.Insert(0, parentCategory.Id.ToString());
                    }
                    else
                    {
                        // infinite recursion
                        break;
                    }

                    parentCategory = parentCategory.ParentCategory;
                }

                InitialItemParentIds = parentCategoryIds.AsDelimited(",");
                ItemName             = mergeTemplate.Name;
            }
            else
            {
                ItemId   = Constants.None.IdValue;
                ItemName = Constants.None.TextHtml;
            }
        }
コード例 #9
0
        public IQueryable <Tag> AvailableNames(int entityTypeId, int ownerId, Guid entityGuid, string name = null, string entityQualifier = null, string entityQualifierValue = null, Guid?categoryGuid = null, bool?includeInactive = null)
        {
            var tags = (( TagService )Service)
                       .Get(entityTypeId, entityQualifier, entityQualifierValue, ownerId, categoryGuid, includeInactive)
                       .Where(t =>
                              t.Name.StartsWith(name) &&
                              !t.TaggedItems.Any(i => i.EntityGuid == entityGuid) &&
                              t.IsActive);

            if (categoryGuid.HasValue)
            {
                var category = CategoryCache.Get(categoryGuid.Value);
                if (category != null)
                {
                    tags = tags
                           .Where(a =>
                                  a.CategoryId.HasValue &&
                                  a.CategoryId.Value == category.Id);
                }
            }

            var person   = GetPerson();
            var tagItems = new List <Tag>();

            foreach (var tag in tags.OrderBy(t => t.Name))
            {
                if (tag.IsAuthorized(Rock.Security.Authorization.TAG, person))
                {
                    tagItems.Add(tag);
                }
            }

            return(tagItems.AsQueryable <Tag>());
        }
コード例 #10
0
 /// <summary>
 /// ts the filter display filter value.
 /// </summary>
 /// <param name="sender">The sender.</param>
 /// <param name="e">The e.</param>
 protected void rFilter_DisplayFilterValue(object sender, GridFilter.DisplayFilterValueArgs e)
 {
     if (e.Key == "Category")
     {
         int?categoryId = e.Value.AsIntegerOrNull();
         if (categoryId.HasValue)
         {
             var category = CategoryCache.Get(categoryId.Value);
             if (category != null)
             {
                 e.Value = category.Name;
             }
         }
         else
         {
             e.Value = string.Empty;
         }
     }
     else if (e.Key == "Active")
     {
         e.Value = ddlActiveFilter.SelectedValue;
     }
     else
     {
         e.Value = string.Empty;
     }
 }
コード例 #11
0
        /// <summary>
        /// Gets the services.
        /// </summary>
        /// <returns></returns>
        private List <Schedule> GetServices()
        {
            var services = new List <Schedule>();

            var scheduleCategory = CategoryCache.Get(GetAttributeValue("ScheduleCategory").AsGuid());

            if (scheduleCategory != null)
            {
                using (var rockContext = new RockContext())
                {
                    foreach (var schedule in new ScheduleService(rockContext)
                             .Queryable().AsNoTracking()
                             .Where(s =>
                                    s.IsActive &&
                                    s.CategoryId.HasValue &&
                                    s.CategoryId.Value == scheduleCategory.Id)
                             .OrderBy(s => s.Name))
                    {
                        services.Add(schedule);
                    }
                }
            }

            return(services);
        }
コード例 #12
0
        void SetPrCategoryByLookupText(object sender, bool isHours)
        {
            var selectedItem = dgProjInvProjectLineGrid.SelectedItem as ProjectInvoiceProjectLineLocal;

            if (selectedItem == null)
            {
                return;
            }
            var le = sender as CorasauGridLookupEditor;

            if (string.IsNullOrEmpty(le.EnteredText))
            {
                return;
            }

            var prCat = CategoryCache?.Get(le.EnteredText);

            if (prCat != null)
            {
                dgProjInvProjectLineGrid.SetLoadedRow(selectedItem);
                selectedItem.PrCategory = prCat.KeyStr;
                le.EditValue            = prCat.KeyStr;
            }
            le.EnteredText = null;
        }
コード例 #13
0
ファイル: Person.ascx.cs プロジェクト: SparkDevNetwork/Rock
        /// <summary>
        /// Binds the attribute to attribute value container
        /// </summary>
        private void BindAttribute(Rock.Model.Person person)
        {
            var adultCategoryGuid = GetAttributeValue(AttributeKey.AdultAttributeCategory).AsGuidOrNull();
            var childCategoryGuid = GetAttributeValue(AttributeKey.ChildAttributeCategory).AsGuidOrNull();
            var isAdult           = person.AgeClassification == AgeClassification.Adult || person.AgeClassification == AgeClassification.Unknown;
            var isChild           = person.AgeClassification == AgeClassification.Child || person.AgeClassification == AgeClassification.Unknown;

            pnlAdultFields.Visible = false;
            pnlChildFields.Visible = false;
            if (isAdult && adultCategoryGuid.HasValue)
            {
                avcAdultAttributes.IncludedCategoryNames = new string[] { CategoryCache.Get(adultCategoryGuid.Value).Name };
                avcAdultAttributes.AddDisplayControls(person);

                pnlAdultFields.Visible = avcAdultAttributes.GetDisplayedAttributes().Any();
            }

            if (isChild && childCategoryGuid.HasValue)
            {
                avcChildAttributes.IncludedCategoryNames = new string[] { CategoryCache.Get(childCategoryGuid.Value).Name };
                avcChildAttributes.AddDisplayControls(person);

                pnlChildFields.Visible = avcChildAttributes.GetDisplayedAttributes().Any();
            }
        }
コード例 #14
0
ファイル: PrayerSession.cs プロジェクト: waldo2590/Rock
        /// <summary>
        /// Gets the prayer requests for the new session.
        /// </summary>
        /// <returns>An enumerable of <see cref="PrayerRequest"/> objects.</returns>
        protected virtual IEnumerable <PrayerRequest> GetPrayerRequests(RockContext rockContext)
        {
            var prayerRequestService = new PrayerRequestService(rockContext);
            var category             = CategoryCache.Get(PrayerCategory);

            if (category == null)
            {
                return(null);
            }

            var query = prayerRequestService.GetByCategoryIds(new List <int> {
                category.Id
            });

            if (PublicOnly)
            {
                query = query.Where(a => a.IsPublic.HasValue && a.IsPublic.Value);
            }

            if (MyCampus)
            {
                var campusId = RequestContext.CurrentPerson?.PrimaryCampusId;

                if (campusId.HasValue)
                {
                    query = query.Where(a => a.CampusId.HasValue && a.CampusId == campusId);
                }
            }

            query = query.OrderByDescending(a => a.IsUrgent)
                    .ThenBy(a => a.PrayerCount);

            return(query);
        }
コード例 #15
0
        /// <summary>
        /// Handles the ItemCommand event of the rptChannels control.
        /// </summary>
        /// <param name="source">The source of the event.</param>
        /// <param name="e">The <see cref="RepeaterCommandEventArgs"/> instance containing the event data.</param>
        protected void rptChannels_ItemCommand(object source, RepeaterCommandEventArgs e)
        {
            string selectedChannelValue = e.CommandArgument.ToString();

            SetUserPreference(SELECTED_CHANNEL_SETTING, selectedChannelValue);

            SelectedChannelId = selectedChannelValue.AsIntegerOrNull();

            var selectedChannelGuid = ContentChannelCache.Get(SelectedChannelId.Value).Guid;
            var queryString         = new Dictionary <string, string> {
                { "ContentChannelGuid", selectedChannelGuid.ToString() }
            };

            // Get CategoryGuid from Route
            var categoryGuid = PageParameter("CategoryGuid").AsGuidOrNull();

            if (!categoryGuid.HasValue)
            {
                var categoryId = ddlCategory.SelectedValueAsId();
                categoryGuid = CategoryCache.Get(categoryId.GetValueOrDefault())?.Guid;
            }

            // if user has selected a category or one was provided as a query param add it to the new route params
            if (categoryGuid.HasValue)
            {
                queryString.Add("CategoryGuid", categoryGuid.ToString());
            }

            // Navigate to page with route parameters set so new Url is generated in browser
            NavigateToCurrentPage(queryString);
        }
コード例 #16
0
ファイル: TemplateList.ascx.cs プロジェクト: ewin66/rockrms
        /// <summary>
        /// Handles the filter display for each saved user value
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The e.</param>
        /// <exception cref="System.NotImplementedException"></exception>
        protected void rFilter_DisplayFilterValue(object sender, GridFilter.DisplayFilterValueArgs e)
        {
            switch (e.Key)
            {
            case "Category":
            {
                var categoryId = e.Value.AsIntegerOrNull();
                if (categoryId.HasValue && categoryId > 0)
                {
                    var category = CategoryCache.Get(categoryId.Value);
                    if (category != null)
                    {
                        e.Value = category.Name;
                    }
                }
                else
                {
                    e.Value = string.Empty;
                }
                break;
            }

            case "Communication Type":
            {
                if (!string.IsNullOrWhiteSpace(e.Value))
                {
                    e.Value = ((CommunicationType)Enum.Parse(typeof(CommunicationType), e.Value)).ConvertToString();
                }

                break;
            }

            case "Active":
            {
                break;
            }

            case "Supports":
            {
                break;
            }

            case "Created By":
            {
                var personId = e.Value.AsIntegerOrNull();
                if (personId.HasValue && personId != 0)
                {
                    var personService = new PersonService(new RockContext());
                    var person        = personService.Get(personId.Value);
                    if (person != null)
                    {
                        e.Value = person.FullName;
                    }
                }

                break;
            }
            }
        }
コード例 #17
0
        public override List <BreadCrumb> GetBreadCrumbs(PageReference pageReference)
        {
            var entityTypeName = string.Empty;

            Guid entityTypeGuid = Guid.Empty;

            Guid.TryParse(GetAttributeValue("EntityType"), out entityTypeGuid);
            var entityType = EntityTypeCache.Get(entityTypeGuid);

            if (entityType != null)
            {
                entityTypeName = entityType.FriendlyName;
            }

            int           parentCategoryId = int.MinValue;
            CategoryCache category         = null;

            if (int.TryParse(PageParameter("CategoryId"), out parentCategoryId))
            {
                category = CategoryCache.Get(parentCategoryId);

                if (entityType == null && category != null)
                {
                    entityType = EntityTypeCache.Get(category.EntityTypeId.Value);

                    if (entityType != null)
                    {
                        entityTypeName = entityType.FriendlyName;
                    }
                }
            }

            if (entityType == null && category == null)
            {
                return(base.GetBreadCrumbs(pageReference));
            }

            var breadCrumbs = new List <BreadCrumb>();

            // add categories to the breadcrumbs
            while (category != null)
            {
                var parms = new Dictionary <string, string>();
                parms.Add("CategoryId", category.Id.ToString());
                breadCrumbs.Add(new BreadCrumb(category.Name, new PageReference(pageReference.PageId, 0, parms)));

                category = category.ParentCategory;
            }

            string rootPageTitle = string.IsNullOrWhiteSpace(GetAttributeValue("EntityQualifierColumn")) ?
                                   entityTypeName + " Categories" : this.RockPage.PageTitle;

            breadCrumbs.Add(new BreadCrumb(rootPageTitle, new PageReference(pageReference.PageId)));

            breadCrumbs.Reverse();

            return(breadCrumbs);
        }
コード例 #18
0
        void SetInvoiceable(ProjectJournalLineLocal rec)
        {
            var Cat = (PrCategory)CategoryCache.Get(rec._PrCategory);

            if (Cat != null)
            {
                rec.Invoiceable = Cat._Invoiceable;
            }
        }
コード例 #19
0
        /// <summary>
        /// Handles the DisplayFilterValue event of the gfSettings control.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The e.</param>
        void gfSettings_DisplayFilterValue(object sender, Rock.Web.UI.Controls.GridFilter.DisplayFilterValueArgs e)
        {
            switch (e.Key)
            {
            case "Category":
            {
                int?categoryId = e.Value.AsIntegerOrNull();
                if (categoryId.HasValue)
                {
                    var category = CategoryCache.Get(categoryId.Value);
                    if (category != null)
                    {
                        e.Value = category.Name;
                    }
                }
                else
                {
                    e.Value = string.Empty;
                }

                break;
            }

            case "Summary Contains":
            {
                break;
            }

            case "Who":
            {
                int personId = int.MinValue;
                if (int.TryParse(e.Value, out personId))
                {
                    var person = new PersonService(new RockContext()).GetNoTracking(personId);
                    if (person != null)
                    {
                        e.Value = person.FullName;
                    }
                }
                break;
            }

            case "Date Range":
            {
                e.Value = DateRangePicker.FormatDelimitedValues(e.Value);
                break;
            }

            default:
            {
                e.Value = string.Empty;
                break;
            }
            }
        }
コード例 #20
0
        /// <summary>
        /// Raises the <see cref="E:System.Web.UI.Control.Load" /> event.
        /// </summary>
        /// <param name="e">The <see cref="T:System.EventArgs" /> object that contains the event data.</param>
        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            RockPage.AddScriptLink("~/Scripts/jquery.visible.min.js");

            string eventTarget = this.Page.Request.Params["__EVENTTARGET"] ?? string.Empty;

            if (!Page.IsPostBack)
            {
                BindFilter();

                tglStatus.Checked = GetUserPreference(STATUS_FILTER_SETTING).AsBoolean();

                SelectedChannelId = PageParameter("ContentChannelId").AsIntegerOrNull();

                if (!SelectedChannelId.HasValue)
                {
                    var selectedChannelGuid = PageParameter("ContentChannelGuid").AsGuidOrNull();

                    if (selectedChannelGuid.HasValue)
                    {
                        SelectedChannelId = ContentChannelCache.Get(selectedChannelGuid.Value)?.Id;
                    }
                }

                if (!SelectedChannelId.HasValue)
                {
                    SelectedChannelId = GetUserPreference(SELECTED_CHANNEL_SETTING).AsIntegerOrNull();
                }

                if (ddlCategory.Visible)
                {
                    var categoryGuid = PageParameter("CategoryGuid").AsGuidOrNull();
                    if (categoryGuid.HasValue)
                    {
                        var categoryId = CategoryCache.Get(categoryGuid.Value)?.Id;

                        SetUserPreference(CATEGORY_FILTER_SETTING, categoryId.ToString());
                        ddlCategory.SetValue(categoryId);
                    }
                    else
                    {
                        ddlCategory.SetValue(GetUserPreference(CATEGORY_FILTER_SETTING).AsIntegerOrNull());
                    }
                }

                GetData();
            }
            else if (eventTarget.StartsWith(gContentChannelItems.UniqueID))
            {
                // if we got a PostBack from the Grid (or child controls) make sure the Grid is bound
                GetData();
            }
        }
コード例 #21
0
        /// <summary>
        /// Gets the occurrences with option to override the ICal.Event.DTStart
        /// </summary>
        /// <param name="beginDateTime">The begin date time.</param>
        /// <param name="endDateTime">The end date time.</param>
        /// <param name="scheduleStartDateTimeOverride">The schedule start date time override.</param>
        /// <returns></returns>
        public IList <Occurrence> GetOccurrences(DateTime beginDateTime, DateTime?endDateTime, DateTime?scheduleStartDateTimeOverride)
        {
            var occurrences = new List <Occurrence>();

            DDay.iCal.Event calEvent = GetCalendarEvent();
            if (calEvent == null)
            {
                return(occurrences);
            }

            if (scheduleStartDateTimeOverride.HasValue)
            {
                calEvent.DTStart = new DDay.iCal.iCalDateTime(scheduleStartDateTimeOverride.Value);
            }

            if (calEvent.DTStart != null)
            {
                var exclusionDates = new List <DateRange>();
                if (this.CategoryId.HasValue && this.CategoryId.Value > 0)
                {
                    var category = CategoryCache.Get(this.CategoryId.Value);
                    if (category != null)
                    {
                        exclusionDates = category.ScheduleExclusions
                                         .Where(e => e.Start.HasValue && e.End.HasValue)
                                         .ToList();
                    }
                }

                foreach (var occurrence in endDateTime.HasValue ?
                         ScheduleICalHelper.GetOccurrences(calEvent, beginDateTime, endDateTime.Value) :
                         ScheduleICalHelper.GetOccurrences(calEvent, beginDateTime))
                {
                    bool exclude = false;
                    if (exclusionDates.Any() && occurrence.Period.StartTime != null)
                    {
                        var occurrenceStart = occurrence.Period.StartTime.Value;
                        if (exclusionDates.Any(d =>
                                               d.Start.Value <= occurrenceStart &&
                                               d.End.Value >= occurrenceStart))
                        {
                            exclude = true;
                        }
                    }

                    if (!exclude)
                    {
                        occurrences.Add(occurrence);
                    }
                }
            }

            return(occurrences);
        }
コード例 #22
0
        /// <summary>
        /// Gets the services.
        /// </summary>
        /// <returns></returns>
        private List <Schedule> GetServices(CampusCache campus = null)
        {
            var services = new List <Schedule>();

            if (!string.IsNullOrWhiteSpace(GetAttributeValue("ScheduleCategories")))
            {
                List <Guid> categoryGuids       = GetAttributeValue("ScheduleCategories").Split(',').Select(g => g.AsGuid()).ToList();
                string      campusAttributeGuid = GetAttributeValue("CampusAttribute");

                DateTime?weekend = bddlWeekend.SelectedValue.AsDateTime();
                using (var rockContext = new RockContext())
                {
                    var attributeValueQry = new AttributeValueService(rockContext).Queryable();
                    foreach (Guid categoryGuid in categoryGuids)
                    {
                        var scheduleCategory = CategoryCache.Get(categoryGuid);
                        if (scheduleCategory != null && campus != null)
                        {
                            var schedules = new ScheduleService(rockContext)
                                            .Queryable().AsNoTracking()
                                            .Where(s => s.CategoryId == scheduleCategory.Id)
                                            .Join(
                                attributeValueQry.Where(av => av.Attribute.Guid.ToString() == campusAttributeGuid &&
                                                        av.Value.Contains(campus.Guid.ToString())),
                                p => p.Id,
                                av => av.EntityId,
                                (p, av) => new { Schedule = p, Value = av.Value });
                            // Check to see if the event was applicable the week for which we are entering data
                            foreach (var schedule in schedules)
                            {
                                var occurrences = InetCalendarHelper.GetOccurrences(schedule.Schedule.iCalendarContent, weekend.Value.Date.AddDays(-6), weekend.Value.Date.AddDays(1));
                                if (occurrences.Count > 0)
                                {
                                    services.Add(schedule.Schedule);
                                }
                            }
                        }
                        else if (scheduleCategory != null)
                        {
                            foreach (var schedule in new ScheduleService(rockContext)
                                     .Queryable().AsNoTracking()
                                     .Where(s =>
                                            s.CategoryId.HasValue &&
                                            s.CategoryId.Value == scheduleCategory.Id)
                                     .OrderBy(s => s.Name))
                            {
                                services.Add(schedule);
                            }
                        }
                    }
                }
            }
            return(services.OrderBy(s => s.GetNextStartDateTime(RockDateTime.Now).HasValue ? s.GetNextStartDateTime(RockDateTime.Now).Value.Ticks : s.EffectiveEndDate.HasValue?s.EffectiveEndDate.Value.Ticks: 0).ToList());
        }
コード例 #23
0
ファイル: PrayerRequestAdd.cs プロジェクト: waldo2590/Rock
        /// <summary>
        /// Gets the category.
        /// </summary>
        /// <returns></returns>
        private CategoryCache GetCategory()
        {
            var guid = GetGuidFromSelectedAttribute(AttributeKey.Category);

            if (!guid.HasValue)
            {
                return(null);
            }

            return(CategoryCache.Get(guid.Value));
        }
コード例 #24
0
        /// <summary>
        /// Gets the Guid for the Category that has the specified Id
        /// </summary>
        /// <param name="id">The identifier.</param>
        /// <returns></returns>
        public override Guid?GetGuid(int id)
        {
            var cacheItem = CategoryCache.Get(id);

            if (cacheItem != null)
            {
                return(cacheItem.Guid);
            }

            return(null);
        }
コード例 #25
0
        /// <summary>
        /// Shows the edit.
        /// </summary>
        /// <param name="attributeId">The attribute id.</param>
        protected void ShowEdit(int categoryId)
        {
            Category category = null;

            if (categoryId > 0)
            {
                category = new CategoryService(new RockContext()).Get(categoryId);
            }

            if (category == null)
            {
                // if there is a parent category set the entity type and qualifiers and hide the settings
                if (_parentCategoryId.HasValue)
                {
                    var parentCategory = CategoryCache.Get(_parentCategoryId.Value);
                    entityTypePicker.SelectedEntityTypeId = parentCategory.EntityTypeId;
                    tbEntityQualifierField.Text           = parentCategory.EntityTypeQualifierColumn;
                    tbEntityQualifierValue.Text           = parentCategory.EntityTypeQualifierValue;
                    pnlEntityInfo.Visible = false;
                }

                category = new Category
                {
                    Id           = 0,
                    EntityTypeId = _entityTypeId,
                    EntityTypeQualifierColumn = _entityCol,
                    EntityTypeQualifierValue  = _entityVal,
                    ParentCategoryId          = _parentCategoryId,
                };
            }
            else
            {
                entityTypePicker.SelectedEntityTypeId = category.EntityTypeId;
                tbEntityQualifierField.Text           = category.EntityTypeQualifierColumn;
                tbEntityQualifierValue.Text           = category.EntityTypeQualifierValue;
            }

            entityTypePicker.RequiredFieldValidator.ErrorMessage = "Entity type is required.";
            entityTypePicker.ValidationGroup = BlockValidationGroup;

            tbName.Text = category.Name;

            tbDescription.Text = category.Description;
            catpParentCategory.SetValue(category.ParentCategoryId);
            tbIconCssClass.Text = category.IconCssClass;
            cpHighlight.Value   = category.HighlightColor;

            category.LoadAttributes();
            phAttributes.Controls.Clear();
            Rock.Attribute.Helper.AddEditControls(category, phAttributes, true, BlockValidationGroup);

            hfIdValue.Value = categoryId.ToString();
            mdDetails.Show();
        }
コード例 #26
0
ファイル: PrayerSessionSetup.cs プロジェクト: waldo2590/Rock
        /// <summary>
        /// Gets the categories to be included in the picker.
        /// </summary>
        /// <returns>A collection of <see cref="CategoryCache"/> objects.</returns>
        protected virtual IEnumerable <CategoryCache> GetCategories()
        {
            var categories     = new List <CategoryCache>();
            var parentCategory = CategoryCache.Get(ParentCategory);

            if (parentCategory != null)
            {
                categories.AddRange(parentCategory.Categories.OrderBy(a => a.Name));
            }

            return(categories);
        }
コード例 #27
0
        /// <summary>
        /// Shows the edit details.
        /// </summary>
        /// <param name="category">The category.</param>
        private void ShowEditDetails(Category category)
        {
            if (category.Id > 0)
            {
                lTitle.Text = ActionTitle.Edit(Category.FriendlyTypeName).FormatAsHtmlTitle();
                lIcon.Text  = "<i class='fa fa-square-o'></i>";
            }
            else
            {
                lTitle.Text = ActionTitle.Add(Category.FriendlyTypeName).FormatAsHtmlTitle();

                if (!string.IsNullOrEmpty(category.IconCssClass))
                {
                    lIcon.Text = String.Format("<i class='{0}'></i>", category.IconCssClass);
                }
                else
                {
                    lIcon.Text = "<i class='fa fa-square-o'></i>";
                }
            }

            SetEditMode(true);

            tbName.Text        = category.Name;
            tbDescription.Text = category.Description;

            var        excludeCategoriesGuids = this.GetAttributeValue(AttributeKey.ExcludeCategories).SplitDelimitedValues().AsGuidList();
            List <int> excludedCategoriesIds  = new List <int>();

            if (excludeCategoriesGuids != null && excludeCategoriesGuids.Any())
            {
                foreach (var excludeCategoryGuid in excludeCategoriesGuids)
                {
                    var excludedCategory = CategoryCache.Get(excludeCategoryGuid);
                    if (excludedCategory != null)
                    {
                        excludedCategoriesIds.Add(excludedCategory.Id);
                    }
                }
            }

            cpParentCategory.EntityTypeId = category.EntityTypeId;
            cpParentCategory.EntityTypeQualifierColumn = category.EntityTypeQualifierColumn;
            cpParentCategory.EntityTypeQualifierValue  = category.EntityTypeQualifierValue;
            cpParentCategory.ExcludedCategoryIds       = excludedCategoriesIds.AsDelimited(",");
            var rootCategory = CategoryCache.Get(this.GetAttributeValue(AttributeKey.RootCategory).AsGuid());

            cpParentCategory.RootCategoryId = rootCategory != null ? rootCategory.Id : ( int? )null;
            cpParentCategory.SetValue(category.ParentCategoryId);

            tbIconCssClass.Text    = category.IconCssClass;
            cpHightlightColor.Text = category.HighlightColor;
        }
コード例 #28
0
        /// <summary>
        /// Gets the changes.
        /// </summary>
        /// <param name="modelType">Type of the model.</param>
        /// <param name="categoryGuid">The category unique identifier.</param>
        /// <param name="entityId">The entity identifier.</param>
        /// <param name="changes">The changes.</param>
        /// <param name="caption">The caption.</param>
        /// <param name="relatedModelType">Type of the related model.</param>
        /// <param name="relatedEntityId">The related entity identifier.</param>
        /// <param name="modifiedByPersonAliasId">The modified by person alias identifier.</param>
        /// <param name="sourceOfChange">The source of change.</param>
        /// <returns></returns>
        internal static List <History> GetChanges(Type modelType, Guid categoryGuid, int entityId, History.HistoryChangeList changes, string caption, Type relatedModelType, int?relatedEntityId, int?modifiedByPersonAliasId, string sourceOfChange = null)
        {
            SetHistoryEntriesSourceOfChange(changes, sourceOfChange, sourceOfChange != null);

            var entityType   = EntityTypeCache.Get(modelType);
            var category     = CategoryCache.Get(categoryGuid);
            var creationDate = RockDateTime.Now;

            int?relatedEntityTypeId = null;

            if (relatedModelType != null)
            {
                var relatedEntityType = EntityTypeCache.Get(relatedModelType);
                if (relatedModelType != null)
                {
                    relatedEntityTypeId = relatedEntityType.Id;
                }
            }

            List <History> historyRecordsToInsert = new List <History>();

            if (entityType != null && category != null)
            {
                foreach (var historyChange in changes.Where(m => m != null))
                {
                    var history = new History();
                    history.EntityTypeId        = entityType.Id;
                    history.CategoryId          = category.Id;
                    history.EntityId            = entityId;
                    history.Caption             = caption.Truncate(200);
                    history.RelatedEntityTypeId = relatedEntityTypeId;
                    history.RelatedEntityId     = relatedEntityId;

                    historyChange.CopyToHistory(history);

                    if (modifiedByPersonAliasId.HasValue)
                    {
                        history.CreatedByPersonAliasId = modifiedByPersonAliasId;
                    }

                    // If not specified, manually set the creation date on these history items so that they will be grouped together.
                    if (historyChange.ChangedDateTime == null)
                    {
                        history.CreatedDateTime = creationDate;
                    }

                    historyRecordsToInsert.Add(history);
                }
            }

            return(historyRecordsToInsert);
        }
コード例 #29
0
        async void getCostAndSales(ProjectInvoiceProjectLineLocal rec)
        {
            var project = rec._Project;

            if (project == null)
            {
                return;
            }
            var proj       = (Uniconta.DataModel.Project)ProjectCache.Get(project);
            var Categories = proj.Categories ?? await proj.LoadCategories(api);

            rec.costPct = 0d; rec.salesPct = 0d; rec.costAmount = 0d; rec.salesAmount = 0d;

            var Category = rec._PrCategory;

            var prcategory = (Uniconta.DataModel.PrCategory)CategoryCache.Get(Category);

            if (prcategory != null && prcategory._Forward)
            {
                rec.ProjectForward = invoiceProposal._Project;
            }

            var projCat = (from ct in Categories where ct._PrCategory == Category select ct).FirstOrDefault();

            if (projCat != null)
            {
                rec.costPct     = projCat._CostPctCharge;
                rec.salesPct    = projCat._SalesPctCharge;
                rec.costAmount  = projCat._CostAmountCharge;
                rec.salesAmount = projCat._SalesAmountCharge;
            }
            else
            {
                var prstd = (PrStandard)PrStandardCache.Get(proj._PrStandard);
                if (prstd == null)
                {
                    return;
                }
                var PrCategories = prstd.Categories ?? await prstd.LoadCategories(api);

                var prCat = (from ct in PrCategories where ct._PrCategory == Category select ct).FirstOrDefault();
                if (prCat != null)
                {
                    rec.costPct     = prCat._CostPctCharge;
                    rec.salesPct    = prCat._SalesPctCharge;
                    rec.costAmount  = prCat._CostAmountCharge;
                    rec.salesAmount = prCat._SalesAmountCharge;
                }
            }
            RecalculateAmount();
        }
コード例 #30
0
        /// <summary>
        /// Gfs the filter_ display filter value.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The e.</param>
        void gfFilter_DisplayFilterValue(object sender, GridFilter.DisplayFilterValueArgs e)
        {
            switch (e.Key)
            {
            case UserPreferenceKey.Categories:
            {
                var categories = new List <string>();

                foreach (var idVal in e.Value.SplitDelimitedValues())
                {
                    int id = int.MinValue;
                    if (int.TryParse(idVal, out id))
                    {
                        if (id != 0)
                        {
                            var category = CategoryCache.Get(id);
                            if (category != null)
                            {
                                categories.Add(CategoryCache.Get(id).Name);
                            }
                        }
                    }
                }

                e.Value = categories.AsDelimited(", ");
                break;
            }

            case UserPreferenceKey.Type:
            {
                int?typeId = e.Value.AsIntegerOrNull();
                if (typeId.HasValue)
                {
                    var contentType = new ContentChannelTypeService(new RockContext()).Get(typeId.Value);
                    if (contentType != null)
                    {
                        e.Value = contentType.Name;
                    }
                }
                break;
            }

            default:
            {
                e.Value = string.Empty;
                break;
            }
            }
        }