private void UpdateRecordsByTag(TagItem tagItem)
        {
            var recordsByTag = new List <Record>();
            var tagItems     = new List <TagItem>(TagItems);

            if (tagItem != null)
            {
                tagItems.Add(tagItem);
            }

            if (tagItems.Count == 0 && recordsByTag.Count == 0)
            {
                RecordsByTag = Records;
            }
            else
            {
                foreach (var tag in tagItems)
                {
                    var records = Records.FindAll((r) => string.Compare(r.Name, tag.Name) == 0);
                    foreach (var record in records)
                    {
                        recordsByTag.Add(record);
                    }
                }

                RecordsByTag = recordsByTag.Distinct().ToList();
            }
        }
Example #2
0
        /// <summary>
        ///     TBD
        /// </summary>
        /// <param name="nodes">TBD</param>
        /// <returns>TBD</returns>
        public Reachability Remove(IEnumerable <UniqueAddress> nodes)
        {
            var nodesSet    = nodes.ToImmutableHashSet();
            var newRecords  = Records.FindAll(r => !nodesSet.Contains(r.Observer) && !nodesSet.Contains(r.Subject));
            var newVersions = Versions.RemoveRange(nodes);

            return(new Reachability(newRecords, newVersions));
        }
Example #3
0
        /// <summary>
        ///     TBD
        /// </summary>
        /// <param name="nodes">TBD</param>
        /// <returns>TBD</returns>
        public Reachability RemoveObservers(ImmutableHashSet <UniqueAddress> nodes)
        {
            if (nodes.Count == 0)
            {
                return(this);
            }

            var newRecords  = Records.FindAll(r => !nodes.Contains(r.Observer));
            var newVersions = Versions.RemoveRange(nodes);

            return(new Reachability(newRecords, newVersions));
        }
Example #4
0
        private Reachability Change(UniqueAddress observer, UniqueAddress subject, ReachabilityStatus status)
        {
            var v               = NextVersion(observer);
            var newVersions     = Versions.SetItem(observer, v);
            var newRecord       = new Record(observer, subject, status, v);
            var oldObserverRows = ObserverRows(observer);

            // don't record Reachable observation if nothing has been noted so far
            if (oldObserverRows == null && status == ReachabilityStatus.Reachable)
            {
                return(this);
            }

            // otherwise, create new instance including this first observation
            if (oldObserverRows == null)
            {
                return(new Reachability(Records.Add(newRecord), newVersions));
            }

            if (!oldObserverRows.TryGetValue(subject, out var oldRecord))
            {
                if (status == ReachabilityStatus.Reachable &&
                    oldObserverRows.Values.All(r => r.Status == ReachabilityStatus.Reachable))
                {
                    return(new Reachability(Records.FindAll(r => !r.Observer.Equals(observer)), newVersions));
                }
                return(new Reachability(Records.Add(newRecord), newVersions));
            }

            if (oldRecord.Status == ReachabilityStatus.Terminated || oldRecord.Status == status)
            {
                return(this);
            }

            if (status == ReachabilityStatus.Reachable &&
                oldObserverRows.Values.All(r => r.Status == ReachabilityStatus.Reachable || r.Subject.Equals(subject)))
            {
                return(new Reachability(Records.FindAll(r => !r.Observer.Equals(observer)), newVersions));
            }

            var newRecords = Records.SetItem(Records.IndexOf(oldRecord), newRecord);

            return(new Reachability(newRecords, newVersions));
        }
Example #5
0
        private void UpdateWeekRecords()
        {
            var weekRecords = new List <WeekRecord>();
            var startDateOfSelectedMonth = SelectedMonth;
            var startDateOfWeek          = new DateTime(startDateOfSelectedMonth.Year, startDateOfSelectedMonth.Month, 1, 0, 0, 0);

            while (startDateOfWeek.Date.DayOfWeek != DayOfWeek.Sunday)
            {
                startDateOfWeek = startDateOfWeek.AddDays(-1);
            }

            var startDateOfMonth = startDateOfWeek;

            while (startDateOfMonth.Ticks <= startDateOfSelectedMonth.Ticks)
            {
                var RecordsOfWeek = Records.FindAll(r => startDateOfWeek.Ticks <= r.RecordTime.Ticks && r.RecordTime.Ticks < startDateOfWeek.AddDays(7).Ticks);

                var weekRecord = new WeekRecord()
                {
                    SelectedMonth   = SelectedMonth.Month,
                    StartDateOfWeek = startDateOfWeek,
                    DayRecords      = RecordsOfWeek.OrderBy(r => r.RecordTime).ToList()
                };

                weekRecords.Add(weekRecord);

                startDateOfWeek = startDateOfWeek.AddDays(7);

                startDateOfMonth = new DateTime(startDateOfWeek.Year, startDateOfWeek.Month, 1, 0, 0, 0);
            }
            ResetSuccessRate();

            WeekRecords.Clear();

            WeekRecords = weekRecords;
            OnPropertyChanged(nameof(WeekRecords));
            OnPropertyChanged(nameof(RoutineNumOfThisMonth));
            OnPropertyChanged(nameof(SuccessRoutineNumOfThisMonth));
        }
Example #6
0
 public Reachability FilterRecords(Predicate <Record> f)
 {
     return(new Reachability(Records.FindAll(f), Versions));
 }
Example #7
0
        public void OnGet()
        {
            Init();

            DataSourceManager dsMan = new DataSourceManager();

            int           pager     = 0;
            string        sortBy    = "";
            QuerySortType sortOrder = QuerySortType.Ascending;

            PageUtils.GetListQueryParams(PageContext.HttpContext, out pager, out sortBy, out sortOrder);
            Page             = pager;
            SortBy           = sortBy;
            SortOrder        = sortOrder;
            ReturnUrlEncoded = HttpUtility.UrlEncode(PageUtils.GetCurrentUrl(PageContext.HttpContext));

            var allDataSources = dsMan.GetAll().OrderBy(x => x.Name).ToList();

            foreach (var ds in allDataSources)
            {
                if (ds is DatabaseDataSource)
                {
                    var record   = new EntityRecord();
                    var recordId = ds.Id;
                    record["action"]           = $"<a class='btn btn-sm btn-outline-secondary' title='Data source details' href='/sdk/objects/data_source/r/{recordId}?returnUrl={ReturnUrlEncoded}'><span class='fa fa-eye'></span></a>";
                    record["icon"]             = PageUtils.GetDataSourceIconBadge(DataSourceType.DATABASE);
                    record["name"]             = ds.Name;
                    record["target"]           = ds.EntityName;
                    record["type_description"] = DataSourceType.DATABASE.GetLabel();
                    record["type"]             = DataSourceType.DATABASE;
                    record["model"]            = ds.ResultModel;
                    record["param_count"]      = ds.Parameters.Count;
                    Records.Add(record);
                }
                else
                {
                    var record   = new EntityRecord();
                    var recordId = ds.Id;
                    record["action"]           = $"<a class='btn btn-sm btn-outline-secondary' title='Data source details' href='/sdk/objects/data_source/r/{recordId}?returnUrl={ReturnUrlEncoded}'><span class='fa fa-eye'></span></a>";
                    record["icon"]             = PageUtils.GetDataSourceIconBadge(DataSourceType.CODE);
                    record["name"]             = ds.Name;
                    record["target"]           = ds.GetType().FullName;
                    record["type_description"] = DataSourceType.CODE.GetLabel();
                    record["type"]             = DataSourceType.CODE;
                    record["model"]            = ds.ResultModel;
                    record["param_count"]      = 0;
                    Records.Add(record);
                }
            }

            TotalCount      = Records.Count;
            PageDescription = PageUtils.GenerateListPageDescription(PageContext.HttpContext, "", TotalCount);

            #region << Filters >>

            var submittedFilters = PageUtils.GetPageFiltersFromQuery(PageContext.HttpContext);
            if (submittedFilters.Count > 0)
            {
                foreach (var filter in submittedFilters)
                {
                    switch (filter.Name)
                    {
                    case "name":
                        Records = Records.FindAll(x => x["name"].ToString().ToLowerInvariant().Contains(filter.Value.ToLowerInvariant())).ToList();
                        break;

                    case "model":
                        Records = Records.FindAll(x => x["model"].ToString().ToLowerInvariant().Contains(filter.Value.ToLowerInvariant())).ToList();
                        break;

                    case "target":
                        Records = Records.FindAll(x => x["target"].ToString().ToLowerInvariant().Contains(filter.Value.ToLowerInvariant())).ToList();
                        break;

                    case "type":
                        Records = Records.FindAll(x => ((int)x["type"]).ToString().Equals(filter.Value)).ToList();
                        break;
                    }
                }
            }

            #endregion

            #region << Sort >>

            if (!String.IsNullOrWhiteSpace(SortBy))
            {
                switch (SortBy)
                {
                case "name":
                    if (SortOrder == QuerySortType.Descending)
                    {
                        Records = Records.OrderByDescending(x => x["name"].ToString()).ToList();
                    }
                    else
                    {
                        Records = Records.OrderBy(x => x["name"].ToString()).ToList();
                    }
                    break;

                case "type":
                    if (SortOrder == QuerySortType.Descending)
                    {
                        Records = Records.OrderByDescending(x => x["type"].ToString()).ToList();
                    }
                    else
                    {
                        Records = Records.OrderBy(x => x["type"].ToString()).ToList();
                    }
                    break;

                case "target":
                    if (SortOrder == QuerySortType.Descending)
                    {
                        Records = Records.OrderByDescending(x => x["target"].ToString()).ToList();
                    }
                    else
                    {
                        Records = Records.OrderBy(x => x["target"].ToString()).ToList();
                    }
                    break;

                default:
                    break;
                }
            }

            #endregion

            #region << Create Columns >>
            Columns = new List <GridColumn>()
            {
                new GridColumn()
                {
                    Label = "",
                    Name  = "action",
                    Width = "1%"
                },
                new GridColumn()
                {
                    Label = "Icon",
                    Name  = "icon",
                    Width = "1%"
                },
                new GridColumn()
                {
                    Label    = "Name",
                    Name     = "name",
                    Width    = "220px",
                    Sortable = true
                },
                new GridColumn()
                {
                    Label    = "Type",
                    Name     = "type",
                    Width    = "120px",
                    Sortable = true
                },
                new GridColumn()
                {
                    Label    = "target",
                    Name     = "Target",
                    Sortable = true
                },
                new GridColumn()
                {
                    Label = "Returned Model",
                    Name  = "model",
                    Width = "220px"
                },
                new GridColumn()
                {
                    Label = "Params",
                    Name  = "param_count",
                    Width = "40px"
                },
            };
            #endregion

            #region << Actions >>
            HeaderActions.AddRange(new List <string>()
            {
                $"<a href='/sdk/objects/data_source/c/create?returnUrl={ReturnUrlEncoded}' class='btn btn-white btn-sm'><span class='fa fa-plus go-green'></span> Add Data Source</a>",
                $"<button type='button' onclick='ErpEvent.DISPATCH(\"WebVella.Erp.Web.Components.PcDrawer\",\"open\")' class='btn btn-white btn-sm'><span class='fa fa-search'></span> Search</a>"
            });

            #endregion


            var skipPages = (Page - 1) * PageSize;
            Records = Records.Skip(skipPages).Take(PageSize).ToList();


            ErpRequestContext.PageContext = PageContext;

            BeforeRender();
        }
Example #8
0
        public void OnGet()
        {
            Init();

            #region << InitPage >>

            HeaderToolbar.AddRange(AdminPageUtils.GetJobAdminSubNav("plan"));

            int           pager     = 0;
            string        sortBy    = "";
            QuerySortType sortOrder = QuerySortType.Ascending;
            PageUtils.GetListQueryParams(PageContext.HttpContext, out pager, out sortBy, out sortOrder);
            Pager     = pager;
            SortBy    = sortBy;
            SortOrder = sortOrder;


            #endregion

            #region << Create Columns >>

            Columns = new List <GridColumn>()
            {
                new GridColumn()
                {
                    Name  = "action",
                    Width = "140px"
                },
                new GridColumn()
                {
                    Label = "",
                    Name  = "status",
                    Width = "30px"
                },
                new GridColumn()
                {
                    Label = "name",
                    Name  = "name"
                },
                new GridColumn()
                {
                    Label = "type",
                    Name  = "type",
                    Width = "100px"
                },
                new GridColumn()
                {
                    Label = "last trigger",
                    Name  = "last_trigger",
                    Width = "140px"
                },
                new GridColumn()
                {
                    Label = "next trigger",
                    Name  = "next_trigger",
                    Width = "140px"
                },
            };

            #endregion

            #region << Records >>
            Records = ScheduleManager.Current.GetSchedulePlans().MapTo <OutputSchedulePlan>();
            Records = Records.OrderBy(x => x.Name).ThenByDescending(x => x.CreatedOn).ToList();

            #region << Apply Filters >>
            var submittedFilters = PageUtils.GetPageFiltersFromQuery(PageContext.HttpContext);
            if (submittedFilters.Count > 0)
            {
                foreach (var filter in submittedFilters)
                {
                    switch (filter.Name)
                    {
                    case "name":
                        if (filter.Type == FilterType.CONTAINS)
                        {
                            Records = Records.FindAll(x => x.Name.ToLowerInvariant().Contains(filter.Value.ToLowerInvariant())).ToList();
                        }
                        break;

                    default:
                        break;
                    }
                }
            }
            #endregion

            TotalCount = Records.Count;
            Records    = Records.Skip((Pager - 1) * PagerSize).Take(PagerSize).ToList();
            #endregion
        }
Example #9
0
        List <List <Record> > FilterRecords(Properties Property)
        {
            // Data arrays
            List <string>         seriesArray = new List <string>();
            List <decimal>        pointsArray = new List <decimal>();
            List <List <Record> > pointsData  = new List <List <Record> >();

            switch (Property)
            {
            case Properties.Project:
                var tempP = Records.Select(x => x.location.project).DistinctBy(p => p.id).ToList();
                for (int i = 0; i < tempP.Count(); i++)
                {
                    pointsData.Add(Records.FindAll(r => r.location.project.id == tempP[i].id));
                    seriesArray.Add(tempP[i].name);
                }
                break;

            case Properties.Location:
                var tempL = Records.Select(x => x.location).DistinctBy(p => p.id).ToList();
                for (int i = 0; i < tempL.Count(); i++)
                {
                    pointsData.Add(Records.FindAll(r => r.location.id == tempL[i].id));
                    seriesArray.Add(tempL[i].name);
                }
                break;

            case Properties.Phase:
                var tempPh = Records.Select(x => x.phase).DistinctBy(p => p.id).ToList();
                for (int i = 0; i < tempPh.Count(); i++)
                {
                    pointsData.Add(Records.FindAll(r => r.phase.id == tempPh[i].id));
                    seriesArray.Add(tempPh[i].phase);
                }
                break;

            case Properties.Name1:
                var temp1 = Records.Select(x => x.template.level4.level3.level2.level1).DistinctBy(p => p.code).ToList();
                for (int i = 0; i < temp1.Count(); i++)
                {
                    pointsData.Add(Records.FindAll(r => r.template.level4.level3.level2.level1.code == temp1[i].code));
                    seriesArray.Add(temp1[i].description);
                }
                break;

            case Properties.Name2:
                var temp2 = Records.Select(x => x.template.level4.level3.level2).DistinctBy(p => p.code).ToList();
                for (int i = 0; i < temp2.Count(); i++)
                {
                    pointsData.Add(Records.FindAll(r => r.template.level4.level3.level2.code == temp2[i].code));
                    seriesArray.Add(temp2[i].description);
                }
                break;

            case Properties.Name3:
                var temp3 = Records.Select(x => x.template.level4.level3).DistinctBy(p => p.code).ToList();
                for (int i = 0; i < temp3.Count(); i++)
                {
                    pointsData.Add(Records.FindAll(r => r.template.level4.level3.code == temp3[i].code));
                    seriesArray.Add(temp3[i].description);
                }
                break;

            case Properties.Name4:
                var temp4 = Records.Select(x => x.template.level4).DistinctBy(p => p.code).ToList();
                for (int i = 0; i < temp4.Count(); i++)
                {
                    pointsData.Add(Records.FindAll(r => r.template.level4.code == temp4[i].code));
                    seriesArray.Add(temp4[i].description);
                }
                break;

            case Properties.Template:
                var temp = Records.Select(x => x.template).DistinctBy(p => p.id).ToList();
                for (int i = 0; i < temp.Count(); i++)
                {
                    pointsData.Add(Records.FindAll(r => r.template.id == temp[i].id));
                    seriesArray.Add(temp[i].code);
                }
                break;

            case Properties.Record:
                var tempR = Records.ToList();
                for (int i = 0; i < tempR.Count(); i++)
                {
                    pointsData.Add(Records.FindAll(r => r.id == tempR[i].id));
                    seriesArray.Add(tempR[i].csi_code.code);
                }
                break;
            }

            return(pointsData);
        }
Example #10
0
        private void GoBack()
        {
            searchBox.Text = "";
            var tocheck = Current.ToList();

            switch (Stage)
            {
            case Pages.Phase:
                Stage   = Pages.Project;
                Current = Records.ToList();
                SetList();
                for (int i = 0; i < checkedList.Items.Count; i++)
                {
                    checkedList.SetItemCheckState(i, tocheck.Any(c => checkedList.Items[i].ToString().StartsWith(c.location.project.id.ToString() + " ", StringComparison.CurrentCultureIgnoreCase)) ? CheckState.Checked : CheckState.Unchecked);
                }
                break;

            case Pages.Location:
                Stage   = Pages.Phase;
                Current = Records.FindAll(x => Current.Any(c => c.location.project.id == x.location.project.id)).ToList();
                SetList();
                for (int i = 0; i < checkedList.Items.Count; i++)
                {
                    checkedList.SetItemCheckState(i, tocheck.Any(c => checkedList.Items[i].ToString().StartsWith(c.phase.id.ToString() + " ", StringComparison.CurrentCultureIgnoreCase)) ? CheckState.Checked : CheckState.Unchecked);
                }
                break;

            case Pages.Level1:
                Stage   = Pages.Location;
                Current = Records.FindAll(x => Current.Any(c => c.phase.id == x.phase.id)).ToList();
                SetList();
                for (int i = 0; i < checkedList.Items.Count; i++)
                {
                    checkedList.SetItemCheckState(i, tocheck.Any(c => checkedList.Items[i].ToString().StartsWith(c.location.id.ToString() + " ", StringComparison.CurrentCultureIgnoreCase)) ? CheckState.Checked : CheckState.Unchecked);
                }
                break;

            case Pages.Level2:
                Stage   = Pages.Level1;
                Current = Records.FindAll(x => Current.Any(c => c.location.id == x.location.id)).ToList();
                SetList();
                for (int i = 0; i < checkedList.Items.Count; i++)
                {
                    checkedList.SetItemCheckState(i, tocheck.Any(c => checkedList.Items[i].ToString().StartsWith(c.template.level4.level3.level2.level1.code + " ", StringComparison.CurrentCultureIgnoreCase)) ? CheckState.Checked : CheckState.Unchecked);
                }
                break;

            case Pages.Level3:
                Stage   = Pages.Level2;
                Current = Records.FindAll(x => Current.Any(c => c.template.level4.level3.level2.level1.code == x.template.level4.level3.level2.level1.code)).ToList();
                SetList();
                for (int i = 0; i < checkedList.Items.Count; i++)
                {
                    checkedList.SetItemCheckState(i, tocheck.Any(c => checkedList.Items[i].ToString().StartsWith(c.template.level4.level3.level2.code + " ", StringComparison.CurrentCultureIgnoreCase)) ? CheckState.Checked : CheckState.Unchecked);
                }
                break;

            case Pages.Level4:
                Stage   = Pages.Level3;
                Current = Records.FindAll(x => Current.Any(c => c.template.level4.level3.level2.code == x.template.level4.level3.level2.code)).ToList();
                SetList();
                for (int i = 0; i < checkedList.Items.Count; i++)
                {
                    checkedList.SetItemCheckState(i, tocheck.Any(c => checkedList.Items[i].ToString().StartsWith(c.template.level4.level3.code + " ", StringComparison.CurrentCultureIgnoreCase)) ? CheckState.Checked : CheckState.Unchecked);
                }
                break;

            case Pages.Template:
                Stage   = Pages.Level4;
                Current = Records.FindAll(x => Current.Any(c => c.template.level4.level3.code == x.template.level4.level3.code)).ToList();
                SetList();
                for (int i = 0; i < checkedList.Items.Count; i++)
                {
                    checkedList.SetItemCheckState(i, tocheck.Any(c => checkedList.Items[i].ToString().StartsWith(c.template.level4.code + " ", StringComparison.CurrentCultureIgnoreCase)) ? CheckState.Checked : CheckState.Unchecked);
                }
                break;

            case Pages.Record:
                Stage   = Pages.Template;
                Current = Records.FindAll(x => Current.Any(c => c.template.level4.code == x.template.level4.code)).ToList();
                SetList();
                for (int i = 0; i < checkedList.Items.Count; i++)
                {
                    checkedList.SetItemCheckState(i, tocheck.Any(c => checkedList.Items[i].ToString().StartsWith(c.template.id.ToString() + " ", StringComparison.CurrentCultureIgnoreCase)) ? CheckState.Checked : CheckState.Unchecked);
                }
                break;
            }
            UpdateSelectedLabel();
        }