Untitled

const calculateGovernanceMetrics = (metadata, requiredFields) => {
  // Helper function to calculate percentage
  const calculatePercentage = (value, total) => Math.round((value / total) * 100);

  // 1. Metadata Completeness
  const calculateMetadataCompleteness = () => {
    const presentFields = Object.keys(metadata).length;
    return calculatePercentage(presentFields, requiredFields.length);
  };

  // 2. Compliance Status
  const calculateComplianceStatus = () => {
    let score = 0;
    const complianceChecks = [
      // Security metadata presence
      Boolean(metadata.security_metadata?.length),
      // Organization fields
      Boolean(metadata.organization_created_by?.length),
      Boolean(metadata.organization_created_for?.length),
      // Date validations
      Boolean(metadata.doc_created_date?.length),
      Boolean(metadata.doc_published_date?.length),
      // Author and publisher
      Boolean(metadata.doc_author?.length),
      Boolean(metadata.publisher?.length)
    ];

    score = complianceChecks.filter(check => check).length;
    return calculatePercentage(score, complianceChecks.length);
  };

  // 3. Data Quality
  const calculateDataQuality = () => {
    let qualityScore = 0;
    const totalChecks = 5;

    // Check for proper date formats
    const hasValidDates = ['doc_created_date', 'doc_published_date', 'project_start_date', 'project_end_date']
      .every(dateField => {
        if (!metadata[dateField]) return true;
        return metadata[dateField].every(date => !isNaN(Date.parse(date)));
      });
    if (hasValidDates) qualityScore++;

    // Check for entity completeness
    const hasEntities = ['entity_person', 'entity_organization', 'entity_location']
      .some(entityField => metadata[entityField]?.length > 0);
    if (hasEntities) qualityScore++;

    // Check for topics
    if (metadata.topics?.length > 0) qualityScore++;

    // Check for consistent organization naming
    const orgNames = [
      ...(metadata.organization_created_by || []),
      ...(metadata.organization_created_for || []),
      ...(metadata.publisher || [])
    ];
    const hasConsistentOrgNames = new Set(orgNames.map(name => name.toLowerCase())).size === new Set(orgNames).size;
    if (hasConsistentOrgNames) qualityScore++;

    // Check for duplicate topics
    const hasDuplicateTopics = metadata.topics ? 
      new Set(metadata.topics).size === metadata.topics.length : true;
    if (hasDuplicateTopics) qualityScore++;

    return calculatePercentage(qualityScore, totalChecks);
  };

  // 4. Risk Level
  const calculateRiskLevel = () => {
    let riskScore = 0;
    const maxRiskScore = 5;

    // Check for security classifications
    if (!metadata.classification) riskScore++;

    // Check for sensitive security metadata
    if (metadata.security_metadata?.some(meta => 
      meta.toLowerCase().includes('restricted') || 
      meta.toLowerCase().includes('shall not be disclosed'))) {
      riskScore++;
    }

    // Check for sensitive personal information
    if (metadata.entity_person?.length > 0) riskScore++;

    // Check for government data
    if (metadata.sector_industry?.includes('government')) riskScore++;

    // Check for missing required security fields
    if (!metadata.security_metadata || !metadata.classification) riskScore++;

    return calculatePercentage(riskScore, maxRiskScore);
  };

  return {
    metadataCompleteness: calculateMetadataCompleteness(),
    complianceStatus: calculateComplianceStatus(),
    dataQuality: calculateDataQuality(),
    riskLevel: calculateRiskLevel()
  };
};

// Example usage with your metadata
const requiredFields = [
  "caption", "classification", "data_domain", "doc_author",
  "doc_created_date", "doc_published_date", "entity_date",
  "entity_event", "entity_location", "entity_organization",
  "entity_person", "entity_product_service", "entity_technology",
  "extracted_domain", "governance_metadata", "organization_created_by",
  "organization_created_for", "organization_names", "processed_date",
  "project_end_date", "project_name_created_for", "project_start_date",
  "publisher", "sector_industry", "security_metadata", "submitted_to",
  "summary", "topics", "version"
];

// Example metadata object (your provided metadata)
const metadata = {
  "doc_created_date": ["2021-02-23T00:00:00.000Z"],
  // ... rest of your metadata
};

const metrics = calculateGovernanceMetrics(metadata, requiredFields);
console.log(metrics);