Sum Over Partition By in Entity Framework subquery

Question

I'm trying to convert a query to lambda, and I'm close to what I want, but I'm having trouble converting a subquery that includes a sum over partition by clause.

The original query is as follows:

DECLARE @mrn VARCHAR(6)

SET @mrn = 000000
SET TRANSACTION isolation level READ uncommitted

SELECT DISTINCT lablog.link                              AS MRN,
                lablog.cpk_lablog                        AS [Label Log #],
                lablog.orderno                           AS [Order #],
                lablog.scriptext                         AS [Rx #],
                parts.name_                              AS [Medication Name],
                parts.ndc,
                lablog.refillnum                         AS [Fill #],
                lablog.bagsdisp                          AS [Quantity],
                lablog.dayssupp                          AS [Days Supplied],
                lablog.rxdays                            AS [Therapy Days],
                LOTLOG.lot                               AS [Lot],
                LOTLOG.[lot quantity],
                LOTLOG.[lot expiration date],
                Cast(lablog.delivdate AS DATE)           AS
                [Delivery Promised Date],
                Cast(tickci.confdate AS DATE)            AS
                [Ticket Confirmed Date],
                Cast(lablog.nextcomp AS DATE)            AS
                [Next Anticipated Fill Date],
                lablog.inits                             AS
                [Dispensing Location],
                doctors.ph_first + ' ' + doctors.ph_last AS [Prescriber Name]
FROM   cprsql.dbo.lablog
       INNER JOIN cprsql.dbo.parts
               ON parts.no = lablog.invno
       LEFT OUTER JOIN cprsql.dbo.doctors
                    ON doctors.no = lablog.docno
       LEFT OUTER JOIN cprsql.dbo.tickc
                    ON tickc.mrn = lablog.link
                       AND tickc.lablogno = lablog.cpk_lablog
       LEFT OUTER JOIN cprsql.dbo.tickci
                    ON tickci.tickno = tickc.tickno
       LEFT OUTER JOIN (SELECT link                                 AS MRN,
                               lotlog.lablogno,
                               lotlog.lot                           AS [Lot],
                               Sum(lotlog.qty)
                                 OVER (
                                   partition BY lablogno, lot, exp) AS
                               [Lot Quantity],
                               Cast(lotlog.exp AS DATE)             AS
       [Lot Expiration Date]
                        FROM   cprsql.dbo.lotlog
                        WHERE  1 = 1
                               AND lotlog.link = @mrn
                               AND lotlog.delflag = 0)LOTLOG
                    ON LOTLOG.lablogno = lablog.cpk_lablog
WHERE  1 = 1
       AND lablog.link = @mrn
       AND lablog.filltype <> 0
ORDER  BY cpk_lablog DESC

My lambda expression thus far looks like this

var query = (from labLog in _context.LabLog
            join parts in _context.Parts on labLog.InvNo equals parts.Id
            join doctors in _context.Doctors on labLog.DocNo equals doctors.Id into Doctors
            from d in Doctors.DefaultIfEmpty()
            join tick in _context.TickC on new {MRN = labLog.Link, ID = (int?) labLog.Id} equals
                new {MRN = mrn, ID = tick.LabLogNo} into Tick
            from t in Tick.DefaultIfEmpty()
            join tickCI in _context.TickCi on t.TickNo equals tickCI.Id into TickCI
            from tci in TickCI.DefaultIfEmpty()
            join lotLog in
                from lLog in _context.LotLog
                where !lLog.Deleted && lLog.Link == mrn
                select new
                {
                    lLog.LabLogNo,
                    lLog.Lot,
                    LotQuantity = // This clearly is not correct
                        (from l in _context.LotLog
                            group l by new {l.LabLogNo, l.Lot, l.Exp}
                            into ll
                            select ll.Sum(lll => lll.Qty)),
                    LotExpirationDate = lLog.Exp
                } on labLog.Id equals lotLog.LabLogNo into LotLog
            from ll in LotLog.DefaultIfEmpty()
            where labLog.Link == mrn && labLog.FillType != 0
            select new PatientDispense
            {
                MRN = labLog.Link,
                LabelLogNumber = labLog.Id,
                OrderNumber = labLog.OrderNo,
                RxNumber = labLog.ScripText,
                MedicationName = parts.Name,
                NationDrugCode = parts.Ndc,
                FillNumber = labLog.RefillNum,
                Quantity = int.TryParse(labLog.BagsDisp, out temp) ? temp : 0,
                DaysSupplied = int.TryParse(labLog.DaysSupp, out temp) ? temp : 0,
                TherapyDays = int.TryParse(labLog.RxDays, out temp) ? temp : 0,
                Lot = ll.Lot,
                LotQuantity = Convert.ToInt32(ll.LotQuantity),
                LotExpirationDate = ll.LotExpirationDate,
                DeliveryPromisedDate = labLog.DelivDate,
                TicketConfirmedDate = tci.ConfDate,
                NextAnticipatedFillDate = labLog.NextComp,
                DispensingLocation = labLog.Inits,
                PrescriberName = $"{d.PhFirst} {d.PhLast}"
            }).Distinct();

Which outputs the following query

DECLARE @__mrn_0 VARCHAR(6) = '000000';

SELECT DISTINCT [c].[link],
                [c].[cpk_lablog],
                [c].[orderno],
                [c].[scriptext],
                [c0].[name_],
                [c0].[ndc],
                [c].[refillnum],
                [c].[bagsdisp],
                [c].[dayssupp],
                [c].[rxdays],
                [t].[lot],
                (SELECT TOP(1) COALESCE(Sum([c5].[qty]), 0.0)
                 FROM   [cpr_lotlog] AS [c5]
                 GROUP  BY [c5].[lablogno],
                           [c5].[lot],
                           [c5].[exp]),
                [t].[exp],
                [c].[delivdate],
                [c3].[confdate],
                [c].[nextcomp],
                [c].[inits],
                [c1].[ph_first],
                [c1].[ph_last]
FROM   [cpr_lablog] AS [c]
       INNER JOIN [cpr_parts] AS [c0]
               ON [c].[invno] = [c0].[no]
       LEFT JOIN [cpr_doctors] AS [c1]
              ON [c].[docno] = [c1].[no]
       LEFT JOIN [cpr_tickc] AS [c2]
              ON ( [c].[link] = @__mrn_0 )
                 AND ( [c].[cpk_lablog] = [c2].[lablogno] )
       LEFT JOIN [cpr_tickci] AS [c3]
              ON [c2].[tickno] = [c3].[tickno]
       LEFT JOIN (SELECT [c4].[exp],
                         [c4].[lablogno],
                         [c4].[lot]
                  FROM   [cpr_lotlog] AS [c4]
                  WHERE  ( [c4].[deleted] = Cast(0 AS BIT) )
                         AND ( [c4].[link] = @__mrn_0 )) AS [t]
              ON [c].[cpk_lablog] = [t].[lablogno]
WHERE  ( [c].[link] = @__mrn_0 )
       AND ( ( [c].[filltype] <> 0 )
              OR ( [c].[filltype] IS NULL ) )