Exemple #1
0
 public static Task<List<QuickIssue>> GetQuickIssues(IssueFilterObject ifo)
 {
     var task = new TaskCompletionSource<List<QuickIssue>>();
     var cee = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);
     cee.GetQuickIssuesCompleted += (s, e) => task.SetResult(Serializer.Deserialize<List<QuickIssue>>(new MemoryStream(e.Result)));
     cee.GetQuickIssuesAsync(ifo);
     return task.Task;
 }
        public byte[] GetQuickIssues(IssueFilterObject ifo)
        {
            using (CmsEntities cee = new CmsEntities())
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();

                var quickIssue = new List<QuickIssue>();

                var query = (from x in cee.Issues select x);

                //ShowInactiveEquipment
                if (ifo.ShowInactiveEquipment == false)
                {
                    query = query.Where(x => x.IsActive == true);
                }

                if (ifo.IssueId.HasValue)
                {
                    query = query.Where(x => x.Id == ifo.IssueId.Value);
                }
                else
                {

                    //Keyword
                    if (!String.IsNullOrEmpty(ifo.Keyword) && ifo.IssueKeywordSearchInclude != null)
                    {
                        string[] textArray = CommonUtils.GetSearchTextArray(ifo.Keyword);

                        query = query.Where(BuildIssueKeywordPredicate(ifo, textArray));
                    }

                    //Status
                    if (ifo.StatusId.HasValue)
                    {
                        //Id = -1, Name = "N/A"
                        //Id = -2, Name = "On Hold / Rejected Or Closed"
                        if (ifo.StatusId == -2)
                        {
                            //IssueStatus.Id 4 = On Hold
                            //IssueStatus.Id 5 = Closed
                            //IssueStatus.Id 6 = Rejected
                            query = query.Include("IssueStatus").Where(x =>
                                x.IssueStatus.Code.Equals("onhold", StringComparison.CurrentCultureIgnoreCase) ||
                                x.IssueStatus.Code.Equals("closed", StringComparison.CurrentCultureIgnoreCase) ||
                                x.IssueStatus.Code.Equals("rejected", StringComparison.CurrentCultureIgnoreCase));
                        }
                        else
                        {
                            query = query.Where(x => x.IssueStatusId == ifo.StatusId.Value);
                        }

                    }

                    //NotStatus
                    if (ifo.NotStatusId.HasValue)
                    {
                        //Id = -1, Name = "N/A"
                        //Id = -2, Name = "On Hold / Rejected Or Closed"
                        if (ifo.NotStatusId == -2)
                        {
                            //IssueStatus.Id 4 = On Hold
                            //IssueStatus.Id 5 = Closed
                            //IssueStatus.Id 6 = Rejected
                            query = query.Include("IssueStatus").Where(x =>
                                x.IssueStatus.Code.ToLower() != "onhold" &&
                                x.IssueStatus.Code.ToLower() != "closed" &&
                                x.IssueStatus.Code.ToLower() != "rejected");
                        }
                        else
                        {
                            query = query.Where(x => x.IssueStatusId == ifo.NotStatusId.Value);
                        }

                    }

                    //Types
                    if (ifo.Types != null && ifo.Types.Any())
                    {
                        query = query.Where(x => ifo.Types.Contains(x.IssueTypeId));
                    }

                    //SubTypes
                    if (ifo.SubTypes != null && ifo.SubTypes.Any())
                    {
                        query = query.Where(x => ifo.SubTypes.Contains(x.IssueSubTypeId.Value));
                    }

                    //Classifications
                    if (ifo.Classifications != null && ifo.Classifications.Any())
                    {
                        query = query.Where(x => ifo.Classifications.Contains(x.IssueClassificationId.Value));
                    }

                    //Priority
                    if (ifo.PriorityId.HasValue)
                    {
                        query = query.Where(x => x.IssuePriorityId == ifo.PriorityId.Value);
                    }

                    //Areas
                    if (ifo.Areas != null && ifo.Areas.Any())
                    {
                        query = query.Include("IssueAreas").Where(x => x.IssueAreas.Any(ia => ifo.Areas.Contains(ia.AreaId)));
                    }

                    //Categories
                    if (ifo.Categories != null && ifo.Categories.Any())
                    {
                        query = query.Include("IssueAssignedCategories").Where(x => x.IssueAssignedCategories.Any(iac => ifo.Categories.Contains(iac.IssueCategoryId)));
                    }

                    //KeyStakeholders
                    if (ifo.KeyStakeholders != null && ifo.KeyStakeholders.Any())
                    {
                        query = query.Include("IssueRelatedKeyStakeholders").Where(x => x.IssueRelatedKeyStakeholders.Any(iac => ifo.KeyStakeholders.Contains(iac.RoleId)));
                    }

                    //Funding
                    if (!(String.IsNullOrEmpty(ifo.FundingType)))
                    {
                        query = query.Include("IssueTracking").Where(x => x.IssueTracking.FundingType == ifo.FundingType);
                    }

                    //Assigned To
                    if (ifo.AssignedToId.HasValue && ifo.AssignedToId != -1)
                    {
                        //-1 = All
                        //-2 = InactiveUser

                        if (ifo.AssignedToId == -2) //Inactive User
                        {
                            query = query.Include("CurrentlyAssignedToUser").Where(x => x.CurrentlyAssignedToUser.ActiveUser == false);
                        }
                        else
                        {
                            query = query.Where(x => x.CurrentlyAssignedToId == ifo.AssignedToId.Value);
                        }
                    }

                    //Project Supervisor
                    if (ifo.ProjectSupervisorId.HasValue && ifo.ProjectSupervisorId != -1)
                    {
                        //-1 = All
                        //-2 = InactiveUser

                        if (ifo.ProjectSupervisorId == -2) //Inactive User
                        {
                            query = query.Include("ProjectSupervisorUser").Where(x => x.ProjectSupervisorUser.ActiveUser == false);
                        }
                        else
                        {
                            query = query.Where(x => x.ProjectSupervisorId == ifo.ProjectSupervisorId.Value);
                        }
                    }

                    //Existing Risk
                    if (ifo.ExistingRiskRatingNumber.HasValue && ifo.ExistingRiskRatingNumber.Value > 0)
                    {
                        int existingRiskTypeId = (from x in cee.IssueRiskTypes where x.Name.ToLower().Contains("existing") select x.Id).FirstOrDefault();

                        query = query.Include("IssueRisks.IssueRiskMatrix").Where(x =>
                            x.IssueRisks.Any(r => r.RiskTypeId == existingRiskTypeId && r.IssueRiskMatrix.RiskRatingNumber >= ifo.ExistingRiskRatingNumber.Value));
                    }

                    //Final Risk
                    if (ifo.FinalRiskRatingNumber.HasValue && ifo.FinalRiskRatingNumber.Value > 0)
                    {
                        int finalRiskTypeId = (from x in cee.IssueRiskTypes where x.Name.ToLower().Contains("final") select x.Id).FirstOrDefault();

                        query = query.Include("IssueRisks.IssueRiskMatrix").Where(x =>
                             x.IssueRisks.Any(r => r.RiskTypeId == finalRiskTypeId && r.IssueRiskMatrix.RiskRatingNumber >= ifo.FinalRiskRatingNumber.Value));
                    }

                    //Critical Control
                    if (ifo.CriticalControl.HasValue && ifo.CriticalControl.Value)
                    {
                        query = query.Where(x => x.HasCriticalControls == ifo.CriticalControl.Value);
                    }

                    //Initiated By
                    if (ifo.InitiatedById.HasValue && ifo.InitiatedById != -1)
                    {
                        //-1 = All
                        query = query.Where(x => x.InitiatedById == ifo.InitiatedById.Value);
                    }

                    //ActionsBy
                    if (ifo.ActionsById.HasValue && ifo.ActionsById != -1)
                    {
                        //-1 All
                        //-2 Overdue
                        //-3 InactiveUser
                        if (ifo.ActionsById == -2) //Overdue
                        {
                            var currentDateTime = DateTime.Now;
                            query = query.Include("IssueRelatedActions").Where(x => x.IssueRelatedActions.Any(ira =>
                                ira.RequiredDate.HasValue && DbFunctions.TruncateTime(ira.RequiredDate.Value) < currentDateTime.Date));
                        }
                        else if (ifo.ActionsById == -3) //Inactive User
                        {
                            query = query.Include("IssueRelatedActions.AssignedToUser").Where(x => x.IssueRelatedActions.Any(ira => ira.AssignedToUser.ActiveUser == false));
                        }
                        else
                        {
                            query = query.Include("IssueRelatedActions").Where(x => x.IssueRelatedActions.Any(ira => ira.AssignedToId == ifo.ActionsById));
                        }
                    }

                    //Modified
                    if (ifo.ShiftPeriod != ShiftPeriodEnum.None)
                    {
                        DateTime shiftDateTime = new DateTime();

                        switch (ifo.ShiftPeriod)
                        {
                            case ShiftPeriodEnum.LastShift:
                                shiftDateTime = DateTime.Now.AddHours(-12);
                                break;
                            case ShiftPeriodEnum.LastDay:
                                shiftDateTime = DateTime.Now.AddDays(-1);
                                break;
                            case ShiftPeriodEnum.LastWeek:
                                shiftDateTime = DateTime.Now.AddDays(-7);
                                break;
                            case ShiftPeriodEnum.LastMonth:
                                shiftDateTime = DateTime.Now.AddMonths(-1);
                                break;
                            case ShiftPeriodEnum.Last3Months:
                                shiftDateTime = DateTime.Now.AddMonths(-3);
                                break;
                        }
                        query = query.Where(x => DbFunctions.TruncateTime(x.ModifiedDate) > shiftDateTime);
                    }
                }

                quickIssue = (from x in query
                              orderby x.Id
                              select new QuickIssue
                              {
                                  Id = x.Id,
                                  Name = x.Name,
                                  Description = x.Description,
                                  IsActive = x.IsActive
                              }).ToList();

                sw.Stop();
                Debug.WriteLine("It took {0} seconds to get Issues from GetQuickIssuess()", sw.Elapsed.TotalSeconds);

                MemoryStream byteStream = new MemoryStream();
                Serializer.Serialize(byteStream, quickIssue);

                return byteStream.ToArray();
            }
        }