google-site-verification: google61fe8ba583a51912.html
MACRO NEPAL
Square Payments Integration in Java: Complete Implementation Guide
awiskar acharya
November 21, 2025
2:42 pm

This guide provides comprehensive Java implementations for integrating with Square Payments API, including payment processing, customer management, subscription billing, and webhook handling.

Square Payments Overview

Key Features:

  • Payment processing (credit cards, digital wallets)
  • Customer and card management
  • Subscription billing
  • Invoice management
  • Webhook handling for real-time notifications

Common Use Cases:

  • E-commerce payments
  • Subscription services
  • Point-of-sale systems
  • Mobile payments
  • Invoice-based billing

Dependencies and Setup

Maven Dependencies
<properties> <spring-boot.version>3.1.0</spring-boot.version> <square-java-sdk.version>26.0.0</square-java-sdk.version> <jackson.version>2.15.2</jackson.version> </properties> <dependencies> <!-- Spring Boot --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>${spring-boot.version}</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-validation</artifactId> <version>${spring-boot.version}</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <version>${spring-boot.version}</version> </dependency> <!-- Square SDK --> <dependency> <groupId>com.squareup.sdk</groupId> <artifactId>square</artifactId> <version>${square-java-sdk.version}</version> </dependency> <!-- JSON Processing --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>${jackson.version}</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.datatype</groupId> <artifactId>jackson-datatype-jsr310</artifactId> <version>${jackson.version}</version> </dependency> <!-- Database --> <dependency> <groupId>org.postgresql</groupId> <artifactId>postgresql</artifactId> <scope>runtime</scope> </dependency> <!-- Utilities --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <scope>provided</scope> </dependency> <!-- Testing --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <version>${spring-boot.version}</version> <scope>test</scope> </dependency> </dependencies>
Application Configuration
# application.yml app: square: # Square API Configuration environment: "production" # sandbox or production access-token: "${SQUARE_ACCESS_TOKEN:your_sandbox_token}" location-id: "${SQUARE_LOCATION_ID:your_location_id}" application-id: "${SQUARE_APPLICATION_ID:your_app_id}" # Webhook Configuration webhook: signature-key: "${SQUARE_WEBHOOK_SIGNATURE:your_webhook_signature}" enabled: true # Payment Configuration payment: timeout: 30000 max-retries: 3 currency: "USD" # Subscription Configuration subscription: plan-prefix: "plan_" trial-period-days: 0 spring: datasource: url: jdbc:postgresql://localhost:5432/square_payments username: postgres password: password driver-class-name: org.postgresql.Driver jpa: hibernate: ddl-auto: update show-sql: true properties: hibernate: dialect: org.hibernate.dialect.PostgreSQLDialect server: port: 8080 logging: level: com.example.squarepayments: DEBUG com.squareup.sdk: INFO

Core Models

1. Payment Models
// PaymentRequest.java package com.example.squarepayments.model; import lombok.Data; import jakarta.validation.constraints.NotBlank; import jakarta.validation.constraints.NotNull; import jakarta.validation.constraints.Positive; import java.math.BigDecimal; import java.util.Map; @Data public class PaymentRequest { @NotBlank(message = "Source ID is required") private String sourceId; // card nonce, customer ID, or card ID @NotNull(message = "Amount is required") @Positive(message = "Amount must be positive") private BigDecimal amount; private String customerId; private String locationId; private String referenceId; private String note; private String idempotencyKey; // Additional payment details private Boolean autocomplete = true; private String currency = "USD"; private Map<String, String> metadata; // Tip amount private BigDecimal tipAmount; // Shipping address private Address shippingAddress; // Buyer information private Buyer buyer; @Data public static class Address { private String firstName; private String lastName; private String addressLine1; private String addressLine2; private String locality; private String administrativeDistrictLevel1; private String postalCode; private String country; } @Data public static class Buyer { private String emailAddress; private String phoneNumber; } } // PaymentResponse.java package com.example.squarepayments.model; import lombok.Data; import lombok.Builder; import java.time.LocalDateTime; import java.math.BigDecimal; import java.util.Map; @Data @Builder public class PaymentResponse { private boolean success; private String message; private LocalDateTime timestamp; private PaymentData payment; private String squarePaymentId; private String receiptUrl; private String status; @Data @Builder public static class PaymentData { private String id; private BigDecimal amount; private String currency; private String status; private String sourceType; private String customerId; private String orderId; private String referenceId; private String note; private LocalDateTime createdAt; private LocalDateTime updatedAt; private Map<String, String> metadata; } public static PaymentResponse success(PaymentData payment) { return PaymentResponse.builder() .success(true) .message("Payment processed successfully") .timestamp(LocalDateTime.now()) .payment(payment) .squarePaymentId(payment.getId()) .status(payment.getStatus()) .build(); } public static PaymentResponse error(String message) { return PaymentResponse.builder() .success(false) .message(message) .timestamp(LocalDateTime.now()) .build(); } } // RefundRequest.java package com.example.squarepayments.model; import lombok.Data; import jakarta.validation.constraints.NotBlank; import jakarta.validation.constraints.NotNull; import jakarta.validation.constraints.Positive; import java.math.BigDecimal; @Data public class RefundRequest { @NotBlank(message = "Payment ID is required") private String paymentId; @NotBlank(message = "Idempotency key is required") private String idempotencyKey; @NotNull(message = "Amount is required") @Positive(message = "Amount must be positive") private BigDecimal amount; private String reason; private String tenderId; } // RefundResponse.java package com.example.squarepayments.model; import lombok.Data; import lombok.Builder; import java.time.LocalDateTime; import java.math.BigDecimal; @Data @Builder public class RefundResponse { private boolean success; private String message; private LocalDateTime timestamp; private String refundId; private String status; private BigDecimal amount; private String currency; public static RefundResponse success(String refundId, String status, BigDecimal amount, String currency) { return RefundResponse.builder() .success(true) .message("Refund processed successfully") .timestamp(LocalDateTime.now()) .refundId(refundId) .status(status) .amount(amount) .currency(currency) .build(); } public static RefundResponse error(String message) { return RefundResponse.builder() .success(false) .message(message) .timestamp(LocalDateTime.now()) .build(); } }
2. Customer Models
// CustomerRequest.java package com.example.squarepayments.model; import lombok.Data; import jakarta.validation.constraints.Email; import java.util.Map; @Data public class CustomerRequest { private String givenName; private String familyName; @Email(message = "Invalid email format") private String emailAddress; private String phoneNumber; private String companyName; private String referenceId; private String note; private Address address; private Map<String, String> metadata; @Data public static class Address { private String addressLine1; private String addressLine2; private String locality; private String administrativeDistrictLevel1; private String postalCode; private String country; } } // CustomerResponse.java package com.example.squarepayments.model; import lombok.Data; import lombok.Builder; import java.time.LocalDateTime; import java.util.Map; @Data @Builder public class CustomerResponse { private boolean success; private String message; private LocalDateTime timestamp; private CustomerData customer; @Data @Builder public static class CustomerData { private String id; private String givenName; private String familyName; private String emailAddress; private String phoneNumber; private String companyName; private String referenceId; private String note; private LocalDateTime createdAt; private LocalDateTime updatedAt; private Map<String, String> metadata; private Integer version; } public static CustomerResponse success(CustomerData customer) { return CustomerResponse.builder() .success(true) .message("Customer operation successful") .timestamp(LocalDateTime.now()) .customer(customer) .build(); } public static CustomerResponse error(String message) { return CustomerResponse.builder() .success(false) .message(message) .timestamp(LocalDateTime.now()) .build(); } } // CustomerCardRequest.java package com.example.squarepayments.model; import lombok.Data; import jakarta.validation.constraints.NotBlank; @Data public class CustomerCardRequest { @NotBlank(message = "Customer ID is required") private String customerId; @NotBlank(message = "Card nonce is required") private String cardNonce; private String cardholderName; private String billingAddress; private String verificationToken; private Boolean isDefault = false; }
3. Subscription Models
// SubscriptionPlanRequest.java package com.example.squarepayments.model; import lombok.Data; import jakarta.validation.constraints.NotBlank; import jakarta.validation.constraints.NotNull; import jakarta.validation.constraints.Positive; import java.math.BigDecimal; import java.util.Map; @Data public class SubscriptionPlanRequest { @NotBlank(message = "Plan name is required") private String name; @NotBlank(message = "Plan description is required") private String description; @NotNull(message = "Amount is required") @Positive(message = "Amount must be positive") private BigDecimal amount; @NotBlank(message = "Currency is required") private String currency = "USD"; @NotBlank(message = "Interval is required") private String interval; // DAILY, WEEKLY, MONTHLY, YEARLY private Integer intervalCount = 1; private Map<String, String> metadata; private Boolean active = true; } // SubscriptionRequest.java package com.example.squarepayments.model; import lombok.Data; import jakarta.validation.constraints.NotBlank; import jakarta.validation.constraints.NotNull; import java.time.LocalDate; import java.util.Map; @Data public class SubscriptionRequest { @NotBlank(message = "Customer ID is required") private String customerId; @NotBlank(message = "Plan ID is required") private String planId; @NotBlank(message = "Card ID is required") private String cardId; private LocalDate startDate; private String timezone; private Map<String, String> metadata; private String idempotencyKey; // Trial period private Integer trialPeriodDays; // Phases for complex subscriptions private java.util.List<Phase> phases; @Data public static class Phase { private String planId; private Integer ordinal; private Integer periods; private BigDecimal recurringPrice; private String cadence; } } // SubscriptionResponse.java package com.example.squarepayments.model; import lombok.Data; import lombok.Builder; import java.time.LocalDateTime; import java.math.BigDecimal; import java.util.Map; @Data @Builder public class SubscriptionResponse { private boolean success; private String message; private LocalDateTime timestamp; private SubscriptionData subscription; @Data @Builder public static class SubscriptionData { private String id; private String planId; private String customerId; private String status; private BigDecimal amount; private String currency; private String interval; private LocalDateTime startDate; private LocalDateTime createdAt; private LocalDateTime updatedAt; private Map<String, String> metadata; private String currentPhase; } public static SubscriptionResponse success(SubscriptionData subscription) { return SubscriptionResponse.builder() .success(true) .message("Subscription created successfully") .timestamp(LocalDateTime.now()) .subscription(subscription) .build(); } public static SubscriptionResponse error(String message) { return SubscriptionResponse.builder() .success(false) .message(message) .timestamp(LocalDateTime.now()) .build(); } }
4. Webhook Models
// WebhookEvent.java package com.example.squarepayments.model; import lombok.Data; import java.time.LocalDateTime; import java.util.Map; @Data public class WebhookEvent { private String merchantId; private String type; private String eventId; private LocalDateTime createdAt; private Map<String, Object> data; // Common webhook event types public static class EventType { public static final String PAYMENT_UPDATED = "payment.updated"; public static final String REFUND_UPDATED = "refund.updated"; public static final String SUBSCRIPTION_UPDATED = "subscription.updated"; public static final String CUSTOMER_CREATED = "customer.created"; public static final String CUSTOMER_UPDATED = "customer.updated"; public static final String INVOICE_UPDATED = "invoice.updated"; } } // WebhookNotification.java package com.example.squarepayments.model; import lombok.Data; import java.util.List; @Data public class WebhookNotification { private String merchantId; private String locationId; private String type; private String eventId; private String createdAt; private List<WebhookData> data; @Data public static class WebhookData { private String type; private String id; private Object object; } }

Square Configuration and Client

1. Square Configuration
// SquareConfig.java package com.example.squarepayments.config; import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; @Data @Component @ConfigurationProperties(prefix = "app.square") public class SquareConfig { private String environment; private String accessToken; private String locationId; private String applicationId; private WebhookConfig webhook = new WebhookConfig(); private PaymentConfig payment = new PaymentConfig(); private SubscriptionConfig subscription = new SubscriptionConfig(); @Data public static class WebhookConfig { private String signatureKey; private boolean enabled; } @Data public static class PaymentConfig { private int timeout; private int maxRetries; private String currency; } @Data public static class SubscriptionConfig { private String planPrefix; private int trialPeriodDays; } }
2. Square Client Service
// SquareClientService.java package com.example.squarepayments.service; import com.squareup.sdk.*; import com.squareup.sdk.api.*; import com.squareup.sdk.models.*; import com.example.squarepayments.config.SquareConfig; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @Slf4j @Service public class SquareClientService { private final SquareClient squareClient; private final PaymentsApi paymentsApi; private final CustomersApi customersApi; private final SubscriptionsApi subscriptionsApi; private final CardsApi cardsApi; private final RefundsApi refundsApi; private final LocationsApi locationsApi; private final ExecutorService executorService; public SquareClientService(SquareConfig squareConfig) { Environment environment = squareConfig.getEnvironment().equals("production") ? Environment.PRODUCTION : Environment.SANDBOX; this.squareClient = new SquareClient.Builder() .environment(environment) .accessToken(squareConfig.getAccessToken()) .userAgentDetail("spring-boot-square-integration/1.0") .build(); this.paymentsApi = squareClient.getPaymentsApi(); this.customersApi = squareClient.getCustomersApi(); this.subscriptionsApi = squareClient.getSubscriptionsApi(); this.cardsApi = squareClient.getCardsApi(); this.refundsApi = squareClient.getRefundsApi(); this.locationsApi = squareClient.getLocationsApi(); this.executorService = Executors.newFixedThreadPool(10); log.info("Square client initialized for environment: {}", environment); } /** * Get Square client instance */ public SquareClient getSquareClient() { return squareClient; } /** * Get Payments API */ public PaymentsApi getPaymentsApi() { return paymentsApi; } /** * Get Customers API */ public CustomersApi getCustomersApi() { return customersApi; } /** * Get Subscriptions API */ public SubscriptionsApi getSubscriptionsApi() { return subscriptionsApi; } /** * Get Cards API */ public CardsApi getCardsApi() { return cardsApi; } /** * Get Refunds API */ public RefundsApi getRefundsApi() { return refundsApi; } /** * Get Locations API */ public LocationsApi getLocationsApi() { return locationsApi; } /** * Execute Square API call asynchronously */ public <T> CompletableFuture<T> executeAsync(java.util.concurrent.Callable<T> task) { return CompletableFuture.supplyAsync(() -> { try { return task.call(); } catch (Exception e) { log.error("Async Square API execution failed", e); throw new RuntimeException("Square API call failed", e); } }, executorService); } /** * Convert Money amount to Square Money object */ public Money toSquareMoney(java.math.BigDecimal amount, String currency) { return new Money.Builder() .amount(amount.movePointRight(2).longValue()) // Convert to cents .currency(currency) .build(); } /** * Convert Square Money to BigDecimal */ public java.math.BigDecimal fromSquareMoney(Money money) { if (money == null) return java.math.BigDecimal.ZERO; return java.math.BigDecimal.valueOf(money.getAmount()).movePointLeft(2); } /** * Generate idempotency key */ public String generateIdempotencyKey() { return java.util.UUID.randomUUID().toString(); } /** * Validate webhook signature */ public boolean validateWebhookSignature(String payload, String signature, String signatureKey) { try { // Square webhook signature validation logic // This is a simplified version - implement proper validation return true; } catch (Exception e) { log.error("Webhook signature validation failed", e); return false; } } }

Payment Service

// PaymentService.java package com.example.squarepayments.service; import com.squareup.sdk.models.*; import com.example.squarepayments.model.*; import com.example.squarepayments.config.SquareConfig; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.math.BigDecimal; import java.util.concurrent.CompletableFuture; @Slf4j @Service @Transactional public class PaymentService { private final SquareClientService squareClientService; private final SquareConfig squareConfig; public PaymentService(SquareClientService squareClientService, SquareConfig squareConfig) { this.squareClientService = squareClientService; this.squareConfig = squareConfig; } /** * Process payment */ public PaymentResponse processPayment(PaymentRequest paymentRequest) { try { String idempotencyKey = paymentRequest.getIdempotencyKey() != null ? paymentRequest.getIdempotencyKey() : squareClientService.generateIdempotencyKey(); String locationId = paymentRequest.getLocationId() != null ? paymentRequest.getLocationId() : squareConfig.getLocationId(); // Create payment request CreatePaymentRequest request = new CreatePaymentRequest.Builder( paymentRequest.getSourceId(), idempotencyKey, squareClientService.toSquareMoney(paymentRequest.getAmount(), paymentRequest.getCurrency()) ) .locationId(locationId) .customerId(paymentRequest.getCustomerId()) .referenceId(paymentRequest.getReferenceId()) .note(paymentRequest.getNote()) .autocomplete(paymentRequest.getAutocomplete()) .build(); // Add tip if provided if (paymentRequest.getTipAmount() != null && paymentRequest.getTipAmount().compareTo(BigDecimal.ZERO) > 0) { request = request.toBuilder() .tipMoney(squareClientService.toSquareMoney(paymentRequest.getTipAmount(), paymentRequest.getCurrency())) .build(); } // Add metadata if provided if (paymentRequest.getMetadata() != null && !paymentRequest.getMetadata().isEmpty()) { request = request.toBuilder() .metadata(paymentRequest.getMetadata()) .build(); } // Add shipping address if provided if (paymentRequest.getShippingAddress() != null) { Address address = convertToSquareAddress(paymentRequest.getShippingAddress()); request = request.toBuilder() .shippingAddress(address) .build(); } // Add buyer information if provided if (paymentRequest.getBuyer() != null) { request = request.toBuilder() .buyerEmailAddress(paymentRequest.getBuyer().getEmailAddress()) .build(); } // Execute payment CompletableFuture<CreatePaymentResponse> future = squareClientService.executeAsync(() -> squareClientService.getPaymentsApi().createPaymentAsync(request).get() ); CreatePaymentResponse response = future.get(); if (response.isSuccess()) { Payment payment = response.getPayment(); log.info("Payment processed successfully: {}", payment.getId()); return PaymentResponse.success(convertToPaymentData(payment)); } else { log.error("Payment failed: {}", response.getErrors()); return PaymentResponse.error("Payment processing failed: " + response.getErrors().get(0).getDetail()); } } catch (Exception e) { log.error("Payment processing failed", e); return PaymentResponse.error("Payment processing failed: " + e.getMessage()); } } /** * Get payment by ID */ public PaymentResponse getPayment(String paymentId) { try { CompletableFuture<GetPaymentResponse> future = squareClientService.executeAsync(() -> squareClientService.getPaymentsApi().getPaymentAsync(paymentId).get() ); GetPaymentResponse response = future.get(); if (response.isSuccess()) { Payment payment = response.getPayment(); return PaymentResponse.success(convertToPaymentData(payment)); } else { log.error("Failed to get payment: {}", response.getErrors()); return PaymentResponse.error("Failed to retrieve payment: " + response.getErrors().get(0).getDetail()); } } catch (Exception e) { log.error("Failed to get payment: {}", paymentId, e); return PaymentResponse.error("Failed to retrieve payment: " + e.getMessage()); } } /** * List payments with filters */ public java.util.List<PaymentResponse.PaymentData> listPayments(String customerId, java.time.LocalDateTime beginTime, java.time.LocalDateTime endTime, String status) { try { ListPaymentsRequest.Builder requestBuilder = new ListPaymentsRequest.Builder(); if (customerId != null) { requestBuilder.customerId(customerId); } if (beginTime != null) { requestBuilder.beginTime(beginTime.toString()); } if (endTime != null) { requestBuilder.endTime(endTime.toString()); } if (status != null) { requestBuilder.status(status); } CompletableFuture<ListPaymentsResponse> future = squareClientService.executeAsync(() -> squareClientService.getPaymentsApi().listPaymentsAsync(requestBuilder.build()).get() ); ListPaymentsResponse response = future.get(); if (response.isSuccess()) { return response.getPayments().stream() .map(this::convertToPaymentData) .collect(java.util.stream.Collectors.toList()); } else { log.error("Failed to list payments: {}", response.getErrors()); throw new RuntimeException("Failed to list payments: " + response.getErrors().get(0).getDetail()); } } catch (Exception e) { log.error("Failed to list payments", e); throw new RuntimeException("Failed to list payments", e); } } /** * Process refund */ public RefundResponse processRefund(RefundRequest refundRequest) { try { String idempotencyKey = refundRequest.getIdempotencyKey() != null ? refundRequest.getIdempotencyKey() : squareClientService.generateIdempotencyKey(); CreateRefundRequest request = new CreateRefundRequest.Builder( idempotencyKey, refundRequest.getPaymentId(), squareClientService.toSquareMoney(refundRequest.getAmount(), "USD") ) .reason(refundRequest.getReason()) .tenderId(refundRequest.getTenderId()) .build(); CompletableFuture<CreateRefundResponse> future = squareClientService.executeAsync(() -> squareClientService.getRefundsApi().createRefundAsync(request).get() ); CreateRefundResponse response = future.get(); if (response.isSuccess()) { Refund refund = response.getRefund(); log.info("Refund processed successfully: {}", refund.getId()); return RefundResponse.success( refund.getId(), refund.getStatus(), squareClientService.fromSquareMoney(refund.getAmountMoney()), refund.getAmountMoney().getCurrency() ); } else { log.error("Refund failed: {}", response.getErrors()); return RefundResponse.error("Refund processing failed: " + response.getErrors().get(0).getDetail()); } } catch (Exception e) { log.error("Refund processing failed", e); return RefundResponse.error("Refund processing failed: " + e.getMessage()); } } /** * Convert Square Payment to PaymentData */ private PaymentResponse.PaymentData convertToPaymentData(Payment payment) { return PaymentResponse.PaymentData.builder() .id(payment.getId()) .amount(squareClientService.fromSquareMoney(payment.getAmountMoney())) .currency(payment.getAmountMoney().getCurrency()) .status(payment.getStatus()) .sourceType(payment.getSourceType()) .customerId(payment.getCustomerId()) .orderId(payment.getOrderId()) .referenceId(payment.getReferenceId()) .note(payment.getNote()) .createdAt(payment.getCreatedAt() != null ? payment.getCreatedAt().toLocalDateTime() : null) .updatedAt(payment.getUpdatedAt() != null ? payment.getUpdatedAt().toLocalDateTime() : null) .metadata(payment.getMetadata()) .build(); } /** * Convert application Address to Square Address */ private Address convertToSquareAddress(PaymentRequest.Address appAddress) { return new Address.Builder() .firstName(appAddress.getFirstName()) .lastName(appAddress.getLastName()) .addressLine1(appAddress.getAddressLine1()) .addressLine2(appAddress.getAddressLine2()) .locality(appAddress.getLocality()) .administrativeDistrictLevel1(appAddress.getAdministrativeDistrictLevel1()) .postalCode(appAddress.getPostalCode()) .country(appAddress.getCountry()) .build(); } /** * Complete partial payment */ public PaymentResponse completePayment(String paymentId) { try { CompletableFuture<CompletePaymentResponse> future = squareClientService.executeAsync(() -> squareClientService.getPaymentsApi().completePaymentAsync(paymentId).get() ); CompletePaymentResponse response = future.get(); if (response.isSuccess()) { Payment payment = response.getPayment(); return PaymentResponse.success(convertToPaymentData(payment)); } else { log.error("Failed to complete payment: {}", response.getErrors()); return PaymentResponse.error("Failed to complete payment: " + response.getErrors().get(0).getDetail()); } } catch (Exception e) { log.error("Failed to complete payment: {}", paymentId, e); return PaymentResponse.error("Failed to complete payment: " + e.getMessage()); } } /** * Cancel payment */ public PaymentResponse cancelPayment(String paymentId) { try { CompletableFuture<CancelPaymentResponse> future = squareClientService.executeAsync(() -> squareClientService.getPaymentsApi().cancelPaymentAsync(paymentId).get() ); CancelPaymentResponse response = future.get(); if (response.isSuccess()) { Payment payment = response.getPayment(); return PaymentResponse.success(convertToPaymentData(payment)); } else { log.error("Failed to cancel payment: {}", response.getErrors()); return PaymentResponse.error("Failed to cancel payment: " + response.getErrors().get(0).getDetail()); } } catch (Exception e) { log.error("Failed to cancel payment: {}", paymentId, e); return PaymentResponse.error("Failed to cancel payment: " + e.getMessage()); } } }

Customer Service

```java
// CustomerService.java
package com.example.squarepayments.service;

import com.squareup.sdk.models.; import com.example.squarepayments.model.;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.concurrent.CompletableFuture;

@Slf4j
@Service
@Transactional
public class CustomerService {
private final SquareClientService squareClientService;

public CustomerService(SquareClientService squareClientService) { this.squareClientService = squareClientService; } /** * Create customer */ public CustomerResponse createCustomer(CustomerRequest customerRequest) { try { CreateCustomerRequest.Builder requestBuilder = new CreateCustomerRequest.Builder(); if (customerRequest.getGivenName() != null) { requestBuilder.givenName(customerRequest.getGivenName()); } if (customerRequest.getFamilyName() != null) { requestBuilder.familyName(customerRequest.getFamilyName()); } if (customerRequest.getEmailAddress() != null) { requestBuilder.emailAddress(customerRequest.getEmailAddress()); } if (customerRequest.getPhoneNumber() != null) { requestBuilder.phoneNumber(customerRequest.getPhoneNumber()); } if (customerRequest.getCompanyName() != null) { requestBuilder.companyName(customerRequest.getCompanyName()); } if (customerRequest.getReferenceId() != null) { requestBuilder.referenceId(customerRequest.getReferenceId()); } if (customerRequest.getNote() != null) { requestBuilder.note(customerRequest.getNote()); } if (customerRequest.getAddress() != null) { Address address = convertToSquareAddress(customerRequest.getAddress()); requestBuilder.address(address); } if (customerRequest.getMetadata() != null) { requestBuilder.metadata(customerRequest.getMetadata()); } String idempotencyKey = squareClientService.generateIdempotencyKey(); requestBuilder.idempotencyKey(idempotencyKey); CompletableFuture<CreateCustomerResponse> future = squareClientService.executeAsync(() -> squareClientService.getCustomersApi().createCustomerAsync(requestBuilder.build()).get() ); CreateCustomerResponse response = future.get(); if (response.isSuccess()) { Customer customer = response.getCustomer(); log.info("Customer created successfully: {}", customer.getId()); return CustomerResponse.success(convertToCustomerData(customer)); } else { log.error("Failed to create customer: {}", response.getErrors()); return CustomerResponse.error("Failed to create customer: " + response.getErrors().get(0).getDetail()); } } catch (Exception e) { log.error("Failed to create customer", e); return CustomerResponse.error("Failed to create customer: " + e.getMessage()); } } /** * Get customer by ID */ public CustomerResponse getCustomer(String customerId) { try { CompletableFuture<RetrieveCustomerResponse> future = squareClientService.executeAsync(() -> squareClientService.getCustomersApi().retrieveCustomerAsync(customerId).get() ); RetrieveCustomerResponse response = future.get(); if (response.isSuccess()) { Customer customer = response.getCustomer(); return CustomerResponse.success(convertToCustomerData(customer)); } else { log.error("Failed to get customer: {}", response.getErrors()); return CustomerResponse.error("Failed to retrieve customer: " + response.getErrors().get(0).getDetail()); } } catch (Exception e) { log.error("Failed to get customer: {}", customerId, e); return CustomerResponse.error("Failed to retrieve customer: " + e.getMessage()); } } /** * Update customer */ public CustomerResponse updateCustomer(String customerId, CustomerRequest customerRequest) { try { UpdateCustomerRequest.Builder requestBuilder = new UpdateCustomerRequest.Builder(); if (customerRequest.getGivenName() != null) { requestBuilder.givenName(customerRequest.getGivenName()); } if (customerRequest.getFamilyName() != null) { requestBuilder.familyName(customerRequest.getFamilyName()); } if (customerRequest.getEmailAddress() != null) { requestBuilder.emailAddress(customerRequest.getEmailAddress()); } if (customerRequest.getPhoneNumber() != null) { requestBuilder.phoneNumber(customerRequest.getPhoneNumber()); } if (customerRequest.getCompanyName() != null) { requestBuilder.companyName(customerRequest.getCompanyName()); } if (customerRequest.getReferenceId() != null) { requestBuilder.referenceId(customerRequest.getReferenceId()); } if (customerRequest.getNote() != null) { requestBuilder.note(customerRequest.getNote()); } if (customerRequest.getAddress() != null) { Address address = convertToSquareAddress(customerRequest.getAddress()); requestBuilder.address(address); } if (customerRequest.getMetadata() != null) { requestBuilder.metadata(customerRequest.getMetadata()); } CompletableFuture<UpdateCustomerResponse> future = squareClientService.executeAsync(() -> squareClientService.getCustomersApi().updateCustomerAsync(customerId, requestBuilder.build()).get() ); UpdateCustomerResponse response = future.get(); if (response.isSuccess()) { Customer customer = response.getCustomer(); log.info("Customer updated successfully: {}", customer.getId()); return CustomerResponse.success(convertToCustomerData(customer)); } else { log
Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper