repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
viniciusflv/gatsby-ts
|
src/components/Core/Flex/style.ts
|
import styled from 'styled-components';
import { FlexProps } from './interface';
import { Container } from '../Container';
export const FlexStyle = styled(Container).attrs(({ display }: FlexProps) => ({
display: display || 'flex',
}))<FlexProps>`
${({ direction }) => direction && `flex-direction:${direction};`}
${({ justifyContent }) =>
justifyContent && `justify-content:${justifyContent};`}
${({ alignItems }) => alignItems && `align-items:${alignItems};`}
${({ wrap }) => wrap && `flex-wrap:${wrap};`}
${({ gap }) => gap && `> * { margin:${gap} !important; }`}
`;
|
viniciusflv/gatsby-ts
|
src/components/Core/Svg/index.tsx
|
import React, { FC, Fragment, memo, useEffect, useState } from 'react';
import { v4 as uuid } from 'uuid';
import { Animate, Gradient, SvgAsset, SvgProps } from './interface';
import { SvgStyle, WrapperStyle } from './style';
import assets from '../../../assets';
export const Svg: FC<SvgProps> = memo(({ vector, color, ...flexProps }) => {
const [svg, setSvg] = useState<SvgAsset>();
const id = uuid();
useEffect(() => {
setSvg(assets[vector] as SvgAsset);
}, [vector]);
function renderStops({ stops }: Gradient) {
return stops?.map(({ stopColor, offset }) => (
<stop key={offset + stopColor} offset={offset} style={{ stopColor }} />
));
}
function renderLinearGradient(linearGradient: Gradient) {
return (
<linearGradient id={id}>{renderStops(linearGradient)}</linearGradient>
);
}
function renderRadialGradient(radialGradient: Gradient) {
return (
<radialGradient id={id}>{renderStops(radialGradient)}</radialGradient>
);
}
function renderAnimation(animates: Array<Animate>) {
return animates.map((animate) => (
<animate key={JSON.stringify(animate)} {...animate} />
));
}
function renderPaths({ paths, linearGradient, radialGradient }: SvgAsset) {
return (
<Fragment>
{linearGradient && renderLinearGradient(linearGradient)}
{radialGradient && renderRadialGradient(radialGradient)}
{paths.map(({ animates, fill, ...path }) => (
<path
{...path}
key={JSON.stringify(path)}
fill={color || (
Boolean(linearGradient || radialGradient)
? `url(#${id})`
: fill
)}
>
{animates && renderAnimation(animates)}
</path>
))}
</Fragment>
);
}
return (
<WrapperStyle {...flexProps}>
<SvgStyle viewBox={svg?.viewBox} fill={color || svg?.fill}>
{svg && renderPaths(svg)}
</SvgStyle>
</WrapperStyle>
);
});
|
viniciusflv/gatsby-ts
|
src/components/Core/IconText/model.ts
|
<gh_stars>0
import { IconProps, IconTextProps } from './interface';
import { FlexProps } from '../Flex/interface';
import { SvgProps } from '../Svg/interface';
import { TextProps } from '../Text/interface';
export class IconTextModel {
public WrapperModel: FlexProps;
public TextModel: TextProps;
public FirstIconModel: SvgProps | any;
public LastIconModel: SvgProps | any;
constructor({
direction,
first,
last,
fill,
size = 1,
...props
}: IconTextProps) {
function vectorHandler(vector?: IconProps) {
const vectorProps = {
color: fill,
width: `${size + 0.5}em`,
height: `${size + 0.5}em`,
};
return typeof vector === 'string'
? { ...vectorProps, vector }
: { ...vector, ...vectorProps };
}
this.WrapperModel = {
justifyContent: 'center',
alignItems: 'center',
direction,
};
this.TextModel = {
grow: '2',
margin: '.1em',
position: 'relative',
...props,
size: `${size}em`,
};
this.FirstIconModel = vectorHandler(first);
this.LastIconModel = vectorHandler(last);
}
}
|
viniciusflv/gatsby-ts
|
src/components/Core/Link/style.ts
|
<gh_stars>0
import { Link } from 'gatsby';
import { Text } from '../Text';
export const LinkStyle = Link;
export const TextStyle = Text;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/controllers/DeleteAcademicYearController.ts
|
import { Request, Response } from 'express';
import { container } from 'tsyringe';
import { validateInput } from 'infra/http/errors/validation';
import { DeleteAcademyYearDTO } from '../dtos/DeleteAcademyYea.dto';
import { DeleteAcademicYearService } from '../services/DeleteAcademicYearService';
export class DeleteAcademicYearController {
async handle(request: Request, response: Response): Promise<Response> {
const { id: academicYearId } = request.params;
const { id: userId } = request.user;
const createAcademicYearService = container.resolve(DeleteAcademicYearService);
const deleteAcademyYearDTO = await validateInput(DeleteAcademyYearDTO, { academicYearId });
await createAcademicYearService.execute(deleteAcademyYearDTO, userId);
return response.status(204).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/http/routes/index.ts
|
import { Router } from 'express';
import { academicYearRoutes } from './academicYears.routes';
import { classRoutes } from './classes.routes';
import { examsRoutes } from './exams.routes';
import { quartersRoutes } from './quarters.routes';
import { subjectsRoutes } from './subjects.routes';
import { tasksRoutes } from './tasks.routes';
import { usersRoutes } from './users.routes';
const router = Router();
router.use('/users', usersRoutes);
router.use('/academicyears', academicYearRoutes);
router.use('/quarters', quartersRoutes);
router.use('/subjects', subjectsRoutes);
router.use('/classes', classRoutes);
router.use('/tasks', tasksRoutes);
router.use('/exams', examsRoutes);
export { router };
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/services/GetClassesBySubjectIdService.ts
|
import { Class } from '@prisma/client';
import { AppError } from 'infra/http/errors/AppError';
import { ISubjectRepository } from 'modules/subjects/repositories/ISubjectRepository';
import { injectable, inject } from 'tsyringe';
import { GetClassesBySubjectIdDTO } from '../dtos/GetClassesBySubjectId.dto';
import { IClassRepository } from '../repositories/IClassRepository';
@injectable()
export class GetClassesBySubjectIdService {
constructor(
@inject('PrismaClassRepository')
private ClassRepository: IClassRepository,
@inject('PrismaSubjectRepository')
private subjectRepository: ISubjectRepository
) {}
async handle({ id }: GetClassesBySubjectIdDTO): Promise<Class[]> {
if (!(await this.subjectRepository.subjectExists(id))) {
throw new AppError('A matéria não existe');
}
return this.ClassRepository.getClassesBySubjectId(id);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/quarters/controllers/DeleteQuarterController.ts
|
<reponame>ES-UFABC/UFABCplanner
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { DeleteQuarterDTO } from '../dtos/DeleteQuarter.dto';
import { DeleteQuarterService } from '../services/DeleteQuarterService';
export class DeleteQuarterController {
async handle(request: Request, response: Response): Promise<Response> {
const { id } = request.params;
const deleteQuarterDto = await validateInput(DeleteQuarterDTO, { id });
await container.resolve(DeleteQuarterService).execute(deleteQuarterDto);
return response.status(204).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/academic_years/AcademicYearFormModal/index.ts
|
export { default as AcademicYearFormModal } from './AcademicYearFormModal.component';
export type { AcademicYearFormModalRef } from './AcademicYearFormModal.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/subjects/SubjectFormModal/index.ts
|
export { default as SubjectFormModal } from './SubjectFormModal.component';
export type { SubjectFormModalRef } from './SubjectFormModal.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/services/DeleteAcademicYearService.ts
|
import { CreateUserService } from 'modules/accounts/services/CreateUserService';
import { inject, injectable } from 'tsyringe';
import { AppError } from 'infra/http/errors/AppError';
import { DeleteAcademyYearDTO } from '../dtos/DeleteAcademyYea.dto';
import { prisma } from 'infra/prisma/client';
import { IAcademicYearRepository } from '../repositories/IAcademicYearRepository';
@injectable()
export class DeleteAcademicYearService {
constructor(
@inject('PrismaAcademicYearRepository')
private academicYearRepository: IAcademicYearRepository
) {}
async execute(params: DeleteAcademyYearDTO, userId: string): Promise<void> {
const { academicYearId } = params;
const academicYear = await this.academicYearRepository.getByAcademicYearId(academicYearId);
if (!academicYear) throw new AppError('Ano acadêmico não existe');
if (academicYear.userId !== userId) throw new AppError('Usuário não é dono desse ano academico');
await this.academicYearRepository.delete(academicYearId);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/repositories/ITaskRepository.ts
|
<reponame>ES-UFABC/UFABCplanner
import { Task } from '@prisma/client';
import { CreateTaskDTO } from '../dtos/CreateTask.dto';
import { UpdateTaskDTO } from '../dtos/UpdateTask.dto';
export interface ITaskRepository {
createTask(params: CreateTaskDTO): Promise<void>;
deleteTask(id: string): Promise<void>;
updateTask(params: UpdateTaskDTO): Promise<void>;
getTasksBySubjectId(subjectId: string): Promise<Task[]>;
getTasksByUserId(userId: string): Promise<Task[]>;
taskExists(id: string): Promise<Boolean>;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/dtos/GetClassesBySubjectId.dto.ts
|
<gh_stars>1-10
import { IsUUID, IsNotEmpty } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { IGetClassesBySubjectId } from './interfaces/IGetClassesBySubjectId';
export class GetClassesBySubjectIdDTO implements IGetClassesBySubjectId {
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
id: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/dtos/interfaces/ICreateClass.ts
|
<reponame>ES-UFABC/UFABCplanner<filename>ufabc_planner-backend/src/modules/classes/dtos/interfaces/ICreateClass.ts
import { BiweeklyType, Weekdays } from '@prisma/client';
export interface ICreateClass {
professor?: string;
room?: string;
campus?: string;
building?: string;
startTime: string;
endTime: string;
weekday: Weekdays;
biweeklyType?: BiweeklyType;
subjectId: string;
userId: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/MainHeader/MainHeader.component.tsx
|
<reponame>ES-UFABC/UFABCplanner
import { FiLogOut } from 'react-icons/fi';
import { useAuth } from '../../contexts/auth';
import usePageProps from '../../hooks/usePageProps.hook';
import { Button } from '../Button';
import styles from './MainHeader.module.scss';
const MainHeader = () => {
const { pageProps: { title, icon: Icon } } = usePageProps();
const { logout } = useAuth();
return (
<div className={styles.main_header}>
<h2><Icon />{title}</h2>
<Button btnType='secondary' style={{ width: '100px' }} onClick={logout}>
<FiLogOut/>Logout
</Button>
</div>
);
};
export default MainHeader;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/tasks/TasksFormModal/index.ts
|
<reponame>ES-UFABC/UFABCplanner
export { default as TasksFormModal } from './TasksFormModal.component';
export type { TaskFormModalRef } from './TasksFormModal.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/pages/calendar/CalendarPage.component.tsx
|
import { PageLayout } from "../../components/PageLayout";
const CalendarPage = () => {
return (
<PageLayout>
Aqui vai ficar o Calendário
</PageLayout>
);
};
export default CalendarPage;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/test/utils.ts
|
import lodash from 'lodash';
import { randomEmails, randomNames } from './constants';
export function pickRandomObject<T>(params: T[]): T | undefined {
return lodash.sample(params);
}
export function pickRandomName(): string {
return pickRandomObject(randomNames) || 'teste';
}
export function generateRandomEmail(): string {
return `${pickRandomName()}@${pickRandomObject(randomEmails)}`;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/IconButton/IconButton.component.tsx
|
import clsx from 'clsx';
import { IconBaseProps } from 'react-icons';
import { Loader } from '../Loader';
import styles from './IconButton.module.scss';
export type IconBtnType = 'standard' | 'primary' | 'info' | 'error';
interface Props {
icon: React.ComponentType<IconBaseProps>;
btnType?: IconBtnType;
onClick: () => void;
loading?: boolean;
}
const IconButton = ({ icon: Icon, btnType = 'standard', onClick, loading = false }: Props) => {
return (
<div className={clsx(styles.icon_button, styles[btnType])} onClick={onClick}>
{loading ? <Loader /> : <Icon size={20} />}
</div>
);
};
export default IconButton;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/services/GetTasksByUserIdService.ts
|
import { Task } from '@prisma/client';
import { inject, injectable } from 'tsyringe';
import { GetTasksByUserIdDTO } from '../dtos/GetTasksByUserId.dto';
import { ITaskRepository } from '../repositories/ITaskRepository';
@injectable()
export class GetTasksByUserIdService {
constructor(
@inject('PrismaTaskRepository')
private TaskRepository: ITaskRepository
) {}
async handle({ id }: GetTasksByUserIdDTO): Promise<Task[]> {
return this.TaskRepository.getTasksByUserId(id);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/controllers/UpdateClassController.ts
|
<filename>ufabc_planner-backend/src/modules/classes/controllers/UpdateClassController.ts
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { IUpdateClass } from '../dtos/interfaces/IUpdateClass';
import { UpdateClassDTO } from '../dtos/UpdateClass.dto';
import { UpdateClassService } from '../services/UpdateClassService';
export class UpdateClassController {
async execute(request: Request, response: Response) {
const responseBody = request.body as Omit<IUpdateClass, 'id'>;
const { id } = request.params;
const updateClassDTO = await validateInput(UpdateClassDTO, { id, ...responseBody });
await container.resolve(UpdateClassService).handle(updateClassDTO);
return response.status(204).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/dtos/interfaces/ICreateSubject.ts
|
export interface ICreateSubject {
userId: string;
quarterId: string;
name: string;
description?: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/test/constants.ts
|
<gh_stars>1-10
export const validPassword = '<PASSWORD>';
export const randomNames = ['Eliza', 'Martinho', 'Felipe', 'Gabriel', 'Jorge', 'Vinicius', 'Leonardo', 'Lucas'];
export const randomEmails = ['yahoo.com', 'gmail.com', 'hotmail.com', 'fake.com', 'user.com', 'test.com', 'mayo.com'];
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/MainHeader/index.ts
|
export { default as MainHeader } from './MainHeader.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/routes/AuthenticatedRoutes.tsx
|
import { Navigate, Route, Routes, } from "react-router-dom";
import { CalendarPage } from "../pages/calendar";
import { DashboardPage } from "../pages/dashboard";
import { ExamsPage } from "../pages/exams";
import { SchedulePage } from "../pages/schedule";
import { TasksPage } from "../pages/tasks";
const AuthenticatedRoutes = () => {
return (
<Routes>
<Route path="*" element={<Navigate to="/dashboard" replace/>} />
<Route path="/dashboard" element={<DashboardPage />} />
<Route path="/calendar" element={<CalendarPage />} />
<Route path="/tasks" element={<TasksPage />} />
<Route path="/exams" element={<ExamsPage />} />
<Route path="/schedule" element={<SchedulePage />} />
</Routes>
);
}
export default AuthenticatedRoutes;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/dtos/interfaces/IGetSubjectByQuarterId.ts
|
<filename>ufabc_planner-backend/src/modules/subjects/dtos/interfaces/IGetSubjectByQuarterId.ts
export interface IGetSubjectByQuarterId {
quarterId: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/dtos/interfaces/IDeleteSubject.ts
|
export interface IDeleteSubject {
id: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/Button/Button.component.tsx
|
<gh_stars>1-10
import clsx from 'clsx';
import { ButtonHTMLAttributes } from 'react';
import { Loader } from '../Loader';
import styles from './Button.module.scss';
interface Props extends ButtonHTMLAttributes<HTMLButtonElement> {
children: React.ReactNode;
loading?: boolean;
btnType?: 'primary' | 'secondary';
}
const Button = ({ children, loading, btnType = 'primary', ...rest }: Props) => {
return (
<button {...rest} className={clsx(styles.default_btn, styles[btnType])}>
{loading ? <Loader /> : children}
</button>
);
};
export default Button;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/services/GetExamsByUserIdService.ts
|
<gh_stars>1-10
import { Exam } from '@prisma/client';
import { injectable, inject } from 'tsyringe';
import { GetExamsByUserIdDTO } from '../dtos/GetExamsByUserId.dto';
import { IExamRepository } from '../repositories/IExamRepository';
@injectable()
export class GetExamsByUserIdService {
constructor(
@inject('PrismaExamRepository')
private ExamRepository: IExamRepository
) {}
async handle({ id }: GetExamsByUserIdDTO): Promise<Exam[]> {
return this.ExamRepository.getExamsByUserId(id);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/repositories/prisma/PrismaAcademicYearRepository.ts
|
<filename>ufabc_planner-backend/src/modules/academicYears/repositories/prisma/PrismaAcademicYearRepository.ts
import { AcademicYear } from '@prisma/client';
import { prisma } from 'infra/prisma/client';
import { CreateAcademyYearDTO } from 'modules/academicYears/dtos/CreateAcademyYear.dto';
import { UpdateAcademyYearDTO } from 'modules/academicYears/dtos/UpdateAcademicYear.dto';
import { IAcademicYearRepository } from '../IAcademicYearRepository';
type updateAcademicYear = {
id: string;
year: string | undefined;
startDate: Date;
endDate: Date;
};
export class PrismaAcademicYearRepository implements IAcademicYearRepository {
async create(academicYear: Omit<AcademicYear, 'id' | 'created_at'>): Promise<void> {
await prisma.academicYear.create({
data: {
userId: academicYear.userId,
year: academicYear.year,
start_date: academicYear.start_date,
end_date: academicYear.end_date,
},
});
}
async delete(academicYearId: string): Promise<void> {
await prisma.academicYear.delete({
where: {
id: academicYearId,
},
});
}
async getByUserId(userId: string): Promise<AcademicYear[]> {
return prisma.academicYear.findMany({
where: {
userId: userId,
},
});
}
async update(academicYear: updateAcademicYear): Promise<void> {
await prisma.academicYear.update({
where: {
id: academicYear.id,
},
data: {
year: academicYear.year,
start_date: academicYear.startDate,
end_date: academicYear.endDate,
},
});
}
async exists(academicYearId: string): Promise<boolean> {
const academicYear = await prisma.academicYear.findUnique({
where: {
id: academicYearId,
},
});
if (!academicYear) return false;
return true;
}
async getByAcademicYearId(academicYearId: string): Promise<AcademicYear | null> {
return prisma.academicYear.findUnique({
where: {
id: academicYearId,
},
});
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/services/DeleteClassService.ts
|
<reponame>ES-UFABC/UFABCplanner
import { AppError } from 'infra/http/errors/AppError';
import { injectable, inject } from 'tsyringe';
import { DeleteClassDTO } from '../dtos/DeleteClass.dto';
import { IClassRepository } from '../repositories/IClassRepository';
@injectable()
export class DeleteClassService {
constructor(
@inject('PrismaClassRepository')
private ClassRepository: IClassRepository
) {}
async handle({ id }: DeleteClassDTO) {
if (!(await this.ClassRepository.classExists(id))) {
throw new AppError('classe não existe');
}
await this.ClassRepository.deleteClass(id);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/controllers/CreateClassController.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 { authenticateUser, createUser } from '../../../../test/entities/UserFactory';
describe('Create class (e2e)', () => {
beforeAll(async () => {
deleteAll();
});
afterAll(async () => {
disconnect();
});
it('Should create a class successfully', 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 response = await supertest(app)
.post('/classes/')
.set('authorization', 'Bearer ' + token)
.send({
subjectId: subject.id,
professor: '<NAME>',
room: 'A202',
campus: '<NAME>',
building: 'Bloco A',
startTime: '10:00',
endTime: '12:00',
weekday: 'seg',
biweeklyType: 'week1',
});
expect(response.status).toBe(201);
});
});
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/services/CreateExamService.ts
|
<filename>ufabc_planner-backend/src/modules/exams/services/CreateExamService.ts
import { injectable, inject } from 'tsyringe';
import { CreateExamDTO } from '../dtos/CreateExam.dto';
import { IExamRepository } from '../repositories/IExamRepository';
@injectable()
export class CreateExamService {
constructor(
@inject('PrismaExamRepository')
private ExamRepository: IExamRepository
) {}
async handle(params: CreateExamDTO): Promise<void> {
await this.ExamRepository.createExam(params);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/controllers/GetSubjectByQuarterIdController.ts
|
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { GetSubjectByQuarterIdDTO } from '../dtos/GetSubjectByQuarterId.dto';
import { GetSubjectByQuarterIdService } from '../services/GetSubjectByQuarterIdService';
export class GetSubjectByQuarterIdController {
async handle(request: Request, response: Response): Promise<Response> {
const { id: quarterId } = request.params;
const GetSubjectByQuarterIdDto = await validateInput(GetSubjectByQuarterIdDTO, { quarterId });
const quarters = await container.resolve(GetSubjectByQuarterIdService).execute(GetSubjectByQuarterIdDto);
return response.json(quarters).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/Input/Input.component.tsx
|
<filename>ufabc_planner-frontend/src/components/Input/Input.component.tsx<gh_stars>1-10
import { InputHTMLAttributes, useEffect, useRef } from 'react';
import { useField } from '@unform/core'
import styles from './Input.module.scss';
interface Props extends InputHTMLAttributes<HTMLInputElement> {
label: string;
name: string
}
const Input = ({ label, name, ...rest }: Props) => {
const inputRef = useRef(null);
const { fieldName, registerField } = useField(name);
useEffect(() => {
registerField({
name: fieldName,
ref: inputRef,
getValue: ref => {
return ref.current.value
},
setValue: (ref, value) => {
ref.current.value = value
},
clearValue: ref => {
ref.current.value = ''
},
})
}, [fieldName, registerField])
return (
<div className={styles.input_container}>
<label htmlFor={name} className={styles.input_label}>{label}</label>
<input ref={inputRef} {...rest} name={name} className={styles.basic_input} />
</div>
)
};
export default Input;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/controllers/GetClassesBySubjectIdController.ts
|
<reponame>ES-UFABC/UFABCplanner
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { GetClassesBySubjectIdDTO } from '../dtos/GetClassesBySubjectId.dto';
import { GetClassesBySubjectIdService } from '../services/GetClassesBySubjectIdService';
export class GetClassesBySubjectIdController {
async execute(request: Request, response: Response) {
const { id } = request.params;
const getClassesBySubjectIdDTO = await validateInput(GetClassesBySubjectIdDTO, { id });
const classes = await container.resolve(GetClassesBySubjectIdService).handle(getClassesBySubjectIdDTO);
return response.json(classes).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/utils/date.ts
|
<reponame>ES-UFABC/UFABCplanner
export const toShortDate = (date: Date) => {
return date.toLocaleDateString('pt-BR', { timeZone: 'UTC' });
};
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/quarters/controllers/GetQuarterByAcademicYearIdController.ts
|
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { GetQuarterByAcademicYearIdDTO } from '../dtos/GetQuarterByAcademicYearId.dto';
import { GetQuarterByAcademicYearIdService } from '../services/GetQuarterByAcademicYearIdService';
export class GetQuarterByAcademicYearIdController {
async handle(request: Request, response: Response): Promise<Response> {
const { id: academicYearId } = request.params;
const GetQuarterByAcademicYearIdDto = await validateInput(GetQuarterByAcademicYearIdDTO, { academicYearId });
const quarters = await container.resolve(GetQuarterByAcademicYearIdService).execute(GetQuarterByAcademicYearIdDto);
return response.json(quarters).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/classes/ClassItem/ClassItem.component.tsx
|
import { useCallback, useState } from "react";
import { FiTrash2 } from "react-icons/fi";
import { IClass, translateBiweeklyType, translateWeekday } from "../../../../interfaces/class";
import api from "../../../../services/api";
import { IconButton } from "../../../IconButton";
import styles from './ClassItem.module.scss';
interface Props {
klass: IClass;
onDelete: () => void;
}
const ClassItem = ({ klass, onDelete }: Props) => {
const [deleteLoading, setDeleteLoading] = useState(false);
const handleDeleteClass = useCallback(async () => {
setDeleteLoading(true);
await api
.delete(`/classes/delete/${klass.id}`)
.then(() => onDelete())
.catch(error => alert(error))
.finally(() => setDeleteLoading(false));
}, [klass.id, onDelete]);
return (
<div className={styles.item_container}>
<div className={styles.info_container}>
<b>{translateWeekday[klass.weekday]}{klass.biweeklyType && ` - ${translateBiweeklyType[klass.biweeklyType]}`}, das {klass.startTime} às {klass.endTime}</b>
{(klass.bulding || klass.campus || klass.room) &&
<div>{klass.campus && ` | ${klass.campus} | `}{klass.bulding && ` | ${klass.bulding} | `}{klass.room && ` | ${klass.room} | `}</div>
}
{klass.professor && <div>{klass.professor}</div>}
</div>
<IconButton btnType="error" icon={FiTrash2} onClick={() => handleDeleteClass()} loading={deleteLoading}/>
</div>
)
}
export default ClassItem;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/dtos/interfaces/IUpdateClass.ts
|
import { BiweeklyType, Weekdays } from '@prisma/client';
export interface IUpdateClass {
id: string;
professor?: string;
room?: string;
campus?: string;
building?: string;
startTime: string;
endTime: string;
weekday?: Weekdays;
biweeklyType?: BiweeklyType;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/controllers/GetExamsByUserIdController.ts
|
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { GetExamsByUserIdDTO } from '../dtos/GetExamsByUserId.dto';
import { GetExamsByUserIdService } from '../services/GetExamsByUserIdService';
export class GetExamsByUserIdController {
async execute(request: Request, response: Response) {
const { id } = request.user;
const getExamsByUserIdDTO = await validateInput(GetExamsByUserIdDTO, { id });
const exams = await container.resolve(GetExamsByUserIdService).handle(getExamsByUserIdDTO);
return response.json(exams).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/repositories/IExamRepository.ts
|
import { Exam } from '@prisma/client';
import { CreateExamDTO } from '../dtos/CreateExam.dto';
import { UpdateExamDTO } from '../dtos/UpdateExam.dto';
export interface IExamRepository {
createExam(params: CreateExamDTO): Promise<void>;
deleteExam(id: string): Promise<void>;
updateExam(params: UpdateExamDTO): Promise<void>;
getExamsBySubjectId(subjectId: string): Promise<Exam[]>;
getExamsByUserId(userId: string): Promise<Exam[]>;
ExamExists(id: string): Promise<boolean>;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/services/GetClassesByUserIdService.ts
|
import { Class } from '@prisma/client';
import { AppError } from 'infra/http/errors/AppError';
import { injectable, inject } from 'tsyringe';
import { GetClassesByUserIdDTO } from '../dtos/GetClassesByUserId.dto';
import { IClassRepository } from '../repositories/IClassRepository';
@injectable()
export class GetClassesByUserIdService {
constructor(
@inject('PrismaClassRepository')
private ClassRepository: IClassRepository
) {}
async handle({ id }: GetClassesByUserIdDTO): Promise<Class[]> {
return this.ClassRepository.getClassesByUserId(id);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/quarters/repositories/prisma/PrismaQuarterRepository.ts
|
<reponame>ES-UFABC/UFABCplanner
import { Quarter } from '@prisma/client';
import { prisma } from 'infra/prisma/client';
import { IQuarterRepository } from '../IQuarterRepository';
export class PrismaQuarterRepository implements IQuarterRepository {
async quarterExists(quarterId: string): Promise<boolean> {
const quarter = await prisma.quarter.findUnique({
where: {
id: quarterId,
},
});
if (!quarter) return false;
return true;
}
async createQuarter(quarter: Omit<Quarter, 'id'>): Promise<void> {
await prisma.quarter.create({
data: {
...quarter,
},
});
}
async deleteQuarter(quarterId: string): Promise<void> {
await prisma.quarter.delete({
where: {
id: quarterId,
},
});
}
async updateQuarter(quarter: Omit<Quarter, 'academyYearId'>): Promise<void> {
await prisma.quarter.update({
where: {
id: quarter.id,
},
data: {
startDate: quarter.startDate,
endDate: quarter.endDate,
},
});
}
async getQuarterByAcademicYearId(academicYearId: string): Promise<Quarter[]> {
return prisma.quarter.findMany({
where: {
academyYearId: academicYearId,
},
});
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/accounts/repositories/IUsersRepository.ts
|
<filename>ufabc_planner-backend/src/modules/accounts/repositories/IUsersRepository.ts
import { User } from '@prisma/client';
import { CreateUserDTO } from '../dtos/CreateUser.dto';
export interface IUsersRepository {
exists(email: string): Promise<boolean>;
findByEmail(email: string): Promise<User | null>;
create(user: CreateUserDTO): Promise<void>;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/test/entities/ClassFactory.ts
|
<reponame>ES-UFABC/UFABCplanner<filename>ufabc_planner-backend/test/entities/ClassFactory.ts
import { Class, Subject, User } from '@prisma/client';
import { prisma } from 'infra/prisma/client';
export async function createClass(user: User, subject: Subject): Promise<Class> {
const Class = await prisma.class.create({
data: {
subjectId: subject.id,
userId: user.id,
professor: '<NAME>',
room: 'A202',
campus: '<NAME>',
building: 'Bloco A',
startTime: '10:00',
endTime: '12:00',
weekday: 'seg',
biweeklyType: 'week1',
},
});
return Class;
}
export async function getClassById(id: string) {
return prisma.class.findUnique({
where: {
id: id,
},
});
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/dtos/interfaces/IUpdateExam.ts
|
export interface IUpdateExam {
subjectId?: string;
id: string;
name?: string;
dueDate: string;
time: string;
description?: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/controllers/GetSubjectByUserIdController.ts
|
<filename>ufabc_planner-backend/src/modules/subjects/controllers/GetSubjectByUserIdController.ts
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { GetSubjectByUserIdDTO } from '../dtos/GetSubjectByUserId.dto';
import { GetSubjectByUserIdService } from '../services/GetSubjectByUserIdService';
export class GetSubjectByUserIdController {
async handle(request: Request, response: Response): Promise<Response> {
const { id } = request.user;
const GetSubjectByUserIdDto = await validateInput(GetSubjectByUserIdDTO, { id });
const subjects = await container.resolve(GetSubjectByUserIdService).execute(GetSubjectByUserIdDto);
return response.json(subjects).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/classes/ClassForm/ClassForm.component.tsx
|
import { Form } from "@unform/web"
import { useCallback, useRef, useState } from "react";
import { IClass } from "../../../../interfaces/class";
import api from "../../../../services/api";
import { Button } from "../../../Button";
import { Input } from "../../../Input";
import styles from './ClassForm.module.scss';
interface Props {
subjectId: string;
onSuccess?: () => void | Promise<void>;
onCancel: () => void;
}
const ClassForm = ({ subjectId, onSuccess, onCancel }: Props) => {
const formRef = useRef(null);
const [loading, setLoading] = useState(false);
const handleSubmit = useCallback(async (data: Omit<IClass, 'id'>) => {
setLoading(true);
try {
await api
.post('/classes/', { ...data, subjectId })
.then(() => { alert('Aula criada com sucesso!'); if (onSuccess) onSuccess(); })
.catch(error => alert(error));
} catch (error) {
alert('Houve um erro na criação/edição da aula...')
} finally {
setLoading(false);
}
}, [onSuccess, subjectId]);
return (
<div className={styles.form_container}>
<Form ref={formRef} onSubmit={handleSubmit}>
<div className={styles.sections_container}>
<div className={styles.form_section}>
<Input name="startTime" label="Horário de início*" placeholder="Ex.: 17:30" />
<Input name="endTime" label="Horário de fim*" placeholder="Ex.: 20:00" />
</div>
<div className={styles.form_section}>
<Input name="weekday" label="Dia da semana*" placeholder="Ex.: 'seg' ou 'ter' ou 'quar' ou 'quin' ou 'sex' ou 'sab' ou 'dom'" />
<Input name="biweeklyType" label="Quinzenal" placeholder="Ex.: 'week1' ou 'week2'" />
</div>
<div className={styles.form_section}>
<Input name="campus" label="Campus" placeholder="Ex.: <NAME>" />
<Input name="building" label="Bloco" placeholder="Ex.: Bloco B ou Beta" />
</div>
<div className={styles.form_section}>
<Input name="room" label="Sala" placeholder="Ex.: 606" />
<Input name="professor" label="Professor" placeholder="Ex.: Girafales" />
</div>
</div>
<div style={{ display: 'flex', gap: '16px', marginTop: '32px', justifyContent: 'center' }}>
<Button btnType="secondary" style={{ width: '200px' }} type="button" onClick={() => onCancel()}>
Cancelar
</Button>
<Button style={{ width: '200px' }} type="submit" loading={loading}>
Salvar
</Button>
</div>
</Form>
</div>
);
}
export default ClassForm;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/services/CreateAcademicYearService.ts
|
import { prisma } from 'infra/prisma/client';
import { inject, injectable } from 'tsyringe';
import { AppError } from 'infra/http/errors/AppError';
import { CreateAcademyYearDTO } from '../dtos/CreateAcademyYear.dto';
import { IDateProvider } from 'infra/container/providers/DateProvider/IDateProvider';
import { IAcademicYearRepository } from '../repositories/IAcademicYearRepository';
@injectable()
export class CreateAcademicYearService {
constructor(
@inject('PrismaAcademicYearRepository')
private academicYearRepository: IAcademicYearRepository,
@inject('DayjsDateProvider')
private dateProvider: IDateProvider
) {}
async execute(params: CreateAcademyYearDTO): Promise<void> {
const { userId, year, startDate, endDate } = params;
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.create({
userId: userId,
year: year,
start_date: startDateUTC,
end_date: endDateUTC,
});
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/interfaces/quarter.ts
|
export interface IQuarter {
id: string;
academicYearId: string;
startDate: string;
endDate: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/Modal/Modal.component.tsx
|
<reponame>ES-UFABC/UFABCplanner
import { forwardRef, useImperativeHandle, useState } from 'react';
import { FiX } from 'react-icons/fi';
import { IconButton } from '../IconButton';
import styles from './Modal.module.scss';
interface Props {
children: React.ReactNode;
title: string;
onClose?: () => void;
width?: string;
}
export interface ModalRef {
handleOpenModal: () => void;
handleCloseModal: () => void;
}
const Modal = forwardRef<ModalRef, Props>(({ children, title, onClose, width = '400px' }, ref) => {
const [open, setOpen] = useState(false);
useImperativeHandle(ref, () => ({
handleOpenModal: () => setOpen(true),
handleCloseModal: () => setOpen(false),
}), []);
if (!open) return <></>;
return (
<div className={styles.modal_container}>
<div className={styles.modal} style={{ width }}>
<div className={styles.modal_header}>
<b className={styles.modal_title}>{title}</b>
<IconButton onClick={() => { setOpen(false); if (onClose) onClose(); }} icon={FiX}/>
</div>
{children}
</div>
</div>
);
});
export default Modal;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/routes/NotAuthenticatedRoutes.tsx
|
import { Navigate, Route, Routes } from "react-router-dom";
import { LoginPage } from "../pages/login";
import { SigninPage } from "../pages/signin";
const NotAuthenticatedRoutes = () => {
return (
<Routes>
<Route path="*" element={<Navigate to="/login" replace/>} />
<Route path="/login" element={<LoginPage />} />
<Route path="/signin" element={<SigninPage />} />
</Routes>
);
}
export default NotAuthenticatedRoutes;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/dtos/CreateAcademyYear.dto.ts
|
import { IsDateString, IsNotEmpty, IsNumberString, IsUUID } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { ICreateAcademyYear } from './interfaces/ICreateAcademyYear';
export class CreateAcademyYearDTO implements ICreateAcademyYear {
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
userId: string;
@IsNotEmpty({ message: messages.isNotEmpty })
@IsNumberString({ message: messages.IsNumberString })
year: 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/CreateTaskService.ts
|
import { inject, injectable } from 'tsyringe';
import { CreateTaskDTO } from '../dtos/CreateTask.dto';
import { ITaskRepository } from '../repositories/ITaskRepository';
@injectable()
export class CreateTaskService {
constructor(
@inject('PrismaTaskRepository')
private TaskRepository: ITaskRepository
) {}
async handle(params: CreateTaskDTO): Promise<void> {
await this.TaskRepository.createTask(params);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/pages/schedule/index.ts
|
<gh_stars>1-10
export { default as SchedulePage } from './SchedulePage.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/http/errors/AppError.ts
|
<gh_stars>1-10
export class AppError {
public readonly name: string;
public readonly message: string;
public readonly statusCode: number;
constructor(message: string, statusCode = 400, name = 'AppError') {
this.name = name;
this.message = message;
this.statusCode = statusCode;
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/quarters/QuarterFormModal/index.ts
|
<reponame>ES-UFABC/UFABCplanner
export { default as QuarterFormModal } from './QuarterFormModal.component';
export type { QuarterFormModalRef } from './QuarterFormModal.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/services/GetSubjectByQuarterIdService.ts
|
import { Subject } from '@prisma/client';
import { AppError } from 'infra/http/errors/AppError';
import { IQuarterRepository } from 'modules/quarters/repositories/IQuarterRepository';
import { inject, injectable } from 'tsyringe';
import { GetSubjectByQuarterIdDTO } from '../dtos/GetSubjectByQuarterId.dto';
import { ISubjectRepository } from '../repositories/ISubjectRepository';
@injectable()
export class GetSubjectByQuarterIdService {
constructor(
@inject('PrismaQuarterRepository')
private QuarterRepository: IQuarterRepository,
@inject('PrismaSubjectRepository')
private subjectRepository: ISubjectRepository
) {}
async execute(params: GetSubjectByQuarterIdDTO): Promise<Subject[]> {
if (!(await this.QuarterRepository.quarterExists(params.quarterId))) {
throw new AppError('Quadrimestre não existe');
}
return this.subjectRepository.getSubjectByQuarterId(params.quarterId);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/exams/ExamsFormModal/ExamsFormModal.component.tsx
|
import { Form } from "@unform/web";
import { forwardRef, useCallback, useEffect, useImperativeHandle, useRef, useState } from "react";
import { IExam } from "../../../../interfaces/exam";
import { ISubject } from "../../../../interfaces/subject";
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 ExamsFormModalRef {
handleOpenFormModal: (exam?: IExam) => void;
}
const ExamsFormModal = forwardRef<ExamsFormModalRef, Props>(({ onSuccess }, ref) => {
const modalRef = useRef<ModalRef>(null);
const formRef = useRef(null);
const [subjects, setSubjects] = useState<ISubject[]>([]);
const [currentExam, setCurrentExam] = useState<IExam | null>(null);
const [loading, setLoading] = useState(false);
const unsetFormModalStates = useCallback(() => {
setCurrentExam(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<IExam, 'id'>) => {
setLoading(true);
try {
if (currentExam) {
await api
.put(`/exams/update/${currentExam.id}`, { ...data, id: currentExam.id })
.then(() => handleSuccess('Prova editada com sucesso!'))
.catch(error => alert(error));
} else {
await api
.post('/exams/', { ...data }) //todo
.then(() => handleSuccess('Prova criada com sucesso!'))
.catch(error => alert(error));
}
} catch (error) {
alert('Houve um erro na criação/edição da prova...')
} finally {
setLoading(false);
}
}, [currentExam, handleSuccess]);
useImperativeHandle(ref, () => ({
handleOpenFormModal: (exam?: IExam) => {
if (exam) setCurrentExam(exam);
modalRef.current?.handleOpenModal();
}
}), []);
useEffect(() => {
handleGetSubjects();
}, [handleGetSubjects]);
return (
<Modal
ref={modalRef}
title={`${currentExam ? 'Editar' : 'Criar'} Prova`}
onClose={unsetFormModalStates}
>
<Form ref={formRef} onSubmit={handleSubmit}>
<div style={{ display: 'flex', flexDirection: 'column', gap: '16px' }}>
<SelectInput name="subjectId" label="Matéria*" defaultValue={currentExam?.subjectId}>
<option value=""></option>
{subjects?.length && subjects?.map(subject => <option value={subject.id}>{subject.name}</option>)}
</SelectInput>
<Input name="name" label="Nome*" placeholder="Ex.: P2" defaultValue={currentExam?.name}/>
<Input name="dueDate" label="Data*" placeholder="Ex.: 2022-12-12" defaultValue={currentExam?.dueDate}/>
<Input name="time" label="Hora de início*" placeholder="Ex.: 15:30" defaultValue={currentExam?.time}/>
<Input name="description" label="Descrição" placeholder="Ex.: Uma prova muito legal" defaultValue={currentExam?.description}/>
<Button style={{ marginTop: '32px' }} type="submit" loading={loading}>Salvar</Button>
</div>
</Form>
</Modal>
);
});
export default ExamsFormModal;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/accounts/controllers/AuthenticateUserController.spec.ts
|
import { app } from 'infra/http/app';
import supertest from 'supertest';
import { deleteAll, disconnect } from '../../../../test/database';
import { createUser, getUserByEmail } from '../../../../test/entities/UserFactory';
import { generateRandomEmail } from '../../../../test/utils';
describe('Create User (e2e)', () => {
beforeAll(async () => {
deleteAll();
});
afterAll(async () => {
disconnect();
});
it('should authenticate user correctly', async () => {
const user = await createUser();
const response = await supertest(app).post('/users/login').send({
email: user.email,
password: '<PASSWORD>',
});
expect(response.status).toBe(200);
});
});
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/repositories/IClassRepository.ts
|
<filename>ufabc_planner-backend/src/modules/classes/repositories/IClassRepository.ts
import { Class } from '@prisma/client';
import { CreateClassDTO } from '../dtos/CreateClass.dto';
import { UpdateClassDTO } from '../dtos/UpdateClass.dto';
export interface IClassRepository {
createClass(params: CreateClassDTO): Promise<void>;
deleteClass(id: string): Promise<void>;
updateClass(params: UpdateClassDTO): Promise<void>;
getClassesBySubjectId(subjectId: string): Promise<Class[]>;
getClassesByUserId(userId: string): Promise<Class[]>;
classExists(id: string): Promise<boolean>;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/BoxesContainer/index.ts
|
export { default as BoxesContainer } from './BoxesContainer.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/controllers/CreateSubjectController.ts
|
<filename>ufabc_planner-backend/src/modules/subjects/controllers/CreateSubjectController.ts
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { CreateSubjectDTO } from '../dtos/CreateSubject.dto';
import { ICreateSubject } from '../dtos/interfaces/ICreateSubject';
import { CreateSubjectService } from '../services/CreateSubjectService';
export class CreateSubjectController {
async handle(request: Request, response: Response): Promise<Response> {
const requestBody = request.body as Omit<ICreateSubject, 'userId'>;
const { id: userId } = request.user;
const createSubjectDto = await validateInput(CreateSubjectDTO, { userId, ...requestBody });
await container.resolve(CreateSubjectService).execute(createSubjectDto);
return response.status(201).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/interfaces/task.ts
|
export interface ITask {
id: string;
subjectId: string;
title: string;
dueDate: string;
description: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/repositories/IAcademicYearRepository.ts
|
import { AcademicYear } from '@prisma/client';
type updateAcademicYear = {
id: string;
year: string | undefined;
startDate: Date;
endDate: Date;
};
export interface IAcademicYearRepository {
create(academicYear: Omit<AcademicYear, 'id' | 'created_at'>): Promise<void>;
delete(academicYearId: string): Promise<void>;
getByUserId(userId: string): Promise<AcademicYear[]>;
update(academicYear: updateAcademicYear): Promise<void>;
exists(academicYearId: string): Promise<boolean>;
getByAcademicYearId(academicYearId: string): Promise<AcademicYear | null>;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/SelectInput/index.ts
|
export { default as SelectInput } from './SelectInput.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/interfaces/academicYear.ts
|
<reponame>ES-UFABC/UFABCplanner<gh_stars>1-10
export interface IAcademicYear {
id: string;
year: string;
startDate: string;
endDate: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/dtos/interfaces/IDeleteClass.ts
|
export interface IDeleteClass {
id: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/controllers/GetClassesByUserIdController.ts
|
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { GetClassesBySubjectIdDTO } from '../dtos/GetClassesBySubjectId.dto';
import { GetClassesByUserIdDTO } from '../dtos/GetClassesByUserId.dto';
import { GetClassesByUserIdService } from '../services/GetClassesByUserIdService';
export class GetClassesByUserIdController {
async execute(request: Request, response: Response) {
const { id } = request.user;
const getClassesByUserIdDTO = await validateInput(GetClassesByUserIdDTO, { id });
const classes = await container.resolve(GetClassesByUserIdService).handle(getClassesByUserIdDTO);
response.json(classes).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/subjects/SubjectFormModal/SubjectFormModal.component.tsx
|
<reponame>ES-UFABC/UFABCplanner
import { Form } from "@unform/web";
import { forwardRef, useCallback, useImperativeHandle, useRef, useState } from "react";
import { ISubject } from "../../../../interfaces/subject";
import api from "../../../../services/api";
import { Button } from "../../../Button";
import { Input } from "../../../Input";
import { Modal, ModalRef } from "../../../Modal";
interface Props {
onSuccess?: () => void;
quarterId: string;
}
export interface SubjectFormModalRef {
handleOpenFormModal: (subject?: ISubject) => void;
}
const SubjectFormModal = forwardRef<SubjectFormModalRef, Props>(({ onSuccess, quarterId }, ref) => {
const modalRef = useRef<ModalRef>(null);
const formRef = useRef(null);
const [currentSubject, setCurrentSubject] = useState<ISubject | null>(null);
const [loading, setLoading] = useState(false);
const unsetFormModalStates = useCallback(() => {
setCurrentSubject(null);
setLoading(false);
}, []);
const handleSuccess = useCallback((message: string) => {
alert(message);
if (onSuccess) onSuccess();
unsetFormModalStates();
modalRef.current?.handleCloseModal();
}, [onSuccess, unsetFormModalStates]);
const handleSubmit = useCallback(async (data: Omit<ISubject, 'id'>) => {
setLoading(true);
try {
if (currentSubject) {
await api
.put(`/subjects/update/${currentSubject.id}`, { ...data, id: currentSubject.id, quarterId })
.then(() => handleSuccess('Matéria editada com sucesso!'))
.catch(error => alert(error));
} else {
await api
.post('/subjects/', { ...data, quarterId })
.then(() => handleSuccess('Matéria criada com sucesso!'))
.catch(error => alert(error));
}
} catch (error) {
alert('Houve um erro na criação/edição da matéria...')
} finally {
setLoading(false);
}
}, [currentSubject, handleSuccess, quarterId]);
useImperativeHandle(ref, () => ({
handleOpenFormModal: (subject?: ISubject) => {
if (subject) setCurrentSubject(subject);
modalRef.current?.handleOpenModal();
}
}), []);
return (
<Modal
ref={modalRef}
title={`${currentSubject ? 'Editar' : 'Criar'} Matéria`}
onClose={unsetFormModalStates}
>
<Form ref={formRef} onSubmit={handleSubmit}>
<div style={{ display: 'flex', flexDirection: 'column', gap: '16px' }}>
<Input name="name" label="Nome*" placeholder="Ex.: Engenharia de Software" defaultValue={currentSubject?.name}/>
<Input name="description" label="Descrição" placeholder="Ex.: Uma matéria muito legal" defaultValue={currentSubject?.description}/>
<Button style={{ marginTop: '32px' }} type="submit" loading={loading}>Salvar</Button>
</div>
</Form>
</Modal>
);
});
export default SubjectFormModal;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/accounts/controllers/CreateUserController.spec.ts
|
import { app } from 'infra/http/app';
import supertest from 'supertest';
import { deleteAll, disconnect } from '../../../../test/database';
import { getUserByEmail } from '../../../../test/entities/UserFactory';
describe('Create User (e2e)', () => {
beforeAll(async () => {
deleteAll();
});
afterAll(async () => {
disconnect();
});
it('should register user correctly', async () => {
const response = await supertest(app).post('/users/').send({
name: 'teste',
email: '<EMAIL>',
password: '<PASSWORD>',
});
expect(response.status).toBe(201);
const user = await getUserByEmail('<EMAIL>');
expect(user).toBeTruthy();
});
});
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/contexts/auth/context.ts
|
<gh_stars>1-10
import { createContext } from 'react';
import { ICredentials } from '../../interfaces/credentials';
export interface AuthContextData {
authenticated: boolean
loading: boolean
login: (credentials: ICredentials, reloadOnAuth?: boolean) => Promise<void>
logout: () => void
}
const AuthContext = createContext<AuthContextData>({} as AuthContextData);
export { AuthContext };
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/dtos/UpdateTask.dto.ts
|
import { IsUUID, IsNotEmpty, IsOptional, IsString, IsDateString } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { IUpdateTask } from './interfaces/IUpdateTask';
export class UpdateTaskDTO implements IUpdateTask {
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
id: string;
@IsOptional()
@IsString({ message: messages.IsString })
title?: string;
@IsNotEmpty({ message: messages.isNotEmpty })
@IsDateString({ message: messages.IsDateString })
dueDate: string;
@IsOptional()
@IsString({ message: messages.IsString })
description?: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/SidebarButton/index.ts
|
export { default as SidebarButton } from './SidebarButton.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/dtos/CreateExam.dto.ts
|
<reponame>ES-UFABC/UFABCplanner
import { IsUUID, IsNotEmpty, IsDateString, IsMilitaryTime, IsOptional, IsString } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { ICreateExam } from './interfaces/ICreateExam';
export class CreateExamDTO implements ICreateExam {
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
subjectId: string;
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
userId: string;
@IsString({ message: messages.IsString })
@IsNotEmpty({ message: messages.isNotEmpty })
name: string;
@IsNotEmpty({ message: messages.isNotEmpty })
@IsDateString({ message: messages.IsDateString })
dueDate: string;
@IsMilitaryTime()
@IsNotEmpty({ message: messages.isNotEmpty })
time: string;
@IsOptional()
@IsString({ message: messages.IsString })
description?: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/controllers/UpdateTaskController.spec.ts
|
<gh_stars>1-10
import { Weekdays, BiweeklyType } from '@prisma/client';
import dayjs from 'dayjs';
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, getTaskById } from '../../../../test/entities/TaskFactory';
import { createUser, authenticateUser } from '../../../../test/entities/UserFactory';
describe('Create class (e2e)', () => {
beforeAll(async () => {
deleteAll();
});
afterAll(async () => {
disconnect();
});
it('Should update a class successfully', 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)
.put('/tasks/update/' + task.id)
.set('authorization', 'Bearer ' + token)
.send({
title: 'novo titulo de task',
dueDate: '2022-08-02',
description: 'nova descrição de task',
});
expect(response.status).toBe(204);
const updatedTask = await getTaskById(task.id);
expect(updatedTask?.title).toBe('novo titulo de task');
expect(updatedTask?.dueDate.toISOString()).toBe('2022-08-02T00:00:00.000Z');
expect(updatedTask?.description).toBe('nova descrição de task');
});
});
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/tasks/dtos/CreateTask.dto.ts
|
import { IsUUID, IsNotEmpty, IsString, IsDateString, IsOptional } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { ICreateTask } from './interfaces/ICreateTask';
export class CreateTaskDTO implements ICreateTask {
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
subjectId: string;
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
userId: string;
@IsString({ message: messages.IsString })
@IsNotEmpty({ message: messages.isNotEmpty })
title: string;
@IsNotEmpty({ message: messages.isNotEmpty })
@IsDateString({ message: messages.IsDateString })
dueDate: string;
@IsOptional()
@IsString({ message: messages.IsString })
description?: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/specific/classes/ClassForm/index.ts
|
export { default as ClassForm } from './ClassForm.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/repositories/prisma/PrismaClassRepository.ts
|
<filename>ufabc_planner-backend/src/modules/classes/repositories/prisma/PrismaClassRepository.ts<gh_stars>1-10
import { Class } from '@prisma/client';
import dayjs from 'dayjs';
import { prisma } from 'infra/prisma/client';
import { includes } from 'lodash';
import { CreateClassDTO } from 'modules/classes/dtos/CreateClass.dto';
import { UpdateClassDTO } from 'modules/classes/dtos/UpdateClass.dto';
import { IClassRepository } from '../IClassRepository';
export class PrismaClassRepository implements IClassRepository {
async classExists(id: string): Promise<boolean> {
const classExists = await prisma.class.findUnique({
where: {
id: id,
},
});
if (!classExists) return false;
return true;
}
async createClass(params: CreateClassDTO): Promise<void> {
await prisma.class.create({
data: { ...params },
});
}
async deleteClass(id: string): Promise<void> {
await prisma.class.delete({
where: {
id: id,
},
});
}
async updateClass(params: UpdateClassDTO): Promise<void> {
await prisma.class.update({
where: {
id: params.id,
},
data: {
...params,
},
});
}
async getClassesBySubjectId(subjectId: string): Promise<Class[]> {
return prisma.class.findMany({
where: {
subjectId: subjectId,
},
});
}
async getClassesByUserId(userId: string): Promise<Class[]> {
return prisma.class.findMany({
where: {
userId: userId,
},
include: {
subject: {
select: {
id: true,
name: true,
},
},
},
});
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/services/DeleteSubjectService.ts
|
<reponame>ES-UFABC/UFABCplanner
import { AppError } from 'infra/http/errors/AppError';
import { inject, injectable } from 'tsyringe';
import { DeleteSubjectDTO } from '../dtos/DeleteSubject.dto';
import { ISubjectRepository } from '../repositories/ISubjectRepository';
@injectable()
export class DeleteSubjectService {
constructor(
@inject('PrismaSubjectRepository')
private subjectRepository: ISubjectRepository
) {}
async execute(params: DeleteSubjectDTO): Promise<void> {
if (!(await this.subjectRepository.subjectExists(params.id))) {
throw new AppError('A matéria não existe');
}
await this.subjectRepository.deleteSubject(params.id);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/accounts/services/CreateUserService.ts
|
<reponame>ES-UFABC/UFABCplanner
import { hash } from 'bcryptjs';
import { prisma } from 'infra/prisma/client';
import { inject, injectable } from 'tsyringe';
import { AppError } from 'infra/http/errors/AppError';
import { CreateUserDTO } from '../dtos/CreateUser.dto';
import { IUsersRepository } from '../repositories/IUsersRepository';
@injectable()
export class CreateUserService {
constructor(
@inject('PrismaUserRepository')
private usersRepository: IUsersRepository
) {}
async execute({ email, name, password }: CreateUserDTO): Promise<void> {
const userExists = await this.usersRepository.exists(email);
if (userExists) {
throw new AppError('E-mail já utilizado, usuário já existente!');
}
const passwordHash = await hash(password, 8);
await this.usersRepository.create({
name,
email,
password: <PASSWORD>,
});
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/pages/login/LoginPage.component.tsx
|
<gh_stars>1-10
import { useCallback, useRef, useState } from 'react';
import { Form } from '@unform/web'
import { Button } from '../../components/Button';
import { Input } from '../../components/Input';
import { InitialPageLayout } from '../../components/InitialPageLayout';
import { useAuth } from '../../contexts/auth';
import { ICredentials } from '../../interfaces/credentials';
const LoginPage = () => {
const formRef = useRef(null);
const { login } = useAuth();
const [loading, setLoading] = useState(false);
const handleSubmit = useCallback(async (data: ICredentials) => {
setLoading(true);
await login(data, true).then(() => setLoading(false));
}, [login]);
return (
<Form ref={formRef} onSubmit={handleSubmit}>
<InitialPageLayout
title="Bem-vindo"
subtitle="Esse é o MVP do UFABCplanner, aproveite!"
subtext={{ question: 'Não tem conta?', linkLabel: 'Faça o cadastro', linkTo: '/signin' }}
>
<Input name="email" label="E-mail*" placeholder="Digite seu e-mail" />
<Input name="password" label="<PASSWORD>ha*" type="password" placeholder="Digite sua senha" />
<Button type="submit" loading={loading}>Entrar</Button>
</InitialPageLayout>
</Form>
);
}
export default LoginPage;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/http/errors/validation.ts
|
import { validate, ValidationError, ValidatorOptions } from 'class-validator';
import { ClassConstructor, plainToClass, plainToInstance } from 'class-transformer';
import { AppError } from './AppError';
export async function validateInput<T extends Object>(Dto: ClassConstructor<T>, obj: any) {
const instance = plainToInstance(Dto, obj);
const errors = await validate(instance, { whitelist: true });
if (errors.length) {
throw new AppError('Erros de validação foram encontrados', 400, 'ValidationError');
}
return instance;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/controllers/CreateClassController.ts
|
<gh_stars>1-10
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container, injectable } from 'tsyringe';
import { CreateClassDTO } from '../dtos/CreateClass.dto';
import { ICreateClass } from '../dtos/interfaces/ICreateClass';
import { CreateClassService } from '../services/CreateClassService';
export class CreateClassController {
async execute(request: Request, response: Response) {
const requestBody = request.body as Omit<ICreateClass, 'userId'>;
const { id: userId } = request.user;
const createClassDTO = await validateInput(CreateClassDTO, { userId, ...requestBody });
await container.resolve(CreateClassService).handle(createClassDTO);
return response.status(201).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/App.tsx
|
import { BrowserRouter } from 'react-router-dom';
import { Sidebar } from './components/Sidebar';
import { MainHeader } from './components/MainHeader';
import { AuthProvider, useAuth } from './contexts/auth';
import AuthenticatedRoutes from './routes/AuthenticatedRoutes';
import NotAuthenticatedRoutes from './routes/NotAuthenticatedRoutes';
import './styles/global.scss';
import styles from './App.module.scss';
function AppContent() {
const { authenticated } = useAuth();
if (!authenticated) return (
<div className={styles.not_authenticated_container}>
<BrowserRouter>
<NotAuthenticatedRoutes />
</BrowserRouter>
</div>
);
return (
<div className={styles.app_container}>
<BrowserRouter>
<Sidebar />
<div className={styles.main}>
<MainHeader />
<div className={styles.content}>
<AuthenticatedRoutes />
</div>
</div>
</BrowserRouter>
</div>
);
}
function App() {
return (
<AuthProvider>
<AppContent />
</AuthProvider>
);
}
export default App;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/components/Loader/index.ts
|
<filename>ufabc_planner-frontend/src/components/Loader/index.ts
export { default as Loader } from './Loader.component';
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/dtos/CreateSubject.dto.ts
|
<filename>ufabc_planner-backend/src/modules/subjects/dtos/CreateSubject.dto.ts
import { IsUUID, IsNotEmpty, IsOptional, IsString } from 'class-validator';
import { messages } from 'infra/http/errors/messages';
import { ICreateSubject } from './interfaces/ICreateSubject';
export class CreateSubjectDTO implements ICreateSubject {
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
quarterId: string;
@IsUUID('all', { message: messages.IsUUID })
@IsNotEmpty({ message: messages.isNotEmpty })
userId: 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/tasks/dtos/interfaces/IGetTasksBySubjectId.ts
|
<reponame>ES-UFABC/UFABCplanner
export interface IGetTasksBySubjectId {
id: string;
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/controllers/DeleteSubjectController.ts
|
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { DeleteSubjectDTO } from '../dtos/DeleteSubject.dto';
import { DeleteSubjectService } from '../services/DeleteSubjectService';
export class DeleteSubjectController {
async handle(request: Request, response: Response): Promise<Response> {
const { id } = request.params;
const deleteSubjectDto = await validateInput(DeleteSubjectDTO, { id });
await container.resolve(DeleteSubjectService).execute(deleteSubjectDto);
return response.status(204).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/classes/controllers/DeleteClassController.ts
|
import { Request, Response } from 'express';
import { validateInput } from 'infra/http/errors/validation';
import { container } from 'tsyringe';
import { DeleteClassDTO } from '../dtos/DeleteClass.dto';
import { DeleteClassService } from '../services/DeleteClassService';
export class DeleteClassController {
async execute(request: Request, response: Response) {
const { id } = request.params;
const deleteClassDto = await validateInput(DeleteClassDTO, { id });
await container.resolve(DeleteClassService).handle(deleteClassDto);
return response.status(204).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/pages/dashboard/DashboardPage.component.tsx
|
<reponame>ES-UFABC/UFABCplanner<filename>ufabc_planner-frontend/src/pages/dashboard/DashboardPage.component.tsx
import { Box } from "../../components/Box";
import { BoxesContainer } from "../../components/BoxesContainer";
import { PageLayout } from "../../components/PageLayout";
const DashboardPage = () => {
return (
<PageLayout>
<BoxesContainer>
<Box>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
</Box>
<Box>
Testeee
</Box>
</BoxesContainer>
<BoxesContainer>
<Box>
Testeee
</Box>
<Box>
Testeee
</Box>
<Box>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
</Box>
<Box>
Testeee
</Box>
</BoxesContainer>
<BoxesContainer>
<Box>
Testeee
</Box>
<Box>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
</Box>
<Box>
Testeee
</Box>
</BoxesContainer>
<BoxesContainer>
<Box>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
<p>Testeasdf AS</p>
</Box>
<Box>
Testeee
</Box>
</BoxesContainer>
</PageLayout>
);
};
export default DashboardPage;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/pages/signin/SigninPage.component.tsx
|
import { useCallback, useRef, useState } from 'react';
import { useNavigate } from 'react-router-dom';
import { Form } from '@unform/web'
import { Button } from '../../components/Button';
import { Input } from '../../components/Input';
import { InitialPageLayout } from '../../components/InitialPageLayout';
import { IUser } from '../../interfaces/user';
import api from '../../services/api';
interface FormData extends IUser {
passwordConfirmation: string;
}
const SigninPage = () => {
const formRef = useRef(null);
const navigate = useNavigate();
const [loading, setLoading] = useState(false);
const handleSubmit = useCallback(async (data: FormData) => {
setLoading(true);
await api
.post('/users', data)
.then(() => { alert('Usuário criado com sucesso!'); navigate('/login') })
.catch(error => error?.response?.data?.message ? alert(error?.response?.data?.message) : alert('Houve um erro ao tentar cadastrar o usuário...'))
.finally(() => setLoading(false))
}, [navigate]);
return (
<Form ref={formRef} onSubmit={handleSubmit}>
<InitialPageLayout
title="Cadastre-se"
subtitle="Você está fazendo o cadastro no UFABCplanner"
subtext={{ question: 'Já tem conta?', linkLabel: 'Faça o login', linkTo: '/login' }}
>
<Input name="name" label="Nome*" placeholder="Digite seu nome completo" />
<Input name="email" label="E-mail*" placeholder="Digite seu e-mail" />
<div style={{ width: '100%', display: 'flex', gap: '32px' }}>
<Input name="password" label="Senha*" placeholder="Crie uma senha" type="password" />
<Input name="passwordConfirmation" label="Confirmar senha*" placeholder="Confirme sua senha" type="password" />
</div>
<Button type="submit" loading={loading}>Cadastrar</Button>
</InitialPageLayout>
</Form>
);
}
export default SigninPage;
|
ES-UFABC/UFABCplanner
|
ufabc_planner-frontend/src/contexts/auth/index.ts
|
import { AuthProvider } from './AuthProvider';
import { useAuth } from './hook';
export { AuthProvider, useAuth };
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/accounts/repositories/prisma/PrismaUserRepository.ts
|
import { User } from '@prisma/client';
import { prisma } from 'infra/prisma/client';
import { CreateUserDTO } from 'modules/accounts/dtos/CreateUser.dto';
import { IUsersRepository } from '../IUsersRepository';
export class PrismaUserRepository implements IUsersRepository {
async exists(email: string): Promise<boolean> {
const user = await prisma.user.findUnique({
where: {
email: email,
},
});
if (!user) return false;
return true;
}
async findByEmail(email: string): Promise<User | null> {
const user = await prisma.user.findUnique({
where: {
email: email,
},
});
if (!user) return null;
return user;
}
async create(user: CreateUserDTO): Promise<void> {
await prisma.user.create({
data: {
...user,
},
});
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/infra/http/routes/academicYears.routes.ts
|
<gh_stars>1-10
import { Router } from 'express';
import { ensureAuthenticated } from 'infra/http/middlewares/ensureAuthenticated';
import { CreateAcademicYearController } from 'modules/academicYears/controllers/CreateAcademicYearController';
import { DeleteAcademicYearController } from 'modules/academicYears/controllers/DeleteAcademicYearController';
import { GetAcademicYearByUserIdController } from 'modules/academicYears/controllers/GetAcademicYearByUserIdController';
import { UpdateAcademicYearController } from 'modules/academicYears/controllers/UpdateAcademicYearController';
const academicYearRoutes = Router();
const createAcademicYearController = new CreateAcademicYearController();
const deleteAcademicYearController = new DeleteAcademicYearController();
const updateAcademicYearController = new UpdateAcademicYearController();
const getAcademicYearByUserIdController = new GetAcademicYearByUserIdController();
academicYearRoutes.post('/', ensureAuthenticated, createAcademicYearController.handle);
academicYearRoutes.delete('/delete/:id', ensureAuthenticated, deleteAcademicYearController.handle);
academicYearRoutes.put('/update/:id', ensureAuthenticated, updateAcademicYearController.handle);
academicYearRoutes.get('/get/user', ensureAuthenticated, getAcademicYearByUserIdController.handle);
export { academicYearRoutes };
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/exams/services/GetExamsBySubjectIdService.ts
|
<filename>ufabc_planner-backend/src/modules/exams/services/GetExamsBySubjectIdService.ts<gh_stars>1-10
import { Exam } from '@prisma/client';
import { GetTasksBySubjectIdDTO } from 'modules/tasks/dtos/GetTasksBySubjecId.dto';
import { injectable, inject } from 'tsyringe';
import { IExamRepository } from '../repositories/IExamRepository';
@injectable()
export class GetExamsBySubjectIdService {
constructor(
@inject('PrismaExamRepository')
private ExamRepository: IExamRepository
) {}
async handle({ id }: GetTasksBySubjectIdDTO): Promise<Exam[]> {
return this.ExamRepository.getExamsBySubjectId(id);
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/academicYears/controllers/UpdateAcademicYearController.ts
|
import { Request, Response } from 'express';
import { container } from 'tsyringe';
import { validateInput } from 'infra/http/errors/validation';
import { UpdateAcademyYearDTO } from '../dtos/UpdateAcademicYear.dto';
import { UpdateAcademicYearService } from '../services/UpdateAcademicYearService';
export class UpdateAcademicYearController {
async handle(request: Request, response: Response): Promise<Response> {
const { year, startDate, endDate } = request.body;
const { id } = request.params;
const updateAcademicYearService = container.resolve(UpdateAcademicYearService);
const updateAcademicYearDTO = await validateInput(UpdateAcademyYearDTO, {
id,
year,
startDate,
endDate,
});
await updateAcademicYearService.execute(updateAcademicYearDTO);
return response.status(204).send();
}
}
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/subjects/controllers/CreateSubjectController.spec.ts
|
<reponame>ES-UFABC/UFABCplanner
import { prisma } from '@prisma/client';
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 { createUser, authenticateUser } from '../../../../test/entities/UserFactory';
describe('create subject (e2e)', () => {
beforeAll(async () => {
deleteAll();
});
afterAll(async () => {
disconnect();
});
it('Should create a subject successfully', async () => {
const user = await createUser();
const token = await authenticateUser(user);
const academicYear = await createAcademicYear(user);
const quarter = await createQuarter(academicYear);
const response = await supertest(app)
.post('/subjects/')
.set('authorization', 'Bearer ' + token)
.send({
quarterId: quarter.id,
name: '<NAME>',
description: 'descrição teste',
});
expect(response.status).toBe(201);
});
});
|
ES-UFABC/UFABCplanner
|
ufabc_planner-backend/src/modules/quarters/dtos/interfaces/IGetQuarterByAcademicYearId.ts
|
export interface IGetQuarterByAcademicYearId {
academicYearId: string;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.