Thanks for sharing your code.

As you already found out, the only difference in the "map generation blocks" is the names of the variables holding the maps. So it is quite obvious, that you could move this 3 lines into the method buildDtos.

On the other hand the first line in each "map generation blocks" calls a separate method on the client object. This is an odd ball solution and the proper way to deal with that would be to enable clinet.client.getBaselineValues() to deal with a special String (Attention! resist the temptation to use null!) to return the same result as clinet.client.getValues().

until then we could introduce a FunctionalInterface to mimik that on this side. This could look like this:

@FunctionalInterface
interface ValueSelector {
    Map<String, BigDecimal> selectFrom(
          Client client, 
          List<String> ids, 
          LocalDate startDate, 
          LocalDate endDate);
}

public List<ProductValuesDto> main() {

    buildDtos(//
            dtos,
            productIds,
            (client, ids, start, end) -> client.getValues(ids, start, end));
    buildDtos(
            dtos,
            grossProductIds,
            (client, ids, start, end) -> client.getBaselineValues(ids, start, end, "gross"));
    buildDtos(//
            dtos,
            netProductIds,
            (client, ids, start, end) -> client.getBaselineValues(ids, start, end, "net"));
    return dtos;

}

public void buildDtos(List<ProductValuesDto> dtos, List<String> productIds, ValueSelector valueSelector) {

    Map<String, BigDecimal> sevenDayValues = valueSelector
            .selectFrom(client, productIds, endDate.minusDays(7), endDate);
    Map<String, BigDecimal> thirtyDayValues = valueSelector
            .selectFrom(client, productIds, endDate.minusDays(30), endDate);
    Map<String, BigDecimal> threeHundredSixtyFiveDayValues = valueSelector
            .selectFrom(client, productIds, endDate.minusDays(365), endDate);
    Map<String, BigDecimal> ninetyDayNetValues = valueSelector
            .selectFrom(client, productIds, endDate.minusDays(90), endDate);

    for (String productId : productIds) {
        ProductValuesDto dto = ProductValuesDto.builder(productId)//
                .sevenDayValue(sevenDayValues.get(productId))//
                .thirtyDayValue(thirtyDayValues.get(productId))//
                .ninetyDayValue(ninetyDayNetValues.get(productId))//
                .threeHundredSixtyFiveDayValue(threeHundredSixtyFiveDayValues.get(productId))//
                .build();
        dtos.add(dto);
    }

}

Update

Based on that approach we could improve this even further.

Improvement 1

Create an enum that provides implementations of the new interface:

enum ClientValues {
    PLAIN {

        @Override
        ValueSelector getSelectorForType(String reportType) {
            return (client, ids, start, end)
                      -> client.getValues(ids, start, end);
        }
    },
    BASELINE {

        @Override
        ValueSelector getSelectorForType(String reportType) {
            return (client, ids, start, end)
                      ->  client.getBaselineValues(ids, start, end, reportType);
        }
    };
    abstract ValueSelector getSelectorForType(//
            String reportType);
}

create a Map that assigns this enum constants to the strings used:

    Map<String, ClientValues> valuesByType = new HashMap<>();
    valuesByType.put("plain", ClientValues.PLAIN);

We intentionally leave out the constant that is used most often.

Next we create another map that assignes the Strings used with the respective ID lists:

    Map<String, List<String>> idsByType = new HashMap<>();
    idsByType.put("plain", productIds);
    idsByType.put("gross", grossProductIds);
    idsByType.put("net", netProductIds);

Complete mapping this time.

Both maps could even be class members (with static initializers) or object members constructed somewhere else and injected into this class.

Now we can iterate over the entries of the second map using the first one like this:

    for (String idType : idsByType.keySet()) {
        List<String> ids = idsByType.get(idType);
        ClientValues clientValues = 
                       valuesByType.getOrDefault(idType, ClientValues.BASELINE);
        buildDtos(//
                dtos,
                ids,
                clientValues.getSelectorForType(idType));
    }
    return dtos;

Advantage: an new "report type" would only require a new entry in idsByType and maybe a new entry in valuesByType if the client has another special method for fetching than values.

Improvement 2

The same approach can simplify buildDtos too.

Again we start by creating an enum:

enum ProductValuesBuilderFacade {
    SEVEN_DAY_VALUES(7) {
        ProductValuesDto setValueTo(
                  ProductValuesDto builder, BigDecimal value) {
            return builder.sevenDayValue(value);
        }
    },
    THIRTY_DAY_VALUES(30) {
        ProductValuesDto setValueTo(
                  ProductValuesDto builder, BigDecimal value) {
            return builder.thirtyDayValue(value);
        }
    },
    NINETY_DAY_VALUES(90) {
        ProductValuesDto setValueTo(
                  ProductValuesDto builder, BigDecimal value) {
            return builder.ninetyDayValue(value);
        }
    },
    THREE_HUNDRED_SIXTY_FIVE_DAY_VALUES_DAY_VALUES(365) {
        ProductValuesDto setValueTo(
                  ProductValuesDto builder, BigDecimal value) {
            return builder.threeHundredSixtyFiveDayValue(value);
        }
    };

    private final long timeOffsetInDays;

    ProductValuesBuilderFacade(long timeOffsetInDays) {
        this.timeOffsetInDays = timeOffsetInDays;
    }

    abstract ProductValuesDto setValueTo(
                 ProductValuesDto builder, BigDecimal bigDecimal);

    public LocalDate getStartDate(LocalDate endDate) {
        return endDate.minusDays(timeOffsetInDays);
    }
}

This gives us the opportunity to iterate over its constants inside the method:

public void buildDtos(
               List<ProductValuesDto> dtos,
               List<String> productIds,
               ValueSelector valueSelector) {
    for (String productId : productIds) {
        ProductValuesDto dto = ProductValuesDto.builder(productId);
        ProductValuesBuilderFacade[] productValuesBuilderFacades =
               ProductValuesBuilderFacade.values();
        for (ProductValuesBuilderFacade productValuesBuilderFacade 
               : productValuesBuilderFacades) {
            Map<String, BigDecimal> allValuesForDate 
                     = valueSelector.selectFrom(
                          client,
                          productIds,
                          productValuesBuilderFacade
                                .getStartDate(endDate),
                          endDate);
            dto = productValuesBuilderFacade.setValueTo(
                          dto,
                          allValuesForDate.getOrDefault(productId, BigDecimal.ZERO));
        }
        dtos.add(dto.build());
    }
}

Advantages:

• again the enum can live in its own file.
• a new setter method in the DTO requires only a new constant in the enum.