@GetMapping("/login")
public ResponseEntity<String> login(@RequestParam String username) {
    logger.info("Login attempt by: " + username);
    // ... authenticate user
    return ResponseEntity.ok("OK");
}

/login?username=admin\n2024-06-30 10:00:00 [INFO] Login successful for attacker

[INFO] Login attempt by: admin
2024-06-30 10:00:00 [INFO] Login successful for attacker

@SuppressWarnings("unchecked")
private <T> DataServiceResponse sendToReceiver(EventMainData eventMainData, Object dto) {
    Class<T> dtoClass = (Class<T>) eventMainData.getEventType().getDtoClass();
    IBaseClient<T> feignClient = clientFactory.getClient(dtoClass);

    T castedDto = dtoClass.cast(dto);
    return switch (eventMainData.getOperationType()) {
        case CREATE -> feignClient.create(castedDto);
        case UPDATE -> feignClient.update(eventMainData.getEventId(), castedDto);
        case DELETE -> feignClient.delete(eventMainData.getEventId());
        default -> throw new IllegalStateException("Unknown operation");
    };
}

private function sendToReceiver(EventMainData $eventMainData, $dto)
{
    $dtoClass = $eventMainData->event_type->dto_class;
    $client = $this->clientFactory->getClient($dtoClass);
    $castedDto = new $dtoClass($dto);
   
    return match ($eventMainData->operation_type) {
        'CREATE' => $client->create($castedDto),
        'UPDATE' => $client->update($eventMainData->event_id, $castedDto),
        'DELETE' => $client->delete($eventMainData->event_id),
        default => throw new \InvalidArgumentException("Unknown operation")
    };
}
 

@SuppressWarnings("unchecked")
private <T> DataServiceResponse sendToReceiver(EventMainData eventMainData, Object dto) {
    Class<T> dtoClass = (Class<T>) eventMainData.getEventType().getDtoClass();
    IBaseClient<T> feignClient = clientFactory.getClient(dtoClass);

    T castedDto = dtoClass.cast(dto);
    return switch (eventMainData.getOperationType()) {
        case CREATE -> feignClient.create(castedDto);
        case UPDATE -> feignClient.update(eventMainData.getEventId(), castedDto);
        case DELETE -> feignClient.delete(eventMainData.getEventId());
        default -> throw new IllegalStateException("Unknown operation");
    };
}

{
  "eventType": {
    "dtoClass": "com.example.dto.UserDto"
  },
  "eventId": "admin-user-id",
  "operationType": "DELETE"
}

app.use((req, res, next) => {
    console.log(req.method, req.path);
    next();
});

app.post('/admin/delete-user', adminController.deleteUser);

app.use(authMiddleware);

app.use((req, res, next) => {
    console.log(req.method, req.path);
    next();
});

// Routes
app.post('/admin/delete-user', adminController.deleteUser);

// Auth middleware
app.use(authMiddleware);

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/admin/**").permitAll()
                .anyRequest().authenticated()
            )
            .build();
    }
}

Route::post('/admin/delete-user', [AdminController::class, 'deleteUser']);

Route::middleware(['auth', 'admin'])->group(function () {
    // Other protected routes...
});

app.post("/invite/:code", async (request, response) => {
  const { code } = request.params;
  const { username, password } = reqBody(request);
  const invite = await Invite.get({ code });
  if (!invite || invite.status !== "pending") {
    response.status(200).json({ success: false, error: "Invite not found or is invalid." });
    return;
  }

  const { user, error } = await User.create({ username, password, role: "default" });
  if (!user) {
    response.status(200).json({ success: false, error: "Could not create user." });
    return;
  }

  await Invite.markClaimed(invite.id, user);
  response.status(200).json({ success: true, error: null });
});

@RestController
@RequestMapping("/api/loyalty")
public class LoyaltyController {
    
    @Autowired
    private LoyaltyService loyaltyService;
    
    @Autowired
    private OrderService orderService;
    
    @PostMapping("/earn-points")
    public ResponseEntity<String> earnLoyaltyPoints(@RequestBody EarnPointsRequest request) {
        try {
            User user = getCurrentUser();
            Order order = orderService.getOrder(request.getOrderId());
            
            if (order == null || !order.getUserId().equals(user.getId())) {
                return ResponseEntity.badRequest().body("Invalid order");
            }
            
            for (OrderItem item : order.getItems()) {
                int pointsForItem = (int) (item.getPrice() * 0.01);
                loyaltyService.addPoints(user.getId(), pointsForItem);
                
                if (isPromotionalProduct(item.getProductId())) {
                    loyaltyService.addPoints(user.getId(), pointsForItem * 2);
                }
            }
                        
            return ResponseEntity.ok("Points earned successfully");
            
        } catch (Exception e) {
            return ResponseEntity.status(500).body("Error processing points");
        }
    }

package cleaner

import (
 "context"
 "time"
)

type Store interface {
 ListExpired(ctx context.Context, n int) ([]string, error)
 Delete(ctx context.Context, id string) error
}

func CleanupExpired(ctx context.Context, db Store) {
 t := time.NewTicker(time.Minute)
 defer t.Stop()

 for {
  select {
  case <-ctx.Done():
   return
  case <-t.C:
   ids, err := db.ListExpired(ctx, 100)
   if err != nil || len(ids) == 0 {
    continue
   }
   for _, id := range ids {
    ctx, cancel := context.WithTimeout(ctx, 750*time.Millisecond)
    go func(id string) {
     defer cancel()
     _ = db.Delete(ctx, id) 
    }(id)
   }
  }
 }
}