WindowsService - Code Quality Report¶

// Separate classes
public class PaymentInquiryService : ServiceBase
{
    private readonly PaymentProcessor paymentProcessor;
    private readonly NotificationManager notificationManager;
    private readonly TimerOrchestrator timerOrchestrator;

    public PaymentInquiryService()
    {
        paymentProcessor = new PaymentProcessor();
        notificationManager = new NotificationManager();
        timerOrchestrator = new TimerOrchestrator();
    }
}

public class PaymentProcessor
{
    public Task ProcessPendingPayments() { }
    public Task ProcessRefunds() { }
    public Task ProcessWalletPayments() { }
    public Task ProcessPackagePayments() { }
}

public class NotificationManager
{
    public Task SendReminders() { }
    public Task SendNotifications() { }
}

public class PaymentGatewayClient
{
    public Task<ProcessResponse> SubmitInquiry() { }
    public Task<ProcessResponse> SubmitRefund() { }
    public SecureHashResponse GenerateHash() { }
}

// Extract methods
public async Task<PendingPaymentResponse> GetPendingPayment()
{
    var response = await FetchPendingPaymentsFromDatabase();
    await ProcessBookingPayments(response);
    await ProcessRefundPayments();
    await ProcessWalletPayments();
    await ProcessPackagePayments();
    return response;
}

private async Task ProcessBookingPayments(PendingPaymentResponse response)
{
    foreach (var payment in response.PendingPaymentsList)
    {
        await ProcessSinglePayment(payment, response.AppConfigSetting);
    }
}

private async Task ProcessSinglePayment(PendingPayment payment, PaymentApplicationConfiguration config)
{
    var hash = GenerateSecureHash(payment, config);
    var inquiryRequest = BuildInquiryRequest(payment, hash);
    var result = await SubmitToGateway(inquiryRequest);
    await UpdatePaymentStatus(payment, result);
}

1. Fetch from database
2. Check counts
3. Build configuration
4. Loop through items
5. Generate hash
6. Process inquiry
7. Update database

// Generic payment processor
private async Task<T> ProcessPaymentType<T>(
    Func<Task<T>> fetchMethod,
    Func<T, Task> processMethod,
    string logType)
{
    try
    {
        var data = await fetchMethod();
        await processMethod(data);
        return data;
    }
    catch (Exception ex)
    {
        LogException(ex, nameof(ProcessPaymentType), logType);
        throw;
    }
}

// Generic thread creator
private void CreateThreadSafe(
    ref Thread threadField,
    Action threadAction,
    string threadName,
    string logType)
{
    lock (threadLock)
    {
        if (threadField == null || !threadField.IsAlive)
        {
            threadField = new Thread(() => threadAction());
            threadField.Name = threadName;
            threadField.Start();
            WriteToFile($"{threadName} started {DateTime.Now}", logType);
        }
    }
}

// Generic API authenticator
private async Task<APIAuthTokenResponse> AuthenticateApi(string baseUrl, string appToken)
{
    var authenticateUrl = $"{baseUrl}Authenticate";
    var pairs = new List<KeyValuePair<string, string>>
    {
        new KeyValuePair<string, string>("applicationtoken", appToken),
        new KeyValuePair<string, string>("grant_type", "password")
    };

    var content = new FormUrlEncodedContent(pairs);
    using (var client = new HttpClient())
    {
        var response = await client.PostAsync(authenticateUrl, content);
        var jObject = JObject.Parse(await response.Content.ReadAsStringAsync());
        return new APIAuthTokenResponse
        {
            AccessToken = jObject.SelectToken("access_token").ToString(),
            RefreshToken = jObject.SelectToken("refresh_token").ToString(),
            TokenExpiresIn = jObject.SelectToken("expires_in").ToString()
        };
    }
}

catch (Exception ex)
{
    WriteToFile("Exception occur " + DateTime.Now + ", Error: " + ex.Message, "Inquiry");
}

catch (SqlException sqlEx)
{
    LogException(sqlEx, "Database Error", "Inquiry");
    // Specific handling for DB errors
    if (sqlEx.Number == 1205) // Deadlock
    {
        // Retry logic
    }
}
catch (HttpRequestException httpEx)
{
    LogException(httpEx, "API Communication Error", "Inquiry");
    // Specific handling for API errors
}
catch (TimeoutException timeoutEx)
{
    LogException(timeoutEx, "Timeout Error", "Inquiry");
    // Specific handling for timeouts
}
catch (Exception ex)
{
    LogException(ex, "Unexpected Error", "Inquiry");
    throw; // Re-throw unexpected errors
}

// Methods: PascalCase, verb-noun
public async Task<PendingPaymentResponse> GetPendingPaymentsAsync()

// Variables: camelCase
private string secretKey;
private long orderId;

// Constants: PascalCase or UPPER_SNAKE_CASE consistently
private const string PaymentGatewayUrl = "...";
// OR
private const string PAYMENT_GATEWAY_URL = "...";

// Properties: PascalCase
public string SecretKey { get; set; }
public long OrderId { get; set; }

timer.Interval = 600000;  // What is 600000?

NewBookingStatusId = 1    // What is status 1?
NewBookingStatusId = 8    // What is status 8?

StatusUpdateAuthority = 2 // What is authority 2?

NotificationType = 11     // What is type 11?
NotificationType = 12     // What is type 12?

UserType = 1              // Patient?
UserType = 0              // Provider?

MESSAGE_ID = "2"          // Inquiry
MESSAGE_ID = "4"          // Refund

if (statusInt == 2)       // What does 2 mean?

CatAppConfigGroupId = 2   // What is group 2?

// Timer intervals
private static class TimerIntervals
{
    public const int PaymentProcessing = 600000;      // 10 minutes
    public const int LogCleanup = 1296000000;         // 15 days
    public const int SchfsExpiry = 86400000;          // 24 hours
    public const int FcmNotifications = 600000;       // 10 minutes
}

// Booking statuses
public enum BookingStatus
{
    Booked = 1,
    Cancelled = 8,
    // ... other statuses
}

// Notification types
public enum NotificationType
{
    General = 11,
    AppointmentReminder = 12
}

// User types
public enum UserType
{
    Provider = 0,
    Patient = 1
}

// Payment gateway message types
public enum PaymentMessageType
{
    Inquiry = 2,
    Refund = 4
}

// Usage
timer.Interval = TimerIntervals.PaymentProcessing;
NewBookingStatusId = (int)BookingStatus.Booked;
NotificationType = (int)NotificationType.AppointmentReminder;

// Define interfaces
public interface IPaymentRepository
{
    Task<PendingPaymentResponse> GetPendingPaymentsAsync();
    Task<bool> UpdatePaymentStatusAsync(UpdateBookingOrderPayForData data);
}

// Implementation
public class SqlPaymentRepository : IPaymentRepository
{
    private readonly Database database;

    public SqlPaymentRepository(Database database)
    {
        this.database = database;
    }

    public async Task<PendingPaymentResponse> GetPendingPaymentsAsync()
    {
        // Implementation
    }
}

// Usage with dependency injection
public class PaymentInquiryService
{
    private readonly IPaymentRepository paymentRepository;

    public PaymentInquiryService(IPaymentRepository repository)
    {
        paymentRepository = repository;
    }
}

<package id="Microsoft.Practices.EnterpriseLibrary.Common.dll" 
         version="3.1.0" />  <!-- Released 2008! -->
<package id="Newtonsoft.Json" version="13.0.1" /> <!-- 2 years old -->

// Test project structure
PsyterPaymentInquiry.Tests/
├── Unit/
│   ├── PaymentProcessorTests.cs
│   ├── SecureHashGeneratorTests.cs
│   └── NotificationManagerTests.cs
├── Integration/
│   ├── DatabaseTests.cs
│   ├── PaymentGatewayTests.cs
│   └── ApiIntegrationTests.cs
└── TestHelpers/
    ├── MockDataBuilder.cs
    └── TestFixtures.cs

// Example unit test
[TestClass]
public class SecureHashGeneratorTests
{
    [TestMethod]
    public void GenerateSecureHash_ValidInput_ReturnsCorrectHash()
    {
        // Arrange
        var request = new RequestSecureHash
        {
            SECRECT_KEY = "test_key",
            MESSAGE_ID = "2",
            TRANSACTION_ID = "PSY123456"
        };
        var config = new PaymentApplicationConfiguration
        {
            SmartRoutingMerchantId = "MERCHANT123",
            SmartRoutingVersion = "1.0"
        };

        // Act
        var generator = new SecureHashGenerator();
        var result = generator.GenerateHash(request, config);

        // Assert
        Assert.IsNotNull(result.SECURE_HASH);
        Assert.AreEqual(64, result.SECURE_HASH.Length); // SHA256 hex = 64 chars
    }
}

public async Task<PendingPaymentResponse> GetPendingPayment()
{
    // No documentation
}

/// <summary>
/// Fetches and processes all pending payment inquiries from the database.
/// This includes booking payments, refunds, wallet purchases, and package purchases.
/// </summary>
/// <returns>
/// A <see cref="PendingPaymentResponse"/> containing the list of processed payments
/// and their updated statuses.
/// </returns>
/// <exception cref="DatabaseException">
/// Thrown when database connection fails or stored procedure errors occur.
/// </exception>
/// <exception cref="PaymentGatewayException">
/// Thrown when communication with the payment gateway fails.
/// </exception>
/// <remarks>
/// This method is called every 10 minutes by the payment inquiry timer.
/// It processes payments sequentially and updates booking statuses via the Scheduling API.
/// Failed payments are automatically cancelled after 3 inquiry attempts.
/// </remarks>
public async Task<PendingPaymentResponse> GetPendingPayment()
{
    // Implementation
}

timer.Interval = 600000;
timerForDeleteLogFiles.Interval = 1296000000;

if (fi.CreationTime < DateTime.Now.AddDays(-30))  // 30-day retention

if (paymentDetail.InquiryCount >= 3)  // 3 retry attempts

<!-- App.config -->
<appSettings>
  <!-- Timer Intervals (milliseconds) -->
  <add key="PaymentInquiryInterval" value="600000"/>
  <add key="LogCleanupInterval" value="1296000000"/>
  <add key="SchfsExpiryInterval" value="86400000"/>
  <add key="FcmNotificationInterval" value="600000"/>

  <!-- Processing Settings -->
  <add key="LogRetentionDays" value="30"/>
  <add key="MaxPaymentInquiryAttempts" value="3"/>
  <add key="ApiRequestTimeout" value="30"/>

  <!-- Feature Flags -->
  <add key="EnableFcmNotifications" value="true"/>
  <add key="EnableSchfsExpiry" value="true"/>
  <add key="EnableLogCleanup" value="true"/>
</appSettings>

// Async method
public async Task<PendingPaymentResponse> GetPendingPayment()

// But calls synchronous method
public void GetPendingFCMNotificationsAndReminders()  // NOT async!

// Thread.Sleep instead of await Task.Delay
System.Threading.Thread.Sleep(System.Threading.Timeout.Infinite);

// Make all I/O operations async
public async Task SendFCMNotificationsAsync()
{
    var notifications = await GetPendingNotificationsAsync();
    foreach (var notification in notifications)
    {
        await SendNotificationAsync(notification);
    }
}

// Use async delays
await Task.Delay(Timeout.Infinite, cancellationToken);

using (var client = new HttpClient())
{
    // Good - using statement
}

// But HttpClient shouldn't be in using per request
// Should be reused

// Singleton HttpClient
private static readonly HttpClient httpClient = new HttpClient
{
    Timeout = TimeSpan.FromSeconds(30)
};

// Or use IHttpClientFactory (.NET Core)
private readonly IHttpClientFactory httpClientFactory;

public async Task CallApi()
{
    var client = httpClientFactory.CreateClient("PsyterAPI");
    // Use client
}

// Use modern logging framework
using Serilog;

Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Information()
    .WriteTo.File("logs/service-.txt", 
        rollingInterval: RollingInterval.Day,
        outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss} [{Level}] {Message}{NewLine}{Exception}")
    .WriteTo.Console()
    .CreateLogger();

// Structured logging
Log.Information("Processing payment {TransactionId} for order {OrderId}", 
    transactionId, orderId);

Log.Error(ex, "Failed to process payment {TransactionId}", transactionId);

Total LOC: ~1,670
├── PaymentInquiryService.cs: 1,000 (60%)
├── PaymentDataAccess.cs: 250 (15%)
├── DBHelper.cs: 120 (7%)
├── DTOs: 300 (18%)
└── Other: ~0 (0%)