-- HINWEIS: Wenn Ihr Handler dauerhafte Vorteile gewährt (Währung, Gegenstände), verwenden Sie
-- DataStoreService:UpdateAsync() mit der TransferRequestId, um zu verhindern,
-- dass bei der Auslieferung des gleichen Belegs an mehrere Server doppelt gewährt wird.

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

-- Bearbeiten Sie Senderbelege (der Spieler, der Robux gesendet hat)
MarketplaceService:BindReceiptHandler(
	Enum.ReceiptType.RobuxTransferSender,
	function(receiptInfo)
		local player = Players:GetPlayerByUserId(receiptInfo.PlayerId)
		if not player then
			-- Spieler ist nicht auf diesem Server; verschieben Sie die Verarbeitung, damit der Beleg
			-- erneut an den Server gesendet wird, in dem er sich gerade befindet
			return Enum.ReceiptDecision.NotProcessedYet
		end

		print(
			`{player.Name} hat {receiptInfo.CurrencySpent} Robux gesendet`
				.. ` (TransferRequestId: {receiptInfo.TransferRequestId})`
		)

		-- Gewähren Sie hier jede senderseitige Bestätigung oder aktualisieren Sie die Benutzeroberfläche

		return Enum.ReceiptDecision.Processed
	end
)

-- Bearbeiten Sie Empfangsbelege (der Spieler, der Robux erhalten hat)
MarketplaceService:BindReceiptHandler(
	Enum.ReceiptType.RobuxTransferReceiver,
	function(receiptInfo)
		local player = Players:GetPlayerByUserId(receiptInfo.PlayerId)
		if not player then
			return Enum.ReceiptDecision.NotProcessedYet
		end

		print(
			`{player.Name} hat {receiptInfo.CurrencySpent} Robux erhalten`
				.. ` (TransferRequestId: {receiptInfo.TransferRequestId})`
		)

		-- Gewähren Sie hier jeden empfangsseitigen Vorteil oder aktualisieren Sie die Benutzeroberfläche

		return Enum.ReceiptDecision.Processed
	end
)

local MarketplaceService = game:GetService("MarketplaceService")

local developerProducts = MarketplaceService:GetDeveloperProductsAsync():GetCurrentPage()

for _, developerProduct in pairs(developerProducts) do
	for field, value in pairs(developerProduct) do
		print(field .. ": " .. value)
	end
	print(" ")
end

local MarketplaceService = game:GetService("MarketplaceService")

local ASSET_ID = 125378389

local asset = MarketplaceService:GetProductInfoAsync(ASSET_ID)
print(asset.Name .. " :: " .. asset.Description)

local MarketplaceService = game:GetService("MarketplaceService")

local PASS_ID = 12345678
local textLabel = script.Parent

local DiscountTypeDisplay = {
	RobloxPlusSubscription = "Rabatt für Roblox Plus",
}

local productInfo = MarketplaceService:GetProductInfoAsync(PASS_ID, Enum.InfoType.GamePass)
print(string.format("Originalpreis: %d", productInfo.UserBasePriceInRobux))

for _, discount in ipairs(productInfo.PriceDiscountDetails) do
	local displayName = DiscountTypeDisplay[discount.Type] or "Anderer Rabatt"
	print(string.format("%s (%d%%): -%d", displayName, discount.Percent, discount.AmountInRobux))
end

print(string.format("Sie zahlen: %d", productInfo.PriceInRobux))

local MarketplaceService = game:GetService("MarketplaceService")
local info = MarketplaceService:GetProductInfoAsync(105589844216517, Enum.InfoType.Asset)

if info.TimedOptions then
	for _, option in info.TimedOptions do
		local days = option.Duration / 86400
		print(string.format("%d Tage - %d Robux", days, option.Price))
	end
end

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

Players.PlayerAdded:Connect(function(player)
    local success, details = pcall(function()
        return MarketplaceService:GetRobloxSubscriptionDetailsAsync(player)
    end)

    if success and details.IsSubscribed then
        -- 1. Überprüfen der Loyalität (z.B. Abonnent für > 60 Tage)
        local threeMonths = 60 * 24 * 60 * 60
        if details.StartTime and (os.time() - details.StartTime.UnixTimestamp) > threeMonths then
            print("Die '3-Monats-Abonnement-Veteranen'-Skin wird verliehen!")
        end

        -- 2. Überprüfen der Attribution
        if details.IsOriginExperience then
            print("Attribution bestätigt: Nutzer hat sich über diese Erfahrung abonniert.")
        else
            print("Nutzer hat sich anderswo abonniert (Webseite oder eine andere Erfahrung).")
        end
    end
end)

-- Hole den MarketplaceService
local MarketplaceService = game:GetService("MarketplaceService")

-- Definiere eine Funktion, um Preislevel für eine Liste von Benutzern abzurufen
local function getPriceLevels(userIds)
    local success, result = pcall(function()
        return MarketplaceService:GetUsersPriceLevelsAsync(userIds)
    end)

    if success then
        -- Ordne jede PriceLevelInfo einer Benutzer-ID -> Preislevel Lookup-Tabelle zu
        local lookup = {}
        for _, info in ipairs(result) do
            lookup[info.UserId] = info.PriceLevel
        end 
        return lookup
    else
        warn("Fehler beim Abrufen der Preislevel:", result)
        return nil
    end
end

-- Beispiel mit Platzhalter-IDs
local user1Id = 123456789
local user2Id = 987654321

-- Rufe die Funktion auf und speichere das Ergebnis
local priceLevels = getPriceLevels({user1Id, user2Id})
-- Wenn erfolgreich, drucke das Niveau jedes Benutzers
if priceLevels then
    print("Preislevel für Benutzer 1:", priceLevels[user1Id])
    print("Preislevel für Benutzer 2:", priceLevels[user2Id])
else
    print("Fehler beim Abrufen der Preislevel.")
end

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local SUBSCRIPTION_ID = "EXP-0"

local function checkSubscriptionHistory(player: Player)
	local subscriptionHistory = {}

	local success, err = pcall(function()
		subscriptionHistory = MarketplaceService:GetUserSubscriptionPaymentHistoryAsync(player, SUBSCRIPTION_ID)
	end)

	if not success then
		warn(`Fehler beim Überprüfen der Abonnementgeschichte: {err}`)
		return
	end

	if next(subscriptionHistory) then
		-- Der Nutzer hat eine Abonnementgeschichte innerhalb der letzten 12 Monate.
		-- Geben Sie die Details jedes Zahlungseintrags aus der Abonnementgeschichte aus.
		print(`Spieler {player.Name} hat zuvor ein Abonnement für {SUBSCRIPTION_ID} abgeschlossen:`)

		for entryNum, paymentEntry in subscriptionHistory do
			local paymentStatus = tostring(paymentEntry.PaymentStatus)
			local cycleStartTime = paymentEntry.CycleStartTime:FormatLocalTime("LLL", "de-de")
			local cycleEndTime = paymentEntry.CycleEndTime:FormatLocalTime("LLL", "de-de")
			print(`{entryNum}: {paymentStatus} ({cycleStartTime} - {cycleEndTime})`)
		end
	else
		print(`Spieler {player.Name} hat zuvor nie ein Abonnement für {SUBSCRIPTION_ID} abgeschlossen.`)
	end
end

-- Rufen Sie checkSubscriptionHistory für alle Spieler auf, die bereits im Spiel sind
for _, player in ipairs(Players:GetPlayers()) do
	checkSubscriptionHistory(player)
end

-- Rufen Sie checkSubscriptionHistory für alle zukünftigen Spieler auf
Players.PlayerAdded:Connect(checkSubscriptionHistory)

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local subscriptionID = "EXP-00000"

local function checkSubStatus(player)
	local subStatus = {}
	local success, message = pcall(function()
		-- gibt IsRenewing und IsSubscribed zurück
		subStatus = MarketplaceService:GetUserSubscriptionStatusAsync(player, subscriptionID)
	end)

	if not success then
		warn("Fehler beim Überprüfen, ob der Spieler ein Abonnement hat: " .. tostring(message))
		return
	end

	if subStatus["IsSubscribed"] then
		print(player.Name .. " ist mit " .. subscriptionID .. " abonniert")
		-- Geben Sie dem Spieler Berechtigungen, die mit dem Abonnement verbunden sind
	end
end

Players.PlayerAdded:Connect(checkSubStatus)

local Players = game:GetService("Players")
local MarketplaceService = game:GetService("MarketplaceService")

-- Der Gegenstand, den wir überprüfen: https://www.roblox.com/catalog/30331986/Midnight-Shades
local ASSET_ID = 30331986
local ASSET_NAME = "Midnight Shades"

local function onPlayerAdded(player)
	local success, doesPlayerOwnAsset =
		pcall(MarketplaceService.PlayerOwnsAssetAsync, MarketplaceService, player, ASSET_ID)
	if not success then
		local errorMessage = doesPlayerOwnAsset
		warn(`Fehler beim Überprüfen, ob {player.Name} {ASSET_NAME} besitzt: {errorMessage}`)
		return
	end

	if doesPlayerOwnAsset then
		print(`{player.Name} besitzt {ASSET_NAME}`)
	else
		print(`{player.Name} besitzt {ASSET_NAME} nicht`)
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)

local Players = game:GetService("Players")
local MarketplaceService = game:GetService("MarketplaceService")

-- Das Bundle, das wir überprüfen: https://www.roblox.com/bundles/589/Junkbot
local BUNDLE_ID = 589
local BUNDLE_NAME = "Junkbot"

Players.PlayerAdded:Connect(function(player)
	local success, doesPlayerOwnBundle = pcall(function()
		return MarketplaceService:PlayerOwnsBundleAsync(player, BUNDLE_ID)
	end)

	if success == false then
		print("PlayerOwnsBundleAsync Aufruf fehlgeschlagen: ", doesPlayerOwnBundle)
		return
	end

	if doesPlayerOwnBundle then
		print(player.Name .. " besitzt " .. BUNDLE_NAME)
	else
		print(player.Name .. " besitzt nicht " .. BUNDLE_NAME)
	end
end)

local ReplicatedStorage = game:GetService("ReplicatedStorage")

local promptBulkPurchaseEvent = ReplicatedStorage:WaitForChild("PromptBulkPurchaseEvent")

local part = Instance.new("Part")
part.Parent = workspace

local clickDetector = Instance.new("ClickDetector")
clickDetector.Parent = part

clickDetector.MouseClick:Connect(function()
	promptBulkPurchaseEvent:FireServer({
		{ Type = Enum.MarketplaceProductType.AvatarAsset, Id = "16630147" },
		{ Type = Enum.MarketplaceProductType.AvatarBundle, Id = "182" },
	})
end)

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local MarketplaceService = game:GetService("MarketplaceService")

local promptBulkPurchaseEvent = Instance.new("RemoteEvent")
promptBulkPurchaseEvent.Name = "PromptBulkPurchaseEvent"
promptBulkPurchaseEvent.Parent = ReplicatedStorage

--Hören Sie auf das RemoteEvent, das von einem Client ausgelöst wird, und lösen Sie dann den Bulk-Kauf-Prompt aus
promptBulkPurchaseEvent.OnServerEvent:Connect(function(player, items)
	MarketplaceService:PromptBulkPurchase(player, items, {})
end)

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local ASSET_ID = 105589844216517

Players.PlayerAdded:Connect(function(player)
	local info = MarketplaceService:GetProductInfoAsync(ASSET_ID, Enum.InfoType.Asset)

	if info.TimedOptions and #info.TimedOptions > 0 then
		-- Finde die Option mit der kürzesten Dauer
		local shortest = info.TimedOptions[1]
		for _, option in info.TimedOptions do
			if option.Duration < shortest.Duration then
				shortest = option
			end
		end

		local items = {
			{
				Type = Enum.MarketplaceProductType.AvatarAsset,
				Id = tostring(ASSET_ID),
				PurchaseOptions = {
					{ Type = Enum.PurchaseOption.TimedOption, Value = shortest.Duration },
				},
			}
		}
		MarketplaceService:PromptBulkPurchase(player, items, {})
	end
end)

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local player = Players.LocalPlayer

local productId = 0000000 -- Ändere dies auf deine Entwicklerprodukt-ID

-- Funktion, um den Kauf des Entwicklerprodukts anzufordern
local function promptPurchase()
	MarketplaceService:PromptProductPurchase(player, productId)
end

promptPurchase()

local ReplicatedStorage = game:GetService("ReplicatedStorage")

local promptPurchaseEvent = ReplicatedStorage:WaitForChild("PromptPurchaseEvent")

local part = Instance.new("Part")
part.Parent = workspace

local clickDetector = Instance.new("ClickDetector")
clickDetector.Parent = part

clickDetector.MouseClick:Connect(function()
	promptPurchaseEvent:FireServer(16630147)
end)

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local MarketplaceService = game:GetService("MarketplaceService")

local promptPurchaseEvent = Instance.new("RemoteEvent")
promptPurchaseEvent.Name = "PromptPurchaseEvent"
promptPurchaseEvent.Parent = ReplicatedStorage

-- Auf das Auslösen des RemoteEvent von einem Client hören und dann den Kaufaufforderungsdialog auslösen
promptPurchaseEvent.OnServerEvent:Connect(function(player, id)
	MarketplaceService:PromptPurchase(player, id)
end)

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local teleporter = script.Parent
local showModal = true

local EXCLUSIVE_AREA_POSITION = Vector3.new(1200, 200, 60)

-- Gewähren Sie die Belohnung und teleportieren Sie den abonnierenden Spieler in den exklusiven Bereich
local function grantRewardAndTeleport(player)
	player:RequestStreamAroundAsync(EXCLUSIVE_AREA_POSITION)

	local character = player.Character
	if character and character.Parent then
		local currentPivot = character:GetPivot()
		character:PivotTo(currentPivot * CFrame.new(EXCLUSIVE_AREA_POSITION))
	end
end

-- Erkennen Sie die berührenden Charakterteile des Teleporters
teleporter.Touched:Connect(function(otherPart)
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
	if not player then
		return
	end

	if not player:GetAttribute("CharacterPartsTouching") then
		player:SetAttribute("CharacterPartsTouching", 0)
	end
	player:SetAttribute("CharacterPartsTouching", player:GetAttribute("CharacterPartsTouching") + 1)

	if player.HasRobloxSubscription then
		-- Spieler hat bereits Roblox Plus; belohnen Sie sofort
		grantRewardAndTeleport(player)
	else
		-- Fordern Sie das Roblox Plus-Abonnement an, gesperrt für einmal alle paar Sekunden
		if not showModal then
			return
		end
		showModal = false
		task.delay(5, function()
			showModal = true
		end)
		MarketplaceService:PromptRobloxSubscriptionPurchase(player)
	end
end)

-- Erkennen Sie die charakterlichen Teile, die den Teleporter verlassen
teleporter.TouchEnded:Connect(function(otherPart)
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
	if player and player:GetAttribute("CharacterPartsTouching") then
		player:SetAttribute("CharacterPartsTouching", player:GetAttribute("CharacterPartsTouching") - 1)
	end
end)

-- Gewähren Sie eine Belohnung, wenn der Server eine Aboänderung bestätigt
-- Verbinden Sie die Änderung von HasRobloxSubscription für jeden Spieler
Players.PlayerAdded:Connect(function(player)
	player:GetPropertyChangedSignal("HasRobloxSubscription"):Connect(function()
		if player.HasRobloxSubscription
			and player:GetAttribute("CharacterPartsTouching")
			and player:GetAttribute("CharacterPartsTouching") > 0
		then
			grantRewardAndTeleport(player)
		end
	end)
end)

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

-- Beispiel: Robux übertragen, wenn ein Spieler ein RemoteEvent auslöst
local transferEvent = game.ReplicatedStorage:WaitForChild("RequestTransfer")

transferEvent.OnServerEvent:Connect(function(sender, receiverUserId, amount)
	-- Eingaben validieren
	if not sender or not sender:IsA("Player") then
		return
	end

	if typeof(receiverUserId) ~= "number" or receiverUserId <= 0 then
		warn("Ungültiger receiverUserId")
		return
	end

	if typeof(amount) ~= "number" or amount <= 0 then
		warn("Ungültiger Betrag")
		return
	end

	local success, result = pcall(function()
		return MarketplaceService:PromptRobuxTransferAsync(sender, receiverUserId, amount)
	end)

	if success then
		print(`Transfer initiiert mit TransferRequestId: {result}`)
	else
		warn(`Transfer fehlgeschlagen: {result}`)
	end
end)

-- Holen Sie sich den MarketplaceService
  local MarketplaceService = game:GetService("MarketplaceService")

-- Erstellen Sie das Array der Produkte, die Sie bewerten möchten
local productIdentifiers = {
    {InfoType = Enum.InfoType.GamePass, Id = 123},
    {InfoType = Enum.InfoType.Product, Id = 456},
    {InfoType = Enum.InfoType.Product, Id = 789}
}

-- Rufen Sie eine geschützte Funktion auf, um Fehler elegant zu behandeln
local success, rankedProducts = pcall(function()
    return MarketplaceService:RankProductsAsync(productIdentifiers)
end)

if not success then
    error("Produkte konnten nicht bewertet werden")
end

-- Laden Sie die zurückgegebenen Artikel in den Store.
for i, rankedItem in ipairs(rankedProducts) do
    local productIdentifier = rankedItem.ProductIdentifier
    local productInfo = rankedItem.ProductInfo
    -- ...
    -- Logik, um Produkte in den Store hinzuzufügen
end

-- Hole den MarketplaceService
local MarketplaceService = game:GetService("MarketplaceService")

-- Erstelle ein Array von Produkttypen, die einbezogen werden sollen. In diesem Fall sowohl Spielpässe als auch Entwicklerprodukte
local productTypes = {Enum.InfoType.GamePass, Enum.InfoType.Product}

-- Führe einen geschützten Aufruf aus, um Fehler elegant zu behandeln
local success, topRankedItems = pcall(function()
    return MarketplaceService:RecommendTopProductsAsync(productTypes)
end)

if not success then
    error("Fehler beim Rangieren der Produkte")
end

-- Lade die zurückgegebenen Artikel in den Shop. Stelle sicher, dass du alle nicht berechtigten Artikel aus topRankedItems herausfilterst, wie Entwicklerprodukte, die der Benutzer nicht mehr kaufen kann
for i, rankedItem in ipairs(topRankedItems) do
    local productIdentifier = rankedItem.ProductIdentifier
    local productInfo = rankedItem.ProductInfo
    -- ...
    -- Logik zum Hinzufügen von Produkten in den Shop
end

local MarketplaceService = game:GetService("MarketplaceService")

local function gamepassPurchaseFinished(...)
	-- Alle Details der Eingabeaufforderung drucken, zum Beispiel:
	-- PromptGamePassPurchaseFinished PlayerName 123456 false
	print("PromptGamePassPurchaseFinished", ...)
end

MarketplaceService.PromptGamePassPurchaseFinished:Connect(gamepassPurchaseFinished)