Каталог товаров:
витрина и правки

catalog_page(category=None, page=1, per_page=5,
             sort_field="price", desc=True) → (items, total)

std::pair<std::vector<Product>, std::int64_t>
catalog_page(mongocxx::collection& products, const std::string& category,
             std::int64_t page, std::int64_t per_page,
             const std::string& sort_field = "price", bool desc = true);

func catalogPage(category string, page, perPage int64,
    sortField string, desc bool) ([]Product, int64, error)

catalog_page(category: nil, page: 1, per_page: 5,
             sort_field: "price", desc: true) → [items, total]

def catalog_page(category=None, page=1, per_page=5,
                 sort_field="price", desc=True):
    query = {}
    if category:
        query["category"] = category

    total = products.count_documents(query)

    cursor = (products
              .find(query, {"_id": 0, "sku": 1, "title": 1,
                            "price": 1, "rating": 1})
              # второй ключ делает порядок однозначным
              .sort([(sort_field, -1 if desc else 1), ("sku", 1)])
              .skip((page - 1) * per_page)
              .limit(per_page))

    return list(cursor), total

bsoncxx::builder::basic::document query{};
if (!category.empty()) query.append(kvp("category", category));
auto filter = query.extract();

auto total = products.count_documents(filter.view());

mongocxx::options::find options;
options.projection(make_document(kvp("_id", 0), kvp("sku", 1),
    kvp("title", 1), kvp("price", 1), kvp("rating", 1)));
// второй ключ делает порядок однозначным
options.sort(make_document(kvp(sort_field, desc ? -1 : 1), kvp("sku", 1)));
options.skip((page - 1) * per_page);
options.limit(per_page);

std::vector<Product> items;
for (const auto& doc : products.find(filter.view(), options))
    items.push_back(to_product(doc));
return {items, total};

query := bson.D{}
if category != "" {
    query = append(query, bson.E{Key: "category", Value: category})
}

total, err := products.CountDocuments(ctx, query)
if err != nil {
    return nil, 0, err
}

direction := 1
if desc {
    direction = -1
}

cursor, err := products.Find(ctx, query, options.Find().
    SetProjection(bson.D{{Key: "_id", Value: 0}, {Key: "sku", Value: 1},
        {Key: "title", Value: 1}, {Key: "price", Value: 1}, {Key: "rating", Value: 1}}).
    // второй ключ делает порядок однозначным
    SetSort(bson.D{{Key: sortField, Value: direction}, {Key: "sku", Value: 1}}).
    SetSkip((page - 1) * perPage).
    SetLimit(perPage))

var items []Product
return items, total, cursor.All(ctx, &items)

query = {}
query["category"] = category if category

total = PRODUCTS.count_documents(query)

# второй ключ делает порядок однозначным
order = { sort_field => desc ? -1 : 1, "sku" => 1 }

items = PRODUCTS
        .find(query, projection: { "_id" => 0, "sku" => 1, "title" => 1,
                                   "price" => 1, "rating" => 1 })
        .sort(order)
        .skip((page - 1) * per_page)
        .limit(per_page)
        .to_a

[items, total]

for sku, qty in ARRIVED.items():
    result = box.update_one({"sku": sku}, {"$inc": {"qty_total": qty}})
    if result.matched_count == 0:
        print(f"  ВНИМАНИЕ: артикул {sku} не найден в каталоге")
    updated += result.modified_count

for (const auto& [sku, qty] : arrived) {
    auto res = box.update_one(
        make_document(kvp("sku", sku)),
        make_document(kvp("$inc", make_document(kvp("qty_total", qty)))));

    if (res->matched_count() == 0)
        std::cout << "  ВНИМАНИЕ: артикул " << sku << " не найден" << std::endl;
    updated += res->modified_count();
}

for _, item := range arrived {
    res, err := box.UpdateOne(ctx,
        bson.D{{Key: "sku", Value: item.SKU}},
        bson.D{{Key: "$inc", Value: bson.D{{Key: "qty_total", Value: item.Qty}}}})
    if err != nil {
        log.Fatal(err)
    }
    if res.MatchedCount == 0 {
        fmt.Printf("  ВНИМАНИЕ: артикул %s не найден\n", item.SKU)
    }
    updated += res.ModifiedCount
}

ARRIVED.each do |sku, qty|
  result = BOX.update_one({ "sku" => sku },
                            { "$inc" => { "qty_total" => qty } })
  puts "  ВНИМАНИЕ: артикул #{sku} не найден" if result.matched_count.zero?
  updated += result.modified_count
end

try:
    result = box.insert_many(NEW_ITEMS, ordered=False)
    report["новых позиций"] = len(result.inserted_ids)
except BulkWriteError as error:
    already = len(error.details["writeErrors"])
    report["новых позиций"] = len(NEW_ITEMS) - already
    print(f"  {already} позиций уже были в каталоге — пропущены")

mongocxx::options::insert insert_options;
insert_options.ordered(false);

try {
    auto many = box.insert_many(new_items, insert_options);
    report.emplace_back("новых позиций", many->inserted_count());
} catch (const mongocxx::bulk_write_exception& error) {
    // список неудач лежит в raw_server_error()["writeErrors"]
    auto already = count_write_errors(error);
    std::cout << "  " << already << " позиций уже были в каталоге" << std::endl;
    report.emplace_back("новых позиций", new_items.size() - already);
}

many, err := box.InsertMany(ctx, newItems,
    options.InsertMany().SetOrdered(false))

switch {
case err == nil:
    report = append(report, [2]any{"новых позиций", len(many.InsertedIDs)})
default:
    var bulkErr mongo.BulkWriteException
    if !errors.As(err, &bulkErr) {
        log.Fatal(err)
    }
    already := len(bulkErr.WriteErrors)
    fmt.Printf("  %d позиций уже были в каталоге\n", already)
    report = append(report, [2]any{"новых позиций", len(newItems) - already})
}

begin
  result = BOX.insert_many(NEW_ITEMS, ordered: false)
  report["новых позиций"] = result.inserted_count
rescue Mongo::Error::BulkWriteError => error
  # частичный отказ пачки — именно BulkWriteError, а не OperationFailure
  already = error.result["writeErrors"].size
  report["новых позиций"] = NEW_ITEMS.size - already
  puts "  #{already} позиций уже были в каталоге — пропущены"
end

query = {"sku": {"$in": DISCONTINUED}}
to_remove = box.count_documents(query)
print(f"  под снятие с продажи попало: {to_remove}")
for doc in box.find(query, {"_id": 1, "title": 1, "price": 1}):
    print(f"    {doc}")
report["снято с продажи"] = box.delete_many(query).deleted_count

auto query = make_document(kvp("sku",
    make_document(kvp("$in", make_array("SKU-CP-018")))));

std::cout << "  под снятие попало: "
          << box.count_documents(query.view()) << std::endl;

mongocxx::options::find preview;
preview.projection(make_document(kvp("_id", 1), kvp("title", 1), kvp("price", 1)));
for (const auto& doc : box.find(query.view(), preview))
    std::cout << "    " << bsoncxx::to_json(doc) << std::endl;

report.emplace_back("снято с продажи",
    box.delete_many(query.view())->deleted_count());

query := bson.D{{Key: "sku",
    Value: bson.D{{Key: "$in", Value: discontinued}}}}

toRemove, _ := box.CountDocuments(ctx, query)
fmt.Printf("\n  под снятие с продажи попало: %d\n", toRemove)

cursor, _ := box.Find(ctx, query, options.Find().SetProjection(
    bson.D{{Key: "_id", Value: 1}, {Key: "title", Value: 1}, {Key: "price", Value: 1}}))
var doomed []bson.M
cursor.All(ctx, &doomed)
for _, doc := range doomed {
    fmt.Printf("    %v\n", doc)
}

deleted, _ := box.DeleteMany(ctx, query)

query = { "sku" => { "$in" => DISCONTINUED } }
puts "  под снятие с продажи попало: #{BOX.count_documents(query)}"

BOX.find(query, projection: { "_id" => 1, "title" => 1, "price" => 1 })
   .each { |doc| puts "    #{doc.inspect}" }

report["снято с продажи"] = BOX.delete_many(query).deleted_count