+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
import * as React from "react"; +import "./FlashcardForm.css"; + +export default function FlashcardForm({ onAdd }: { onAdd: Function }) { + // Estado para armazenar o texto da frente do card + const [front, setFront] = React.useState(""); + + // Estado para armazenar o texto do verso do card + const [back, setBack] = React.useState(""); + + // Estado para controlar se está enviando o formulário + const [isSubmitting, setIsSubmitting] = React.useState(false); + + // Função que adiciona um novo flashcard + const handleSubmit = (e: React.FormEvent) => { + e.preventDefault(); + Iif (!front.trim() || !back.trim()) return; + + setIsSubmitting(true); + onAdd(front, back); + setFront(""); + setBack(""); + setIsSubmitting(false); + }; + + // Verifica se os campos estão preenchidos + const isValid = front.trim().length > 0 && back.trim().length > 0; + + return ( + <form onSubmit={handleSubmit} className="flashcard-form"> + <div className="form-container"> + <h3 className="form-title">📝 Criar Novo Flashcard</h3> + + {/* Campo para a frente do card */} + <div className="form-group"> + <label htmlFor="front">Frente (Pergunta)</label> + <input + id="front" + type="text" + placeholder="Ex: O que é recursão?" + value={front} + onChange={(e) => setFront(e.target.value)} + maxLength={200} + /> + {/* Contador de caracteres */} + <span className="char-count">{front.length}/200</span> + </div> + + {/* Campo para o verso do card */} + <div className="form-group"> + <label htmlFor="back">Verso (Resposta)</label> + <input + id="back" + type="text" + placeholder="Ex: Uma função que chama a si mesma..." + value={back} + onChange={(e) => setBack(e.target.value)} + maxLength={200} + /> + {/* Contador de caracteres */} + <span className="char-count">{back.length}/200</span> + </div> + + {/* Botão para adicionar o flashcard */} + <button + type="submit" + className="btn-submit" + disabled={!isValid || isSubmitting} + > + {isSubmitting ? "Adicionando..." : "✨ Adicionar Flashcard"} + </button> + </div> + </form> + ); +} + +export {};
export class FlashcardService { + private baseUrl = "http://localhost:3005/api/flashcards"; + + async getAll() { + try { + const res = await fetch(this.baseUrl); + if (!res.ok) { + throw new Error(`HTTP error! status: ${res.status}`); + } + const text = await res.text(); + if (!text) { + return []; + } + return JSON.parse(text); + } catch (error) { + console.error("Error fetching flashcards:", error); + throw error; + } + } + + async add(front: string, back: string) { + try { + const res = await fetch(this.baseUrl, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ front, back }), + }); + if (!res.ok) { + throw new Error(`HTTP error! status: ${res.status}`); + } + const text = await res.text(); + if (!text) { + return null; + } + return JSON.parse(text); + } catch (error) { + console.error("Error adding flashcard:", error); + throw error; + } + } + + async delete(id: number) { + try { + const res = await fetch(`${this.baseUrl}/${id}`, { + method: "DELETE", + }); + if (!res.ok) { + throw new Error(`HTTP error! status: ${res.status}`); + } + const text = await res.text(); + if (!text) { + return { success: true }; + } + return JSON.parse(text); + } catch (error) { + console.error("Error deleting flashcard:", error); + throw error; + } + } +} + +export {}; +
Loading students...
Aprenda e memorize com flashcards interativos
Comece adicionando seu primeiro flashcard acima!
{fc.front}
{fc.back}
import { Student } from './Student'; +import { Enrollment } from './Enrollment'; + +export class Class { + private topic: string; + private semester: number; + private year: number; + private enrollments: Enrollment[]; + + constructor(topic: string, semester: number, year: number, enrollments: Enrollment[] = []) { + this.topic = topic; + this.semester = semester; + this.year = year; + this.enrollments = enrollments; + } + + + getTopic(): string { + return this.topic; + } + + getSemester(): number { + return this.semester; + } + + getYear(): number { + return this.year; + } + + getEnrollments(): Enrollment[] { + return [...this.enrollments]; + } + + + getClassId(): string { + return `${this.topic}-${this.year}-${this.semester}`; + } + + + setTopic(topic: string): void { + this.topic = topic; + } + + setSemester(semester: number): void { + this.semester = semester; + } + + setYear(year: number): void { + this.year = year; + } + + + addEnrollment(student: Student): Enrollment { + + const existingEnrollment = this.findEnrollmentByStudentCPF(student.getCPF()); + if (existingEnrollment) { + throw new Error('Student is already enrolled in this class'); + } + + const enrollment = new Enrollment(student); + this.enrollments.push(enrollment); + return enrollment; + } + + removeEnrollment(studentCPF: string): boolean { + const index = this.enrollments.findIndex(enrollment => + enrollment.getStudent().getCPF() === studentCPF + ); + + if (index === -1) { + return false; + } + + this.enrollments.splice(index, 1); + return true; + } + + findEnrollmentByStudentCPF(studentCPF: string): Enrollment | undefined { + return this.enrollments.find(enrollment => + enrollment.getStudent().getCPF() === studentCPF + ); + } + + + getEnrolledStudents(): Student[] { + return this.enrollments.map(enrollment => enrollment.getStudent()); + } + + + toJSON() { + return { + id: this.getClassId(), + topic: this.topic, + semester: this.semester, + year: this.year, + enrollments: this.enrollments.map(enrollment => enrollment.toJSON()) + }; + } + + + static fromJSON(data: { topic: string; semester: number; year: number; enrollments: any[] }, allStudents: Student[]): Class { + const enrollments = data.enrollments + ? data.enrollments.map((enrollmentData: any) => { + const student = allStudents.find(s => s.getCPF() === enrollmentData.student.cpf); + if (!student) { + throw new Error(`Student with CPF ${enrollmentData.student.cpf} not found`); + } + return Enrollment.fromJSON(enrollmentData, student); + }) + : []; + + return new Class(data.topic, data.semester, data.year, enrollments); + } +}
import { Class } from './Class'; +import { Student } from './Student'; + +export class Classes { + private classes: Class[] = []; + + constructor() { + + } + + + addClass(classObj: Class): Class { + + if (this.findClassById(classObj.getClassId())) { + throw new Error('Class with same topic, year, and semester already exists'); + } + + this.classes.push(classObj); + return classObj; + } + + + removeClass(classId: string): boolean { + const index = this.classes.findIndex(c => c.getClassId() === classId); + + if (index === -1) { + return false; + } + + this.classes.splice(index, 1); + return true; + } + + + updateClass(updatedClass: Class): Class { + const existingClass = this.findClassById(updatedClass.getClassId()); + + if (!existingClass) { + throw new Error('Class not found'); + } + + + existingClass.setTopic(updatedClass.getTopic()); + existingClass.setSemester(updatedClass.getSemester()); + existingClass.setYear(updatedClass.getYear()); + + + const updatedEnrollments = updatedClass.getEnrollments(); + const existingEnrollments = existingClass.getEnrollments(); + + + updatedEnrollments.forEach(updatedEnrollment => { + const studentCPF = updatedEnrollment.getStudent().getCPF(); + const existingEnrollment = existingClass.findEnrollmentByStudentCPF(studentCPF); + + if (existingEnrollment) { + + const updatedEvaluations = updatedEnrollment.getEvaluations(); + updatedEvaluations.forEach(evaluation => { + existingEnrollment.addOrUpdateEvaluation(evaluation.getGoal(), evaluation.getGrade()); + }); + } else { + + try { + existingClass.addEnrollment(updatedEnrollment.getStudent()); + const newEnrollment = existingClass.findEnrollmentByStudentCPF(studentCPF); + if (newEnrollment) { + + const updatedEvaluations = updatedEnrollment.getEvaluations(); + updatedEvaluations.forEach(evaluation => { + newEnrollment.addOrUpdateEvaluation(evaluation.getGoal(), evaluation.getGrade()); + }); + } + } catch (error) { + + console.warn(`Could not add enrollment for student ${studentCPF}: ${error}`); + } + } + }); + + return existingClass; + } + + + findClassById(classId: string): Class | undefined { + return this.classes.find(c => c.getClassId() === classId); + } + + + getAllClasses(): Class[] { + return [...this.classes]; + } + + + getCount(): number { + return this.classes.length; + } + + + findClassesByYear(year: number): Class[] { + return this.classes.filter(c => c.getYear() === year); + } + + + findClassesByTopic(topic: string): Class[] { + return this.classes.filter(c => c.getTopic().toLowerCase().includes(topic.toLowerCase())); + } + + + getAllEnrolledStudents(): Student[] { + const students: Student[] = []; + const seenCPFs = new Set<string>(); + + this.classes.forEach(classObj => { + classObj.getEnrolledStudents().forEach(student => { + if (!seenCPFs.has(student.getCPF())) { + seenCPFs.add(student.getCPF()); + students.push(student); + } + }); + }); + + return students; + } +}
import { Student } from './Student'; +import { Evaluation } from './Evaluation'; + +export class Enrollment { + private student: Student; + private evaluations: Evaluation[]; + private mediaPreFinal: number | null; + private mediaPosFinal: number | null; + private reprovadoPorFalta: Boolean; + + constructor(student: Student, evaluations: Evaluation[] = [], mediaPreFinal: number | null = null, mediaPosFinal: number | null = null, reprovadoPorFalta: Boolean = false) { + this.student = student; + this.evaluations = evaluations; + this.mediaPreFinal = mediaPreFinal; + this.mediaPosFinal = mediaPosFinal; + this.reprovadoPorFalta = reprovadoPorFalta; + } + + getStudent(): Student { + return this.student; + } + + getEvaluations(): Evaluation[] { + return [...this.evaluations]; + } + + calculateMediaPreFinal(): number { + throw new Error('calculateMedia() not implemented yet'); + } + + + calculateMediaPosFinal(): number { + throw new Error('calculateMedia() not implemented yet'); + } + + + getMediaPreFinal(): number | null { + return this.mediaPreFinal; + } + + + setMediaPreFinal(mediaPreFinal: number){ + this.mediaPreFinal = mediaPreFinal; + } + + + getMediaPosFinal(): number | null { + return this.mediaPosFinal; + } + + + setMediaPosFinal(mediaPosFinal: number){ + this.mediaPosFinal = mediaPosFinal; + } + + + getReprovadoPorFalta(): Boolean { + return this.reprovadoPorFalta; + } + + + setReprovadoPorFalta(reprovadoPorFalta: Boolean){ + this.reprovadoPorFalta = reprovadoPorFalta; + } + + + addOrUpdateEvaluation(goal: string, grade: 'MANA' | 'MPA' | 'MA'): void { + const existingIndex = this.evaluations.findIndex(evaluation => evaluation.getGoal() === goal); + if (existingIndex >= 0) { + this.evaluations[existingIndex].setGrade(grade); + } else { + this.evaluations.push(new Evaluation(goal, grade)); + } + } + + + removeEvaluation(goal: string): boolean { + const existingIndex = this.evaluations.findIndex(evaluation => evaluation.getGoal() === goal); + if (existingIndex >= 0) { + this.evaluations.splice(existingIndex, 1); + return true; + } + return false; + } + + + getEvaluationForGoal(goal: string): Evaluation | undefined { + return this.evaluations.find(evaluation => evaluation.getGoal() === goal); + } + + + toJSON() { + return { + student: this.student.toJSON(), + evaluations: this.evaluations.map(evaluation => evaluation.toJSON()), + mediaPreFinal: this.mediaPreFinal, + mediaPosFinal: this.mediaPosFinal, + reprovadoPorFalta: this.reprovadoPorFalta + }; + } + + + static fromJSON(data: { + student: any; + evaluations: any[]; + mediaPreFinal?: number; + mediaPosFinal?: number; + reprovadoPorFalta?: boolean; + }, student: Student): Enrollment { + const evaluations = data.evaluations + ? data.evaluations.map((evalData: any) => Evaluation.fromJSON(evalData)) + : []; + + const mediaPreFinal = data.mediaPreFinal ?? 0; + const mediaPosFinal = data.mediaPosFinal ?? 0; + const reprovadoPorFalta = data.reprovadoPorFalta ?? false; + + return new Enrollment(student, evaluations, mediaPreFinal, mediaPosFinal, reprovadoPorFalta); + } +} +
export type Grade = 'MANA' | 'MPA' | 'MA'; + +export class Evaluation { + private goal: string; + private grade: Grade; + + constructor(goal: string, grade: Grade) { + this.goal = goal; + this.grade = grade; + } + + public getGoal(): string { + return this.goal; + } + + public getGrade(): Grade { + return this.grade; + } + + public setGrade(grade: Grade): void { + this.grade = grade; + } + + public toJSON() { + return { + goal: this.goal, + grade: this.grade + }; + } + + public static fromJSON(data: { goal: string; grade: Grade }): Evaluation { + return new Evaluation(data.goal, data.grade); + } +} + +export const EVALUATION_GOALS = [ + 'Requirements', + 'Configuration Management', + 'Project Management', + 'Design', + 'Tests', + 'Refactoring' +] as const;
export class Flashcard { + constructor( + private id: number, + private front: string, + private back: string + ) {} + + getId() { + return this.id; + } + + getFront() { + return this.front; + } + + getBack() { + return this.back; + } + + setFront(front: string) { + this.front = front; + } + + setBack(back: string) { + this.back = back; + } + + toJSON() { + return { + id: this.id, + front: this.front, + back: this.back + }; + } + + static fromJSON(json: any): Flashcard { + return new Flashcard(json.id, json.front, json.back); + } +} +
import { Flashcard } from "./Flashcard"; + +export class FlashcardSet { + private flashcards: Flashcard[] = []; + private nextId = 1; + + getAll() { + return this.flashcards.map(fc => fc.toJSON()); + } + + add(front: string, back: string) { + const flashcard = new Flashcard(this.nextId++, front, back); + this.flashcards.push(flashcard); + return flashcard.toJSON(); + } + + delete(id: number) { + const index = this.flashcards.findIndex(fc => fc.getId() === id); + if (index === -1) return false; + this.flashcards.splice(index, 1); + return true; + } +} +
import { Evaluation } from './Evaluation'; + +export class Student { + constructor( + public name: string, + public cpf: string, + public email: string + ) { + this.cpf = this.cleanCPF(cpf); + this.validateCPF(this.cpf); + this.validateEmail(email); + } + + private cleanCPF(cpf: string): string { + return cpf.replace(/[.-]/g, ''); + } + + private validateCPF(cleanCPF: string): void { + if (cleanCPF.length !== 11 || !/^\d+$/.test(cleanCPF)) { + throw new Error('Invalid CPF format'); + } + } + + private validateEmail(email: string): void { + const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/; + if (!emailRegex.test(email)) { + throw new Error('Invalid email format'); + } + } + + + getFormattedCPF(): string { + return this.cpf.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-$4'); + } + + + getCPF(): string { + return this.cpf; + } + + + toJSON() { + return { + name: this.name, + cpf: this.getFormattedCPF(), + email: this.email + }; + } +}
import { Student } from './Student'; + +export class StudentSet { + private students: Student[] = []; + + constructor() { + + } + + + addStudent(student: Student): Student { + + if (this.findStudentByCPF(student.cpf)) { + throw new Error('Student with this CPF already exists'); + } + + this.students.push(student); + return student; + } + + + removeStudent(cpf: string): boolean { + const index = this.students.findIndex(s => s.cpf === cpf); + + Iif (index === -1) { + return false; + } + + this.students.splice(index, 1); + return true; + } + + + updateStudent(updatedStudent: Student): Student { + + const existingStudent = this.findStudentByCPF(updatedStudent.cpf); + + Iif (!existingStudent) { + throw new Error('Student not found'); + } + + + existingStudent.name = updatedStudent.name; + existingStudent.email = updatedStudent.email; + + + + return existingStudent; + } + findStudentByCPF(cpf: string): Student | undefined { + return this.students.find(s => s.cpf === cpf); + } + + + getAllStudents(): Student[] { + return [...this.students]; + } + + + getCount(): number { + return this.students.length; + } +}