Media Repository - Code Quality Report¶

// MediaController.cs - No tests for file validation
private E_ResponseReason FileValidations(MediaCategory mediaCategory)
{
    // Complex validation logic - UNTESTED
    // What if allowedExtensions is null?
    // What if file.ContentLength is negative?
    // What if extension parsing fails?
}

// SecurityHelper.cs - No tests for encryption
public static string Encrypt(string strText, string strPassPhrase)
{
    // Encryption logic - UNTESTED
    // What if text is null?
    // What if passPhrase is empty?
}

// iTextSharpHelper.cs - No tests for PDF generation
public async Task<FileObject> CreateAgreementPDF(...)
{
    // PDF generation - UNTESTED
    // What if template is missing?
    // What if user data is invalid?
}

// PsyterMediaUploadAPI.Tests project

[TestFixture]
public class MediaControllerTests
{
    [Test]
    public void FileValidations_WithValidPNG_ReturnsSuccess()
    {
        // Arrange
        var controller = new MediaController();
        var mockFile = CreateMockFile("test.png", "image/png", 1024);

        // Act
        var result = controller.FileValidations(MediaCategory.ProfileImage);

        // Assert
        Assert.AreEqual(E_ResponseReason.SUCCESS, result);
    }

    [Test]
    public void FileValidations_WithOversizedFile_ReturnsError()
    {
        // Test file size validation
    }

    [Test]
    public void FileValidations_WithMaliciousExtension_ReturnsError()
    {
        // Test extension validation
    }
}

[TestFixture]
public class SecurityHelperTests
{
    [Test]
    public void Encrypt_WithValidInput_ReturnsEncryptedString()
    {
        // Test encryption
    }

    [Test]
    public void Encrypt_WithNullInput_ThrowsException()
    {
        // Test null handling
    }
}

// MediaController.cs
MediaRepository _repo = new MediaRepository();  // ❌ Hard-coded dependency
iTextSharpHelper _helper = new iTextSharpHelper();  // ❌ Hard-coded
SecurityHelper.DecryptString(text);  // ❌ Static methods

// Controllers/MediaController.cs
public string GetMediaPhysicalPath()
{
    MediaRepository _repo = new MediaRepository();  // ❌ New instance every call
    // ...
}

// Install: Install-Package Microsoft.Extensions.DependencyInjection

// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    // Register dependencies
    services.AddScoped<IMediaRepository, MediaRepository>();
    services.AddScoped<IPdfGenerator, iTextSharpHelper>();
    services.AddScoped<ISecurityHelper, SecurityHelper>();
    services.AddScoped<IFileValidator, FileValidator>();
}

// MediaController.cs - Constructor injection
public class MediaController : BaseController
{
    private readonly IMediaRepository _mediaRepository;
    private readonly IPdfGenerator _pdfGenerator;
    private readonly IFileValidator _fileValidator;

    public MediaController(
        IMediaRepository mediaRepository,
        IPdfGenerator pdfGenerator,
        IFileValidator fileValidator)
    {
        _mediaRepository = mediaRepository;
        _pdfGenerator = pdfGenerator;
        _fileValidator = fileValidator;
    }

    public async Task<IHttpActionResult> UploadMedia()
    {
        // Use injected dependencies
        var validationResult = _fileValidator.Validate(file);
        await _mediaRepository.SaveFileMetadata(fileData);
    }
}

// Enable testing
[Test]
public void UploadMedia_WithValidFile_SavesSuccessfully()
{
    var mockRepo = new Mock<IMediaRepository>();
    var mockPdf = new Mock<IPdfGenerator>();
    var mockValidator = new Mock<IFileValidator>();

    var controller = new MediaController(mockRepo.Object, mockPdf.Object, mockValidator.Object);

    // Test with mocked dependencies
}

// MediaController.cs
if (file.ContentLength > maxFileSize)  // maxFileSize from config, good
if (totalFiles > 1)  // ❌ Magic number
if (totalFiles > 3)  // ❌ Magic number

// File signature validation - Magic strings
switch (data.ToUpper())
{
    case "IVBO":  // ❌ What is IVBO?
        return ".png";
    case "/9J/":  // ❌ What is /9J/?
        return ".jpeg";
}

// Extension constants
public const string AllowedDocumentExtensions = ".doc,.docx,.xlsx,.pdf,.jpg,.jpeg,.png";  // ❌ Should be in config

// Time zones
DateTime.UtcNow.AddHours(3)  // ❌ Magic number 3 - Should be config

// Models/UploadConfiguration.cs
public class UploadConfiguration
{
    public int ProfileImageMaxFiles { get; set; } = 1;
    public int EducationHistoryMaxFiles { get; set; } = 3;
    public Dictionary<string, string> AllowedExtensions { get; set; }
    public Dictionary<string, string> FileSignatures { get; set; }
    public int TimeZoneOffsetHours { get; set; } = 3;
}

// Web.config or appsettings.json
{
  "UploadConfiguration": {
    "ProfileImageMaxFiles": 1,
    "EducationHistoryMaxFiles": 3,
    "TimeZoneOffsetHours": 3,
    "FileSignatures": {
      "IVBO": ".png",
      "/9J/": ".jpg"
    }
  }
}

// iTextSharpHelper.cs
//if (!string.IsNullOrEmpty(responseData.FirstNamePLang))
//{
//    userName = responseData.FirstNamePLang + ...
//}

//htmlString = htmlString.Replace("{NATIONAL_ID}", responseData.NationalId);
//htmlString = htmlString.Replace("{CLASSIFICATION_NUMBER}", responseData.SCFHSClassificationNo);

// MediaController.cs
//string allowedMimeTypeForExtension = GetAllowedMimeType(extension);
//if (file.ContentType != allowedMimeTypeForExtension || allowedMimeTypeForExtension == "")
//{
//    response = E_ResponseReason.FILE_MIMETYPE_NOT_ALLOWED;
//    break;
//}

// Web.config
<!--<add name="PsyterDatabase" connectionString="...Live..." />-->

// MediaController.cs
catch (Exception ex)
{
    return GetErrorResponse(ex);  // Generic handling, no logging
}

// MediaRepository.cs
catch (Exception ex)
{
    throw ex;  // ❌ Loses stack trace, should be 'throw;'
}

// BaseRepository.cs
catch (Exception)
{
    response.Status = 0;  // ❌ Swallows exception, no logging
}

// iTextSharpHelper.cs
catch (Exception ex)
{
    return null;  // ❌ Silent failure
}

// Add structured logging
private readonly ILogger<MediaController> _logger;

try
{
    // Operation
}
catch (SqlException ex)
{
    _logger.LogError(ex, "Database error uploading file. UserId={UserId}, Category={Category}", 
        userId, category);
    return GetErrorResponse(E_ResponseReason.SQL_SERVER_EXCEPTION);
}
catch (IOException ex)
{
    _logger.LogError(ex, "File system error. Path={Path}", filePath);
    return GetErrorResponse(E_ResponseReason.PHYSICAL_DIRECTORY_NOT_FOUND);
}
catch (Exception ex)
{
    _logger.LogCritical(ex, "Unexpected error in UploadMedia");
    return GetErrorResponse(E_ResponseReason.ERROR);
}

// MediaController.cs - UploadMedia method is 300+ lines
public async Task<IHttpActionResult> UploadMedia()
{
    // 1. Parameter extraction
    // 2. Validation
    // 3. Path determination (huge switch statement)
    // 4. Directory creation
    // 5. File upload
    // 6. Special processing
    // 7. Database operations
    // 8. Response creation

    // Too many responsibilities!
}

public async Task<IHttpActionResult> UploadMedia()
{
    var request = ExtractUploadRequest();
    var validationResult = ValidateUploadRequest(request);
    if (!validationResult.IsValid)
        return GetInvalidResponse(validationResult.Reason);

    var storagePath = DetermineStoragePath(request);
    var uploadedFiles = await SaveFiles(request, storagePath);
    var processedFiles = await ProcessUploadedFiles(uploadedFiles, request);

    return GetSuccessResponse(processedFiles);
}

private UploadRequest ExtractUploadRequest() { /* ... */ }
private ValidationResult ValidateUploadRequest(UploadRequest request) { /* ... */ }
private StoragePath DetermineStoragePath(UploadRequest request) { /* ... */ }
private async Task<List<FileObject>> SaveFiles(UploadRequest request, StoragePath path) { /* ... */ }
private async Task<dynamic> ProcessUploadedFiles(List<FileObject> files, UploadRequest request) { /* ... */ }

// Interfaces/IMediaRepository.cs
public interface IMediaRepository
{
    Task<FileListWrapper> SaveHomeWorkImages(long homeWorkId, string filesDetailXML);
    Task<FileObject> DeleteMediaFromDB(long userId, long mediaId, int category);
    Task<UserAgreementDetails> GetUserAgreementDetails(long userLoginInfoId);
    Task<bool> UpdateAgreementFilePath(long userLoginInfoId, string pdfPath, string signaturePath);
}

// Interfaces/IPdfGenerator.cs
public interface IPdfGenerator
{
    Task<FileObject> CreateAgreementPDF(string userLoginInfoId, string userName, 
        string agreementPath, string signaturePath, string language);
}

// Interfaces/IFileValidator.cs
public interface IFileValidator
{
    ValidationResult ValidateFile(HttpPostedFile file, MediaCategory category);
}

// Path building duplicated for each category
relativePath = "/Media/" + userType.ToDescription() + "/User_" + userId + "/" + MediaCategory.ProfileImage.ToDescription() + "/";
physicalPath = MediaPhysicalPath + "\\Media\\" + userType.ToDescription() + "\\User_" + userId + "\\" + MediaCategory.ProfileImage.ToDescription();

// Repeated for 11 different categories...

private (string relativePath, string physicalPath) BuildStoragePaths(
    E_UserType userType, string userId, MediaCategory category, string homeWorkId = null)
{
    var userPath = $"Media/{userType.ToDescription()}/User_{userId}";
    var categoryPath = category.ToDescription();

    if (category == MediaCategory.HomeWork || category == MediaCategory.HomeWorkSubmission)
    {
        if (string.IsNullOrEmpty(homeWorkId))
            throw new ArgumentException("HomeWorkId required for this category");
        categoryPath += $"/HomeWork_{homeWorkId}";
    }

    var relativePath = $"/{userPath}/{categoryPath}/";
    var physicalPath = Path.Combine(MediaPhysicalPath, userPath, categoryPath);

    return (relativePath, physicalPath);
}

E_ResponseReason  // ❌ Why E_ prefix?
E_UserType
E_HomeWorkType

PsyterDbCommand  // ❌ Inconsistent with DbCommand pattern

umfProvider  // ❌ Unclear abbreviation
ds  // ❌ Single letter
da  // ❌ Single letter

strTemp, strTemp1, strTemp2, strTemp3  // ❌ Meaningless names

ResponseReason instead of E_ResponseReason
UserType instead of E_UserType

uploadFormProvider instead of umfProvider
dataSet instead of ds
dataAdapter instead of da

hashedOnce, hashedTwice, hashedThrice instead of strTemp1, strTemp2, strTemp3

// ❌ No documentation
public async Task<IHttpActionResult> UploadMedia()

// ❌ No documentation
public class MediaRepository : BaseRespository

// ❌ No documentation
public enum MediaCategory

/// <summary>
/// Uploads one or more media files with validation and category-specific processing.
/// </summary>
/// <returns>File details including path, name, and type</returns>
/// <exception cref="ArgumentException">Invalid upload parameters</exception>
public async Task<IHttpActionResult> UploadMedia()

/// <summary>
/// Represents media file categories supported by the upload API.
/// </summary>
public enum MediaCategory
{
    /// <summary>
    /// User profile image (max 1 file, images only)
    /// </summary>
    ProfileImage = 1,
    // etc.
}