let
    f=(x)=>(y)=>List.Sum(Table.Column(y,x)),
    lst=List.Transform({"Цена","кол-во ","сумма"},(x)=>{x,f(x)}),
    from = Excel.CurrentWorkbook(){[Name="Таблица13"]}[Content],
    gr= Table.Group(from,{"ID","наименование"},lst)
in
    gr

let
    f=(x)=>Excel.CurrentWorkbook(){[Name=x]}[Content],
    g=(x)=>List.Transform(List.RemoveMatchingItems(Text.Split(x??"","#(lf)"),{""}), f_txtTrim),
    h=(x)=>List.Zip({List.Difference(x{0},x{1}),List.Difference(x{1},x{0})}),
    
    tr_new=Table.TransformColumns(f("table_new"),{"Шифр",g}),
    exp_new =Table.Buffer(Table.ExpandListColumn(tr_new, "Шифр")),
    tr_old=Table.TransformColumns(f("table_old"),{"Шифр",g}),
    exp_old =Table.Buffer(Table.ExpandListColumn(tr_old, "Шифр")),
    gr_new=Table.Group(exp_new,"Номер Этапа",{"Этап",(x)=>x[Шифр]}),
    gr_old=Table.Group(exp_old,"Номер Этапа",{"Этап",(x)=>x[Шифр]}),
    join=Table.NestedJoin(gr_new,"Номер Этапа",gr_old,"Номер Этапа","tmp"),
    exp = Table.ExpandTableColumn(join, "tmp", {"Этап"}, {"tmp"}),
    com=Table.CombineColumns(exp,{"Этап","tmp"},h,"tmp"),
    sel=Table.SelectRows(com,(x)=>x[tmp]<>{}),
    tbl =Table.FromColumns(sel[tmp],sel[Номер Этапа]),
    acc=List.Accumulate(List.Buffer(sel[Номер Этапа]),tbl,(s,c)=>Table.SplitColumn(s,c,(x)=>x??{},{c&" new",c&" old"}) )
in
    acc

let
    f=(x)=>Excel.CurrentWorkbook(){[Name=x]}[Content],
    g=(x)=>List.Transform(List.RemoveMatchingItems(Text.Split(x??"","#(lf)"),{""}), f_txtTrim),
    tr_new=Table.TransformColumns(f("table_new"),{"Шифр",g}),
    exp_new =Table.ExpandListColumn(tr_new, "Шифр"),
    tr_old=Table.TransformColumns(f("table_old"),{"Шифр",g}),
    exp_old =Table.ExpandListColumn(tr_old, "Шифр"),
    gr_new=Table.Buffer(Table.Group(exp_new,"Номер Этапа",{"Этап",(x)=>x[Шифр]})),
    gr_old=Table.Buffer(Table.Group(exp_old,"Номер Этапа",{"Этап",(x)=>x[Шифр]})),
    nms_new=List.Buffer(List.Transform(gr_new[Номер Этапа],(x)=>x&" new")),
    nms_old=List.Buffer(List.Transform(gr_old[Номер Этапа],(x)=>x&" old")),
    to=Table.FromColumns(gr_new[Этап]&gr_old[Этап],nms_new&nms_old),
    nms=List.Combine(List.Zip({nms_new,nms_old})),
    sel=Table.SelectColumns(to,nms)
in
    sel 

let
    f=(x)=> Excel.CurrentWorkbook(){[Name=x]}[Content],
    g=(x)=>[tb=Table.Sort(x,"Дата"),
            rec=List.Buffer(Table.ToRecords(tb)),
            gen=List.Generate(
                ()=>[i=0,r=rec{i},ost_mon=Record.FieldOrDefault(dict,r[Товар],0),ost=ost_mon+r[Поступление]-r[Выбытие]],
                (x)=>x[i]<List.Count(rec),
                (x)=>[i=x[i]+1,r=rec{i},ost_mon=x[ost], ost=ost_mon+(r[Поступление]??0)-(r[Выбытие]??0)],
                (x)=>x[r] & [остаток на начало дня=x[ost_mon], остаток на конец дня=x[ost]])][gen],
    from=Table.TransformColumns(Table.Buffer(f("data")),{"Дата",Date.From},(x)=>x??0),                         
    dict=((a)=>Record.FromList(a[Остаток],a[Товар]))(f("dict")),
    gr=Table.Group(from,"Товар",{"tmp",g}),
    nms=((a)=>List.FirstN(a,2)&{"остаток на начало дня"}&List.Skip(a,2)&{"остаток на конец дня"})(Table.ColumnNames(from)),
    to=Table.FromRecords(List.Combine(gr[tmp]),nms)
in
    to

let
    f=(x)=> Excel.CurrentWorkbook(){[Name=x]}[Content],
    g=(optional x)=>[i=if x=null then 0 else x[i]+1,
                    dict=if x=null then dict else x[new_dict], 
                    r=rec{i},
                    ost=Record.FieldOrDefault(dict,r[Товар],0),
                    new_ost=ost + r[Поступление] - r[Выбытие],
                    new_dict=if Record.HasFields(dict,r[Товар]) 
                            then Record.TransformFields(dict,{r[Товар],(x)=>new_ost})
                            else Record.AddField(dict,r[Товар],new_ost) ],
    dict=((a)=>Record.FromList(a[Остаток],a[Товар]))(f("dict")),
    from = Table.Sort(Table.TransformColumns(Table.Buffer(f("data")),{"Дата",Date.From},(x)=>x??0),{"Дата"}),
    n=List.Count(rec),
    rec=List.Buffer(Table.ToRecords(from)),
    gen=List.Generate(g,(x)=>x[i] < n,g,(x)=>x[r] &[остаток на начало дня=x[ost], остаток на конец дня=x[new_ost]]),
    nms=((a)=>List.FirstN(a,2)&{"остаток на начало дня"}&List.Skip(a,2)&{"остаток на конец дня"})(List.Buffer(Table.ColumnNames(from))),
    tb=Table.FromRecords(gen,nms)
in
    tb

let
    f=(x)=>Excel.CurrentWorkbook(){[Name=x]}[Content],
    from=List.Buffer(Table.ToColumns(f("event"))),
    dt=Table.FirstValue(f("date")),
    lst=List.Transform(List.FirstN(from,2),(x)=>List.PositionOf(x,dt,Occurrence.All)),
    to=((pos)=>if pos={} 
               then "нет" 
               else Text.Combine(List.Distinct(List.Transform(List.Buffer(pos),(i)=>List.Last(from){i})),", "))
                    (List.Combine(lst))
in
   to

let
    f=(x)=>Excel.CurrentWorkbook(){[Name=x]}[Content],
    from=List.Buffer(Table.ToList(f("event"),(x)=>List.Transform(x,Text.From))),
    dt=Table.FirstValue(f("date")),
    fnd=List.FindText(from,Text.From(dt)),
    to=if fnd={} then "нет" else Text.Combine(List.Distinct(List.Transform(fnd,List.Last)),", ")
in
    to

let
    f=(x)=>((n)=>List.Repeat({null},n) & lst{x[row]-1})
            (Number.IntegerDivide(x[порядок]-1,3)*4),
    from = Excel.CurrentWorkbook(){[Name="data"]}[Content],
    typ=List.Zip({{"поле 1","поле 2","поле 3","поле 4"},List.Repeat({Text.Type},4)}),
    tr=Table.TransformColumnTypes(from,typ),
    lst= List.Buffer(Table.ToList(tr,(x)=>List.RemoveLastN(List.Skip(x),1)&List.FirstN(x,1))),
    add=Table.AddColumn(tr,"x", f),
    to=Table.SplitColumn(add,"x",(x)=>x,21)
in
    to

Источник = Excel.Workbook(File.Contents("S:\B2C\МАРКЕТИНГ\Аналитика\Проекты и разработки\Категорийный анализ\2025\4 кв 2025\Автоматизация\Отчет (4 квартал 2025 г.).xlsx"), null, true),
   #"База по группам_Sheet" = Источник{[Item="База по группам",Kind="Sheet"]}[Data],

#"Повышенные заголовки" = Table.PromoteHeaders(#"База по группам_Sheet", [PromoteAllScalars=true]),

#"Измененный тип" = Table.TransformColumnTypes(#"Повышенные заголовки",{{"Группа", type text}, {"Подгруппа ", type text}, {"Номер артикула", type text}, {"Номенклатура", type text}, {"Статус товара", type text}, {"Поставщик", type text},}}),

 #"Удаленные столбцы" = Table.RemoveColumns(#"Измененный тип",{"Подгруппа ", "Номер артикула", "Статус товара", "Поставщик",}),

 #"Removed Other Columns" = Table.SelectColumns(#"База по группам_Sheet",{"Группа", "Номенклатура", "АВС 4 кв 2025", "XYZ 4 кв. 2025", "Индекс Х-Х 4 кв. 2025"}),

f=(x)=>Table.FromColumns(List.Transform(Table.ToColumns(x),List.RemoveNulls),{"X","y","Z"}),

#"Сгруппированные строки" = Table.Group(#"Удаленные столбцы1", 
                              {"Группа", "АВС 4 кв 2025", "Индекс Х-Х 4 кв. 2025"}, 
                              {"tmp",(x)=>((tbl)=>Table.FromColumns(List.Transform(Table.ToColumns(tbl),List.RemoveNulls),{"X","Y","Z"}))
                              (x[[X],[Y],[Z]])})

let
  Источник = Excel.Workbook(File.Contents("S:\B2C\МАРКЕТИНГ\Аналитика\Проекты и разработки\Категорийный анализ\2025\4 кв 2025\Автоматизация\Отчет (4 квартал 2025 г.).xlsx"),true),
  #"База по группам_Sheet" = Источник{[Item="База по группам",Kind="Sheet"]}[Data],
  #"Removed Other Columns" = Table.SelectColumns(#"База по группам_Sheet",{"Группа", "Номенклатура", "АВС 4 кв 2025", "XYZ 4 кв. 2025", "Индекс Х-Х 4 кв. 2025"}),
  #"Добавлен пользовательский объект" = Table.AddColumn(#"Removed Other Columns", "new", (x)=>Record.FromList({x[Номенклатура]},{x[XYZ 4 кв. 2025]})),
  #"Развернутый элемент new" = Table.ExpandRecordColumn(#"Добавлен пользовательский объект", "new", {"Z", "Y", "X"}),
  #"Удаленные столбцы1" = Table.RemoveColumns(#"Развернутый элемент new",{"Номенклатура","XYZ 4 кв. 2025"}),
  #"Сгруппированные строки" = Table.Group(#"Удаленные столбцы1", 
                              {"Группа", "АВС 4 кв 2025", "Индекс Х-Х 4 кв. 2025"}, 
                              {"tmp",(x)=>((tbl)=>Table.FromColumns(List.Transform(Table.ToColumns(tbl),List.RemoveNulls),{"X","Y","Z"}))
                              (x[[X],[Y],[Z]])})
in
    #"Сгруппированные строки"

let
    Source = Excel.CurrentWorkbook(){[Name="table1"]}[Content],
    gr=Table.Group(Source,"ИСХОДНИК",{"count",Table.RowCount})
in
    gr

let
    lst=(x)=>List.Buffer(Table.ToList(x,(x)=>List.Skip(x))),
    f=(x)=>Text.Combine({Text.From(Table.FirstValue(x))} & List.Transform(lst(x),(y)=>Text.Format("-#{0}(#{1})",y))),
    from = Excel.CurrentWorkbook(){[Name="Таблица1"]}[Content],
    sel=Table.SelectRows(from,(x)=>List.RemoveNulls(Record.FieldValues(x))<>{}),
    max =List.Max(List.Transform(gr[tmp],List.Count)),
    nms=List.TransformMany({1..max/2},(x)=>{"Диаметр","Длина"},(x,y)=>y& Text.From(x)),
    gr=Table.Group(sel,"Номер",{{"tmp",(x)=>List.Combine(lst(x))},{"txt",f}}),
    spl=Table.SplitColumn(gr,"tmp",(x)=>x,nms)
in
    spl

let
    from = Excel.CurrentWorkbook(){[Name="Smart_BD_status"]}[Content],
    skip=Table.SelectRows(Table.Skip(from,(x)=>x[Статус] is number),(x)=>x[ID_idei]<>null),
    gr=Table.Group(skip,"ID_idei",{"tmp",(x)=>Table.Last(x)}),
    to=Table.FromRecords(gr[tmp]),
    sel=Table.SelectRows(to,(x)=>x[Статус]=status)
in
    sel

let
    f=(x)=>Table.FromColumns(List.Transform(Table.ToColumns(x),List.RemoveNulls),{"X","y","Z"}),

    from = Excel.Workbook(File.Contents(fParam("Path")),true){[Name="База по группам"]}[Data],
    sel = Table.SelectColumns(from,{"Группа", "Номенклатура", "АВС 4 кв 2025", "XYZ 4 кв. 2025", "Индекс Х-Х 4 кв. 2025"}),
    add=Table.AddColumn(sel,"new",(x)=>Record.FromList({x[Номенклатура]},{x[XYZ 4 кв. 2025]})),
    exp = Table.ExpandRecordColumn(add, "new", {"Z", "Y", "X"}),
    rem = Table.RemoveColumns(exp,{"Номенклатура", "XYZ 4 кв. 2025"}),
    gr=Table.Buffer(Table.Group(rem,{"Группа","АВС 4 кв 2025", "Индекс Х-Х 4 кв. 2025"},{"tmp",(x)=>f(x[[X],[Y],[Z]])})),
    to =Table.Sort(Table.ExpandTableColumn(gr, "tmp", {"X", "y", "Z"}),{"АВС 4 кв 2025", "Индекс Х-Х 4 кв. 2025"})
in
    to

let
    f=(x)=>((a)=>List.Split(Table.ToColumns(a),4))
            (Table.Skip(x,(x)=>x[Столбец1]=null)),

    from = Excel.CurrentWorkbook(){[Name="Таблица1"]}[Content],
    gr=Table.Group(from,"Столбец1",{"tmp",f},GroupKind.Local,(s,c)=>Number.From(c=null))[[tmp]],
    exp = Table.ExpandListColumn(gr, "tmp"),
    tr=Table.TransformColumns(exp,{"tmp",List.Zip}),
    exp1 = Table.ExpandListColumn(tr, "tmp"),
    spl=Table.SplitColumn(exp1,"tmp",(x)=>x,{"1".."4"})
in
    spl

let
    f=(x)=>List.Transform(List.Transform(Text.Split(x{0}," — "),Time.From),(i)=> if i=#time(0,0,0) then (#time(23,59,59)) else i),
    from = Excel.CurrentWorkbook(){[Name="table1"]}[Content],
    lst=List.Buffer(Table.ToList(from,f)),
    tm=List.Buffer(List.Times(#time(9,0,0),Duration.Hours(#time(24,0,0)-#time(9,0,0)),#duration(0,1,0,0))),
    acc=List.Accumulate(tm,{},(s,cur)=>s & {List.Count(List.PositionOf(lst,cur,Occurrence.All,(c,v)=>c{0}<=v and c{1}>v))}),
    to=Table.FromRecords({Record.FromList(acc,List.Transform(tm,Text.From))})
in
    to

let
    f=(x)=>List.Transform(List.Transform(Text.Split(x{0}," — "),Time.From),(i)=> if i=#time(0,0,0) then (#time(23,59,59)) else i),
    from = Excel.CurrentWorkbook(){[Name="table1"]}[Content],
    lst=List.Buffer(Table.ToList(from,f)),
    tm=List.Buffer(List.Times(#time(9,0,0),Duration.Hours(#time(24,0,0)-#time(9,0,0)),#duration(0,1,0,0))),
    tr=List.Transform(tm,(x)=>List.Sum(List.Transform(lst,(i)=>if i{0}<=x and i{1}>x then 1 else null))),
    rec=Record.FromList(tr,List.Transform(tm,Text.From)),
    to=Table.FromRecords({rec})
in
    to

let
    f=(x)=>{Date.From(x{0}) &Time.From(x{1}),Date.From(x{2}) &Time.From(x{3})},
    g=(x)=>[начало=Table.FirstValue(x), окончание=List.Last(x[end]), продолжительность=окончание-начало],
    Source = Excel.Workbook(File.Contents(fParam("Path")),true){[Name="Исходный"]}[Data],
    tb=Table.FromList(Table.ToList(Source,f),(x)=>x,{"start","end"}),
    gr=Table.Group(tb,"start",{"tmp",g},GroupKind.Local,(s,c)=>Number.From(Date.From(s)<>Date.From(c))),
    to=Table.FromRecords(gr[tmp])
in
    to

let
    f=(x)=>List.Zip(((a,b)=>a & {b & {a{1}{0}}} & {b & {List.Last(a{3})}} )
    (Table.ToColumns(x), List.Repeat({null},Table.RowCount(x)-1))),
    from = Excel.Workbook(File.Contents(fParam("Path")),true){[Name="Исходный"]}[Data],
    typ = Table.TransformColumnTypes(from,{{"Начало", type date}, {"периода", type time}, {"Конец", type date}, {"периода1", type time}}),
    gr=Table.Group(typ,"Начало",{"tmp",f},GroupKind.Local,(s,c)=>Number.From(Date.From(s)<>Date.From(c))),
    tb=Table.FromList(List.Combine(gr[tmp]),(x)=>x,{"1".."6"})
in
    tb

let
    f=(x)=>((tb)=>Record.FromList(tb[value],tb[направление])) 
            (Table.Group(x,"направление",{"value",(x)=>Table.Max(x,"время")[время]})),
    from = Excel.CurrentWorkbook(){[Name="table1"]}[Content],
    gr=Table.Group(from,{"Дата","ФИО"},{"tmp",f}),
    exp=Table.ExpandRecordColumn(gr,"tmp",{"выход","вход"})
in
    exp

let
    f = (x)=>List.Repeat({List.FirstN(x,2) & {1,x{3},x{4}/x{2}}},x{2}),
    from = Excel.CurrentWorkbook(){[Name="Таблица1"]}[Content],
    lst = List.Combine(List.Buffer(Table.ToList(from,f))),
    to=Table.FromList(lst,(x)=>x,Table.ColumnNames(from))
in
    to

let
    f=(x)=>[a=Table.Group(Table.RemoveColumns(x,"Магазины"),"Категория",
            {"tmp1",(i)=>{{Table.FirstValue(i)}} & Table.ToList(i[[Продукт],[Вес]], (x)=>x)}),
            b=List.Zip({{Table.FirstValue(x)}} & List.Combine(a[tmp1])),
            c=Table.FromColumns(b,{"Продукт","Вес"}) & #table({},{{}})  ][c],
    from = Excel.CurrentWorkbook(){[Name="Таблица1"]}[Content],
    gr=Table.Group(from,"Магазины",{"tmp", f}), 
    to=Table.SplitColumn(Table.Combine(gr[tmp]),"Вес",(x)=>{null,x}, {"x","Вес"})
in
    to

let
    f=(x)=>{Text.Split(x{1},"/ ")}&{null}&List.Skip(x,2),
    Source = Excel.CurrentWorkbook(){[Name="table1"]}[Content],
    lst=Table.FromList(Table.ToList(Source,f),(x)=>x,Table.ColumnNames(Source)),
    exp=Table.ExpandListColumn(lst,"Артикул")
in
    exp