package main

import (
  "log"
  "net/http"
  "time"

  dd "github.com/datadome/fraud-sdk-go-package/v2"
)

func addOpt[T any](opts []T, opt T, err error) []T {
    if err != nil {
        log.Printf("option error: %v", err)
        return opts
    }
    return append(opts, opt)
}

func passwordHandler(client *dd.Client) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        if r.Method == http.MethodPut {
            email := "[email protected]"
            user := dd.PasswordUpdatePayloadAllOfUser{
                Id: "fake_user_id",
            }

            createdAt := time.Now().Format(time.RFC3339)
            sessionId := "fake_session_id"
            session := dd.Session{
                Id:        &sessionId,
                CreatedAt: &createdAt,
            }

            var opts []dd.PasswordUpdatePayloadOption
            sessionOpt, err := dd.PasswordUpdatePayloadWithSession(session)
            opts = addOpt(opts, sessionOpt, err)

            op, err := dd.NewValidatePasswordUpdate(
                email,
                dd.PasswordUpdatePayloadReasonUserUpdate,
                dd.PasswordUpdatePayloadStatusSucceeded,
                user,
                opts...,
            )
            if err != nil {
                log.Printf("error creating validate password update operation: %v\n", err)
                http.Error(w, "invalid request", http.StatusBadRequest)
                return
            }
            validate, err := op.PerformOperation(r.Context(), client, r, nil)
            if err != nil {
                log.Printf("error during validation: %v\n", err)
            }
            if validate.Action == dd.ALLOW {
                w.WriteHeader(http.StatusOK)
                return
            } else {
                // Business Logic here
                // MFA
                // Challenge
                // Notification email
                // temporarly lock account
                http.Error(w, "failed", http.StatusForbidden)
                return
            }
        }
    }
}

func main() {
  client, _ := dd.NewClient("FRAUD_API_KEY")

  mux := http.NewServeMux()
  mux.HandleFunc("/password", passwordHandler(client))

  _ = http.ListenAndServe(":8080", mux)
}

using DataDome.AspNetCore.Fraud.SDK;
using DataDome.AspNetCore.Fraud.SDK.Api;
using DataDome.AspNetCore.Fraud.SDK.Model;

var appBuilder = WebApplication.CreateBuilder(args);
appBuilder.Services.AddSingleton(_ => Client.Builder("your-api-key").Build());
var app = appBuilder.Build();

app.MapPut("/password", PasswordHandler);

app.Run();

static IResult PasswordHandler(HttpContext ctx, Client client)
{
    var email = "[email protected]";
    var user = new PasswordUpdatePayloadAllOfUser { Id = "fake_user_id" };

    var session = new Session { Id = "fake_session_id", CreatedAt = DateTime.UtcNow };

    var builder = new PasswordUpdatePayload.Builder()
        .Account(email)
        .Reason(PasswordUpdatePayloadReason.UserUpdate)
        .Status(PasswordUpdatePayloadStatus.Succeeded)
        .User(user)
        .Session(session);

    var validate = new ValidatePasswordUpdate(builder).Perform(client, ctx.Request, null);
    if (validate?.Action == ResponseAction.Allow)
    {
        return Results.Ok();
    }
    else
    {
        // Business Logic here
        // MFA
        // Challenge
        // Notification email
        // temporarly lock account
        return Results.Problem("failed", statusCode: 403);
    }
}

const datadomeClient = new DataDome("FraudAPIKey");

app.put('/password', async function (req: Request, res: Response) {
  const emailAccount = req.body.email;

  const session: Session = { id: 'fake_session_id', createdAt: new Date() };
  const user: Pick<User, 'id'> = {
    id: 'fake_user_id',
  };
  const customFields: CustomField[] = [{
    name: "customField",
    value: "customValue",
  }];
  const datadomeResponse = await datadomeClient.validate(
    req,
    new PasswordUpdateEvent({
      account: emailAccount,
      reason: 'userUpdate',
      session,
      status: 'succeeded',
      user,
      customFields,
    })
  );

  if (datadomeResponse?.action == ResponseAction.ALLOW) {
    res.status(200).send({ ...user, fp: datadomeResponse });
  } else {
    // Business Logic here
    // MFA
    // Challenge
    // Notification email
    // temporarly lock account
    res.status(403).send(datadomeResponse);
  }
});

package example;

import co.datadome.fraud.Client;
import co.datadome.fraud.ApiException;
import co.datadome.fraud.api.*;
import co.datadome.fraud.model.*;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.time.Instant;
import java.util.logging.Logger;

@SpringBootApplication
@RestController
public class ExampleApplication {

    private static final Logger logger = Logger.getLogger(ExampleApplication.class.getName());

    @Bean
    public Client fraudClient() {
        return Client.builder("your-api-key").build();
    }

    private final Client client;

    public ExampleApplication(Client client) {
        this.client = client;
    }

    public static void main(String[] args) {
        SpringApplication.run(ExampleApplication.class, args);
    }

    @PutMapping("/password")
    public ResponseEntity<String> passwordHandler(HttpServletRequest request) {
        String email = "[email protected]";

        PasswordUpdatePayloadAllOfUser user = new PasswordUpdatePayloadAllOfUser();
        user.setId("fake_user_id");

        Session session = new Session();
        session.setId("fake_session_id");
        session.setCreatedAt(Instant.now().toString());

        PasswordUpdatePayload.Builder builder = PasswordUpdatePayload.builder()
                .account(email)
                .reason(PasswordUpdatePayload.Reason.USER_UPDATE)
                .status(PasswordUpdatePayload.Status.SUCCEEDED)
                .user(user)
                .session(session);

        try {
            Response validate = new ValidatePasswordUpdate(builder).perform(client, request, null);
            if (validate.getAction() == ResponseAction.ALLOW) {
                return ResponseEntity.ok().build();
            } else {
                // Business Logic here
                // MFA
                // Challenge
                // Notification email
                // temporarly lock account
                return ResponseEntity.status(403).body("failed");
            }
        } catch (ApiException e) {
            logger.severe("error during validation: " + e.getMessage());
            return ResponseEntity.status(403).body("failed");
        }
    }
}