DeleteRetentionSourceAuthority API¶

/srv.asmx/DeleteRetentionSourceAuthority

<root success="true" />

<root success="false" error="[ErrorCode] Error message" />

GET /srv.asmx/DeleteRetentionSourceAuthority?authenticationTicket=abc123-def456&authorityName=GDPR%20-%20General%20Data%20Protection%20Regulation HTTP/1.1
Host: server.example.com

POST /srv.asmx/DeleteRetentionSourceAuthority HTTP/1.1
Content-Type: application/x-www-form-urlencoded

authenticationTicket=abc123-def456&authorityName=GDPR - General Data Protection Regulation

POST /srv.asmx HTTP/1.1
Content-Type: text/xml; charset=utf-8
SOAPAction: "http://tempuri.org/DeleteRetentionSourceAuthority"

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <DeleteRetentionSourceAuthority xmlns="http://tempuri.org/">
      <authenticationTicket>abc123-def456</authenticationTicket>
      <authorityName>GDPR - General Data Protection Regulation</authorityName>
    </DeleteRetentionSourceAuthority>
  </soap:Body>
</soap:Envelope>

<?xml version="1.0" encoding="utf-8"?>
<root success="true" />

<root success="false" error="Retention source authority not found" />

<root success="false" error="Cannot delete authority because it is referenced by one or more R&D schedules" />

<root success="false" error="Authority name cannot be empty" />

<root success="false" error="[901]Session expired or Invalid ticket" />

async function deleteAuthority(authorityName) {
    // First, check if authority is in use
    const inUse = await isAuthorityInUse(authorityName);
    if (inUse) {
        alert('Cannot delete authority: it is currently in use by R&D schedules');
        return false;
    }

    // Confirm deletion
    if (!confirm(`Are you sure you want to delete authority: ${authorityName}?`)) {
        return false;
    }

    const ticket = getUserAuthTicket();
    const formData = new FormData();
    formData.append('authenticationTicket', ticket);
    formData.append('authorityName', authorityName);

    const response = await fetch('/srv.asmx/DeleteRetentionSourceAuthority', {
        method: 'POST',
        body: formData
    });

    const xmlText = await response.text();
    const parser = new DOMParser();
    const xmlDoc = parser.parseFromString(xmlText, "text/xml");

    const success = xmlDoc.querySelector("root").getAttribute("success");
    if (success === "true") {
        console.log("Authority deleted successfully");
        return true;
    } else {
        const error = xmlDoc.querySelector("root").getAttribute("error");
        console.error("Failed to delete authority:", error);
        alert(error);
        return false;
    }
}

async function isAuthorityInUse(authorityName) {
    // Check if any R&D schedules reference this authority
    const ticket = getUserAuthTicket();
    const response = await fetch(
        `/srv.asmx/GetRandDSchedules?authenticationTicket=${ticket}`
    );
    const xmlText = await response.text();
    const parser = new DOMParser();
    const xmlDoc = parser.parseFromString(xmlText, "text/xml");

    // Parse schedules and check for authority reference
    // (Actual implementation would need to check schedule details)
    return false; // Simplified for example
}

using (var client = new SrvSoapClient())
{
    try
    {
        // First check if authority exists
        var authoritiesResponse = await client.GetRetentionSourceAuthoritiesAsync(authTicket);
        var authorities = authoritiesResponse.Descendants("Authority")
            .Select(a => a.Attribute("Name")?.Value)
            .ToList();

        if (!authorities.Contains(authorityToDelete))
        {
            Console.WriteLine("Authority not found");
            return;
        }

        // Check if in use (simplified - would need to check R&D schedules)
        var schedulesResponse = await client.GetRandDSchedulesAsync(authTicket);
        // ... check if any schedules reference the authority ...

        // Confirm deletion
        Console.WriteLine($"Are you sure you want to delete '{authorityToDelete}'? (y/n)");
        var confirm = Console.ReadLine();
        if (confirm?.ToLower() != "y")
        {
            Console.WriteLine("Deletion cancelled");
            return;
        }

        // Perform deletion
        var response = await client.DeleteRetentionSourceAuthorityAsync(
            authTicket, 
            authorityToDelete
        );

        var root = response.Root;
        if (root.Attribute("success")?.Value == "true")
        {
            Console.WriteLine("Authority deleted successfully");
        }
        else
        {
            var error = root.Attribute("error")?.Value;
            Console.WriteLine($"Error: {error}");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Exception: {ex.Message}");
    }
}

1. Get list of all authorities
2. Identify test authorities (e.g., names starting with "TEST_")
3. For each test authority:
   - Verify it's not in use
   - Delete the authority
4. Verify cleanup complete

1. Identify duplicate authorities (e.g., "SEC" and "SEC - Securities and Exchange Commission")
2. Choose the authority name to keep
3. Update all R&D schedules to use the kept authority
4. Delete the duplicate authorities
5. Verify all schedules still function correctly

1. Identify the superseded authority (e.g., old regulation)
2. Create new authority for replacement regulation
3. Update all R&D schedules to reference new authority
4. Delete the old authority
5. Document the change in compliance records