Яндекс Алиса (Yandex Alice)

Code:
function get_devices(all)
    local result = {} 

    if redis:exists(name_devices2) then 
        local devices = redis:hgetall(name_devices2)

        for id, device in pairs(devices) do
            device = json.pdecode(device)

            if type(device) == "table" and device.name then
                device.id = id 
                
                -- Группируем skills по типам capabilities
                local capabilities_map = {}
                local simple_capabilities = {}
                
                if type(device.skills) == "table" then 
                    for skill_id, s in pairs(device.skills) do 
                        if all then 
                            local skill = {id=skill_id}
                            local has_act = false
                            local has_status = false
                            
                            -- Обработка act
                            if s.act then 
                                local addr = grp.find(s.act)
                                if addr then 
                                    if not mapping[s.act] then 
                                        mapping[s.act] = {dt = addr.datatype}
                                    end 
                                    mapping[s.act].actor = true 
                                    mapping[s.act].init = true 
                                    mapping[s.act].value = grp.getvalue(addr)
                                    skill.act = s.act
                                    has_act = true
                                end 
                            end
                            
                            -- Обработка status
                            if s.status then 
                                local addr = grp.find(s.status)
                                if addr then 
                                    if not mapping[s.status] then 
                                        mapping[s.status] = {dt = addr.datatype}
                                    end 
                                    mapping[s.status].status = true
                                    mapping[s.status].value = grp.getvalue(s.status)
                                    skill.status = s.status 
                                    skill.value = grp.getvalue(s.status)
                                    has_status = true
                                end                                 
                            end
                            
                            skill.f = s.f
                            
                            -- Проверяем, относится ли skill к color_setting
                            if skill_id:match("^color_setting%.") then
                                local param_name = skill_id:match("^color_setting%.(.+)$")
                                
                                if not capabilities_map.color_setting then
                                    capabilities_map.color_setting = {
                                        type = "color_setting",
                                        parameters = {}
                                    }
                                end
                                
                                -- Добавляем параметр в color_setting
                                if param_name == "temperature_k" then
                                    if type(skill.f) == "table" and skill.f.min and skill.f.max then
                                        capabilities_map.color_setting.parameters.temperature_k = {
                                            min = skill.f.min,
                                            max = skill.f.max
                                        }
                                        if skill.f.precision then
                                            capabilities_map.color_setting.parameters.temperature_k.precision = skill.f.precision
                                        end
                                    end
                                elseif param_name == "color_model" then
                                    capabilities_map.color_setting.parameters.color_model = "hsv" -- или "rgb"
                                end
                                
                                -- Сохраняем адреса для управления
                                if has_act or has_status then
                                    if not capabilities_map.color_setting.addresses then
                                        capabilities_map.color_setting.addresses = {}
                                    end
                                    capabilities_map.color_setting.addresses[param_name] = {
                                        act = skill.act,
                                        status = skill.status,
                                        value = skill.value,
                                        f = skill.f
                                    }
                                end
                                
                            else
                                -- Обычный skill, не относящийся к color_setting
                                if has_act or has_status then
                                    table.insert(simple_capabilities, skill)
                                end
                            end
                        else
                            -- Режим для UI (не all)
                            table.insert(simple_capabilities, skill_id) 
                        end 
                    end
                    
                    -- Формируем итоговый массив skills
                    if all then
                        local skills = {}
                        
                        -- Добавляем сгруппированные capabilities
                        for cap_type, cap_data in pairs(capabilities_map) do
                            table.insert(skills, cap_data)
                        end
                        
                        -- Добавляем обычные skills
                        for _, skill in ipairs(simple_capabilities) do
                            table.insert(skills, skill)
                        end
                        
                        device.skills = skills
                    else
                        device.skills = simple_capabilities
                    end
                else 
                    device.skills = {} 
                end 

                table.insert(result, device)
            end 
        end 
    end 

    return result 
end