C#

/*********************************************************
    * Get the Hardware Vendors
    *********************************************************/
var vendors = (from v in db.JobHardwareVendors
                join c in db.Companies on v.VendorId equals c.Id
                where v.JobId == result.Id &&
                    !v.DeletedDT.HasValue
                select new CompanyHeaderEntity
                {
                    Id = c.Id,
                    CompanyName = c.CompanyName,
                    StatusId = c.StatusId
                }).Distinct().ToList();
result.HardwareCompanies.AddRange(vendors.Where(x => x.StatusId == companyStatuseActive.Id));

// Get the vendor's initials
foreach (var vendor in vendors)
{
    result.VendorInitials += GetInitials(vendor.CompanyName) + ",";
}

public async Task<List<TimelineReportEntity>> GetTimelineReportData(GenericReportArgsEntity reportArgs)
{
    var t = await Task.Factory.StartNew(() =>
    {
        List<TimelineReportEntity> results = null;

        using (var db = GetDataContext())
        {
            try
            {
                IQueryable<TimelineReportEntity> query = (from j in db.Jobs
                                                            join p in db.Projects on j.ProjectId equals p.Id
                                                            join c in db.Companies on p.CompanyId equals c.Id
                                                            join e in db.Employees on j.ForemanId equals e.Id into ep
                                                            from e in ep.DefaultIfEmpty()
                                                            join lc in db.Companies on j.LumberVendorId equals lc.Id into elc
                                                            from lc in elc.DefaultIfEmpty()
                                                            join hc in db.Companies on j.HardwareVendorId equals hc.Id into ehc
                                                            from hc in ehc.DefaultIfEmpty()
                                                            join tc in db.Companies on j.HardwareVendorId equals tc.Id into etc
                                                            from tc in etc.DefaultIfEmpty()
                                                            where !j.DeletedDT.HasValue
                                                            select new TimelineReportEntity
                                                            {
                                                                Id = j.Id,
                                                                JobId = j.JobNumber,
                                                                ProjectId = p.Id,
                                                                ProjectName = p.ProjectName,
                                                                CompanyId = c.Id,
                                                                CompanyName = c.CompanyName,
                                                                ForemanId = e.Id,
                                                                ForemanName = $"{e.FirstName} {e.LastName}",
                                                                Phase = j.Phase,
                                                                Quantity = j.Quantity,
                                                                Notes = j.Notes,
                                                            });

                // Create the predicate builder
                ExpressionStarter<TimelineReportEntity> predicate = null;

                if (reportArgs.IncludeAllProjects &&
                    reportArgs.IncludeAllCompanies &&
                    reportArgs.IncludeAllForemen)
                {
                    results = query.ToList();
                }
                else
                {
                    predicate = PredicateBuilder.New<TimelineReportEntity>();

                    if (!reportArgs.IncludeAllProjects)
                    {
                        foreach (var projectId in reportArgs.ProjectIds)
                        {
                            predicate = predicate.Or(p => p.ProjectId == projectId);
                        }
                    }

                    if (!reportArgs.IncludeAllCompanies)
                    {
                        foreach (var companyId in reportArgs.CompanyIds)
                        {
                            predicate = predicate.Or(p => p.CompanyId == companyId);
                        }
                    }

                    if (!reportArgs.IncludeAllForemen)
                    {
                        foreach (var foremanId in reportArgs.ForemenIds)
                        {
                            predicate = predicate.Or(p => p.ForemanId == foremanId);
                        }
                    }

                    results = query.Where(predicate).ToList();
                }

                var companyStatuses = GetLookups(Constants.LookupCategoryGenericFilters);
                var companyStatuseActive = companyStatuses.FirstOrDefault(x => x.AppCode == Constants.LookupCategoryGenericFiltersTypeActive);

                foreach (var result in results)
                {
                    result.ForemanInitials = result.ForemanName;

                    /*********************************************************
                        * Get the Hardware Vendors
                        *********************************************************/
                    var vendors = (from v in db.JobHardwareVendors
                                    join c in db.Companies on v.VendorId equals c.Id
                                    where v.JobId == result.Id &&
                                        !v.DeletedDT.HasValue
                                    select new CompanyHeaderEntity
                                    {
                                        Id = c.Id,
                                        CompanyName = c.CompanyName,
                                        StatusId = c.StatusId
                                    }).Distinct().ToList();
                    result.HardwareCompanies.AddRange(vendors.Where(x => x.StatusId == companyStatuseActive.Id));

                    // Get the vendor's initials
                    foreach (var vendor in vendors)
                    {
                        result.VendorInitials += GetInitials(vendor.CompanyName) + ",";
                    }

                    /*********************************************************
                        * Get the Lumber Vendors
                        *********************************************************/
                    vendors = (from v in db.JobLumberVendors
                                join c in db.Companies on v.VendorId equals c.Id
                                where v.JobId == result.Id &&
                                        !v.DeletedDT.HasValue
                                select new CompanyHeaderEntity
                                {
                                    Id = c.Id,
                                    CompanyName = c.CompanyName,
                                    StatusId = c.StatusId
                                }).Distinct().ToList();
                    result.LumberCompanies.AddRange(vendors.Where(x => x.StatusId == companyStatuseActive.Id));

                    // Get the vendor's initials
                    foreach (var vendor in vendors)
                    {
                        result.VendorInitials += GetInitials(vendor.CompanyName) + ",";
                    }

                    /*********************************************************
                        * Get the Equipment Vendors
                        *********************************************************/
                    vendors = (from v in db.JobEquipmentVendors
                                join c in db.Companies on v.VendorId equals c.Id
                                where v.JobId == result.Id &&
                                        !v.DeletedDT.HasValue
                                select new CompanyHeaderEntity
                                {
                                    Id = c.Id,
                                    CompanyName = c.CompanyName,
                                    StatusId = c.StatusId
                                }).Distinct().ToList();
                    result.EquipmentCompanies.AddRange(vendors.Where(x => x.StatusId == companyStatuseActive.Id));

                    // Get the vendor's initials
                    foreach (var vendor in vendors)
                    {
                        result.VendorInitials += GetInitials(vendor.CompanyName) + ",";
                    }

                    /*********************************************************
                        * Get the Truss Vendors
                        *********************************************************/
                    vendors = (from v in db.JobTrussVendors
                                join c in db.Companies on v.VendorId equals c.Id
                                where v.JobId == result.Id &&
                                        !v.DeletedDT.HasValue
                                select new CompanyHeaderEntity
                                {
                                    Id = c.Id,
                                    CompanyName = c.CompanyName,
                                    StatusId = c.StatusId
                                }).Distinct().ToList();
                    result.TrussCompanies.AddRange(vendors.Where(x => x.StatusId == companyStatuseActive.Id));

                    // Get the vendor's initials
                    foreach (var vendor in vendors)
                    {
                        result.VendorInitials += GetInitials(vendor.CompanyName) + ",";
                    }

                    // Remove trailing comma from vendor initials
                    if (!string.IsNullOrEmpty(result.VendorInitials))
                    {
                        result.VendorInitials = result.VendorInitials.TrimEnd(',');
                    }

                    /*********************************************************
                        * Get the latest Start Date
                        *********************************************************/
                    var startDateRevision = GetJobStartDateRevisions(result.Id).OrderByDescending(x => x.Revision).FirstOrDefault();

                    if (startDateRevision != null)
                    {
                        result.StartDate = startDateRevision.StartDate;
                        result.WeekGroup = result.StartDate.StartOfWeek(DayOfWeek.Monday);
                        result.FromDate = reportArgs.FromDate;
                        result.ToDate = reportArgs.ToDate;
                    }
                }

                results = results.Where(x => x.StartDate >= reportArgs.FromDate && x.StartDate <= reportArgs.ToDate).OrderBy(x => x.StartDate).ToList();
            }
            catch (Exception e)
            {
                throw;
            }
        }

        return results.ToList();
    });

    return t;
}

TransformedProfile = profileList.Select(x => new TransformedProfile
    {
    ProfileType = GetProfileType(x.PropertyA),
    ProfileSubType = GetProfileSubType(x.PropertyB),
    ProfileValidity = GetValidity(x.StartDate, x.ExpiryDate)
    })
    .OrderBy(y => typePriorityDict[y.ProfileType])
    .ThenBy(y => subTypePriorityDict[y.ProfileSubType])
    .ThenBy(y => validityPriorityDict[y.ProfileValidity])
    .FirstOrDefault();