用于显示默认最小值和最大值的计算日期度量在 Power BI 桌面中不起作用

问题描述

我对 power bi DAX 非常陌生，我不明白为什么我的度量不能正常工作。因此，我为日期创建了一个度量，并将其应用于视觉级别过滤器以默认数据始终显示最近 x 个月或所有适用的数据。到目前为止，它给了我最小值和最大值之间的日期范围，但视觉效果没有根据默认日期范围更新。当我更改日期范围时，我的视觉效果就会更新。我希望我的视觉对象具有最新的默认日期和数据。请让我知道我该怎么做 做到这一点。 注意：我将此度量应用于显示日期范围的切片器。

这是我采用的措施：

Min_Max_ad_srch = VAR LatestDate = CALculaTE(MAX(ADS[DATE]),ALL(ADS)) RETURN IF(MIN(ADS[DATE]) = LatestDate,1,0)

解决方法

如果我理解正确，您希望在视觉对象中显示一组固定的数据，并且在进行其他选择时不更改。

您最好不要通过过滤视觉对象，而是通过将过滤条件应用于视觉对象正在显示的度量来实现这一点。

所以，你会使用类似的东西：

const EditableCell = ({
    value: initialValue,row: { index },column: { id },row: row,updateMyData,// This is a custom function that we supplied to our table instance
  }: CellValues) => {
    const [value,setValue] = useState(initialValue)
  
    const onChange = (e: any) => {
      setValue(e.target.value)
    }
 
    const onBlur = () => {
      updateMyData(index,id,value)
    }
  
    useEffect(() => {
      setValue(initialValue)
    },[initialValue])
  
    return <EditableInput value={value} onChange={onChange} onBlur={onBlur} />
}

const Dashboard: FC<IProps> = (props) => {
    const [bars,setBars] = useState<Bar[]>([])
    const [loading,setLoading] = useState(false)

    const COLUMNS: any = [
        {
            Header: () => null,id: 'approver',disableSortBy: true,Cell: (props :any) => {
                return (
                    <input
                        id="approved"
                        name="approved"
                        type="checkbox"
                        checked={props.cell.row.original.is_approved}
                        onChange={() => handleApprovedUpdate(props.cell.row.original.id)}
                    />
                )
            }
        }
    ];

    const defaultColumn = React.useMemo(
      () => ({
        Filter: DefaultColumnFilter,Cell: EditableCell,}),[])

    const updateMyData = (rowIndex: any,columnId: any,value: any) => {
        let barUpdate;
        setBars(old =>
            old.map((row,index) => {
                if (index === rowIndex) {
                    barUpdate = {
                        ...old[rowIndex],[columnId]: value,}
                    return barUpdate;
                }
                return row
            })
        )
        if(barUpdate) updateBar(barUpdate)
    }

    const columns = useMemo(() => COLUMNS,[]);
    const data = useMemo(() => bars,[bars]);
    const tableInstance = useTable({
        columns: columns,data: data,initialState: {

        },defaultColumn,updateMyData
    },useFilters,useSortBy,useExpanded );

    const fetchBars = () => {
         axios
            .get("/api/allbars",{
                    headers: {
                        Authorization: "Bearer " + localStorage.getItem("token")
                    }
                },)
            .then(response => {
                setBars(response.data)
            })
            .catch(() => {
            });
    };

    useEffect(() => {
        fetchBars()
    },[]);

    const handleApprovedUpdate = (barId: number): void => {
        const approvedUrl = `/api/bar/approved?id=${barId}`
        setLoading(true)
        axios
            .put(
                approvedUrl,{},{
                    headers: {Authorization: "Bearer " + localStorage.getItem("token")}
                }
            )
            .then(() => {
                const updatedBar: Bar | undefined = bars.find(bar => bar.id === barId);
                if(updatedBar == null) {
                    setLoading(false)
                    return;
                }

                updatedBar.is_approved = !updatedBar?.is_approved
                setBars(bars.map(bar => (bar.id === barId ? updatedBar : bar)))
                setLoading(false)
            })
            .catch((error) => {
                setLoading(false)
                renderToast(error.response.request.responseText);
            });
    };

    const renderTable = () => {
        const {
            getTableProps,getTableBodyProps,headerGroups,rows,prepareRow
        } = tableInstance;

        return(
            <table {...getTableProps()}>
                <thead>
                    {headerGroups.map(headerGroup => (
                        <tr {...headerGroup.getHeaderGroupProps()}>
                            {headerGroup.headers.map(column => (
                                <th {...column.getHeaderProps()}>
                                    <span {...column.getSortByToggleProps()}>
                                        {column.render('Header')}
                                    </span>{' '}
                                    <span>
                                        {column.isSorted ? column.isSortedDesc ? ' ▼' : ' ▲' : ''}
                                    </span>
                                    <div>{column.canFilter ? column.render('Filter') : <Spacer/>}</div>
                                </th>
                            ))}
                        </tr>
                    ))}
                </thead>
                <tbody {...getTableBodyProps()}>
                    {rows.map(row => {
                        prepareRow(row)
                        const rowProps = {...row.getRowProps()}
                        delete rowProps.role;
                        return (
                            <React.Fragment {...rowProps}>
                                <tr {...row.getRowProps()}>
                                    {row.cells.map(cell => {
                                        return (
                                            <td {...cell.getCellProps()}>{cell.render('Cell')}</td>
                                        )
                                    })}
                                </tr>
                                {row.isExpanded ? renderRowSubComponent({row}): null}
                            </React.Fragment>
                        )})
                    }
                </tbody>
            </table>
        )
    }
}

export default Dashboard;

使用 My Measure (for Latest Date) = VAR LatestDate = CALCULATE(MAX(ADS[DATE]),ALL(ADS)) RETURN CALCULATE([a Measure],ALL(ADS[DATE]),ADS[Date] = LastestDate) 可以有效地忽略在 ADS[DATE] 中所做的任何选择，然后说 ALL(ADS[DATE]) 会应用您要求的日期过滤器。

在您的视觉对象中使用此公式，您将始终显示最新日期的数据，而不管选择了哪些其他日期。