Assignment Grader

// Define a comprehensive rubric
const rubricDefinition = {
  criteria: [
    {
      pointsPossible: 25,
      title: "Thesis Statement",
      description: "Clear, arguable thesis that addresses the prompt"
    },
    {
      pointsPossible: 30,
      title: "Evidence and Analysis",
      description: "Strong evidence with thorough analysis"
    },
    {
      pointsPossible: 25,
      title: "Organization",
      description: "Logical structure with smooth transitions"
    },
    {
      pointsPossible: 20,
      title: "Writing Mechanics",
      description: "Grammar, spelling, and citation format"
    }
  ],
  assignmentContent: "Optional — source material or reading passage" // Optional
};

// Total points: 100

# Define a comprehensive rubric
rubric_definition = {
    "criteria": [
        {
            "pointsPossible": 25,
            "title": "Thesis Statement",
            "description": "Clear, arguable thesis that addresses the prompt"
        },
        {
            "pointsPossible": 30,
            "title": "Evidence and Analysis",
            "description": "Strong evidence with thorough analysis"
        },
        {
            "pointsPossible": 25,
            "title": "Organization",
            "description": "Logical structure with smooth transitions"
        },
        {
            "pointsPossible": 20,
            "title": "Writing Mechanics",
            "description": "Grammar, spelling, and citation format"
        }
    ],
    "assignmentContent": "Optional — source material or reading passage"  # Optional
}

# Total points: 100

import com.studyfetch.javasdk.models.v1.assignmentgrader.AssignmentGraderCreateParams;
import com.studyfetch.javasdk.models.v1.assignmentgrader.rubrictemplates.RubricCriterion;

// Define a comprehensive rubric
AssignmentGraderCreateParams.Rubric rubricDefinition = AssignmentGraderCreateParams.Rubric.builder()
    .addCriterion(RubricCriterion.builder()
        .pointsPossible(25.0)
        .title("Thesis Statement")
        .description("Clear, arguable thesis that addresses the prompt")
        .build())
    .addCriterion(RubricCriterion.builder()
        .pointsPossible(30.0)
        .title("Evidence and Analysis")
        .description("Strong evidence with thorough analysis")
        .build())
    .addCriterion(RubricCriterion.builder()
        .pointsPossible(25.0)
        .title("Organization")
        .description("Logical structure with smooth transitions")
        .build())
    .addCriterion(RubricCriterion.builder()
        .pointsPossible(20.0)
        .title("Writing Mechanics")
        .description("Grammar, spelling, and citation format")
        .build())
    .assignmentContent("Optional — source material or reading passage") // Optional
    .build();

// Total points: 100

using StudyfetchSDK.Models.V1.AssignmentGrader.AssignmentGraderCreateParamsProperties;
using StudyfetchSDK.Models.V1.AssignmentGrader.RubricTemplates;
using System.Collections.Generic;

// Define a comprehensive rubric
var rubricDefinition = new Rubric()
{
    Criteria = new List<RubricCriterion>
    {
        new RubricCriterion()
        {
            PointsPossible = 25,
            Title = "Thesis Statement",
            Description = "Clear, arguable thesis that addresses the prompt"
        },
        new RubricCriterion()
        {
            PointsPossible = 30,
            Title = "Evidence and Analysis",
            Description = "Strong evidence with thorough analysis"
        },
        new RubricCriterion()
        {
            PointsPossible = 25,
            Title = "Organization",
            Description = "Logical structure with smooth transitions"
        },
        new RubricCriterion()
        {
            PointsPossible = 20,
            Title = "Writing Mechanics",
            Description = "Grammar, spelling, and citation format"
        }
    },
    AssignmentContent = "Optional — source material or reading passage" // Optional
};

// Total points: 100

import StudyfetchSDK from '@studyfetch/sdk';

const client = new StudyfetchSDK({
  apiKey: 'your-api-key',
  baseURL: 'https://studyfetchapi.com',
});

// Use the rubric definition from above
const params = {
  title: "Essay on Climate Change",
  textToGrade: "Student essay content here...",
  rubric: rubricDefinition,           // Optional: Custom rubric definition
  rubricTemplateId: "template-123",   // Optional: Use existing rubric template
  assignmentContent: "The source material or reading passage students were given...", // Optional: Reference material for grading
  assignmentId: "assign-456",         // Optional: Group submissions
  studentIdentifier: "[email protected]", // Optional: Student email or ID
  userId: "student123",               // Optional: For tracking
  model: "gpt-4.1-2025-04-14"         // Optional: AI model to use
};

const result = await client.v1.assignmentGrader.create(params);

console.log(`Success: ${result.success}`);
console.log(`Grade: ${result.gradedAssignment?.grade || 0}/100`);
console.log(`Assignment ID: ${result.gradedAssignment?._id}`);

from studyfetch_sdk import StudyfetchSDK

client = StudyfetchSDK(
    api_key="your-api-key",
    base_url="https://studyfetchapi.com",
)

# Use the rubric definition from above
params = {
    "title": "Essay on Climate Change",
    "textToGrade": "Student essay content here...",
    "rubric": rubric_definition,           # Optional: Custom rubric definition
    "rubricTemplateId": "template-123",    # Optional: Use existing rubric template
    "assignmentContent": "The source material or reading passage students were given...",  # Optional: Reference material for grading
    "assignmentId": "assign-456",          # Optional: Group submissions
    "studentIdentifier": "[email protected]",  # Optional: Student email or ID
    "userId": "student123",                # Optional: For tracking
    "model": "gpt-4.1-2025-04-14"          # Optional: AI model to use
}

result = client.v1.assignment_grader.create(params)

print(f"Grade: {result.grade}/100")

import com.studyfetch.javasdk.client.StudyfetchSdkClient;
import com.studyfetch.javasdk.client.okhttp.StudyfetchSdkOkHttpClient;
import com.studyfetch.javasdk.models.v1.assignmentgrader.AssignmentGraderCreateParams;
import com.studyfetch.javasdk.models.v1.assignmentgrader.AssignmentGraderCreateResponse;

StudyfetchSdkClient client = StudyfetchSdkOkHttpClient.builder()
    .apiKey("your-api-key")
    .baseUrl("https://studyfetchapi.com")
    .build();

// Use the rubric definition from above
AssignmentGraderCreateParams params = AssignmentGraderCreateParams.builder()
    .title("Essay on Climate Change")
    .textToGrade("Student essay content here...")
    .rubric(rubricDefinition)           // Optional: Custom rubric definition
    .rubricTemplateId("template-123")   // Optional: Use existing rubric template
    .assignmentContent("The source material or reading passage students were given...") // Optional: Reference material for grading
    .assignmentId("assign-456")         // Optional: Group submissions
    .studentIdentifier("[email protected]") // Optional: Student email or ID
    .userId("student123")               // Optional: For tracking
    .model("gpt-4.1-2025-04-14")        // Optional: AI model to use
    .build();

AssignmentGraderCreateResponse result = client.v1().assignmentGrader().create(params);

System.out.println("Success: " + result.success());
if (result.gradedAssignment().isPresent()) {
    System.out.println("Grade: " + result.gradedAssignment().get().grade() + "/100");
    System.out.println("Assignment ID: " + result.gradedAssignment().get()._id());
}

using StudyfetchSDK;
using StudyfetchSDK.Models.V1.AssignmentGrader;
using System;
using System.Threading.Tasks;

public class CreateAssignmentGrader
{
    public static async Task GradeAssignment()
    {
        var client = new StudyfetchSDKClient()
        {
            APIKey = Environment.GetEnvironmentVariable("STUDYFETCH_API_KEY"),
            BaseUrl = new Uri("https://studyfetchapi.com")
        };

        // Use the rubric definition from above
        var params_ = new AssignmentGraderCreateParams()
        {
            Title = "Essay on Climate Change",
            TextToGrade = "Student essay content here...",
            Rubric = rubricDefinition,           // Optional: Custom rubric definition
            RubricTemplateID = "template-123",   // Optional: Use existing rubric template
            AssignmentContent = "The source material or reading passage students were given...", // Optional: Reference material for grading
            AssignmentID = "assign-456",         // Optional: Group submissions
            StudentIdentifier = "[email protected]", // Optional: Student email or ID
            UserID = "student123",               // Optional: For tracking
            Model = "gpt-4.1-2025-04-14"         // Optional: AI model to use
        };

        var result = await client.V1.AssignmentGrader.Create(params_);

        Console.WriteLine($"Success: {result.Success}");
        Console.WriteLine($"Grade: {result.GradedAssignment?.Grade ?? 0}/100");
        Console.WriteLine($"Assignment ID: {result.GradedAssignment?._ID}");
    }
}

const graders = await client.v1.assignmentGrader.getAll();

graders.forEach(grader => {
  console.log(`ID: ${grader._id}`);
  console.log(`Title: ${grader.title}`);
  console.log(`Grade: ${grader.grade}`);
  console.log(`Created: ${grader.createdAt}`);
  console.log(`Assignment ID: ${grader.assignmentId}`);
  console.log(`Student: ${grader.studentIdentifier}`);
});

graders = client.v1.assignment_grader.get_all()

for grader in graders:
    print(f"Title: {grader.title}")
    print(f"Grade: {grader.grade}")
    print(f"Created: {grader.created_at}")
    print(f"Assignment ID: {grader.assignment_id}")
    print(f"Student: {grader.student_identifier}")

import com.studyfetch.javasdk.models.v1.assignmentgrader.AssignmentGraderResponse;

List<AssignmentGraderResponse> graders = client.v1().assignmentGrader().getAll();

for (AssignmentGraderResponse grader : graders) {
    System.out.println("ID: " + grader._id());
    System.out.println("Title: " + grader.title());
    System.out.println("Grade: " + grader.grade());
    System.out.println("Created: " + grader.createdAt());
    System.out.println("Assignment ID: " + grader.assignmentId());
    System.out.println("Student: " + grader.studentIdentifier());
}

using StudyfetchSDK;
using StudyfetchSDK.Models.V1.AssignmentGrader;
using System;
using System.Threading.Tasks;

public class GetAllGraders
{
    public static async Task GetAll()
    {
        var client = new StudyfetchSDKClient()
        {
            APIKey = Environment.GetEnvironmentVariable("STUDYFETCH_API_KEY"),
            BaseUrl = new Uri("https://studyfetchapi.com")
        };

        var graders = await client.V1.AssignmentGrader.GetAll(new());

        foreach (var grader in graders)
        {
            Console.WriteLine($"ID: {grader._ID}");
            Console.WriteLine($"Title: {grader.Title}");
            Console.WriteLine($"Grade: {grader.Grade}");
            Console.WriteLine($"Created: {grader.CreatedAt}");
            Console.WriteLine($"Assignment ID: {grader.AssignmentID}");
            Console.WriteLine($"Student: {grader.StudentIdentifier}");
        }
    }
}

const graderId = "grader_123456";
const grader = await client.v1.assignmentGrader.getByID(graderId);

console.log(`ID: ${grader._id}`);
console.log(`Assignment: ${grader.title}`);
console.log(`Grade: ${grader.grade}/100`);
console.log(`Student: ${grader.studentIdentifier}`);
console.log(`Assignment ID: ${grader.assignmentId}`);

grader_id = "grader_123456"
grader = client.v1.assignment_grader.get_by_id(grader_id)

print(f"Assignment: {grader.title}")
print(f"Grade: {grader.grade}/100")
print(f"Student: {grader.student_identifier}")
print(f"Assignment ID: {grader.assignment_id}")

import com.studyfetch.javasdk.models.v1.assignmentgrader.AssignmentGraderGetByIdParams;
import com.studyfetch.javasdk.models.v1.assignmentgrader.AssignmentGraderResponse;

String graderId = "grader_123456";
AssignmentGraderResponse grader = client.v1().assignmentGrader().getById(
    AssignmentGraderGetByIdParams.builder()
        .id(graderId)
        .build()
);

System.out.println("ID: " + grader._id());
System.out.println("Assignment: " + grader.title());
System.out.println("Grade: " + grader.grade() + "/100");
System.out.println("Student: " + grader.studentIdentifier());
System.out.println("Assignment ID: " + grader.assignmentId());

using StudyfetchSDK;
using StudyfetchSDK.Models.V1.AssignmentGrader;
using System;
using System.Threading.Tasks;

public class GetGraderById
{
    public static async Task GetById()
    {
        var client = new StudyfetchSDKClient()
        {
            APIKey = Environment.GetEnvironmentVariable("STUDYFETCH_API_KEY"),
            BaseUrl = new Uri("https://studyfetchapi.com")
        };

        string graderID = "grader_123456";
        var grader = await client.V1.AssignmentGrader.GetByID(new()
        {
            ID = graderID
        });

        Console.WriteLine($"ID: {grader._ID}");
        Console.WriteLine($"Assignment: {grader.Title}");
        Console.WriteLine($"Grade: {grader.Grade}/100");
        Console.WriteLine($"Student: {grader.StudentIdentifier}");
        Console.WriteLine($"Assignment ID: {grader.AssignmentID}");
    }
}

const graderId = "grader_123456";
await client.v1.assignmentGrader.delete(graderId);
console.log("Assignment grader deleted successfully");

grader_id = "grader_123456"
client.v1.assignment_grader.delete(grader_id)
print("Assignment grader deleted successfully")

String graderId = "grader_123456";
client.v1().assignmentGrader().delete(graderId);
System.out.println("Assignment grader deleted successfully");

using StudyfetchSDK;
using System;
using System.Threading.Tasks;

public class DeleteGrader
{
    public static async Task Delete()
    {
        var client = new StudyfetchSDKClient()
        {
            APIKey = Environment.GetEnvironmentVariable("STUDYFETCH_API_KEY"),
            BaseUrl = new Uri("https://studyfetchapi.com")
        };

        string graderID = "grader_123456";
        await client.V1.AssignmentGrader.Delete(new()
        {
            ID = graderID
        });
        Console.WriteLine("Assignment grader deleted successfully");
    }
}

const assignmentId = "assign-456";
const report = await client.v1.assignmentGrader.generateReport(assignmentId);

console.log("Assignment Report:");
console.log(`Title: ${report.title}`);
console.log(`Total Submissions: ${report.totalSubmissions}`);
console.log(`Average Grade: ${report.statistics.averageGrade}`);
console.log(`Max Grade: ${report.statistics.maxGrade}`);
console.log(`Min Grade: ${report.statistics.minGrade}`);
console.log(`Standard Deviation: ${report.statistics.standardDeviation}`);

// Grade distribution
console.log("Grade Distribution:");
console.log(`  A (90-100): ${report.gradeDistribution.A}`);
console.log(`  B (80-89): ${report.gradeDistribution.B}`);
console.log(`  C (70-79): ${report.gradeDistribution.C}`);
console.log(`  D (60-69): ${report.gradeDistribution.D}`);
console.log(`  F (0-59): ${report.gradeDistribution.F}`);

// Top performing criteria
console.log("Strengths:");
report.strengths.forEach(strength => {
  console.log(`  ${strength.title}: ${strength.avgScore}/${strength.maxPossible} (${strength.performanceRatio})`);
});

// Criteria needing improvement
console.log("Weaknesses:");
report.weaknesses.forEach(weakness => {
  console.log(`  ${weakness.title}: ${weakness.avgScore}/${weakness.maxPossible} (${weakness.performanceRatio})`);
});

assignment_id = "assign-456"
report = client.v1.assignment_grader.generate_report(assignment_id)

print("Assignment Report:")
print(f"Title: {report.title}")
print(f"Total Submissions: {report.total_submissions}")
print(f"Average Grade: {report.statistics.average_grade}")
print(f"Max Grade: {report.statistics.max_grade}")
print(f"Min Grade: {report.statistics.min_grade}")
print(f"Standard Deviation: {report.statistics.standard_deviation}")

# Grade distribution
print("Grade Distribution:")
print(f"  A (90-100): {report.grade_distribution.A}")
print(f"  B (80-89): {report.grade_distribution.B}")
print(f"  C (70-79): {report.grade_distribution.C}")
print(f"  D (60-69): {report.grade_distribution.D}")
print(f"  F (0-59): {report.grade_distribution.F}")

# Top performing criteria
print("Strengths:")
for strength in report.strengths:
    print(f"  {strength.title}: {strength.avg_score}/{strength.max_possible} ({strength.performance_ratio})")

# Criteria needing improvement
print("Weaknesses:")
for weakness in report.weaknesses:
    print(f"  {weakness.title}: {weakness.avg_score}/{weakness.max_possible} ({weakness.performance_ratio})")

import com.studyfetch.javasdk.models.v1.assignmentgrader.AssignmentGraderGenerateReportResponse;

String assignmentId = "assign-456";
AssignmentGraderGenerateReportResponse report = client.v1().assignmentGrader().generateReport(assignmentId);

System.out.println("Assignment Report:");
System.out.println("Title: " + report.title());
System.out.println("Total Submissions: " + report.totalSubmissions());
System.out.println("Average Grade: " + report.statistics().averageGrade());
System.out.println("Max Grade: " + report.statistics().maxGrade());
System.out.println("Min Grade: " + report.statistics().minGrade());
System.out.println("Standard Deviation: " + report.statistics().standardDeviation());

// Grade distribution
System.out.println("Grade Distribution:");
System.out.println("  A (90-100): " + report.gradeDistribution().a());
System.out.println("  B (80-89): " + report.gradeDistribution().b());
System.out.println("  C (70-79): " + report.gradeDistribution().c());
System.out.println("  D (60-69): " + report.gradeDistribution().d());
System.out.println("  F (0-59): " + report.gradeDistribution().f());

// Top performing criteria
System.out.println("Strengths:");
for (AssignmentGraderGenerateReportResponse.Strength strength : report.strengths()) {
    System.out.println("  " + strength.title() + ": " + strength.avgScore() + "/" + 
                      strength.maxPossible() + " (" + strength.performanceRatio() + ")");
}

// Criteria needing improvement
System.out.println("Weaknesses:");
for (AssignmentGraderGenerateReportResponse.Weakness weakness : report.weaknesses()) {
    System.out.println("  " + weakness.title() + ": " + weakness.avgScore() + "/" + 
                      weakness.maxPossible() + " (" + weakness.performanceRatio() + ")");
}

using StudyfetchSDK;
using StudyfetchSDK.Models.V1.AssignmentGrader;
using System;
using System.Threading.Tasks;

public class GenerateReport
{
    public static async Task GenerateEducatorReport()
    {
        var client = new StudyfetchSDKClient()
        {
            APIKey = Environment.GetEnvironmentVariable("STUDYFETCH_API_KEY"),
            BaseUrl = new Uri("https://studyfetchapi.com")
        };

        string assignmentID = "assign-456";
        var report = await client.V1.AssignmentGrader.GenerateReport(new()
        {
            AssignmentID = assignmentID
        });

        Console.WriteLine("Assignment Report:");
        Console.WriteLine($"Title: {report.Title}");
        Console.WriteLine($"Total Submissions: {report.TotalSubmissions}");
        Console.WriteLine($"Average Grade: {report.Statistics.AverageGrade}");
        Console.WriteLine($"Max Grade: {report.Statistics.MaxGrade}");
        Console.WriteLine($"Min Grade: {report.Statistics.MinGrade}");
        Console.WriteLine($"Standard Deviation: {report.Statistics.StandardDeviation}");

        // Grade distribution
        Console.WriteLine("Grade Distribution:");
        Console.WriteLine($"  A (90-100): {report.GradeDistribution.A}");
        Console.WriteLine($"  B (80-89): {report.GradeDistribution.B}");
        Console.WriteLine($"  C (70-79): {report.GradeDistribution.C}");
        Console.WriteLine($"  D (60-69): {report.GradeDistribution.D}");
        Console.WriteLine($"  F (0-59): {report.GradeDistribution.F}");

        // Top performing criteria
        Console.WriteLine("Strengths:");
        foreach (var strength in report.Strengths)
        {
            Console.WriteLine($"  {strength.Title}: {strength.AvgScore}/{strength.MaxPossible} ({strength.PerformanceRatio})");
        }

        // Criteria needing improvement
        Console.WriteLine("Weaknesses:");
        foreach (var weakness in report.Weaknesses)
        {
            Console.WriteLine($"  {weakness.Title}: {weakness.AvgScore}/{weakness.MaxPossible} ({weakness.PerformanceRatio})");
        }
    }
}

const templateParams = {
  name: "Standard Essay Rubric",
  description: "Basic 100-point essay grading rubric",
  assignmentContent: "Optional — default source material for this template", // Optional: used when no assignmentContent is provided at grading time
  criteria: [
    {
      pointsPossible: 25,
      title: "Thesis Statement",
      description: "Clear, arguable thesis that addresses the prompt"
    },
    {
      pointsPossible: 30,
      title: "Evidence and Analysis",
      description: "Strong evidence with thorough analysis"
    },
    {
      pointsPossible: 25,
      title: "Organization",
      description: "Logical structure with smooth transitions"
    },
    {
      pointsPossible: 20,
      title: "Writing Mechanics",
      description: "Grammar, spelling, and citation format"
    }
  ]
};

const template = await client.v1.assignmentGrader.rubricTemplates.create(templateParams);
console.log(`Template created: ${template._id}`);

template_params = {
    "name": "Standard Essay Rubric",
    "description": "Basic 100-point essay grading rubric",
    "assignmentContent": "Optional — default source material for this template",  # Optional: used when no assignmentContent is provided at grading time
    "criteria": [
        {
            "pointsPossible": 25,
            "title": "Thesis Statement",
            "description": "Clear, arguable thesis that addresses the prompt"
        },
        {
            "pointsPossible": 30,
            "title": "Evidence and Analysis",
            "description": "Strong evidence with thorough analysis"
        },
        {
            "pointsPossible": 25,
            "title": "Organization",
            "description": "Logical structure with smooth transitions"
        },
        {
            "pointsPossible": 20,
            "title": "Writing Mechanics",
            "description": "Grammar, spelling, and citation format"
        }
    ]
}

template = client.v1.assignment_grader.rubric_templates().create(template_params)
print(f"Template created: {template._id}")

RubricTemplateCreateParams templateParams = RubricTemplateCreateParams.builder()
    .name("Standard Essay Rubric")
    .description("Basic 100-point essay grading rubric")
    .assignmentContent("Optional — default source material for this template") // Optional: used when no assignmentContent is provided at grading time
    .addCriterion(RubricTemplateCreateParams.Criterion.builder()
        .pointsPossible(25.0)
        .title("Thesis Statement")
        .description("Clear, arguable thesis that addresses the prompt")
        .build())
    .addCriterion(RubricTemplateCreateParams.Criterion.builder()
        .pointsPossible(30.0)
        .title("Evidence and Analysis")
        .description("Strong evidence with thorough analysis")
        .build())
    .addCriterion(RubricTemplateCreateParams.Criterion.builder()
        .pointsPossible(25.0)
        .title("Organization")
        .description("Logical structure with smooth transitions")
        .build())
    .addCriterion(RubricTemplateCreateParams.Criterion.builder()
        .pointsPossible(20.0)
        .title("Writing Mechanics")
        .description("Grammar, spelling, and citation format")
        .build())
    .build();

RubricTemplateCreateResponse template = client.v1().assignmentGrader()
    .rubricTemplates().create(templateParams);
System.out.println("Template created: " + template._id());

using StudyfetchSDK;
using StudyfetchSDK.Models.V1.AssignmentGrader;
using StudyfetchSDK.Models.V1.AssignmentGrader.RubricTemplates;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class CreateRubricTemplate
{
    public static async Task CreateTemplate()
    {
        var client = new StudyfetchSDKClient()
        {
            APIKey = Environment.GetEnvironmentVariable("STUDYFETCH_API_KEY"),
            BaseUrl = new Uri("https://studyfetchapi.com")
        };

        var templateParams = new RubricTemplateCreateParams()
        {
            Name = "Standard Essay Rubric",
            Description = "Basic 100-point essay grading rubric",
            AssignmentContent = "Optional — default source material for this template", // Optional: used when no assignmentContent is provided at grading time
            Criteria = new List<RubricCriterion>
            {
                new RubricCriterion()
                {
                    PointsPossible = 25,
                    Title = "Thesis Statement",
                    Description = "Clear, arguable thesis that addresses the prompt"
                },
                new RubricCriterion()
                {
                    PointsPossible = 30,
                    Title = "Evidence and Analysis",
                    Description = "Strong evidence with thorough analysis"
                },
                new RubricCriterion()
                {
                    PointsPossible = 25,
                    Title = "Organization",
                    Description = "Logical structure with smooth transitions"
                },
                new RubricCriterion()
                {
                    PointsPossible = 20,
                    Title = "Writing Mechanics",
                    Description = "Grammar, spelling, and citation format"
                }
            }
        };

        var template = await client.V1.AssignmentGrader.RubricTemplates.Create(templateParams);
        Console.WriteLine($"Template created: {template._ID}");
    }
}

const templates = await client.v1.assignmentGrader.rubricTemplates.list();

templates.forEach(template => {
  console.log(`Name: ${template.name}`);
  console.log(`Description: ${template.description}`);
  console.log(`Created: ${template.createdAt}`);
});

templates = client.v1.assignment_grader.rubric_templates().list()

for template in templates:
    print(f"Name: {template.name}")
    print(f"Description: {template.description}")
    print(f"Created: {template.created_at}")

import com.studyfetch.javasdk.models.v1.assignmentgrader.rubrictemplates.RubricTemplateListParams;
import com.studyfetch.javasdk.models.v1.assignmentgrader.rubrictemplates.RubricTemplateListResponse;

List<RubricTemplateListResponse> templates = client.v1().assignmentGrader()
    .rubricTemplates().list(
        RubricTemplateListParams.builder()
            .build()
    );

for (RubricTemplateListResponse template : templates) {
    System.out.println("Name: " + template.name());
    System.out.println("Description: " + template.description());
    System.out.println("Created: " + template.createdAt());
}

using StudyfetchSDK;
using StudyfetchSDK.Models.V1.AssignmentGrader;
using System;
using System.Threading.Tasks;

public class ListRubricTemplates
{
    public static async Task ListTemplates()
    {
        var client = new StudyfetchSDKClient()
        {
            APIKey = Environment.GetEnvironmentVariable("STUDYFETCH_API_KEY"),
            BaseUrl = new Uri("https://studyfetchapi.com")
        };

        var templates = await client.V1.AssignmentGrader.RubricTemplates.List();

        foreach (var template in templates)
        {
            Console.WriteLine($"Name: {template.Name}");
            Console.WriteLine($"Description: {template.Description}");
            Console.WriteLine($"Created: {template.CreatedAt}");
        }
    }
}

const templateId = "template-123";
const template = await client.v1.assignmentGrader.rubricTemplates.getByID(templateId);

console.log(`Template: ${template.name}`);
console.log(`Description: ${template.description}`);
console.log(`Criteria:`, template.criteria);

template_id = "template-123"
template = client.v1.assignment_grader.rubric_templates().get_by_id(template_id)

print(f"Template: {template.name}")
print(f"Description: {template.description}")
print(f"Criteria: {template.criteria}")

import com.studyfetch.javasdk.models.v1.assignmentgrader.rubrictemplates.RubricTemplateGetByIdParams;
import com.studyfetch.javasdk.models.v1.assignmentgrader.rubrictemplates.RubricTemplateGetByIdResponse;

String templateId = "template-123";
RubricTemplateGetByIdResponse template = client.v1().assignmentGrader()
    .rubricTemplates().getById(
        RubricTemplateGetByIdParams.builder()
            .id(templateId)
            .build()
    );

System.out.println("Template: " + template.name());
System.out.println("Description: " + template.description());
System.out.println("Criteria: " + template.criteria());

using StudyfetchSDK;
using StudyfetchSDK.Models.V1.AssignmentGrader;
using System;
using System.Threading.Tasks;

public class GetRubricTemplateById
{
    public static async Task GetTemplateById()
    {
        var client = new StudyfetchSDKClient()
        {
            APIKey = Environment.GetEnvironmentVariable("STUDYFETCH_API_KEY"),
            BaseUrl = new Uri("https://studyfetchapi.com")
        };

        string templateID = "template-123";
        var template = await client.V1.AssignmentGrader.RubricTemplates.GetByID(new()
        {
            ID = templateID
        });

        Console.WriteLine($"Template: {template.Name}");
        Console.WriteLine($"Description: {template.Description}");
        Console.WriteLine($"Criteria: {template.Criteria}");
    }
}

const templateId = "template-123";
await client.v1.assignmentGrader.rubricTemplates.delete(templateId);
console.log("Rubric template deleted successfully");

template_id = "template-123"
client.v1.assignment_grader.rubric_templates().delete(template_id)
print("Rubric template deleted successfully")

String templateId = "template-123";
client.v1().assignmentGrader().rubricTemplates().delete(templateId);
System.out.println("Rubric template deleted successfully");

using StudyfetchSDK;
using System;
using System.Threading.Tasks;
using StudyfetchSDK.Models.V1.AssignmentGrader.RubricTemplates;

public class DeleteRubricTemplate
{
    public static async Task DeleteTemplate()
    {
        var client = new StudyfetchSDKClient()
        {
            APIKey = Environment.GetEnvironmentVariable("STUDYFETCH_API_KEY"),
            BaseUrl = new Uri("https://studyfetchapi.com")
        };

        string templateID = "template-123";
        await client.V1.AssignmentGrader.RubricTemplates.Delete(new()
        {
            ID = templateID
        });
        Console.WriteLine("Rubric template deleted successfully");
    }
}

// First upload the assignment as a material
const material = await client.v1.materials.create({
  name: "Student Essay - John Doe",
  content: {
    type: "pdf",
    file: studentEssayFile
  },
  references: [
    {
      title: 'Assignment Instructions',
      url: 'https://example.com/assignment-instructions'
    }
  ] // Optional: source references
});

// Wait for material to finish processing
let materialStatus = 'processing';
while (materialStatus !== 'active') {
  const updatedMaterial = await client.v1.materials.retrieve(material._id);
  materialStatus = updatedMaterial.status;
  if (materialStatus === 'error') {
    throw new Error('Material processing failed');
  }
  if (materialStatus === 'processing') {
    await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2 seconds
  }
}

// Then grade using the material ID
const gradeResult = await client.v1.assignmentGrader.create({
  rubric: rubricDefinition,
  title: "Essay Assignment",
  materialId: material._id,
  assignmentId: "assign-456",
  studentIdentifier: "[email protected]"
});

import time

# First upload the assignment as a material
material = client.v1.materials.create({
    "name": "Student Essay - John Doe",
    "content": {
        "type": "pdf",
        "file": student_essay_file
    },
    "references": [
        {
            "title": "Assignment Instructions",
            "url": "https://example.com/assignment-instructions"
        }
    ]  # Optional: source references
})

# Wait for material to finish processing
material_status = "processing"
while material_status != "active":
    updated_material = client.v1.materials.retrieve(material["_id"])
    material_status = updated_material.status
    if material_status == "error":
        raise Exception("Material processing failed")
    if material_status == "processing":
        time.sleep(2)  # Wait 2 seconds

# Then grade using the material ID
grade_result = client.v1.assignment_grader.create({
    "rubric": rubric_definition,
    "title": "Essay Assignment",
    "materialId": material["_id"],
    "assignmentId": "assign-456",
    "studentIdentifier": "[email protected]"
})

import com.studyfetch.javasdk.models.v1.materials.upload.UploadUploadFileParams;
import com.studyfetch.javasdk.models.v1.materials.MaterialResponse;
import com.studyfetch.javasdk.models.v1.materials.MaterialRetrieveParams;
import java.io.File;
import java.io.FileInputStream;

// First upload the assignment as a material
File studentEssayFile = new File("student-essay.pdf");
UploadUploadFileParams uploadParams = UploadUploadFileParams.builder()
    .file(new FileInputStream(studentEssayFile))
    .name("Student Essay - John Doe")
    .build();
MaterialResponse material = client.v1().materials().upload().uploadFile(uploadParams);

// Wait for material to finish processing
MaterialResponse.Status status = MaterialResponse.Status.PROCESSING;
while (status.equals(MaterialResponse.Status.PROCESSING)) {
    Thread.sleep(2000); // Wait 2 seconds
    MaterialResponse updatedMaterial = client.v1().materials().retrieve(
        MaterialRetrieveParams.builder()
            .id(material._id())
            .build()
    );
    status = updatedMaterial.status();
    if (status.equals(MaterialResponse.Status.ERROR)) {
        throw new Exception("Material processing failed");
    }
}

// Then grade using the material ID
AssignmentGraderCreateParams gradeParams = AssignmentGraderCreateParams.builder()
    .rubric(rubricDefinition)
    .title("Essay Assignment")
    .materialId(material._id())
    .assignmentId("assign-456")
    .studentIdentifier("[email protected]")
    .build();
AssignmentGraderCreateResponse gradeResult = client.v1().assignmentGrader().create(gradeParams);