repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/Loader/Loader.component.tsx
|
import styles from './Loader.module.scss';
const Loader = () => {
return (
<div style={{ width: '100%', height: '48px', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
<div className={styles.loader} />
</div>
)
}
export default Loader;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/dtos/interfaces/IUpdateTask.ts
|
<filename>ufabc_planner-backend/src/modules/tasks/dtos/interfaces/IUpdateTask.ts
export interface IUpdateTask {
id: string;
title?: string;
dueDate: string;
description?: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/quarters/controllers/UpdateQuarterController.ts
|
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { UpdateQuarterDTO } from '../dtos/UpdateQuarter.dto';
import { UpdateQuarterService } from '../services/UpdateQuarterService';
export class UpdateQuarterController {
async handle(request: Request, response: Response): Promise<Response> {
const { id } = request.params;
const { startDate, endDate } = request.body;
const updateQuarterDto = await validateInput(UpdateQuarterDTO, {
id,
startDate,
endDate,
});
container.resolve(UpdateQuarterService).execute(updateQuarterDto);
return response.status(204).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/services/api.ts
|
import axios from "axios";
const api = axios.create({
baseURL: "http://localhost:3001", //todo DOT ENV
});
api.interceptors.request.use(
config => ({
...config,
headers: {
...config.headers,
common: {
'Authorization': `Basic ${localStorage.getItem('auth_token')}`,
}
}
})
);
export default api;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/quarters/repositories/IQuarterRepository.ts
|
import { Quarter } from '@prisma/client';
import { createQuarterDTO } from '../dtos/CreateQuarter.dto.';
export interface IQuarterRepository {
quarterExists(quarterId: string): Promise<boolean>;
createQuarter(quarter: Omit<Quarter, 'id'>): Promise<void>;
deleteQuarter(quarterId: string): Promise<void>;
updateQuarter(quarter: Omit<Quarter, 'academyYearId'>): Promise<void>;
getQuarterByAcademicYearId(academicYearId: string): Promise<Quarter[]>;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/List/index.ts
|
<gh_stars>1-10
export { default as List } from './List.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/http/routes/classes.routes.ts
|
<filename>ufabc_planner-backend/src/infra/http/routes/classes.routes.ts
import { Router } from 'express';
import { CreateClassController } from 'modules/classes/controllers/CreateClassController';
import { DeleteClassController } from 'modules/classes/controllers/DeleteClassController';
import { GetClassesBySubjectIdController } from 'modules/classes/controllers/GetClassesBySubjectIdController';
import { GetClassesByUserIdController } from 'modules/classes/controllers/GetClassesByUserIdController';
import { UpdateClassController } from 'modules/classes/controllers/UpdateClassController';
import { container } from 'tsyringe';
import { ensureAuthenticated } from '../middlewares/ensureAuthenticated';
const createClassController = new CreateClassController();
const deleteClassController = new DeleteClassController();
const getClassesBySubjectIdController = new GetClassesBySubjectIdController();
const getClassesByUserIdController = new GetClassesByUserIdController();
const updateClassController = new UpdateClassController();
const classRoutes = Router();
classRoutes.post('/', ensureAuthenticated, createClassController.execute);
classRoutes.delete('/delete/:id', ensureAuthenticated, deleteClassController.execute);
classRoutes.get('/get/subject/:id', ensureAuthenticated, getClassesBySubjectIdController.execute);
classRoutes.get('/get/user', ensureAuthenticated, getClassesByUserIdController.execute);
classRoutes.put('/update/:id', ensureAuthenticated, updateClassController.execute);
export { classRoutes };
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/pages/login/index.ts
|
export { default as LoginPage } from './LoginPage.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/repositories/ISubjectRepository.ts
|
<reponame>ES-UFABC/UFABCplanner
import { Subject } from '@prisma/client';
import { CreateSubjectDTO } from '../dtos/CreateSubject.dto';
import { UpdateSubjectDTO } from '../dtos/UpdateSubject.dto';
export interface ISubjectRepository {
subjectExists(id: string): Promise<boolean>;
createSubject(params: CreateSubjectDTO): Promise<void>;
deleteSubject(id: string): Promise<void>;
updateSubject(quarter: UpdateSubjectDTO): Promise<void>;
getSubjectByQuarterId(quarterId: string): Promise<Subject[]>;
getSubjectByUserId(userId: string): Promise<Subject[]>;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/services/CreateClassService.ts
|
import dayjs from 'dayjs';
import { AppError } from 'infra/http/errors/AppError';
import { inject, injectable } from 'tsyringe';
import { CreateClassDTO } from '../dtos/CreateClass.dto';
import { IClassRepository } from '../repositories/IClassRepository';
@injectable()
export class CreateClassService {
constructor(
@inject('PrismaClassRepository')
private ClassRepository: IClassRepository
) {}
async handle(params: CreateClassDTO): Promise<void> {
if (params.startTime > params.endTime) {
throw new AppError('horário final é antes do horário inicial');
}
await this.ClassRepository.createClass(params);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/controllers/CreateAcademicYearController.ts
|
import { Request, Response } from 'express';
import { container } from 'tsyringe';
import { validateInput } from 'infra/http/errors/validation';
import { CreateAcademyYearDTO } from '../dtos/CreateAcademyYear.dto';
import { CreateAcademicYearService } from '../services/CreateAcademicYearService';
export class CreateAcademicYearController {
async handle(request: Request, response: Response): Promise<Response> {
const { year, startDate, endDate } = request.body;
const { id } = request.user;
const createAcademicYearService = container.resolve(CreateAcademicYearService);
const createAcademicYearDTO = await validateInput(CreateAcademyYearDTO, { userId: id, year, startDate, endDate });
await createAcademicYearService.execute(createAcademicYearDTO);
return response.status(201).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/dtos/CreateClass.dto.ts
|
<reponame>ES-UFABC/UFABCplanner
import { BiweeklyType, Weekdays } from '@prisma/client';
import { IsUUID, IsNotEmpty, IsOptional, IsString, isMilitaryTime, IsMilitaryTime, IsEnum } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { ICreateClass } from './interfaces/ICreateClass';
export class CreateClassDTO implements ICreateClass {
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
subjectId: string;
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
userId: string;
@IsOptional()
@IsString({ message: messages.IsString })
professor?: string;
@IsOptional()
@IsString({ message: messages.IsString })
room?: string;
@IsOptional()
@IsString({ message: messages.IsString })
campus?: string;
@IsOptional()
@IsString({ message: messages.IsString })
building?: string;
@IsMilitaryTime()
@IsNotEmpty({ message: messages.isNotEmpty })
startTime: string;
@IsMilitaryTime()
@IsNotEmpty({ message: messages.isNotEmpty })
endTime: string;
@IsEnum(Weekdays)
@IsNotEmpty({ message: messages.isNotEmpty })
weekday: Weekdays;
@IsOptional()
@IsEnum(BiweeklyType)
biweeklyType?: BiweeklyType;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/controllers/GetAcademicYearByUserIdController.ts
|
<reponame>ES-UFABC/UFABCplanner
import { Request, Response } from 'express';
import { container } from 'tsyringe';
import { GetAcademicYearByUserIdService } from '../services/GetAcademicYearByUserIdService';
export class GetAcademicYearByUserIdController {
async handle(request: Request, response: Response): Promise<Response> {
const { id: userId } = request.user;
const getAcademicYearByUserIdService = container.resolve(GetAcademicYearByUserIdService);
const academicYears = await getAcademicYearByUserIdService.execute(userId);
return response.json(academicYears).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/container/providers/DateProvider/IDateProvider.ts
|
<filename>ufabc_planner-backend/src/infra/container/providers/DateProvider/IDateProvider.ts
export interface IDateProvider {
toDate(date: string): Date;
convertToUTC(date: Date): string;
compareInDays(startDate: Date, endDate: Date): number;
compareIfBefore(startDate: Date, endDate: Date): boolean;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/pages/schedule/SchedulePage.component.tsx
|
<gh_stars>1-10
import { useCallback, useEffect, useRef, useState } from "react";
import { FiCalendar, FiEdit, FiTrash2 } from "react-icons/fi";
import { Box } from "../../components/Box";
import { BoxesContainer } from "../../components/BoxesContainer";
import { List } from "../../components/List";
import { PageLayout } from "../../components/PageLayout";
import { AcademicYearFormModal, AcademicYearFormModalRef } from "../../components/specific/academic_years/AcademicYearFormModal";
import { QuarterFormModal, QuarterFormModalRef } from "../../components/specific/quarters/QuarterFormModal";
import { SubjectFormModal, SubjectFormModalRef } from "../../components/specific/subjects/SubjectFormModal";
import { ClassesModal, ClassesModalRef } from "../../components/specific/classes/ClassesModal";
import { IAcademicYear } from "../../interfaces/academicYear";
import { IQuarter } from "../../interfaces/quarter";
import { ISubject } from "../../interfaces/subject";
import api from "../../services/api";
import { toShortDate } from "../../utils/date";
const SchedulePage = () => {
const formModalRef = useRef<AcademicYearFormModalRef>(null);
const quarterFormModalRef = useRef<QuarterFormModalRef>(null);
const subjectFormModalRef = useRef<SubjectFormModalRef>(null);
const classesModalRef = useRef<ClassesModalRef>(null);
const [academicYears, setAcademicYears] = useState<{ data: IAcademicYear[], loading: boolean }>({ data: [], loading: false });
const [quarters, setQuarters] = useState<{ data: IQuarter[], loading: boolean }>({ data: [], loading: false });
const [subjects, setSubjects] = useState<{ data: ISubject[], loading: boolean }>({ data: [], loading: false });
const [currentYear, setCurrentYear] = useState<IAcademicYear | null>(null);
const [currentQuarter, setCurrentQuarter] = useState<IQuarter | null>(null);
const handleGetAcademicYears = useCallback(async () => {
setAcademicYears(prevYears => ({ ...prevYears, loading: true }));
await api
.get('/academicyears/get/user')
.then(({ data }) => setAcademicYears({ data: data.sort((a: IAcademicYear, b: IAcademicYear) => Number(a.year) - Number(b.year)), loading: false }))
.catch(error => alert(error));
}, []);
const handleGetQuarters = useCallback(async () => {
if (!currentYear) return;
setQuarters(prevQuarters => ({ ...prevQuarters, loading: true }));
await api
.get(`/quarters/get/academicYear/${currentYear?.id}`)
.then(({ data }) => setQuarters({ data: data.sort((a: IQuarter, b: IQuarter) => Number(a.startDate) - Number(b.startDate)), loading: false }))
.catch(error => alert(error));
}, [currentYear]);
const handleGetSubjects = useCallback(async () => {
if (!currentQuarter) return;
setSubjects(prevSubjects => ({ ...prevSubjects, loading: true }));
await api
.get(`/subjects/get/quarter/${currentQuarter?.id}`)
.then(({ data }) => setSubjects({ data, loading: false }))
.catch(error => alert(error));
}, [currentQuarter]);
const handleDeleteAcademicYear = useCallback(async (academicYear: IAcademicYear) => {
if (window.confirm(`Tem certeza que quer deletar o ano acadêmico de ${academicYear.year}?`)) {
setAcademicYears(prevAcademicYears => ({ ...prevAcademicYears, loading: true }));
await api
.delete(`/academicyears/delete/${academicYear.id}`)
.then(() => {
setAcademicYears(prevYears => ({
data: prevYears.data.filter(year => year.id !== academicYear.id),
loading: false,
}));
alert('Ano acadêmico deletado com sucesso!');
})
.catch(error => alert(error));
}
}, []);
const handleDeleteQuarter = useCallback(async (quarter: IQuarter) => {
if (window.confirm(`Tem certeza que quer deletar o quadrimestre?`)) {
setQuarters(prevQuarters => ({ ...prevQuarters, loading: true }));
await api
.delete(`/quarters/delete/${quarter.id}`)
.then(() => {
setQuarters(prevQuarters => ({
data: prevQuarters.data.filter(q => q.id !== quarter.id),
loading: false,
}));
alert('Quadrimestre deletado com sucesso!');
})
.catch(error => alert(error));
}
}, []);
const handleDeleteSubject = useCallback(async (subject: ISubject) => {
if (window.confirm(`Tem certeza que quer deletar a matéria ${subject.name}?`)) {
setSubjects(prevSubjects => ({ ...prevSubjects, loading: true }));
await api
.delete(`/subjects/delete/${subject.id}`)
.then(() => {
setSubjects(prevSubjects => ({
data: prevSubjects.data.filter(s => s.id !== subject.id),
loading: false,
}));
alert('Matéria deletada com sucesso!');
})
.catch(error => alert(error));
}
}, []);
useEffect(() => {
handleGetAcademicYears();
}, [handleGetAcademicYears]);
useEffect(() => {
handleGetQuarters();
}, [handleGetQuarters]);
useEffect(() => {
handleGetSubjects();
}, [handleGetSubjects]);
return (
<PageLayout>
<BoxesContainer>
<Box
flex
maxWidth="360px"
height="calc(100vh - 192px)"
title="Anos acadêmicos"
onAdd={() => formModalRef.current?.handleOpenFormModal()}
>
<List
data={{
items: academicYears.data,
loading: academicYears.loading,
selectors: { title: 'year', id: 'id', descriptionGenerator: (academicYear: IAcademicYear) => `${toShortDate(new Date(academicYear.startDate))} até ${toShortDate(new Date(academicYear.endDate))}` }
}}
actions={[
{ type: 'primary', icon: FiEdit, method: (item: IAcademicYear) => formModalRef.current?.handleOpenFormModal(item) },
{ type: 'error', icon: FiTrash2, method: (item: IAcademicYear) => handleDeleteAcademicYear(item) },
]}
onSelect={(academicYear: IAcademicYear) => { setCurrentYear(academicYear); setCurrentQuarter(null); setSubjects({ data: [], loading: false }) }}
/>
</Box>
<Box
flex
maxWidth="360px"
height="calc(100vh - 192px)"
title="Quadrimestres"
onAdd={() => quarterFormModalRef.current?.handleOpenFormModal()}
>
<List
data={{
items: quarters.data,
loading: quarters.loading,
selectors: { id: 'id', descriptionGenerator: (quarter: IQuarter) => `${toShortDate(new Date(quarter.startDate))} até ${toShortDate(new Date(quarter.endDate))}` }
}}
actions={[
{ type: 'primary', icon: FiEdit, method: (item: IQuarter) => quarterFormModalRef.current?.handleOpenFormModal(item) },
{ type: 'error', icon: FiTrash2, method: (item: IQuarter) => handleDeleteQuarter(item) },
]}
overlapMessages={[
{ show: !currentYear, message: 'Nenhum ano acadêmico selecionado' },
{ show: !quarters.loading && !!currentYear && !quarters.data.length, message: 'Não há quadrimestres criados para esse ano acadêmico' },
]}
onSelect={(quarter: IQuarter) => setCurrentQuarter(quarter)}
/>
</Box>
<Box
flex
height="calc(100vh - 192px)"
title="Matérias"
onAdd={() => subjectFormModalRef.current?.handleOpenFormModal()}
>
<List
data={{
items: subjects.data,
loading: subjects.loading,
selectors: { title: 'name', id: 'id', description: 'description' }
}}
actions={[
{ type: 'primary', icon: FiEdit, method: (item: ISubject) => subjectFormModalRef.current?.handleOpenFormModal(item) },
{ type: 'info', icon: FiCalendar, method: (item: ISubject) => classesModalRef.current?.handleOpenModal(item) },
{ type: 'error', icon: FiTrash2, method: (item: ISubject) => handleDeleteSubject(item) }
]}
overlapMessages={[
{ show: !currentQuarter, message: 'Nenhum quadrimestre selecionado' },
{ show: !subjects.loading && !!currentQuarter && !subjects.data.length, message: 'Não há matérias criadas para esse quadrimestre' },
]}
/>
</Box>
</BoxesContainer>
<AcademicYearFormModal ref={formModalRef} onSuccess={() => handleGetAcademicYears()} />
<QuarterFormModal ref={quarterFormModalRef} academicYearId={currentYear?.id || ''} onSuccess={() => handleGetQuarters()}/>
<SubjectFormModal ref={subjectFormModalRef} quarterId={currentQuarter?.id || ''} onSuccess={() => handleGetSubjects()}/>
<ClassesModal ref={classesModalRef} />
</PageLayout>
);
};
export default SchedulePage;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/services/UpdateSubjectService.ts
|
<filename>ufabc_planner-backend/src/modules/subjects/services/UpdateSubjectService.ts
import { AppError } from 'infra/http/errors/AppError';
import { inject, injectable } from 'tsyringe';
import { UpdateSubjectDTO } from '../dtos/UpdateSubject.dto';
import { ISubjectRepository } from '../repositories/ISubjectRepository';
@injectable()
export class UpdateSubjectService {
constructor(
@inject('PrismaSubjectRepository')
private subjectRepository: ISubjectRepository
) {}
async execute(params: UpdateSubjectDTO): Promise<void> {
if (!(await this.subjectRepository.subjectExists(params.id))) {
throw new AppError('A matéria não existe');
}
await this.subjectRepository.updateSubject(params);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/Box/Box.component.tsx
|
<gh_stars>1-10
import clsx from 'clsx';
import { FiPlus } from 'react-icons/fi';
import { Button } from '../Button';
import styles from './Box.module.scss';
interface Props {
children: React.ReactNode;
style?: React.CSSProperties;
flex?: boolean;
onAdd?: () => void | Promise<void>;
title?: string
maxWidth?: string;
height?: string;
}
const Box = ({ children, style, flex, onAdd, title, maxWidth, height }: Props) => {
return (
<div className={clsx(styles.box, { [styles.flex]: flex })} style={{ ...style, maxWidth: maxWidth ?? 'none', height: height ?? 'auto' }}>
{(!!onAdd || !!title) &&
<div className={styles.box_header}>
{!!title && <b style={{ fontSize: '22px' }}>{title}</b>}
{!!onAdd &&
<Button onClick={onAdd} style={{ width: '40px', height: '40px' }}>
<FiPlus size={20}/>
</Button>
}
</div>
}
{children}
</div>
)
};
export default Box;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/contexts/auth/AuthProvider.tsx
|
<reponame>ES-UFABC/UFABCplanner
import { useCallback, useEffect, useState } from 'react';
import { ICredentials } from '../../interfaces/credentials';
import api from '../../services/api';
import { AuthContext } from './context';
interface Props {
children: React.ReactNode;
}
const AuthProvider = ({ children }: Props) => {
const [loading, setLoading] = useState(false);
const [authenticated, setAuthenticated] = useState(false);
const login = useCallback(async (data: ICredentials, reloadOnAuth?: boolean) => {
setLoading(true);
await api
.post('/users/login', data)
.then(({ data }) => {
if (data.token) {
localStorage.setItem('auth_token', data.token)
if (reloadOnAuth) window.location.reload();
} else {
alert('A API foi incapaz de gerar seu token de autenticação')
}
})
.catch(error => {
error?.response?.data?.message
? alert(error?.response?.data?.message)
: alert('Houve um erro ao tentar fazer o login...');
})
.finally(() => setLoading(false));
}, []);
const logout = () => {
localStorage.removeItem('auth_token');
window.location.reload();
};
useEffect(() => {
setAuthenticated(!!localStorage.getItem('auth_token'));
}, []);
return (
<AuthContext.Provider value={{ authenticated, loading, login, logout }}>
{children}
</AuthContext.Provider>
);
};
export { AuthProvider };
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/dtos/interfaces/ICreateTask.ts
|
<reponame>ES-UFABC/UFABCplanner<filename>ufabc_planner-backend/src/modules/tasks/dtos/interfaces/ICreateTask.ts<gh_stars>1-10
export interface ICreateTask {
subjectId: string;
userId: string;
title: string;
dueDate: string;
description?: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/pages/tasks/TasksPage.component.tsx
|
import { useCallback, useEffect, useRef, useState } from "react";
import { FiEdit, FiTrash2 } from "react-icons/fi";
import { Box } from "../../components/Box";
import { BoxesContainer } from "../../components/BoxesContainer";
import { List } from "../../components/List";
import { PageLayout } from "../../components/PageLayout";
import { TaskFormModalRef, TasksFormModal } from "../../components/specific/tasks/TasksFormModal";
import { ITask } from "../../interfaces/task";
import api from "../../services/api";
import { toShortDate } from "../../utils/date";
const TasksPage = () => {
const formModalRef = useRef<TaskFormModalRef>(null);
const [tasks, setTasks] = useState<{ data: ITask[], loading: boolean }>({ data: [], loading: false });
const handleGetTasks = useCallback(async () => {
setTasks(prevTasks => ({ ...prevTasks, loading: true }));
await api
.get('/tasks/get/user')
.then(({ data }) => setTasks({ data: data.sort((a: ITask, b: ITask) => new Date(a.dueDate).getTime() - new Date(b.dueDate).getTime()), loading: false }))
.catch(error => alert(error));
}, []);
const handleDeleteTask = useCallback(async (task: ITask) => {
if (window.confirm(`Tem certeza que quer deletar a tarefa "${task.title}"?`)) {
setTasks(prevTasks => ({ ...prevTasks, loading: true }));
await api
.delete(`/tasks/delete/${task.id}`)
.then(() => {
setTasks(prevTasks => ({
data: prevTasks.data.filter(prevTask => prevTask.id !== task.id),
loading: false,
}));
alert('Tarefa deletada com sucesso!');
})
.catch(error => alert(error));
}
}, []);
useEffect(() => {
handleGetTasks();
}, [handleGetTasks]);
return (
<PageLayout>
<BoxesContainer>
<Box flex height="calc(100vh - 192px)" title="Tarefas" onAdd={() => formModalRef.current?.handleOpenFormModal()}>
<List
data={{
items: tasks.data,
loading: tasks.loading,
selectors: { title: 'title', id: 'id', descriptionGenerator: (task: ITask) => `até ${toShortDate(new Date(task.dueDate))}` }
}}
actions={[
{ type: 'primary', icon: FiEdit, method: (item: ITask) => formModalRef.current?.handleOpenFormModal(item) },
{ type: 'error', icon: FiTrash2, method: (item: ITask) => handleDeleteTask(item) },
]}
/>
</Box>
</BoxesContainer>
<TasksFormModal ref={formModalRef} onSuccess={() => handleGetTasks()} />
</PageLayout>
);
};
export default TasksPage;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/dtos/GetExamsByUserId.dto.ts
|
<reponame>ES-UFABC/UFABCplanner<filename>ufabc_planner-backend/src/modules/exams/dtos/GetExamsByUserId.dto.ts
import { IsUUID, IsNotEmpty } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { IGetExamsByUserId } from './interfaces/IGetExamsByUserId';
export class GetExamsByUserIdDTO implements IGetExamsByUserId {
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
id: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/dtos/UpdateSubject.dto.ts
|
<reponame>ES-UFABC/UFABCplanner
import { IsNotEmpty, IsOptional, IsString, IsUUID } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { IUpdateSubject } from './interfaces/IUpdateSubject';
export class UpdateSubjectDTO implements IUpdateSubject {
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
id: string;
@IsString({ message: messages.IsString })
@IsNotEmpty({ message: messages.isNotEmpty })
name: string;
@IsOptional()
@IsString({ message: messages.IsString })
description?: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/services/UpdateAcademicYearService.ts
|
import { AcademicYear } from '@prisma/client';
import { prisma } from 'infra/prisma/client';
import { inject, injectable } from 'tsyringe';
import { AppError } from 'infra/http/errors/AppError';
import { UpdateAcademyYearDTO } from '../dtos/UpdateAcademicYear.dto';
import { IDateProvider } from 'infra/container/providers/DateProvider/IDateProvider';
import { IAcademicYearRepository } from '../repositories/IAcademicYearRepository';
@injectable()
export class UpdateAcademicYearService {
constructor(
@inject('PrismaAcademicYearRepository')
private academicYearRepository: IAcademicYearRepository,
@inject('DayjsDateProvider')
private dateProvider: IDateProvider
) {}
async execute(params: UpdateAcademyYearDTO): Promise<void> {
const { id, year, startDate, endDate } = params;
if (!(await this.academicYearRepository.exists(id))) {
throw new AppError('Este ano acadêmico não existe!');
}
const startDateUTC = this.dateProvider.toDate(startDate);
const endDateUTC = this.dateProvider.toDate(endDate);
if (this.dateProvider.compareIfBefore(startDateUTC, endDateUTC)) {
throw new AppError('Data final é antes da data inicial');
}
await this.academicYearRepository.update({
id: id,
year: year,
startDate: startDateUTC,
endDate: endDateUTC,
});
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/Sidebar/index.ts
|
<reponame>ES-UFABC/UFABCplanner<filename>ufabc_planner-frontend/src/components/Sidebar/index.ts<gh_stars>1-10
export { default as Sidebar } from './Sidebar.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/controllers/DeleteExamController.ts
|
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { DeleteExamDTO } from '../dtos/DeleteExam.dto';
import { DeleteExamService } from '../services/DeleteExamService';
export class DeleteExamController {
async execute(request: Request, response: Response) {
const { id } = request.params;
const deleteExamDto = await validateInput(DeleteExamDTO, { id });
await container.resolve(DeleteExamService).handle(deleteExamDto);
return response.status(204).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/controllers/UpdateSubjectController.ts
|
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { UpdateSubjectDTO } from '../dtos/UpdateSubject.dto';
import { UpdateSubjectService } from '../services/UpdateSubjectService';
export class UpdateSubjectController {
async handle(request: Request, response: Response): Promise<Response> {
const { id } = request.params;
const { name, description } = request.body;
const UpdateSubjectDto = await validateInput(UpdateSubjectDTO, {
id,
name,
description,
});
container.resolve(UpdateSubjectService).execute(UpdateSubjectDto);
return response.status(204).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/PageLayout/index.ts
|
export { default as PageLayout } from './PageLayout.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/dtos/interfaces/IUpdateAcademicYear.ts
|
<reponame>ES-UFABC/UFABCplanner<gh_stars>1-10
export interface IUpdateAcademyYear {
id: string;
year?: string;
startDate: string;
endDate: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/accounts/controllers/CreateUserController.ts
|
<gh_stars>1-10
import { Request, Response } from 'express';
import { container } from 'tsyringe';
import { validateInput } from 'infra/http/errors/validation';
import { CreateUserDTO } from '../dtos/CreateUser.dto';
import { CreateUserService } from '../services/CreateUserService';
export class CreateUserController {
async handle(request: Request, response: Response): Promise<Response> {
const { name, email, password } = request.body;
const createUserService = container.resolve(CreateUserService);
const createUserDTO = await validateInput(CreateUserDTO, { name, email, password });
await createUserService.execute(createUserDTO);
return response.status(201).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/tasks/TasksFormModal/TasksFormModal.component.tsx
|
<filename>ufabc_planner-frontend/src/components/specific/tasks/TasksFormModal/TasksFormModal.component.tsx<gh_stars>1-10
import { Form } from "@unform/web";
import { forwardRef, useCallback, useEffect, useImperativeHandle, useRef, useState } from "react";
import { ISubject } from "../../../../interfaces/subject";
import { ITask } from "../../../../interfaces/task";
import api from "../../../../services/api";
import { Button } from "../../../Button";
import { Input } from "../../../Input";
import { Modal, ModalRef } from "../../../Modal";
import { SelectInput } from "../../../SelectInput";
interface Props {
onSuccess?: () => void;
}
export interface TaskFormModalRef {
handleOpenFormModal: (task?: ITask) => void;
}
const TaskFormModal = forwardRef<TaskFormModalRef, Props>(({ onSuccess }, ref) => {
const modalRef = useRef<ModalRef>(null);
const formRef = useRef(null);
const [subjects, setSubjects] = useState<ISubject[]>([]);
const [currentTask, setCurrentTask] = useState<ITask | null>(null);
const [loading, setLoading] = useState(false);
const unsetFormModalStates = useCallback(() => {
setCurrentTask(null);
setLoading(false);
}, []);
const handleGetSubjects = useCallback(async () => {
setSubjects(prevSubjects => ({ ...prevSubjects, loading: true }));
await api
.get(`/subjects/get/user`)
.then(({ data }) => setSubjects(data))
.catch(error => alert(error));
}, []);
const handleSuccess = useCallback((message: string) => {
alert(message);
if (onSuccess) onSuccess();
unsetFormModalStates();
modalRef.current?.handleCloseModal();
}, [onSuccess, unsetFormModalStates]);
const handleSubmit = useCallback(async (data: Omit<ITask, 'id'>) => {
setLoading(true);
try {
if (currentTask) {
await api
.put(`/tasks/update/${currentTask.id}`, { ...data, id: currentTask.id })
.then(() => handleSuccess('Tarefa editada com sucesso!'))
.catch(error => alert(error));
} else {
await api
.post('/tasks/', { ...data })
.then(() => handleSuccess('Tarefa criada com sucesso!'))
.catch(error => alert(error));
}
} catch (error) {
alert('Houve um erro na criação/edição da tarefa...')
} finally {
setLoading(false);
}
}, [currentTask, handleSuccess]);
useImperativeHandle(ref, () => ({
handleOpenFormModal: (task?: ITask) => {
if (task) setCurrentTask(task);
modalRef.current?.handleOpenModal();
}
}), []);
useEffect(() => {
handleGetSubjects();
}, [handleGetSubjects]);
return (
<Modal
ref={modalRef}
title={`${currentTask ? 'Editar' : 'Criar'} Tarefa`}
onClose={unsetFormModalStates}
>
<Form ref={formRef} onSubmit={handleSubmit}>
<div style={{ display: 'flex', flexDirection: 'column', gap: '16px' }}>
<SelectInput name="subjectId" label="Matéria*" defaultValue={currentTask?.subjectId}>
<option value=""></option>
{subjects.length && subjects?.map(subject => <option value={subject.id}>{subject.name}</option>)}
</SelectInput>
<Input name="title" label="Nome*" placeholder="Ex.: Fazer atividade X" defaultValue={currentTask?.title}/>
<Input name="dueDate" label="Prazo*" placeholder="Ex.: 2022-12-12" defaultValue={currentTask?.dueDate}/>
<Input name="description" label="Descrição" placeholder="Ex.: Uma tarefa muito legal" defaultValue={currentTask?.description}/>
<Button style={{ marginTop: '32px' }} type="submit" loading={loading}>Salvar</Button>
</div>
</Form>
</Modal>
);
});
export default TaskFormModal;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/http/routes/quarters.routes.ts
|
<reponame>ES-UFABC/UFABCplanner
import { Router } from 'express';
import { CreateQuarterController } from 'modules/quarters/controllers/CreateQuarterController';
import { DeleteQuarterController } from 'modules/quarters/controllers/DeleteQuarterController';
import { GetQuarterByAcademicYearIdController } from 'modules/quarters/controllers/GetQuarterByAcademicYearIdController';
import { UpdateQuarterController } from 'modules/quarters/controllers/UpdateQuarterController';
import { ensureAuthenticated } from '../middlewares/ensureAuthenticated';
const quartersRoutes = Router();
const createQuarterController = new CreateQuarterController();
const deleteQuarterController = new DeleteQuarterController();
const updateQuarterController = new UpdateQuarterController();
const getQuarterByACademicYearIdController = new GetQuarterByAcademicYearIdController();
quartersRoutes.post('/', ensureAuthenticated, createQuarterController.handle);
quartersRoutes.get('/get/academicyear/:id', ensureAuthenticated, getQuarterByACademicYearIdController.handle);
quartersRoutes.delete('/delete/:id', ensureAuthenticated, deleteQuarterController.handle);
quartersRoutes.put('/update/:id', ensureAuthenticated, updateQuarterController.handle);
export { quartersRoutes };
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/InitialPageLayout/InitialPageLayout.component.tsx
|
<gh_stars>1-10
import { Link } from 'react-router-dom';
import styles from './InitialPageLayout.module.scss';
interface Props {
title: string;
subtitle: string;
subtext: { question: string, linkLabel: string, linkTo: string }
children: React.ReactNode;
}
const InitialPageLayout = ({ title, subtitle, children, subtext }: Props) => {
return (
<div className={styles.page_layout}>
<div style={{ gridArea: 'logo-container' }}>
<img
src="/UFABCplanner_logo_dark.svg"
alt="UFABCplanner_logo_dark"
width="240px"
/>
</div>
<div className={styles.form_container}>
<div className={styles.card_container}>
<div className={styles.titles_container}>
<h1 className={styles.title}>{title}</h1>
<p className={styles.sub_title}>{subtitle}</p>
</div>
{children}
<div className={styles.sub_text}>
{subtext.question}
<Link to={subtext.linkTo} className={styles.subtext_link}>
{subtext.linkLabel}
</Link>
</div>
</div>
</div>
</div>
);
}
export default InitialPageLayout;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/interfaces/class.ts
|
<reponame>ES-UFABC/UFABCplanner<filename>ufabc_planner-frontend/src/interfaces/class.ts
export type Weekday = 'seg' | 'ter' | 'quar' | 'quin' | 'sex' | 'sab' | 'dom'
export type BiweeklyType = 'week1' | 'week2'
export interface IClass {
id: string;
subjectId: string;
userId: string;
professor?: string;
room?: string;
campus?: string;
bulding?: string;
startTime: string;
endTime: string;
weekday: Weekday;
biweeklyType?: BiweeklyType
}
export const translateWeekday = {
seg: 'Segunda-feira',
ter: 'Terça-feira',
quar: 'Quarta-feira',
quin: 'Quinta-feira',
sex: 'Sexta-feira',
sab: 'Sábado-feira',
dom: 'Domingo-feira',
}
export const translateBiweeklyType = {
week1: 'Quinzenal I',
week2: 'Quinzenal II',
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/accounts/dtos/AuthenticateUser.dto.ts
|
import { IsEmail, IsNotEmpty, IsString } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { IAuthenticateUser } from './interfaces/IAuthenticateUser';
export class AuthenticateUserDTO implements IAuthenticateUser {
@IsNotEmpty({ message: messages.isNotEmpty })
@IsString()
@IsEmail()
email: string;
@IsNotEmpty({ message: messages.isNotEmpty })
@IsString()
password: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/controllers/GetTasksByUserIdController.ts
|
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { GetTasksByUserIdDTO } from '../dtos/GetTasksByUserId.dto';
import { GetTasksByUserIdService } from '../services/GetTasksByUserIdService';
export class GetTasksByUserIdController {
async execute(request: Request, response: Response) {
const { id } = request.user;
const getTasksByUserIdDTO = await validateInput(GetTasksByUserIdDTO, { id });
const tasks = await container.resolve(GetTasksByUserIdService).handle(getTasksByUserIdDTO);
response.json(tasks).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/test/entities/SubjectFactory.ts
|
import { Quarter, Subject, User } from '@prisma/client';
import { prisma } from 'infra/prisma/client';
export async function createSubject(quarter: Quarter, user: User): Promise<Subject> {
const subject = await prisma.subject.create({
data: {
name: 'engenharia de software',
description: 'link da ementa ou algo que o professor disse',
quarterId: quarter.id,
userId: user.id,
},
});
return subject;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/services/CreateSubjectService.ts
|
<gh_stars>1-10
import { AppError } from 'infra/http/errors/AppError';
import { IQuarterRepository } from 'modules/quarters/repositories/IQuarterRepository';
import { inject, injectable } from 'tsyringe';
import { CreateSubjectDTO } from '../dtos/CreateSubject.dto';
import { ISubjectRepository } from '../repositories/ISubjectRepository';
@injectable()
export class CreateSubjectService {
constructor(
@inject('PrismaQuarterRepository')
private QuarterRepository: IQuarterRepository,
@inject('PrismaSubjectRepository')
private subjectRepository: ISubjectRepository
) {}
async execute(params: CreateSubjectDTO): Promise<void> {
if (!(await this.QuarterRepository.quarterExists(params.quarterId))) {
throw new AppError('Quadrimestre não existe');
}
await this.subjectRepository.createSubject(params);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/container/providers/DateProvider/implementations/DayjsDateProvider.ts
|
<gh_stars>1-10
import dayjs from 'dayjs';
import utc from 'dayjs/plugin/utc';
import { injectable } from 'tsyringe';
import { IDateProvider } from '../IDateProvider';
dayjs.extend(utc);
@injectable()
export class DayjsDateProvider implements IDateProvider {
toDate(date: string): Date {
return dayjs(date).toDate();
}
convertToUTC(date: Date): string {
return dayjs(date).utc().format();
}
compareInDays(startDate: Date, endDate: Date): number {
const startDateUtc = this.convertToUTC(startDate);
const endDateUtc = this.convertToUTC(endDate);
return dayjs(endDateUtc).diff(startDateUtc, 'days');
}
compareIfBefore(startDate: Date, endDate: Date): boolean {
return dayjs(endDate).isBefore(startDate);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/classes/ClassesModal/ClassesModal.component.tsx
|
import { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
import { IClass } from "../../../../interfaces/class";
import { ISubject } from "../../../../interfaces/subject";
import api from "../../../../services/api";
import { Button } from "../../../Button";
import { Modal, ModalRef } from "../../../Modal";
import { ClassForm } from "../ClassForm";
import { ClassItem } from "../ClassItem";
export interface ClassesModalRef {
handleOpenModal: (subject: ISubject) => void;
}
const ClassesModal = forwardRef<ClassesModalRef>((_, ref) => {
const modalRef = useRef<ModalRef>(null);
const [subject, setSubject] = useState<ISubject | null>(null);
const [classes, setClasses] = useState<IClass[]>([]);
const [addingClass, setAddingClass] = useState(false);
const unsetModalStates = useCallback(() => {
setSubject(null);
setClasses([]);
}, []);
const modalTitle = useMemo(() => {
if (subject) {
return addingClass ? `Adicionando aula à ${subject.name}` : `Aulas de ${subject.name}`;
} else {
return 'N/A';
}
}, [addingClass, subject]);
const handleGetClasses = useCallback(async () => {
if (!subject) return;
setClasses(prevYears => ({ ...prevYears, loading: true }));
await api
.get(`/classes/get/subject/${subject.id}`)
.then(({ data }) => setClasses(data))
.catch(error => alert(error));
}, [subject]);
useImperativeHandle(ref, () => ({
handleOpenModal: (subject: ISubject) => {
setSubject(subject);
modalRef.current?.handleOpenModal();
}
}), []);
useEffect(() => {
handleGetClasses();
}, [handleGetClasses]);
return (
<Modal ref={modalRef} title={modalTitle} onClose={unsetModalStates} width="800px">
{addingClass
? (
<ClassForm
subjectId={subject?.id || ''}
onSuccess={() => { setAddingClass(false); handleGetClasses() }}
onCancel={() => setAddingClass(false)}
/>
)
: (
<div style={{ display: 'flex', flexDirection: 'column', gap: '16px' }}>
{classes.length && classes?.map(klass =>
<ClassItem
klass={klass}
onDelete={() => setClasses(prevClasses => prevClasses.filter(prevClass => prevClass.id !== klass.id))}
/>
)}
</div>
)
}
{!addingClass &&
<div style={{ display: 'flex', marginTop: '32px', justifyContent: 'center' }}>
<Button onClick={() => setAddingClass(true)} style={{ width: '200px' }}>
Adicionar nova aula
</Button>
</div>
}
</Modal>
);
});
export default ClassesModal;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/test/entities/UserFactory.ts
|
import { User } from '@prisma/client';
import { hash } from 'bcryptjs';
import auth from 'config/auth';
import { prisma } from 'infra/prisma/client';
import { sign } from 'jsonwebtoken';
import { emit } from 'process';
import { validPassword } from '../constants';
import { generateRandomEmail, pickRandomName } from '../utils';
//TODO: necessário melhorar esta função
export async function createUser(email?: string, name?: string, password?: string): Promise<User> {
const user = await prisma.user.create({
data: {
name: name || 'teste',
email: email || generateRandomEmail(),
password: await hash(password || '<PASSWORD>', 8),
},
});
return user;
}
export async function getUserByEmail(email: string): Promise<User | null> {
return prisma.user.findUnique({
where: {
email: email,
},
});
}
export async function authenticateUser(user: User): Promise<string> {
const token = sign({}, auth.secret_token, {
subject: user.id,
expiresIn: auth.expires_in_token,
});
return token;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/controllers/GetTasksBySubjectIdController.ts
|
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { GetTasksBySubjectIdDTO } from '../dtos/GetTasksBySubjecId.dto';
import { GetTasksBySubjectIdService } from '../services/GetTasksBySubjectIdService';
export class GetTasksBySubjectIdController {
async execute(request: Request, response: Response) {
const { id } = request.params;
const getTasksBySubjectIdDTO = await validateInput(GetTasksBySubjectIdDTO, { id });
const tasks = await container.resolve(GetTasksBySubjectIdService).handle(getTasksBySubjectIdDTO);
return response.json(tasks).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/List/List.component.tsx
|
import clsx from 'clsx';
import { useCallback, useState } from 'react';
import { IconBaseProps } from 'react-icons';
import { IconBtnType, IconButton } from '../IconButton';
import { Loader } from '../Loader';
import styles from './List.module.scss';
interface ListData {
loading: boolean;
items: any[];
selectors: {
id: string;
title?: string;
description?: string;
descriptionGenerator?: (item: any) => string;
}
}
interface Action {
type: IconBtnType;
icon: React.ComponentType<IconBaseProps>;
method: (item?: any) => void;
}
interface OverlapMessage {
show: boolean;
message: string;
}
interface Props {
data: ListData;
actions?: Action[];
overlapMessages?: OverlapMessage[];
onSelect?: (item?: any) => void;
}
const List = ({ data, actions, overlapMessages, onSelect }: Props) => {
const [selectedId, setSelectedId] = useState('');
const handleClickItem = useCallback((item: any) => {
setSelectedId(item[data.selectors.id]);
if (onSelect) onSelect(item);
}, [data.selectors.id, onSelect]);
return (
<div className={styles.list_container}>
{data.loading && <Loader />}
{overlapMessages?.map(({ show, message }) => show && <div className={styles.no_message}>{message}</div>)}
{!data.loading && data.items.map((item: any, index) =>
<div key={item[data.selectors.id]} className={clsx(styles.list_item, { [styles.selected]: item[data.selectors.id] === selectedId })}>
<div className={styles.list_item_info} onClick={() => handleClickItem(item)}>
{!!data.selectors.title
? <b>{item[data.selectors.title]}</b>
: <b>#{index + 1}</b>
}
{!!data.selectors.descriptionGenerator
? <div>{data.selectors.descriptionGenerator(item)}</div>
: <div>{data.selectors.description ? item[data.selectors.description] : ''}</div>
}
</div>
<div className={styles.actions_container}>
{actions?.map(({ icon, method, type }) =>
<IconButton btnType={type} icon={icon} onClick={() => method(item)} />
)}
</div>
</div>
)}
</div>
);
}
export default List;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/controllers/CreateExamController.ts
|
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { CreateExamDTO } from '../dtos/CreateExam.dto';
import { ICreateExam } from '../dtos/interfaces/ICreateExam';
import { CreateExamService } from '../services/CreateExamService';
export class CreateExamController {
async execute(request: Request, response: Response) {
const requestBody = request.body as Omit<ICreateExam, 'userId'>;
const { id: userId } = request.user;
const createExamDTO = await validateInput(CreateExamDTO, { userId, ...requestBody });
await container.resolve(CreateExamService).handle(createExamDTO);
return response.status(201).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/jest.config.ts
|
<reponame>ES-UFABC/UFABCplanner<filename>ufabc_planner-backend/jest.config.ts
import { Config } from '@jest/types';
import { pathsToModuleNameMapper } from 'ts-jest';
const config: Config.InitialOptions = {
preset: 'ts-jest',
testTimeout: 30000,
modulePaths: ['<rootDir>/src/'],
testEnvironment: 'node',
rootDir: '.',
globals: {
'ts-jest': {
isolatedModules: true,
},
},
};
export default config;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/test/entities/AcademicYearFactory.ts
|
<filename>ufabc_planner-backend/test/entities/AcademicYearFactory.ts
import { AcademicYear, User } from '@prisma/client';
import dayjs from 'dayjs';
import { prisma } from 'infra/prisma/client';
export async function createAcademicYear(user: User): Promise<AcademicYear> {
const AcademicYear = await prisma.academicYear.create({
data: {
userId: user.id,
year: '2022',
end_date: dayjs().toDate(),
start_date: dayjs().toDate(),
},
});
return AcademicYear;
}
export async function getAcademicYearById(academicYearId: string): Promise<AcademicYear | null> {
return prisma.academicYear.findUnique({
where: {
id: academicYearId,
},
});
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/services/GetTasksBySubjectIdService.ts
|
import { Task } from '@prisma/client';
import { inject, injectable } from 'tsyringe';
import { GetTasksBySubjectIdDTO } from '../dtos/GetTasksBySubjecId.dto';
import { ITaskRepository } from '../repositories/ITaskRepository';
@injectable()
export class GetTasksBySubjectIdService {
constructor(
@inject('PrismaTaskRepository')
private TaskRepository: ITaskRepository
) {}
async handle({ id }: GetTasksBySubjectIdDTO): Promise<Task[]> {
return this.TaskRepository.getTasksBySubjectId(id);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/quarters/controllers/CreateQuarterController.spec.ts
|
<filename>ufabc_planner-backend/src/modules/quarters/controllers/CreateQuarterController.spec.ts
import { app } from 'infra/http/app';
import { prisma } from 'infra/prisma/client';
import supertest from 'supertest';
import { deleteAll, disconnect } from '../../../../test/database';
import { createAcademicYear } from '../../../../test/entities/AcademicYearFactory';
import { authenticateUser, createUser } from '../../../../test/entities/UserFactory';
import { generateRandomEmail } from '../../../../test/utils';
describe('Create Quarter (e2e)', () => {
beforeAll(async () => {
deleteAll();
});
afterAll(async () => {
disconnect();
});
it('Should create a quarter successfully', async () => {
const user = await createUser();
const token = await authenticateUser(user);
const academicYear = await createAcademicYear(user);
const response = await supertest(app)
.post('/quarters/')
.set('authorization', 'Bearer ' + token)
.send({
academicYearId: academicYear.id,
startDate: '2022-06-01',
endDate: '2022-08-01',
});
expect(response.status).toBe(201);
const quarter = await prisma.quarter.findFirst({
where: {
academyYearId: academicYear.id,
},
});
expect(quarter).toBeTruthy();
});
});
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/test/database.ts
|
<filename>ufabc_planner-backend/test/database.ts<gh_stars>1-10
import { prisma } from 'infra/prisma/client';
export async function deleteAll() {
const deleteUser = prisma.user.deleteMany();
const deleteAcademicYear = prisma.academicYear.deleteMany();
const deleteQuarter = prisma.quarter.deleteMany();
const deleteSubject = prisma.subject.deleteMany();
const deleteClass = prisma.class.deleteMany();
const deleteTask = prisma.task.deleteMany();
const deleteExam = prisma.exam.deleteMany();
await prisma.$transaction([
deleteExam,
deleteTask,
deleteClass,
deleteSubject,
deleteQuarter,
deleteAcademicYear,
deleteUser,
]);
}
export async function disconnect() {
await prisma.$disconnect();
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/dtos/interfaces/IDeleteAcademyYear.ts
|
<reponame>ES-UFABC/UFABCplanner
export interface IDeleteAcademyYear {
academicYearId: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/services/DeleteExamService.ts
|
import { injectable, inject } from 'tsyringe';
import { DeleteExamDTO } from '../dtos/DeleteExam.dto';
import { IExamRepository } from '../repositories/IExamRepository';
@injectable()
export class DeleteExamService {
constructor(
@inject('PrismaExamRepository')
private ExamRepository: IExamRepository
) {}
async handle({ id }: DeleteExamDTO): Promise<void> {
await this.ExamRepository.deleteExam(id);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/repositories/prisma/PrismaSubjectRepository.ts
|
<filename>ufabc_planner-backend/src/modules/subjects/repositories/prisma/PrismaSubjectRepository.ts
import { Subject } from '@prisma/client';
import { prisma } from 'infra/prisma/client';
import { CreateSubjectDTO } from 'modules/subjects/dtos/CreateSubject.dto';
import { UpdateSubjectDTO } from 'modules/subjects/dtos/UpdateSubject.dto';
import { ISubjectRepository } from '../ISubjectRepository';
export class PrismaSubjectRepository implements ISubjectRepository {
async subjectExists(id: string): Promise<boolean> {
const subject = await prisma.subject.findUnique({
where: {
id: id,
},
});
if (!subject) return false;
return true;
}
async createSubject(params: CreateSubjectDTO): Promise<void> {
await prisma.subject.create({
data: {
...params,
},
});
}
async deleteSubject(id: string): Promise<void> {
await prisma.subject.delete({
where: {
id: id,
},
});
}
async updateSubject(quarter: UpdateSubjectDTO): Promise<void> {
await prisma.subject.update({
where: {
id: quarter.id,
},
data: {
name: quarter.name,
description: quarter.description,
},
});
}
getSubjectByQuarterId(quarterId: string): Promise<Subject[]> {
return prisma.subject.findMany({
where: {
quarterId: quarterId,
},
});
}
getSubjectByUserId(userId: string): Promise<Subject[]> {
return prisma.subject.findMany({
where: {
userId: userId,
},
});
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/pages/exams/ExamsPage.component.tsx
|
import { useCallback, useEffect, useRef, useState } from "react";
import { FiEdit, FiTrash2 } from "react-icons/fi";
import { Box } from "../../components/Box";
import { BoxesContainer } from "../../components/BoxesContainer";
import { List } from "../../components/List";
import { PageLayout } from "../../components/PageLayout";
import { ExamsFormModal, ExamsFormModalRef } from "../../components/specific/exams/ExamsFormModal";
import { IExam } from "../../interfaces/exam";
import api from "../../services/api";
import { toShortDate } from "../../utils/date";
const ExamsPage = () => {
const formModalRef = useRef<ExamsFormModalRef>(null);
const [exams, setExams] = useState<{ data: IExam[], loading: boolean }>({ data: [], loading: false });
const handleGetExams = useCallback(async () => {
setExams(prevExams => ({ ...prevExams, loading: true }));
await api
.get('/exams/get/user')
.then(({ data }) => setExams({ data: data.sort((a: IExam, b: IExam) => new Date(a.dueDate).getTime() - new Date(b.dueDate).getTime()), loading: false }))
.catch(error => alert(error));
}, []);
const handleDeleteExam = useCallback(async (exam: IExam) => {
if (window.confirm(`Tem certeza que quer deletar a prova "${exam.name}"?`)) {
setExams(prevExams => ({ ...prevExams, loading: true }));
await api
.delete(`/exams/delete/${exam.id}`)
.then(() => {
setExams(prevExams => ({
data: prevExams.data.filter(prevExam => prevExam.id !== exam.id),
loading: false,
}));
alert('Prova deletada com sucesso!');
})
.catch(error => alert(error));
}
}, []);
useEffect(() => {
handleGetExams();
}, [handleGetExams]);
return (
<PageLayout>
<BoxesContainer>
<Box flex height="calc(100vh - 192px)" title="Provas" onAdd={() => formModalRef.current?.handleOpenFormModal()}>
<List
data={{
items: exams.data,
loading: exams.loading,
selectors: { title: 'name', id: 'id', descriptionGenerator: (exam: IExam) => `dia ${toShortDate(new Date(exam.dueDate))} às ${exam.time}` }
}}
actions={[
{ type: 'primary', icon: FiEdit, method: (exam: IExam) => formModalRef.current?.handleOpenFormModal(exam) },
{ type: 'error', icon: FiTrash2, method: (exam: IExam) => handleDeleteExam(exam) },
]}
/>
</Box>
</BoxesContainer>
<ExamsFormModal ref={formModalRef} onSuccess={() => handleGetExams()} />
</PageLayout>
);
};
export default ExamsPage;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/quarters/dtos/interfaces/ICreateQuarter.ts
|
export interface ICreateQuarter {
academicYearId: string;
startDate: string;
endDate: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/Sidebar/Sidebar.component.tsx
|
<reponame>ES-UFABC/UFABCplanner
import { useMemo } from 'react';
import { SidebarButton } from '../SidebarButton';
import { MainLogo } from '../MainLogo';
import { pagesProps } from '../../hooks/usePageProps.hook';
import styles from './Sidebar.module.scss';
const Sidebar = () => {
const sidebarButtons = useMemo(() => {
return Object.keys(pagesProps).map(key => {
const { icon: Icon, title } = pagesProps[key];
return (
<SidebarButton key={key} linkTo={`/${key}`}>
<Icon />
{title}
</SidebarButton>
);
});
}, []);
return (
<div className={styles.sidebar}>
<MainLogo />
<div className={styles.btns_container}>
{sidebarButtons}
</div>
</div>
);
};
export default Sidebar;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/dtos/interfaces/ICreateAcademyYear.ts
|
export interface ICreateAcademyYear {
userId: string;
year: string;
startDate: string;
endDate: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/classes/ClassesModal/index.ts
|
<filename>ufabc_planner-frontend/src/components/specific/classes/ClassesModal/index.ts
export { default as ClassesModal } from './ClassesModal.component';
export type { ClassesModalRef } from './ClassesModal.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/test/entities/TaskFactory.ts
|
import { Subject, Task, User } from '@prisma/client';
import dayjs from 'dayjs';
import { prisma } from 'infra/prisma/client';
export async function createTask(subject: Subject, user: User): Promise<Task> {
return prisma.task.create({
data: {
subjectId: subject.id,
userId: user.id,
title: 'Titulo de task',
dueDate: dayjs().toDate(),
description: 'descrição de uma task',
},
});
}
export async function getTaskById(id: string): Promise<Task | null> {
return prisma.task.findUnique({ where: { id: id } });
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/http/routes/subjects.routes.ts
|
import { Router } from 'express';
import { CreateSubjectController } from 'modules/subjects/controllers/CreateSubjectController';
import { DeleteSubjectController } from 'modules/subjects/controllers/DeleteSubjectController';
import { GetSubjectByQuarterIdController } from 'modules/subjects/controllers/GetSubjectByQuarterIdController';
import { GetSubjectByUserIdController } from 'modules/subjects/controllers/GetSubjectByUserIdController';
import { UpdateSubjectController } from 'modules/subjects/controllers/UpdateSubjectController';
import { ensureAuthenticated } from '../middlewares/ensureAuthenticated';
const subjectsRoutes = Router();
const createSubjectController = new CreateSubjectController();
const deleteSubjectController = new DeleteSubjectController();
const updateSubjectController = new UpdateSubjectController();
const getSubjectByQuarterIdController = new GetSubjectByQuarterIdController();
const getSubjectByUserIdController = new GetSubjectByUserIdController();
subjectsRoutes.post('/', ensureAuthenticated, createSubjectController.handle);
subjectsRoutes.get('/get/quarter/:id', ensureAuthenticated, getSubjectByQuarterIdController.handle);
subjectsRoutes.get('/get/user', ensureAuthenticated, getSubjectByUserIdController.handle);
subjectsRoutes.delete('/delete/:id', ensureAuthenticated, deleteSubjectController.handle);
subjectsRoutes.put('/update/:id', ensureAuthenticated, updateSubjectController.handle);
export { subjectsRoutes };
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/hooks/usePageProps.hook.ts
|
import { useMemo } from "react";
import { IconType } from "react-icons";
import { FiAlertOctagon, FiArchive, FiCalendar, FiCheckCircle, FiFileText, FiGrid } from "react-icons/fi";
import { useLocation } from "react-router-dom";
export type UrlPage = 'dashboard' | 'calendar' | 'tasks' | 'exams' | 'schedule';
export const pagesProps: { [key: string]: { title: string, icon: IconType } } = {
dashboard: { title: 'Dashboard', icon: FiGrid },
calendar: { title: 'Calendário', icon: FiCalendar },
tasks: { title: 'Tarefas', icon: FiCheckCircle },
exams: { title: 'Avaliações', icon: FiFileText },
schedule: { title: 'Períodos e Matérias', icon: FiArchive },
};
const usePageProps = () => {
const { pathname } = useLocation();
const currentPage = pathname.split('/')[1];
const pageProps = useMemo(() => {
const props = pagesProps[currentPage];
if (!props) return { title: '404', icon: FiAlertOctagon };
return props;
}, [currentPage]);
return { pageProps };
}
export default usePageProps;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/quarters/services/DeleteQuarterService.ts
|
<filename>ufabc_planner-backend/src/modules/quarters/services/DeleteQuarterService.ts
import { IDateProvider } from 'infra/container/providers/DateProvider/IDateProvider';
import { AppError } from 'infra/http/errors/AppError';
import { injectable, inject } from 'tsyringe';
import { createQuarterDTO } from '../dtos/CreateQuarter.dto.';
import { DeleteQuarterDTO } from '../dtos/DeleteQuarter.dto';
import { IQuarterRepository } from '../repositories/IQuarterRepository';
@injectable()
export class DeleteQuarterService {
constructor(
@inject('PrismaQuarterRepository')
private QuarterRepository: IQuarterRepository,
@inject('DayjsDateProvider')
private dateProvider: IDateProvider
) {}
async execute(params: DeleteQuarterDTO) {
if (!(await this.QuarterRepository.quarterExists(params.id))) {
throw new AppError('Quadrimestre não existe');
}
await this.QuarterRepository.deleteQuarter(params.id);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/dtos/interfaces/ICreateExam.ts
|
export interface ICreateExam {
subjectId: string;
userId: string;
name: string;
dueDate: string;
time: string;
description?: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/pages/exams/index.ts
|
export { default as ExamsPage } from './ExamsPage.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/container/index.ts
|
import 'infra/container/providers';
import { container } from 'tsyringe';
import { IUsersRepository } from 'modules/accounts/repositories/IUsersRepository';
import { PrismaUserRepository } from 'modules/accounts/repositories/prisma/PrismaUserRepository';
import { IAcademicYearRepository } from 'modules/academicYears/repositories/IAcademicYearRepository';
import { PrismaAcademicYearRepository } from 'modules/academicYears/repositories/prisma/PrismaAcademicYearRepository';
import { IQuarterRepository } from 'modules/quarters/repositories/IQuarterRepository';
import { PrismaQuarterRepository } from 'modules/quarters/repositories/prisma/PrismaQuarterRepository';
import { ISubjectRepository } from 'modules/subjects/repositories/ISubjectRepository';
import { PrismaSubjectRepository } from 'modules/subjects/repositories/prisma/PrismaSubjectRepository';
import { IClassRepository } from 'modules/classes/repositories/IClassRepository';
import { PrismaClassRepository } from 'modules/classes/repositories/prisma/PrismaClassRepository';
import { ITaskRepository } from 'modules/tasks/repositories/ITaskRepository';
import { PrismaTaskRepository } from 'modules/tasks/repositories/prisma/PrismaTaskRepository';
import { IExamRepository } from 'modules/exams/repositories/IExamRepository';
import { PrismaExamRepository } from 'modules/exams/repositories/prisma/PrismaExamRepository';
container.registerSingleton<IUsersRepository>('PrismaUserRepository', PrismaUserRepository);
container.registerSingleton<IAcademicYearRepository>('PrismaAcademicYearRepository', PrismaAcademicYearRepository);
container.registerSingleton<IQuarterRepository>('PrismaQuarterRepository', PrismaQuarterRepository);
container.registerSingleton<ISubjectRepository>('PrismaSubjectRepository', PrismaSubjectRepository);
container.registerSingleton<IClassRepository>('PrismaClassRepository', PrismaClassRepository);
container.registerSingleton<ITaskRepository>('PrismaTaskRepository', PrismaTaskRepository);
container.registerSingleton<IExamRepository>('PrismaExamRepository', PrismaExamRepository);
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/controllers/UpdateExamController.ts
|
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { IUpdateExam } from '../dtos/interfaces/IUpdateExam';
import { UpdateExamDTO } from '../dtos/UpdateExam.dto';
import { UpdateExamService } from '../services/UpdateExamService';
export class UpdateExamController {
async execute(request: Request, response: Response) {
const responseBody = request.body as Omit<IUpdateExam, 'id'>;
const { id } = request.params;
const updateExamDTO = await validateInput(UpdateExamDTO, { id, ...responseBody });
await container.resolve(UpdateExamService).handle(updateExamDTO);
return response.status(204).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/services/UpdateExamService.ts
|
import { injectable, inject } from 'tsyringe';
import { UpdateExamDTO } from '../dtos/UpdateExam.dto';
import { IExamRepository } from '../repositories/IExamRepository';
@injectable()
export class UpdateExamService {
constructor(
@inject('PrismaExamRepository')
private examRepository: IExamRepository
) {}
async handle(params: UpdateExamDTO): Promise<void> {
await this.examRepository.updateExam(params);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/quarters/controllers/CreateQuarterController.ts
|
<gh_stars>1-10
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { createQuarterDTO } from '../dtos/CreateQuarter.dto.';
import { CreateQuarterService } from '../services/CreateQuarterService';
export class CreateQuarterController {
async handle(request: Request, response: Response): Promise<Response> {
const { academicYearId, startDate, endDate } = request.body;
const createQuarterDto = await validateInput(createQuarterDTO, { academicYearId, startDate, endDate });
await container.resolve(CreateQuarterService).execute(createQuarterDto);
return response.status(201).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/test/entities/QuarterFactory.ts
|
import { AcademicYear, Quarter } from '@prisma/client';
import dayjs from 'dayjs';
import { prisma } from 'infra/prisma/client';
export async function createQuarter(params: AcademicYear): Promise<Quarter> {
const quarter = await prisma.quarter.create({
data: {
academyYearId: params.id,
startDate: dayjs().toDate(),
endDate: dayjs().toDate(),
},
});
return quarter;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/MainLogo/index.ts
|
export { default as MainLogo } from './MainLogo.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/pages/tasks/index.ts
|
export { default as TasksPage } from './TasksPage.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/http/routes/tasks.routes.ts
|
import { Router } from 'express';
import { CreateTaskController } from 'modules/tasks/controllers/CreateTaskController';
import { DeleteTaskController } from 'modules/tasks/controllers/DeleteTaskController';
import { GetTasksBySubjectIdController } from 'modules/tasks/controllers/GetTasksBySubjectIdController';
import { GetTasksByUserIdController } from 'modules/tasks/controllers/GetTasksByUserIdController';
import { UpdateTaskController } from 'modules/tasks/controllers/UpdateTaskController';
import { ensureAuthenticated } from '../middlewares/ensureAuthenticated';
const tasksRoutes = Router();
const createTaskController = new CreateTaskController();
const deleteTaskController = new DeleteTaskController();
const updateTaskController = new UpdateTaskController();
const getTasksBySubjectIdController = new GetTasksBySubjectIdController();
const getTasksByUserIdController = new GetTasksByUserIdController();
tasksRoutes.post('/', ensureAuthenticated, createTaskController.execute);
tasksRoutes.delete('/delete/:id', ensureAuthenticated, deleteTaskController.execute);
tasksRoutes.get('/get/subject/:id', ensureAuthenticated, getTasksBySubjectIdController.execute);
tasksRoutes.get('/get/user', ensureAuthenticated, getTasksByUserIdController.execute);
tasksRoutes.put('/update/:id', ensureAuthenticated, updateTaskController.execute);
export { tasksRoutes };
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/classes/ClassItem/index.ts
|
<reponame>ES-UFABC/UFABCplanner
export { default as ClassItem } from './ClassItem.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/quarters/services/CreateQuarterService.ts
|
<filename>ufabc_planner-backend/src/modules/quarters/services/CreateQuarterService.ts
import { IDateProvider } from 'infra/container/providers/DateProvider/IDateProvider';
import { AppError } from 'infra/http/errors/AppError';
import { IAcademicYearRepository } from 'modules/academicYears/repositories/IAcademicYearRepository';
import { inject, injectable } from 'tsyringe';
import { createQuarterDTO } from '../dtos/CreateQuarter.dto.';
import { IQuarterRepository } from '../repositories/IQuarterRepository';
@injectable()
export class CreateQuarterService {
constructor(
@inject('PrismaQuarterRepository')
private QuarterRepository: IQuarterRepository,
@inject('PrismaAcademicYearRepository')
private academicYearRepository: IAcademicYearRepository,
@inject('DayjsDateProvider')
private dateProvider: IDateProvider
) {}
async execute(params: createQuarterDTO) {
const { academicYearId, startDate, endDate } = params;
const startDateUTC = this.dateProvider.toDate(startDate);
const endDateUTC = this.dateProvider.toDate(endDate);
if (!(await this.academicYearRepository.exists(academicYearId))) {
throw new AppError('Ano acadêmico não existe');
}
if (this.dateProvider.compareIfBefore(startDateUTC, endDateUTC)) {
throw new AppError('Data final é antes da data inicial');
}
await this.QuarterRepository.createQuarter({
academyYearId: academicYearId,
startDate: startDateUTC,
endDate: endDateUTC,
});
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/accounts/controllers/AuthenticateUserController.ts
|
import { Request, Response } from 'express';
import { container } from 'tsyringe';
import { validateInput } from 'infra/http/errors/validation';
import { AuthenticateUserDTO } from '../dtos/AuthenticateUser.dto';
import { AuthenticateUserService } from '../services/AuthenticateUserService';
class AuthenticateUserController {
async handle(request: Request, response: Response): Promise<Response> {
const { email, password } = request.body;
const authenticateUserService = container.resolve(AuthenticateUserService);
const authenticateUserDTO = await validateInput(AuthenticateUserDTO, { email, password });
const token = await authenticateUserService.execute(authenticateUserDTO);
return response.json(token);
}
}
export { AuthenticateUserController };
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/pages/calendar/index.ts
|
<filename>ufabc_planner-frontend/src/pages/calendar/index.ts<gh_stars>1-10
export { default as CalendarPage } from './CalendarPage.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/accounts/dtos/CreateUser.dto.ts
|
<reponame>ES-UFABC/UFABCplanner
import { IsEmail, isNotEmpty, IsNotEmpty, IsString } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { ICreateUser } from './interfaces/ICreateUser';
export class CreateUserDTO implements ICreateUser {
@IsNotEmpty({ message: messages.isNotEmpty })
@IsString()
name: string;
@IsNotEmpty({ message: messages.isNotEmpty })
@IsEmail()
@IsString()
email: string;
@IsNotEmpty({ message: messages.isNotEmpty })
@IsString()
password: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/pages/signin/index.ts
|
<filename>ufabc_planner-frontend/src/pages/signin/index.ts
export { default as SigninPage } from './SigninPage.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/controllers/GetTasksByUserId.spec.ts
|
<filename>ufabc_planner-backend/src/modules/tasks/controllers/GetTasksByUserId.spec.ts<gh_stars>1-10
import { app } from 'infra/http/app';
import supertest from 'supertest';
import { deleteAll, disconnect } from '../../../../test/database';
import { createAcademicYear } from '../../../../test/entities/AcademicYearFactory';
import { createQuarter } from '../../../../test/entities/QuarterFactory';
import { createSubject } from '../../../../test/entities/SubjectFactory';
import { createTask } from '../../../../test/entities/TaskFactory';
import { createUser, authenticateUser } from '../../../../test/entities/UserFactory';
describe('Get tasks by user Id (e2e)', () => {
beforeAll(async () => {
deleteAll();
});
afterAll(async () => {
disconnect();
});
it('Should return a task successfully using the user id', async () => {
const user = await createUser();
const token = await authenticateUser(user);
const academicYear = await createAcademicYear(user);
const quarter = await createQuarter(academicYear);
const subject = await createSubject(quarter, user);
const task = await createTask(subject, user);
const response = await supertest(app)
.get('/tasks/get/user')
.set('authorization', 'Bearer ' + token);
const responseBody = JSON.parse(response.text);
expect(response.status).toBe(200);
expect(responseBody.length).toBe(1);
});
});
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/config/auth.ts
|
export default {
secret_token: '<KEY>',
expires_in_token: '3d',
};
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/services/UpdateClassService.ts
|
import { AppError } from 'infra/http/errors/AppError';
import { injectable, inject } from 'tsyringe';
import { UpdateClassDTO } from '../dtos/UpdateClass.dto';
import { IClassRepository } from '../repositories/IClassRepository';
@injectable()
export class UpdateClassService {
constructor(
@inject('PrismaClassRepository')
private ClassRepository: IClassRepository
) {}
async handle(params: UpdateClassDTO) {
if (!(await this.ClassRepository.classExists(params.id))) {
throw new AppError('classe não existe');
}
await this.ClassRepository.updateClass(params);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/BoxesContainer/BoxesContainer.component.tsx
|
import styles from './BoxesContainer.module.scss';
interface Props {
children: React.ReactNode;
style?: React.CSSProperties;
}
const BoxesContainer = ({ children, style }: Props) => {
return (
<div className={styles.boxes_container} style={style}>
{children}
</div>
)
};
export default BoxesContainer;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/controllers/CreateTaskController.ts
|
<gh_stars>1-10
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { CreateTaskDTO } from '../dtos/CreateTask.dto';
import { ICreateTask } from '../dtos/interfaces/ICreateTask';
import { CreateTaskService } from '../services/CreateTaskService';
export class CreateTaskController {
async execute(request: Request, response: Response) {
const requestBody = request.body as Omit<ICreateTask, 'userId'>;
const { id: userId } = request.user;
const createTaskDTO = await validateInput(CreateTaskDTO, { userId, ...requestBody });
await container.resolve(CreateTaskService).handle(createTaskDTO);
return response.status(201).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/http/routes/exams.routes.ts
|
<gh_stars>1-10
import { Router } from 'express';
import { CreateExamController } from 'modules/exams/controllers/CreateExamController';
import { DeleteExamController } from 'modules/exams/controllers/DeleteExamController';
import { GetExamsBySubjectIdController } from 'modules/exams/controllers/GetExamsBySubjectIdController';
import { GetExamsByUserIdController } from 'modules/exams/controllers/GetExamsByUserIdController';
import { UpdateExamController } from 'modules/exams/controllers/UpdateExamController';
import { ensureAuthenticated } from '../middlewares/ensureAuthenticated';
const createExamController = new CreateExamController();
const deleteExamController = new DeleteExamController();
const updateExamController = new UpdateExamController();
const getExamsBySubjectIdController = new GetExamsBySubjectIdController();
const getExamsByUserIdController = new GetExamsByUserIdController();
const examsRoutes = Router();
examsRoutes.post('/', ensureAuthenticated, createExamController.execute);
examsRoutes.delete('/delete/:id', ensureAuthenticated, deleteExamController.execute);
examsRoutes.get('/get/subject/:id', ensureAuthenticated, getExamsBySubjectIdController.execute);
examsRoutes.get('/get/user', ensureAuthenticated, getExamsByUserIdController.execute);
examsRoutes.put('/update/:id', ensureAuthenticated, updateExamController.execute);
export { examsRoutes };
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/dtos/UpdateAcademicYear.dto.ts
|
<filename>ufabc_planner-backend/src/modules/academicYears/dtos/UpdateAcademicYear.dto.ts
import { IsDateString, IsNotEmpty, IsNumberString, IsOptional, IsUUID } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { IUpdateAcademyYear } from './interfaces/IUpdateAcademicYear';
export class UpdateAcademyYearDTO implements IUpdateAcademyYear {
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
id: string;
@IsNumberString({ message: messages.IsNumberString })
year?: string;
@IsDateString({ message: messages.IsDateString })
startDate: string;
@IsDateString({ message: messages.IsDateString })
endDate: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/services/UpdateTaskService.ts
|
<gh_stars>1-10
import { inject, injectable } from 'tsyringe';
import { UpdateTaskDTO } from '../dtos/UpdateTask.dto';
import { ITaskRepository } from '../repositories/ITaskRepository';
@injectable()
export class UpdateTaskService {
constructor(
@inject('PrismaTaskRepository')
private TaskRepository: ITaskRepository
) {}
async handle(params: UpdateTaskDTO): Promise<void> {
await this.TaskRepository.updateTask(params);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/repositories/prisma/PrismaTaskRepository.ts
|
<reponame>ES-UFABC/UFABCplanner
import { Task } from '@prisma/client';
import dayjs from 'dayjs';
import { prisma } from 'infra/prisma/client';
import { CreateTaskDTO } from 'modules/tasks/dtos/CreateTask.dto';
import { UpdateTaskDTO } from 'modules/tasks/dtos/UpdateTask.dto';
import { ITaskRepository } from '../ITaskRepository';
export class PrismaTaskRepository implements ITaskRepository {
async createTask(params: CreateTaskDTO): Promise<void> {
await prisma.task.create({ data: { ...params, dueDate: dayjs(params.dueDate, 'YYYY-MM-DD').toDate() } });
}
async deleteTask(id: string): Promise<void> {
await prisma.task.delete({ where: { id: id } });
}
async updateTask(params: UpdateTaskDTO): Promise<void> {
await prisma.task.update({
where: { id: params.id },
data: { ...params, dueDate: dayjs(params.dueDate).toDate() },
});
}
getTasksBySubjectId(subjectId: string): Promise<Task[]> {
return prisma.task.findMany({
where: {
subjectId: subjectId,
},
});
}
getTasksByUserId(userId: string): Promise<Task[]> {
return prisma.task.findMany({
where: {
userId: userId,
},
include: {
subject: {
select: {
id: true,
name: true,
},
},
},
});
}
async taskExists(id: string): Promise<Boolean> {
const taskExists = await prisma.task.findUnique({
where: {
id: id,
},
});
if (!taskExists) return false;
return true;
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/http/errors/messages.ts
|
<filename>ufabc_planner-backend/src/infra/http/errors/messages.ts
export const messages = {
IsString: '$property deve ser uma string válida',
IsUUID: '$property deve ser um uuid válido',
isNotEmpty: '$property não pode ser vazio',
IsNumberString: '$property deve ser uma string de número',
IsDateString: '$property deve ser uma string de data válida',
};
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/exams/ExamsFormModal/index.ts
|
export { default as ExamsFormModal } from './ExamsFormModal.component';
export type { ExamsFormModalRef } from './ExamsFormModal.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/repositories/prisma/PrismaExamRepository.ts
|
import { Exam } from '@prisma/client';
import dayjs from 'dayjs';
import { prisma } from 'infra/prisma/client';
import { CreateExamDTO } from 'modules/exams/dtos/CreateExam.dto';
import { UpdateExamDTO } from 'modules/exams/dtos/UpdateExam.dto';
import { IExamRepository } from '../IExamRepository';
export class PrismaExamRepository implements IExamRepository {
async createExam(params: CreateExamDTO): Promise<void> {
await prisma.exam.create({
data: {
...params,
dueDate: dayjs(params.dueDate).toDate(),
},
});
}
async deleteExam(id: string): Promise<void> {
await prisma.exam.delete({
where: {
id: id,
},
});
}
async updateExam(params: UpdateExamDTO): Promise<void> {
await prisma.exam.update({
where: {
id: params.id,
},
data: {
...params,
dueDate: dayjs(params.dueDate).toDate(),
},
});
}
async getExamsBySubjectId(subjectId: string): Promise<Exam[]> {
return prisma.exam.findMany({
where: {
subjectId: subjectId,
},
});
}
async getExamsByUserId(userId: string): Promise<Exam[]> {
return prisma.exam.findMany({
where: {
userId: userId,
},
});
}
async ExamExists(id: string): Promise<boolean> {
const exam = await prisma.exam.findUnique({
where: {
id: id,
},
});
if (!exam) return false;
return true;
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/test/entities/ExamFactory.ts
|
<filename>ufabc_planner-backend/test/entities/ExamFactory.ts
import { Subject, User } from '@prisma/client';
import dayjs from 'dayjs';
import { prisma } from 'infra/prisma/client';
export async function createExam(subject: Subject, user: User) {
return prisma.exam.create({
data: {
subjectId: subject.id,
userId: user.id,
name: 'prova de FUV',
dueDate: dayjs().toDate(),
time: '10:00',
description: 'descrição de uma prova',
},
});
}
export async function findExamById(id: string) {
return prisma.exam.findUnique({
where: {
id: id,
},
});
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/http/routes/users.routes.ts
|
<reponame>ES-UFABC/UFABCplanner
import { Router } from 'express';
import { AuthenticateUserController } from 'modules/accounts/controllers/AuthenticateUserController';
import { CreateUserController } from 'modules/accounts/controllers/CreateUserController';
const usersRoutes = Router();
const createUserController = new CreateUserController();
const authenticateUserController = new AuthenticateUserController();
usersRoutes.post('/', createUserController.handle);
usersRoutes.post('/login', authenticateUserController.handle);
export { usersRoutes };
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/services/GetAcademicYearByUserIdService.ts
|
<reponame>ES-UFABC/UFABCplanner<filename>ufabc_planner-backend/src/modules/academicYears/services/GetAcademicYearByUserIdService.ts
import { AcademicYear } from '@prisma/client';
import { start } from 'repl';
import { inject, injectable } from 'tsyringe';
import { AppError } from 'infra/http/errors/AppError';
import { prisma } from 'infra/prisma/client';
import { IAcademicYearRepository } from '../repositories/IAcademicYearRepository';
@injectable()
export class GetAcademicYearByUserIdService {
constructor(
@inject('PrismaAcademicYearRepository')
private academicYearRepository: IAcademicYearRepository
) {}
async execute(userId: string): Promise<Partial<AcademicYear>[]> {
const academicYears = await this.academicYearRepository.getByUserId(userId);
return academicYears.map((value) => {
return {
id: value.id,
year: value.year,
startDate: value.start_date.toISOString().split('T')[0],
endDate: value.end_date.toISOString().split('T')[0],
};
});
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/interfaces/exam.ts
|
<gh_stars>1-10
export interface IExam {
id: string;
name: string;
subjectId: string;
dueDate: string;
time: string;
description?: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/SelectInput/SelectInput.component.tsx
|
import { SelectHTMLAttributes, useEffect, useRef } from 'react';
import { useField } from '@unform/core';
import styles from './SelectInput.module.scss';
interface Props extends SelectHTMLAttributes<HTMLSelectElement> {
label: string;
name: string
}
const SelectInput: React.FC<Props> = ({ children, name, label, ...rest }) => {
const { fieldName, defaultValue, registerField } = useField(name);
const inputRef = useRef<HTMLSelectElement>(null);
useEffect(() => {
registerField({
name: fieldName,
ref: inputRef.current,
path: 'value',
});
}, [fieldName, registerField]);
return (
<div className={styles.input_container}>
<label htmlFor={name} className={styles.input_label}>{label}</label>
<select className={styles.basic_input} defaultValue={defaultValue} name={name} ref={inputRef} {...rest}>
{children}
</select>
</div>
);
};
export default SelectInput;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/services/GetSubjectByUserIdService.ts
|
<filename>ufabc_planner-backend/src/modules/subjects/services/GetSubjectByUserIdService.ts<gh_stars>1-10
import { Subject } from '@prisma/client';
import { injectable, inject } from 'tsyringe';
import { GetSubjectByUserIdDTO } from '../dtos/GetSubjectByUserId.dto';
import { ISubjectRepository } from '../repositories/ISubjectRepository';
@injectable()
export class GetSubjectByUserIdService {
constructor(
@inject('PrismaSubjectRepository')
private subjectRepository: ISubjectRepository
) {}
async execute({ id }: GetSubjectByUserIdDTO): Promise<Subject[]> {
return this.subjectRepository.getSubjectByUserId(id);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/Modal/index.ts
|
export { default as Modal } from './Modal.component';
export type { ModalRef } from './Modal.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/SidebarButton/SidebarButton.component.tsx
|
<reponame>ES-UFABC/UFABCplanner
import clsx from 'clsx';
import { Link, useLocation } from 'react-router-dom';
import styles from './SidebarButton.module.scss';
interface Props {
children: React.ReactNode;
selected?: boolean;
linkTo: string;
}
const SidebarButton = ({ children, selected, linkTo }: Props) => {
const { pathname } = useLocation();
return (
<Link to={linkTo} style={{ textDecoration: 'none' }}>
<button className={clsx(styles.sidebar_btn, { [styles.selected]: pathname.includes(linkTo) })}>
{children}
</button>
</Link>
);
};
export default SidebarButton;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/dtos/GetSubjectByQuarterId.dto.ts
|
<filename>ufabc_planner-backend/src/modules/subjects/dtos/GetSubjectByQuarterId.dto.ts
import { IsUUID, IsNotEmpty } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { IGetSubjectByQuarterId } from './interfaces/IGetSubjectByQuarterId';
export class GetSubjectByQuarterIdDTO implements IGetSubjectByQuarterId {
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
quarterId: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/quarters/dtos/CreateQuarter.dto..ts
|
<reponame>ES-UFABC/UFABCplanner<gh_stars>1-10
import { IsDateString, IsNotEmpty, IsUUID } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { ICreateQuarter } from './interfaces/ICreateQuarter';
export class createQuarterDTO implements ICreateQuarter {
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
academicYearId: string;
@IsNotEmpty({ message: messages.isNotEmpty })
@IsDateString({ message: messages.IsDateString })
startDate: string;
@IsNotEmpty({ message: messages.isNotEmpty })
@IsDateString({ message: messages.IsDateString })
endDate: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/services/DeleteTaskService.ts
|
<filename>ufabc_planner-backend/src/modules/tasks/services/DeleteTaskService.ts
import { AppError } from 'infra/http/errors/AppError';
import { inject, injectable } from 'tsyringe';
import { DeleteTaskDTO } from '../dtos/DeleteTask.dto';
import { ITaskRepository } from '../repositories/ITaskRepository';
@injectable()
export class DeleteTaskService {
constructor(
@inject('PrismaTaskRepository')
private TaskRepository: ITaskRepository
) {}
async handle({ id }: DeleteTaskDTO): Promise<void> {
if (!(await this.TaskRepository.taskExists(id))) {
throw new AppError('Essa task não existe');
}
await this.TaskRepository.deleteTask(id);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/PageLayout/PageLayout.component.tsx
|
<filename>ufabc_planner-frontend/src/components/PageLayout/PageLayout.component.tsx
import styles from './PageLayout.module.scss';
interface Props {
children: React.ReactNode;
}
const PageLayout = ({ children }: Props) => {
return (
<div className={styles.page_layout}>
<div className={styles.page_content}>
{children}
</div>
<div className={styles.footer}>
Footer legalzinho pro UFABCplanner | 2022
</div>
</div>
);
};
export default PageLayout;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.