repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
JKusiak/isshu
|
frontend/src/api/User/ManageMemberCard.tsx
|
<reponame>JKusiak/isshu<filename>frontend/src/api/User/ManageMemberCard.tsx
import axios from "axios";
import { FC, useContext, useEffect, useState } from "react";
import { AuthUserContext } from "../../App";
import MemberCard from "../../components/User/MemberCard";
import { INestedUser } from "../../types/ModelTypes";
interface ManageMemberCardProps {
member: INestedUser,
}
const ManageMemberCard: FC<ManageMemberCardProps> = (props) => {
const [imageExists, setImageExists] = useState<boolean>(false);
const [imageUrl, setImageUrl] = useState<string>('');
const { loggedInUser } = useContext(AuthUserContext);
// when props are loaded, fetches image from the server
useEffect(() => {
checkIfExists();
}, [props.member]);
function checkIfExists() {
// substitutes backslash (/) with %2f as the whole path is passed as one parameter
const path = `uploads%2forganization-${loggedInUser.organizationId}%2fuser-profile%2f${props.member._id}.jpg`;
axios.get(`/uploads/get/${path}`)
.then((resp) => {
setImageExists(resp.data);
if (resp.data) {
const adjustedPath = path.replaceAll('%2f', '/');
setImageUrl(`http://localhost:5000/${adjustedPath}`);
}
}).catch((err) => {
console.log(err);
})
}
return (
<>
<MemberCard
member={props.member}
imageExists={imageExists}
imageUrl={imageUrl}
/>
</>
);
}
export default ManageMemberCard;
|
JKusiak/isshu
|
frontend/src/components/Organization/DeleteMemberButton.tsx
|
<filename>frontend/src/components/Organization/DeleteMemberButton.tsx
import { createStyles, IconButton, makeStyles, Theme } from "@material-ui/core";
import DeleteIcon from '@material-ui/icons/ClearOutlined';
import { FC, useContext, useState } from "react";
import { FetchMembersContext } from "../../api/Authentication/GetHomePage";
import { INestedUser } from "../../types/ModelTypes";
import ConfirmationModal from "../Commons/ConfirmationModal";
const useStyles = makeStyles((theme: Theme) => createStyles({
button: {
},
icon: {
color: theme.palette.secondary.main,
},
}))
interface DeleteMemberButtonProps {
clickedMember: INestedUser,
deleteMember: () => void,
}
const DeleteMemberButton: FC<DeleteMemberButtonProps> = (props) => {
const classes = useStyles();
const [modalOpen, setModalOpen] = useState(false);
const { members, setMembers } = useContext(FetchMembersContext);
function handleDelete() {
const newMembers = members.filter(member => member._id !== props.clickedMember._id) as any;
setMembers(newMembers);
props.deleteMember();
}
return (
<>
<IconButton className={classes.button} onClick={() => { setModalOpen(true) }}>
<DeleteIcon className={classes.icon} />
</IconButton>
<ConfirmationModal
handleConfirm={handleDelete}
open={modalOpen}
setOpen={setModalOpen}
/>
</>
);
}
export default DeleteMemberButton
|
JKusiak/isshu
|
frontend/src/components/Tag/AllTagsGallery.tsx
|
<gh_stars>0
import { Card, CardContent, createStyles, IconButton, makeStyles, Theme, Typography } from '@material-ui/core';
import DeleteIcon from '@material-ui/icons/ClearOutlined';
import React, { FC, useContext } from 'react';
import { BoardReducerContext } from '../../api/Board/GetBoard';
import { ActionTypes } from '../../reducers/BoardReducer';
import { INestedIssue, ITag } from '../../types/ModelTypes';
import AddTagButton from './AddTagButton';
const useStyles = makeStyles((theme: Theme) => createStyles({
tagsContainer: {
display: 'flex',
flexDirection: 'column',
},
headline: {
fontSize: '20px',
fontWeight: 'bold',
color: theme.palette.secondary.main,
alignSelf: 'center',
marginBottom: theme.spacing(2),
},
tagItem: {
display: 'flex',
},
tagIncludedCard: {
width: '100%',
marginBottom: '10px',
marginRight: '10px',
backgroundColor: theme.palette.primary.light,
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
"&:hover": {
cursor: 'pointer',
boxShadow: theme.shadows[5],
},
"& .MuiCardContent-root": {
padding: theme.spacing(1),
},
"& *": {
fontWeight: 'bold',
color: theme.palette.secondary.main
}
},
tagNotIncludedCard: {
width: '100%',
marginBottom: '10px',
marginRight: '10px',
backgroundColor: theme.palette.primary.light,
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
"&:hover": {
cursor: 'pointer',
boxShadow: theme.shadows[5],
},
"& .MuiCardContent-root": {
padding: theme.spacing(1),
},
"& *": {
color: theme.palette.secondary.main
}
},
tagName: {
fontSize: '12px',
},
deleteButton: {
width: '30px',
height: '30px',
},
deleteIcon: {
color: theme.palette.secondary.main,
}
})
);
interface AllTagsGalleryProps {
issue: INestedIssue,
updateIssueTags: () => void,
allTags: [ITag],
deleteTag: (e: React.SyntheticEvent, tagId: string) => void,
addTag: (e: React.SyntheticEvent, newTagName: string) => void,
}
const AllTagsGallery: FC<AllTagsGalleryProps> = (props) => {
const classes = useStyles();
const { dispatch } = useContext(BoardReducerContext);
function checkIfChosen(tag: ITag) {
return (
props.issue.tags.some((issueTag: ITag) => issueTag._id === tag._id) ? true : false
);
}
function displayType(isChosen: boolean) {
return (
isChosen ?
classes.tagIncludedCard :
classes.tagNotIncludedCard
);
}
function manageClicked(e: React.SyntheticEvent, isChosen: boolean, clickedTag: ITag) {
e.preventDefault();
if (isChosen) {
const tagsWithoutClicked = props.issue.tags.filter((issueTag: ITag) => issueTag._id !== clickedTag._id);
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
modified: {
tags: tagsWithoutClicked,
},
}
dispatch({ type: ActionTypes.UpdateIssue, payload: payload })
} else {
const tagsWithClicked = [...props.issue.tags, clickedTag];
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
modified: {
tags: tagsWithClicked,
},
}
dispatch({ type: ActionTypes.UpdateIssue, payload: payload })
}
props.updateIssueTags();
}
return (
<div className={classes.tagsContainer}>
<Typography className={classes.headline} component="h5" variant="h5">
All tags
</Typography>
{props.allTags.map((tag: ITag, index: number) => {
const isChosen = checkIfChosen(tag);
return (
<div className={classes.tagItem} key={index}>
<Card className={displayType(isChosen)} onClick={(e) => manageClicked(e, isChosen, tag)}>
<CardContent>
<Typography className={classes.tagName} component="h5" variant="h5">
{tag.name}
</Typography>
</CardContent>
</Card>
<IconButton className={classes.deleteButton} onClick={(e) => props.deleteTag(e, tag._id)}>
<DeleteIcon className={classes.deleteIcon} />
</IconButton>
</div>
)
})}
<AddTagButton
addTag={props.addTag}
/>
</div>
);
}
export default AllTagsGallery;
|
JKusiak/isshu
|
frontend/src/pages/Project/Subpages/BoardPage.tsx
|
<filename>frontend/src/pages/Project/Subpages/BoardPage.tsx
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import { FC, Fragment, useContext } from "react";
import { DragDropContext, DropResult } from "react-beautiful-dnd";
import DeleteBoard from "../../../api/Board/DeleteBoard";
import { BoardReducerContext } from "../../../api/Board/GetBoard";
import UpdateBoard from "../../../api/Board/UpdateBoard";
import AddColumn from "../../../api/Column/AddColumn";
import GoBackButton from "../../../components/Board/GoBackButton";
import ColumnData from "../../../components/Column/ColumnData";
import { ActionTypes } from "../../../reducers/BoardReducer";
import { INestedBoard, INestedColumn } from "../../../types/ModelTypes";
const useStyles = makeStyles((theme: Theme) => createStyles({
navigation: {
display: 'flex',
justifyContent: 'space-between',
width: '100%',
padding: theme.spacing(2),
[theme.breakpoints.down('xs')]: {
width: '90%',
padding: 0,
},
marginBottom: theme.spacing(8),
},
boardTitle: {
fontSize: '36px',
[theme.breakpoints.down('xs')]: {
fontSize: '28px',
},
color: theme.palette.secondary.main,
display: 'flex',
justifyContent: 'center',
alignItems: 'center',
width: '30%',
overflow: 'hidden',
},
wrapper: {
display: 'flex',
[theme.breakpoints.down('xs')]: {
flexDirection: 'column',
},
justifyContent: 'center',
marginLeft: theme.spacing(8),
marginRight: theme.spacing(8),
},
container: {
display: "flex",
[theme.breakpoints.down('xs')]: {
flexDirection: 'column',
marginLeft: 0,
},
},
}
));
interface BoardPageProps {
board: INestedBoard,
changeColumn: (newColumnId: string, issueId: string) => void,
}
const BoardPage: FC<BoardPageProps> = (props) => {
const classes = useStyles();
const { dispatch } = useContext(BoardReducerContext);
const onDragEnd = (result: DropResult) => {
const { source, destination, draggableId } = result;
if (!destination) return;
if (source.droppableId !== destination.droppableId) {
const oldColumnId = source.droppableId;
const newColumnId = destination.droppableId;
const payload = {
oldColumnId: oldColumnId,
newColumnId: newColumnId,
issueId: draggableId,
};
dispatch({ type: ActionTypes.ChangeColumns, payload: payload });
props.changeColumn(destination.droppableId, draggableId);
}
else {
return;
}
};
// function reorderColumn(issues: [INestedIssue], startIndex: number, endIndex: number) {
// const [removed] = issues.splice(startIndex, 1);
// issues.splice(endIndex, 0, removed);
// return issues;
// };
function displayBoardContent() {
if (props.board.columns !== undefined && props.board.columns.length > 0) {
return (
<div className={classes.container}>
<DragDropContext onDragEnd={result => onDragEnd(result)}>
{props.board.columns.map((column: INestedColumn, index: number) => {
return (
<Fragment key={index}>
<ColumnData column={column} />
</Fragment>
);
})}
</DragDropContext>
</div>
);
}
}
return (
<>
<div className={classes.navigation}>
<GoBackButton />
<div className={classes.boardTitle}>
<UpdateBoard boardName={props.board.name} />
</div>
<div>
<DeleteBoard />
</div>
</div>
<div className={classes.wrapper}>
{displayBoardContent()}
<AddColumn />
</div>
</>
);
}
export default BoardPage;
|
JKusiak/isshu
|
frontend/src/components/Issue/IssueModal.tsx
|
<reponame>JKusiak/isshu<filename>frontend/src/components/Issue/IssueModal.tsx<gh_stars>0
import { Backdrop, createStyles, Fade, makeStyles, Modal, Theme } from "@material-ui/core";
import React, { FC, useState } from "react";
import ArchiveIssue from "../../api/Issue/ArchiveIssue";
import ManageAttachments from "../../api/Issue/Attachment/ManageAttachments";
import ManageContributors from "../../api/Issue/Contributor/ManageContributors";
import UpdateDescription from "../../api/Issue/Description/UpdateDescription";
import ManageCompletion from "../../api/Issue/ManageCompletion";
import ManageMessages from "../../api/Issue/Message/ManageMessages";
import UpdateName from "../../api/Issue/Name/UpdateName";
import ManageSteps from "../../api/Issue/Step/ManageSteps";
import { INestedIssue } from "../../types/ModelTypes";
import IssueTagsGallery from "../Tag/IssueTagsGallery";
import CreatorText from "./Creator/CreatorText";
const useStyles = makeStyles<Theme, ModalProps>((theme: Theme) => createStyles({
modal: {
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
},
paper: {
pointerEvents: ({ displayOnly }) => displayOnly ? 'none' : 'auto',
[theme.breakpoints.up('sm')]: {
display: 'grid',
gridTemplateColumns: '2fr 1fr',
gridTemplateRows: 'auto 10fr',
gridTemplateAreas: `
"header header"
"leftColumn rightColumn"`,
width: '75vw',
minWidth: '430px',
height: '75vh',
padding: theme.spacing(4, 4, 4),
},
[theme.breakpoints.down('xs')]: {
display: 'flex',
flexDirection: 'column',
width: '75vw',
height: '75vh',
overflow: 'scroll',
padding: theme.spacing(2),
},
backgroundColor: theme.palette.primary.main,
border: '2px solid',
borderColor: theme.palette.secondary.main,
borderRadius: '10px',
boxShadow: theme.shadows[2],
},
buttons: {
display: 'flex',
[theme.breakpoints.up('sm')]: {
gridArea: 'header',
justifySelf: 'end',
display: 'flex',
overflowX: 'hidden',
},
[theme.breakpoints.down('sm')]: {
height: '100%',
marginBottom: theme.spacing(4),
},
},
leftColumn: {
gridArea: 'leftColumn',
display: 'flex',
flexDirection: 'column',
[theme.breakpoints.up('sm')]: {
paddingRight: theme.spacing(2),
minHeight: 0,
minWidth: 0,
overflowY: 'auto',
overflowX: 'hidden',
},
[theme.breakpoints.down('sm')]: {
height: 'auto',
},
},
rightColumn: {
gridArea: 'rightColumn',
display: 'flex',
flexDirection: 'column',
[theme.breakpoints.up('sm')]: {
paddingRight: theme.spacing(2),
paddingLeft: theme.spacing(2),
minHeight: 0,
minWidth: 0,
overflowY: 'auto',
overflowX: 'hidden',
},
[theme.breakpoints.down('sm')]: {
height: 'auto',
},
},
})
);
interface ModalProps {
issue: INestedIssue,
isIssueModalOpen: boolean,
setIssueModalOpen: React.Dispatch<React.SetStateAction<boolean>>,
displayOnly: boolean,
}
const IssueContentModal: FC<ModalProps> = (props) => {
const classes = useStyles(props);
const [isTagsModalOpen, setTagsModalOpen] = useState(false);
return (
<Modal
className={classes.modal}
aria-labelledby="transition-modal-title"
aria-describedby="transition-modal-description"
open={props.isIssueModalOpen}
onClose={() => { props.setIssueModalOpen(false) }}
closeAfterTransition
BackdropComponent={Backdrop}
BackdropProps={{
timeout: 500,
}}
>
<Fade in={props.isIssueModalOpen}>
<div className={classes.paper}>
<UpdateName issue={props.issue} />
<div className={classes.buttons}>
<ManageCompletion issue={props.issue} />
<ArchiveIssue issue={props.issue} setIssueModalOpen={props.setIssueModalOpen} />
</div>
<div className={classes.leftColumn}>
<IssueTagsGallery
issue={props.issue}
isTagsModalOpen={isTagsModalOpen}
setTagsModalOpen={setTagsModalOpen}
/>
<UpdateDescription issue={props.issue} />
<ManageAttachments issue={props.issue} />
<ManageMessages issue={props.issue} />
</div>
<div className={classes.rightColumn}>
<CreatorText issue={props.issue} />
<ManageContributors issue={props.issue} displayOnly={props.displayOnly}/>
<ManageSteps issue={props.issue} />
</div>
</div>
</Fade>
</Modal>
);
}
export default IssueContentModal;
|
JKusiak/isshu
|
frontend/src/api/Issue/Step/ManageSteps.tsx
|
<reponame>JKusiak/isshu<gh_stars>0
import axios from 'axios';
import { FC } from 'react';
import IssueStepsGallery from '../../../components/Issue/Step/IssueStepsGallery';
import { INestedIssue } from '../../../types/ModelTypes';
interface ManageStepsProps {
issue: INestedIssue,
}
const ManageSteps: FC<ManageStepsProps> = (props) => {
function updateSteps() {
const requestBody = {
steps: props.issue.steps,
};
axios.post(`/issues/update/${props.issue._id}`, requestBody)
.catch((err) => {
console.log(err);
})
}
return (
<IssueStepsGallery
issue={props.issue}
updateSteps={updateSteps}
/>
);
}
export default ManageSteps;
|
JKusiak/isshu
|
frontend/src/api/Board/AddBoard.tsx
|
<reponame>JKusiak/isshu<gh_stars>0
import axios, { AxiosResponse } from 'axios';
import { FC, useState } from 'react';
import { useParams } from 'react-router-dom';
import AddBoardButton from '../../components/Board/AddBoardButton';
interface AddBoardProps {
fetchBoards: () => void,
}
const AddBoard: FC<AddBoardProps> = (props) => {
const { projectId } = useParams<{ projectId: string }>();
const [boardName, setBoardName] = useState<string>('');
const [addMode, setAddMode] = useState<boolean>(false);
function createColumn(columnName: string, boardResponse: AxiosResponse) {
const newBoardId = boardResponse.data._id;
const requestBody = {
columnName: columnName,
boardId: newBoardId,
}
axios.post('/columns/add', requestBody);
}
function createDefaultColumns(boardResponse: AxiosResponse) {
createColumn('TO DO', boardResponse);
createColumn('IN PROGRESS', boardResponse);
createColumn('DONE', boardResponse);
}
function onSubmit(e: React.SyntheticEvent) {
e.preventDefault();
const board = {
boardName: boardName,
projectId: projectId,
}
axios.post('/boards/add', board)
.then((res) => {
createDefaultColumns(res);
setAddMode(false);
window.scroll({
top: document.body.scrollHeight,
left: 0,
behavior: 'smooth'
});
props.fetchBoards();
})
}
return (
<>
<AddBoardButton
onSubmit={onSubmit}
addMode={addMode}
setAddMode={setAddMode}
setBoardName={setBoardName}
/>
</>
);
}
export default AddBoard;
|
JKusiak/isshu
|
frontend/src/components/Issue/Description/UpdateDescriptionButton.tsx
|
import { ClickAwayListener, TextField } from '@material-ui/core';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import { FC, useState } from 'react';
import DescriptionText from './DescriptionText';
const useStyles = makeStyles((theme: Theme) => createStyles({
descriptionContainer: {
maxWidth: '100%',
marginBottom: theme.spacing(4),
},
descriptionTitle: {
fontWeight: 'bold',
fontSize: '16px',
color: theme.palette.secondary.main,
marginBottom: theme.spacing(1),
},
descriptionText: {
textAlign: 'start',
color: theme.palette.secondary.main,
"&:hover": {
cursor: 'pointer'
}
},
formContainer: {
width: '100%',
},
inputField: {
width: '100%',
height: '100%',
"& .MuiOutlinedInput-root": {
height: '100%',
minHeight: '10vh',
color: theme.palette.secondary.main,
"& .MuiOutlinedInput-notchedOutline": {
height: 'auto',
borderColor: theme.palette.secondary.light,
borderRadius: '6px',
},
"&.Mui-focused .MuiOutlinedInput-notchedOutline": {
height: 'auto',
borderColor: theme.palette.secondary.light,
borderWidth: "2px",
},
alignItems: 'start',
},
"& .MuiOutlinedInput-input": {
fontSize: 15,
padding: theme.spacing(0.5),
},
},
}));
interface UpdateDescriptionButtonProps {
tempDescription: string,
setTempDescription: React.Dispatch<React.SetStateAction<string>>,
permDescription: string,
onSubmit: (e: any) => void,
}
const UpdateDescriptionButton: FC<UpdateDescriptionButtonProps> = (props) => {
const classes = useStyles();
const [updateMode, setUpdateMode] = useState<boolean>(false);
function handleSubmit(e: any) {
if (updateMode) {
props.onSubmit(e);
}
setUpdateMode(false);
}
return (
<>
<div className={classes.descriptionTitle}>Description</div>
<ClickAwayListener onClickAway={handleSubmit}>
<div className={classes.descriptionContainer} onClick={() => setUpdateMode(true)}>
{updateMode &&
<form className={classes.formContainer} onSubmit={handleSubmit} autoComplete="off">
<TextField
className={classes.inputField}
required
autoFocus
size="small"
multiline={true}
variant='outlined'
name="issueDescription"
id="issueDescription"
value={props.tempDescription}
autoComplete="issue-description"
inputProps={{ style: {} }}
onChange={e => {
props.setTempDescription(e.target.value);
}}
/>
</form>
}
{!updateMode &&
<DescriptionText
permDescription={props.permDescription}
/>
}
</div>
</ClickAwayListener>
</>
);
}
export default UpdateDescriptionButton;
|
JKusiak/isshu
|
frontend/src/api/User/GetUsersGallery.tsx
|
<filename>frontend/src/api/User/GetUsersGallery.tsx<gh_stars>0
import axios from "axios";
import { FC, useContext, useEffect, useState } from "react";
import { useParams } from "react-router-dom";
import { AuthUserContext } from "../../App";
import UsersGallery from "../../components/User/UsersGallery";
import { UserTemplate } from "../../types/ModelContentTemplate";
import { IUser } from "../../types/ModelTypes";
interface GetUsersGalleryProps {
mobileOpen: boolean,
handleSidebarToggle: () => void,
}
const GetUsersGallery: FC<GetUsersGalleryProps> = (props) => {
const { projectId } = useParams<{ projectId: string }>();
const [otherUsers, setOtherUsers] = useState<[IUser]>([UserTemplate]);
const [contributors, setContributors] = useState<[IUser]>([UserTemplate]);
const { loggedInUser } = useContext(AuthUserContext);
useEffect(() => {
fetchOtherUsers();
fetchContributors();
}, [projectId]);
// fetching users that do not belong to currently displayed project
function fetchOtherUsers() {
axios.get(`/users/getUsersWithoutProject/${loggedInUser.organizationId}/${projectId}`)
.then(resp => {
setOtherUsers(resp.data);
}).catch((err) => {
console.log(err);
});
}
// fetching users that belong to currently displayed project
function fetchContributors() {
axios.get(`/users/getUsersByProject/${projectId}`)
.then(resp => {
setContributors(resp.data);
}).catch((err) => {
console.log(err);
});;
}
// add currently displayed project to clicked user
function addProjectToUser(userId: string) {
const projectIdData = {
projectId: projectId
}
axios.post(`/users/addProject/${userId}`, projectIdData)
.catch((err) => {
console.log(err);
});
fetchContributors();
fetchOtherUsers();
}
// remove currently displayed project from clicked user
function removeProjectFromUser(userId: string) {
axios.delete(`/users/deleteProject/${userId}`, {
data: {
projectId: projectId
}
}).then(() => {
}).catch((err) => {
console.log(err);
});
fetchContributors();
fetchOtherUsers();
}
return (
<>
<UsersGallery
contributors={contributors}
otherUsers={otherUsers}
mobileOpen={props.mobileOpen}
handleSidebarToggle={props.handleSidebarToggle}
addProjectToUser={addProjectToUser}
removeProjectFromUser={removeProjectFromUser}
/>
</>
);
}
export default GetUsersGallery;
|
JKusiak/isshu
|
frontend/src/api/Organization/ManageInvitation.tsx
|
import axios from "axios";
import { FC, useContext } from "react";
import { AuthUserContext } from "../../App";
import InvitationModal from "../../components/Organization/InvitationModal";
import { IOrganization, IUser } from "../../types/ModelTypes";
interface ManageInvitationsProps {
invite: IOrganization,
user: any,
}
const ManageInvitations: FC<ManageInvitationsProps> = (props) => {
const { setLoggedInUser } = useContext(AuthUserContext);
function accept() {
const requestBody = {
organizationId: props.invite._id,
invitations: []
}
axios.post(`/users/update/${props.user._id}`, requestBody)
.then((resp) => {
updateToken(resp.data);
}).catch((err) => {
console.log(err);
});
}
function updateToken(user: IUser) {
const requestBody = {
_id: user._id,
email: user.email,
name: user.name,
surname: user.surname,
organizationId: user.organizationId,
}
axios.post(`/login/newOrganization/`, requestBody)
.then((res) => {
localStorage.setItem('token', res.data.token);
setLoggedInUser(requestBody);
window.location.reload();
}).catch((err) => {
console.log(err);
})
}
return (
<>
<InvitationModal invite={props.invite} accept={accept} />
</>
);
}
export default ManageInvitations;
|
JKusiak/isshu
|
frontend/src/components/Column/ColumnData.tsx
|
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import { FC, Fragment, useState } from "react";
import { Droppable } from "react-beautiful-dnd";
import DeleteColumn from "../../api/Column/DeleteColumn";
import UpdateColumn from "../../api/Column/UpdateColumn";
import AddIssue from "../../api/Issue/AddIssue";
import { INestedColumn, INestedIssue } from "../../types/ModelTypes";
import IssueData from "../Issue/IssueData";
const useStyles = makeStyles((theme: Theme) => createStyles({
columnWrapper: {
display: "flex",
flexDirection: "column",
minHeight: '500px',
alignItems: "center",
"&:not(:last-child)": {
[theme.breakpoints.up('sm')]: {
borderRight: '1px solid',
borderRightColor: theme.palette.secondary.light,
},
[theme.breakpoints.down('xs')]: {
borderRight: 'none',
marginBottom: theme.spacing(4),
},
},
},
columnHeader: {
display: 'grid',
gridTemplateColumns: '0.5fr 1fr 0.5fr',
width: '100%',
borderBottom: '0.1px solid',
borderBottomColor: theme.palette.secondary.light,
},
columnName: {
gridColumn: '2',
overflow: 'hidden',
maxHeight: '100%',
maxWidth: '100%',
whiteSpace: 'nowrap',
justifySelf: 'center',
paddingTop: theme.spacing(2),
paddingBottom: theme.spacing(2),
fontSize: '20px',
fontWeight: 400,
color: theme.palette.secondary.light,
},
deleteColumnButton: {
gridColumn: '3',
justifySelf: 'center',
display: 'flex',
justifyContent: 'center',
alignItems: 'center',
},
columnContentWrapper: {
width: '275px',
minHeight: '50vh',
height: 'auto',
margin: '15px',
},
}
));
interface ColumnDataProps {
column: INestedColumn,
}
const ColumnData: FC<ColumnDataProps> = (props) => {
const classes = useStyles();
const [showDeleteColumn, setShowDeleteColumn] = useState<boolean>(window.innerWidth < 600 ? true : false);
const [showAddIssue, setShowAddIssue] = useState<boolean>(window.innerWidth < 600 ? true : false);
function displayColumnContent() {
return (
props.column.issues.map((issue: INestedIssue, index: number) => {
return (
<Fragment key={index}>
<IssueData issue={issue} index={index} />
</Fragment>
);
})
)
}
return (
<>
<div className={classes.columnWrapper}>
<div
className={classes.columnHeader}
onMouseOver={() => setShowDeleteColumn(true)}
onMouseLeave={() => setShowDeleteColumn(false)}
>
<div className={classes.columnName}>
<UpdateColumn column={props.column} />
</div>
{showDeleteColumn &&
<div className={classes.deleteColumnButton}>
<DeleteColumn column={props.column} />
</div>
}
</div>
<Droppable droppableId={props.column._id}>
{provided => {
return (
<div
className={classes.columnContentWrapper}
onMouseOver={() => setShowAddIssue(true)}
onMouseLeave={() => setShowAddIssue(false)}
{...provided.droppableProps}
ref={provided.innerRef}
>
{displayColumnContent()}
{provided.placeholder}
{showAddIssue &&
<AddIssue column={props.column} />
}
</div>
);
}}
</Droppable>
</div>
</>
);
}
export default ColumnData;
|
JKusiak/isshu
|
frontend/src/api/Authentication/GetHomePage.tsx
|
import axios from "axios";
import { createContext, useContext, useEffect, useState } from "react";
import { AuthUserContext } from "../../App";
import HomePage from "../../pages/Home/HomePage";
import { NestedUserTemplate, OrganizationTemplate, UserTemplate } from "../../types/ModelContentTemplate";
import { INestedUser, IOrganization, IUser } from "../../types/ModelTypes";
export const FetchMembersContext = createContext<{ members: [INestedUser], setMembers: React.Dispatch<React.SetStateAction<[INestedUser]>> }>({} as any);
const GetHomePage = () => {
const [organization, setOrganization] = useState<IOrganization>(OrganizationTemplate);
const [user, setUser] = useState<IUser>(UserTemplate);
const [members, setMembers] = useState<[INestedUser]>([NestedUserTemplate]);
const [isLoaded, setIsLoaded] = useState(false);
const { loggedInUser } = useContext(AuthUserContext);
useEffect(() => {
fetchUser();
if (user.organizationId !== '') {
fetchOrganization();
fetchMembers();
}
}, [user.organizationId]);
function fetchUser() {
axios.get(`/users/getProjects/${loggedInUser._id}`)
.then(resp => {
setUser(resp.data);
setIsLoaded(true);
}).catch((err) => {
console.log(err);
});
}
function fetchOrganization() {
if (user.organizationId) {
axios.get(`/organization/${user.organizationId}`)
.then(resp => {
setOrganization(resp.data);
}).catch((err) => {
console.log(err);
});;
}
}
function fetchMembers() {
if (user.organizationId) {
axios.get(`/organization/members/${user.organizationId}`)
.then(resp => {
setMembers(resp.data);
}).catch((err) => {
console.log(err);
});;
}
}
return (
<>
{isLoaded &&
<FetchMembersContext.Provider value={{ members, setMembers }}>
<HomePage
organization={organization}
user={user}
/>
</FetchMembersContext.Provider>
}
</>
);
}
export default GetHomePage;
|
JKusiak/isshu
|
frontend/src/resources/theme.tsx
|
<filename>frontend/src/resources/theme.tsx
import { Shadows } from "@material-ui/core/styles/shadows";
const lightTheme = {
light: '#ffffff',
main: '#fafafa',
dark: '#c7c7c7',
};
const darkTheme = {
light: '#424242',
main: '#212121',
dark: '#171717',
};
export const lightPalette = {
primary: {
...lightTheme
},
secondary: {
...darkTheme
},
}
// this swap is necessary to make fonts readible in dark mode
export const darkPalette = {
primary: {
...darkTheme
},
secondary: {
light: lightTheme.main,
main: lightTheme.dark,
dark: lightTheme.dark,
},
}
// anti shadows mirror depth from light mode on dark mode, only
// one used in the project is the sixth shadow
export function getAntiShadows() {
let antiShadows = Array(19).fill("none");
antiShadows[5] = "0px 3px 1px -2px rgba(255,255,255,0.05),0px 2px 2px 0px rgba(255,255,255,0.14),0px 1px 5px 0px rgba(255,255,255,0.12)";
return antiShadows as Shadows;
}
// necessary for ensuring on hover visibility of button background in dark mode
export const overrides = {
MuiIconButton: {
root: {
'&:hover': {
backgroundColor: '#575757',
}
}
},
MuiButton: {
root: {
'&:hover': {
backgroundColor: '#575757',
}
}
},
MuiMenuItem: {
root: {
'&:hover': {
backgroundColor: '#575757',
}
}
}
}
|
JKusiak/isshu
|
frontend/src/components/Tag/TagsListModal.tsx
|
<gh_stars>0
import { Backdrop, createStyles, Fade, makeStyles, Modal, Theme } from "@material-ui/core";
import React, { FC } from "react";
import ManageTags from "../../api/Tag/ManageTags";
import { INestedIssue } from "../../types/ModelTypes";
const useStyles = makeStyles((theme: Theme) => createStyles({
modal: {
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
},
paper: {
display: 'grid',
width: '25vw',
minWidth: '270px',
height: '60vh',
backgroundColor: theme.palette.primary.main,
border: '2px solid',
borderColor: theme.palette.secondary.main,
borderRadius: '10px',
boxShadow: theme.shadows[2],
padding: theme.spacing(2, 2, 2),
},
}
));
interface TagsListModalProps {
issue: INestedIssue,
isTagsModalOpen: boolean,
setTagsModalOpen: React.Dispatch<React.SetStateAction<boolean>>,
}
const TagsListModal: FC<TagsListModalProps> = (props) => {
const classes = useStyles();
return (
<Modal
className={classes.modal}
aria-labelledby="transition-modal-title"
aria-describedby="transition-modal-description"
open={props.isTagsModalOpen}
onClose={() => props.setTagsModalOpen(false)}
closeAfterTransition
BackdropComponent={Backdrop}
BackdropProps={{
timeout: 500,
}}
>
<Fade in={props.isTagsModalOpen}>
<div className={classes.paper}>
<ManageTags
issue={props.issue}
isTagsModalOpen={props.isTagsModalOpen}
setTagsModalOpen={props.setTagsModalOpen}
/>
</div>
</Fade>
</Modal>
);
}
export default TagsListModal;
|
JKusiak/isshu
|
frontend/src/pages/Home/Subpages/ProjectsGalleryPage.tsx
|
import { Typography } from "@material-ui/core";
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import { FC, Fragment } from "react";
import ManageProjectCard from "../../../api/Project/ManageProjectCard";
import { IProject } from "../../../types/ModelTypes";
const useStyles = makeStyles((theme: Theme) => createStyles({
header: {
display: 'flex',
width: '100%',
alignItems: 'center',
justifyContent: 'center',
fontSize: '28px',
[theme.breakpoints.down('xs')]: {
fontSize: '22px',
},
fontWeight: 'bold',
color: theme.palette.secondary.main,
paddingBottom: theme.spacing(5),
},
projectsGrid: {
display: 'grid',
justifyContent: 'center',
gap: theme.spacing(4),
gridTemplateColumns: 'repeat(auto-fill, 400px)',
[theme.breakpoints.down('xs')]: {
gridTemplateColumns: 'repeat(auto-fill, 250px)',
},
marginRight: theme.spacing(8),
marginLeft: theme.spacing(8),
marginBottom: theme.spacing(4),
},
})
);
interface ProjectListProps {
projects: [IProject];
}
const ProjectsGallery: FC<ProjectListProps> = (props) => {
const classes = useStyles();
function displayProjects() {
if (props.projects.length > 0) {
return (props.projects.map((project: IProject) => {
return (
<Fragment key={project._id}>
<ManageProjectCard project={project} />
</Fragment>
);
}));
}
}
return (
<>
<Typography className={classes.header}>
Your projects
</Typography>
<div className={classes.projectsGrid}>
{displayProjects()}
</div>
</>
);
}
export default ProjectsGallery;
|
JKusiak/isshu
|
frontend/src/components/Issue/Attachment/AttachmentsGallery.tsx
|
import { Card } from "@material-ui/core";
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import AddIcon from '@material-ui/icons/AddOutlined';
import { FC, Fragment, useContext, useRef } from "react";
import { BoardReducerContext } from "../../../api/Board/GetBoard";
import { ActionTypes } from "../../../reducers/BoardReducer";
import { IAttachment, INestedIssue } from "../../../types/ModelTypes";
import EnlargedAttachmentModal from "./EnlargedAttachmentModal";
const useStyles = makeStyles((theme: Theme) => createStyles({
wrapper: {
marginBottom: theme.spacing(2),
},
title: {
fontWeight: 'bold',
fontSize: '16px',
marginBottom: theme.spacing(1),
color: theme.palette.secondary.main,
},
gallery: {
display: 'flex',
flexWrap: 'wrap',
[theme.breakpoints.down('xs')]: {
justifyContent: 'center',
},
},
addAttachmentIcon: {
fontSize: '35px',
color: theme.palette.secondary.main,
},
attachmentCard: {
display: 'flex',
flexShrink: 0,
height: '80px',
width: '142px',
justifyContent: 'center',
alignItems: 'center',
backgroundColor: theme.palette.primary.light,
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
"&:hover": {
boxShadow: theme.shadows[5],
cursor: 'pointer',
},
marginBottom: theme.spacing(2),
},
})
);
interface AttachmentsGalleryProps {
issue: INestedIssue,
addAttachment: (file: string | Blob) => void,
deleteAttachment: () => void,
deleteImage: (clickedAttachment: IAttachment) => void,
}
const AttachmentsGallery: FC<AttachmentsGalleryProps> = (props) => {
const classes = useStyles();
const imageInputRef = useRef<HTMLInputElement>(null);
const { dispatch } = useContext(BoardReducerContext);
function handleImageClick() {
imageInputRef.current?.click();
}
function handleChooseFile(e: any) {
const newAttachment = {
name: e.target.files[0].name,
};
const updatedAttachments = [...props.issue.attachments, newAttachment];
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
modified: {
attachments: updatedAttachments,
},
};
const mimeType = e.target.files[0].type;
const correctExtension = mimeType === 'image/png' || mimeType === 'image/jpg' || mimeType === 'image/jpeg';
if (correctExtension) {
dispatch({ type: ActionTypes.UpdateIssue, payload: payload });
props.addAttachment(e.target.files[0]);
}
}
function displayAttachments() {
return (props.issue.attachments.map((attachment: IAttachment, index: number) => {
if (attachment._id) {
return (
<Fragment key={index}>
<EnlargedAttachmentModal
issue={props.issue}
clickedAttachment={attachment}
deleteAttachment={props.deleteAttachment}
deleteImage={props.deleteImage}
/>
</Fragment>
);
}
return null;
}));
}
return (
<div className={classes.wrapper}>
<div className={classes.title}>Attachments</div>
<div className={classes.gallery}>
{displayAttachments()}
<Card className={classes.attachmentCard} onClick={handleImageClick}>
<AddIcon className={classes.addAttachmentIcon} />
<input
style={{ display: 'none' }}
type="file"
accept=".jpg, .jpeg, .png"
onChange={handleChooseFile}
ref={imageInputRef}
/>
</Card>
</div>
</div>
);
}
export default AttachmentsGallery;
|
JKusiak/isshu
|
frontend/src/components/Organization/OrganizationNameButton.tsx
|
<filename>frontend/src/components/Organization/OrganizationNameButton.tsx
import { ClickAwayListener, TextField } from '@material-ui/core';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import { FC, useState } from 'react';
const useStyles = makeStyles((theme: Theme) => createStyles({
inputField: {
width: 'auto',
"& .MuiOutlinedInput-root": {
color: theme.palette.secondary.main,
"& .MuiOutlinedInput-notchedOutline": {
borderRadius: '6px',
borderColor: theme.palette.secondary.light,
},
"&.Mui-focused .MuiOutlinedInput-notchedOutline": {
borderColor: theme.palette.secondary.light,
borderWidth: "2px",
},
},
"& .MuiOutlinedInput-input": {
marginLeft: theme.spacing(0.5),
fontSize: '28px',
padding: 8,
[theme.breakpoints.down('xs')]: {
fontSize: '20px',
minWidth: '100px',
},
},
marginLeft: theme.spacing(4),
marginRight: theme.spacing(4),
},
headerText: {
maxWidth: '250px',
height: '40px',
overflow: 'hidden',
fontSize: '32px',
fontWeight: 'bold',
color: theme.palette.secondary.main,
textAlign: 'center',
[theme.breakpoints.down('xs')]: {
fontSize: '26px',
maxWidth: '120px',
},
"&:hover": {
cursor: 'pointer',
},
marginLeft: theme.spacing(4),
marginRight: theme.spacing(4),
},
}));
interface OrganizationNameButtonProps {
tempOrgName: string,
setTempOrgName: React.Dispatch<React.SetStateAction<string>>,
onSubmit: (e: any) => void,
}
const OrganizationNameButton: FC<OrganizationNameButtonProps> = (props) => {
const classes = useStyles();
const [updateMode, setUpdateMode] = useState<boolean>(false);
function handleSubmit(e: any) {
if (updateMode) {
props.onSubmit(e);
}
setUpdateMode(false);
}
return (
<ClickAwayListener onClickAway={handleSubmit}>
<div onClick={() => setUpdateMode(true)}>
{updateMode &&
<form onSubmit={handleSubmit} autoComplete="off">
<TextField
className={classes.inputField}
required
autoFocus
size="small"
variant='outlined'
name="organizationName"
id="organizationName"
value={props.tempOrgName}
autoComplete="organization-name"
onChange={e => {
if (e.target.value !== '') {
props.setTempOrgName(e.target.value);
} else {
props.setTempOrgName('Enter value');
}
}}
/>
</form>
}
{!updateMode &&
<div className={classes.headerText}>
{props.tempOrgName}
</div>
}
</div>
</ClickAwayListener>
);
}
export default OrganizationNameButton;
|
JKusiak/isshu
|
frontend/src/components/Issue/Message/IssueMessagesText.tsx
|
<filename>frontend/src/components/Issue/Message/IssueMessagesText.tsx<gh_stars>0
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import React, { FC, Fragment, useContext } from "react";
import { BoardReducerContext } from "../../../api/Board/GetBoard";
import { getUserLanguage } from "../../../api/User/GetLoggedInUser";
import { AuthUserContext } from "../../../App";
import { ActionTypes } from "../../../reducers/BoardReducer";
import { INestedIssue, INestedMessage } from "../../../types/ModelTypes";
const useStyles = makeStyles((theme: Theme) => createStyles({
messageContainer: {
marginBottom: theme.spacing(2),
marginLeft: theme.spacing(2),
},
name: {
fontWeight: 'bold',
color: theme.palette.secondary.main,
},
date: {
fontSize: '12px',
color: theme.palette.secondary.main,
},
content: {
marginBottom: theme.spacing(1),
marginTop: theme.spacing(1),
color: theme.palette.secondary.main,
},
deleteButton: {
fontSize: '12px',
color: theme.palette.secondary.main,
"&:hover": {
cursor: 'pointer',
fontWeight: 'bold',
},
}
})
);
interface MessagesTextProps {
issue: INestedIssue,
deleteMessage: () => void,
displayOnly: boolean,
}
const IssueMessagesText: FC<MessagesTextProps> = (props) => {
const classes = useStyles();
const { dispatch } = useContext(BoardReducerContext);
const { loggedInUser } = useContext(AuthUserContext);
function handleDelete(e: React.SyntheticEvent, clickedMessage: INestedMessage) {
const updatedMessages = props.issue.messages.filter(message =>
props.issue.messages.indexOf(message) !== props.issue.messages.indexOf(clickedMessage));
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
modified: {
messages: updatedMessages,
},
};
dispatch({ type: ActionTypes.UpdateIssue, payload: payload })
props.deleteMessage();
}
function displayMessages() {
if (props.issue.messages.length > 0) {
return (props.issue.messages.map((message: INestedMessage) => {
const msgTime = new Date(message.addTime);
const formattedTime = msgTime.toLocaleDateString(getUserLanguage(), {
year: "numeric",
month: "2-digit",
day: "2-digit",
hour: "2-digit",
minute: "2-digit",
});
const ownMessage = (message.sender._id === loggedInUser._id);
const displayDelete = ownMessage && !props.displayOnly;
return (
<Fragment key={props.issue.messages.indexOf(message)}>
<div className={classes.messageContainer}>
<div>
<span className={classes.name}>{message.sender.name}</span>
<span className={classes.date}> at {formattedTime}</span>
</div>
<div className={classes.content}>
{message.content}
</div>
{displayDelete &&
<div>
<span className={classes.deleteButton} onClick={(e) => handleDelete(e, message)}>Delete</span>
</div>
}
</div>
</Fragment>
);
}));
}
}
return (
<>
{displayMessages()}
</>
);
}
export default IssueMessagesText;
|
JKusiak/isshu
|
frontend/src/api/User/GetData.tsx
|
<gh_stars>0
import axios from "axios";
import { useEffect, useState } from "react";
import { useParams } from "react-router-dom";
import PersonalData from "../../components/User/PersonalData";
import { UserTemplate } from "../../types/ModelContentTemplate";
import { IUser } from "../../types/ModelTypes";
const GetData = () => {
const { userId } = useParams<{ userId: string }>();
const [user, setUser] = useState<IUser>(UserTemplate);
useEffect(() => {
axios.get(`/users/${userId}`)
.then(resp => {
setUser(resp.data);
}).catch((err) => {
console.log(err);
});
}, [userId]);
return (
<>
<PersonalData user={user} />
</>
);
}
export default GetData;
|
JKusiak/isshu
|
frontend/src/components/User/UserIssuesGallery.tsx
|
import { createStyles, makeStyles, Theme } from "@material-ui/core";
import { FC, Fragment, useEffect, useState } from "react";
import { INestedIssue } from "../../types/ModelTypes";
import UserIssuesCard from "./UserIssueCard";
const useStyles = makeStyles((theme: Theme) => createStyles({
statistics: {
fontSize: '16px',
marginBottom: theme.spacing(8),
},
userStat: {
marginRight: theme.spacing(4),
},
container: {
display: 'grid',
justifyContent: 'center',
width: '70%',
[theme.breakpoints.up('md')]: {
gridTemplateColumns: '1fr 1fr',
},
[theme.breakpoints.down('sm')]: {
gridTemplateRows: '1fr 1fr',
},
},
column: {
textAlign: 'center',
[theme.breakpoints.up('md')]: {
marginLeft: theme.spacing(8),
},
[theme.breakpoints.down('sm')]: {
marginBottom: theme.spacing(4),
},
},
header: {
fontSize: '24px',
marginBottom: theme.spacing(2),
},
}));
interface UserIssuesGalleryProps {
issuesTaken: [INestedIssue];
issuesCreated: [INestedIssue];
}
const UserIssuesGallery: FC<UserIssuesGalleryProps> = (props) => {
const classes = useStyles();
const [totalCreated, setCreated] = useState<number>(0);
const [totalTaken, setTaken] = useState<number>(0);
const [totalCompleted, setCompleted] = useState<number>(0);
const [totalArchived, setArchived] = useState<number>(0);
useEffect(() => {
for (let issue of props.issuesCreated) {
setCreated(prev => prev + 1);
if (!issue.columnId) {
setArchived(prev => prev + 1);
}
}
}, []);
useEffect(() => {
for (let issue of props.issuesTaken) {
setTaken(prev => prev + 1);
if (issue.isFinished) {
setCompleted(prev => prev + 1);
}
if (!issue.columnId) {
setArchived(prev => prev + 1);
}
}
}, []);
function displayIssues(type: 'issuesTaken' | 'issuesCreated') {
if (props[type].length > 0) {
return (props[type].map((issue: INestedIssue) => {
// only show active issues
if (!issue.columnId) return;
return (
<Fragment key={issue._id}>
<UserIssuesCard issue={issue} />
</Fragment>
);
}));
} else {
return (
<p>No issues yet</p>
);
}
}
return (
<>
<div className={classes.statistics}>
<span className={classes.userStat}>
Total created: <b>{totalCreated}</b>
</span>
<span className={classes.userStat}>
Total taken: <b>{totalTaken}</b>
</span>
<span className={classes.userStat}>
Total completed: <b>{totalCompleted}</b>
</span>
<span className={classes.userStat}>
Total archived: <b>{totalArchived}</b>
</span>
</div>
<div className={classes.container}>
<div className={classes.column}>
<div className={classes.header}>Active issues created: </div>
{displayIssues('issuesCreated')}
</div>
<div className={classes.column}>
<div className={classes.header}> Active issues taken:</div>
{displayIssues('issuesTaken')}
</div>
</div>
</>
);
}
export default UserIssuesGallery;
|
JKusiak/isshu
|
frontend/src/api/Issue/ArchiveIssue.tsx
|
import axios from 'axios';
import React, { FC, useContext } from 'react';
import { AuthUserContext } from '../../App';
import ArchiveIssueButton from '../../components/Issue/ArchiveIssueButton';
import { INestedIssue } from '../../types/ModelTypes';
interface ArchiveIssueProps {
issue: INestedIssue,
setIssueModalOpen: React.Dispatch<React.SetStateAction<boolean>>,
}
// this does not work as delete because issues remain after deleting
// in the organization archive of all issues
const ArchiveIssue: FC<ArchiveIssueProps> = (props) => {
const { loggedInUser } = useContext(AuthUserContext);
function updateIssue() {
const requestBody = {
columnId: null,
contributors: [],
}
axios.post(`/issues/update/${props.issue._id}`, requestBody)
.catch((err) => {
console.log(err);
})
}
function addToArchive() {
const requestBody = {
issueId: props.issue._id,
}
axios.post(`/organization/addToArchive/${loggedInUser.organizationId}`, requestBody)
.catch((err) => {
console.log(err);
})
}
function archiveIssue() {
addToArchive();
updateIssue();
props.setIssueModalOpen(false);
}
return (
<>
<ArchiveIssueButton
issue={props.issue}
archiveIssue={archiveIssue}
/>
</>
);
}
export default ArchiveIssue;
|
JKusiak/isshu
|
frontend/src/components/Project/AddProjectModal/NameForm.tsx
|
import { TextField } from '@material-ui/core';
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import React, { FC } from "react";
import { Action, ActionTypes } from "../../../reducers/ProjectReducer";
const useStyles = makeStyles((theme: Theme) => createStyles({
inputField: {
"& .MuiOutlinedInput-root": {
color: theme.palette.secondary.main,
"& .MuiOutlinedInput-notchedOutline": {
borderRadius: '10px',
borderColor: theme.palette.secondary.light,
},
"&.Mui-focused .MuiOutlinedInput-notchedOutline": {
borderColor: theme.palette.secondary.light,
borderWidth: "2px",
}
},
},
}));
interface NameProps {
dispatch: React.Dispatch<Action>,
setErrorText: React.Dispatch<React.SetStateAction<string>>,
setIsValid: React.Dispatch<React.SetStateAction<boolean>>,
}
const NameForm: FC<NameProps> = (props) => {
const classes = useStyles(props);
const projectNameRegex = /^$|^[A-Za-z][a-z\s]*$/;
return (
<TextField
className={classes.inputField}
required
fullWidth
autoFocus
variant="outlined"
name="projectName"
id="projectName"
placeholder="Project Name"
autoComplete="project-name"
onChange={e => {
if (e.target.value.match(projectNameRegex)) {
props.dispatch({ type: ActionTypes.UpdateName, payload: e.target.value })
props.setIsValid(true);
} else {
props.setErrorText("Name must contain only letters and spaces");
props.setIsValid(false);
}
}}
/>
);
}
export default NameForm;
|
JKusiak/isshu
|
frontend/src/components/Issue/ArchiveIssueButton.tsx
|
import { Button, Card } from '@material-ui/core';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import { FC, useContext, useState } from 'react';
import { BoardReducerContext } from '../../api/Board/GetBoard';
import { ActionTypes } from '../../reducers/BoardReducer';
import { INestedIssue } from '../../types/ModelTypes';
import ConfirmationModal from '../Commons/ConfirmationModal';
const useStyles = makeStyles((theme: Theme) => createStyles({
cardWrapper: {
display: 'flex',
width: '100px',
height: '33px',
backgroundColor: theme.palette.primary.light,
justifyContent: 'center',
alignItems: 'center',
marginLeft: theme.spacing(1),
},
button: {
width: '100%',
textTransform: 'none',
fontWeight: 'bold',
"&:hover": {
fontWeight: 'bold',
}
},
text: {
fontSize: '14px',
color: theme.palette.secondary.main,
},
}));
interface ArchiveProps {
issue: INestedIssue,
archiveIssue: () => void,
}
const ArchiveButton: FC<ArchiveProps> = (props) => {
const classes = useStyles();
const [modalOpen, setModalOpen] = useState(false);
const { dispatch } = useContext(BoardReducerContext);
function handleSubmit() {
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
};
dispatch({ type: ActionTypes.ArchiveIssue, payload: payload });
props.archiveIssue();
}
return (
<>
<Card className={classes.cardWrapper}>
<Button className={classes.button} onClick={() => {setModalOpen(true)}}>
<div className={classes.text}>
Archive
</div>
</Button>
<ConfirmationModal
handleConfirm={handleSubmit}
open={modalOpen}
setOpen={setModalOpen}
/>
</Card>
</>
);
}
export default ArchiveButton;
|
JKusiak/isshu
|
frontend/src/api/Organization/UpdateOrganization.tsx
|
<gh_stars>0
import axios from 'axios';
import { FC, useEffect, useState } from 'react';
import OrganizationNameButton from '../../components/Organization/OrganizationNameButton';
import { IOrganization } from '../../types/ModelTypes';
interface UpdateOrganizationProps {
organization: IOrganization,
}
const UpdateOrganization: FC<UpdateOrganizationProps> = (props) => {
const [tempOrgName, setTempOrgName] = useState(props.organization.name);
useEffect(() => {
setTempOrgName(props.organization.name)
}, [props.organization.name]);
function onSubmit(e: React.SyntheticEvent) {
e.preventDefault();
const requestBody = {
name: tempOrgName,
}
axios.post(`/organization/update/${props.organization._id}`, requestBody);
}
return (
<>
<OrganizationNameButton
tempOrgName={tempOrgName}
setTempOrgName={setTempOrgName}
onSubmit={onSubmit}
/>
</>
);
}
export default UpdateOrganization;
|
JKusiak/isshu
|
frontend/src/components/Issue/Contributor/DeleteContributorButton.tsx
|
import { IconButton } from '@material-ui/core';
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import DeleteIcon from '@material-ui/icons/ClearOutlined';
import React, { FC, useContext } from "react";
import { BoardReducerContext } from '../../../api/Board/GetBoard';
import { ActionTypes } from '../../../reducers/BoardReducer';
import { INestedIssue, INestedUser } from '../../../types/ModelTypes';
const useStyles = makeStyles((theme: Theme) => createStyles({
buttonWrapper: {
marginLeft: 'auto',
},
iconButton: {
justifyContent: 'center',
alignItems: 'center',
transform: 'scale(0.7)',
padding: theme.spacing(1),
},
icon: {
color: theme.palette.secondary.main,
},
})
);
interface DeleteContributorButtonProps {
issue: INestedIssue,
clickedContributor: INestedUser,
updateContributors: () => void,
}
const DeleteContributorButton: FC<DeleteContributorButtonProps> = (props) => {
const classes = useStyles();
const { dispatch } = useContext(BoardReducerContext);
function handleDelete(e: React.SyntheticEvent) {
const updatedContributors = props.issue.contributors.filter(contributor =>
props.issue.contributors.indexOf(contributor) !== props.issue.contributors.indexOf(props.clickedContributor));
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
modified: {
contributors: updatedContributors,
},
};
dispatch({ type: ActionTypes.UpdateIssue, payload: payload });
props.updateContributors();
}
return (
<>
<div className={classes.buttonWrapper}>
<IconButton className={classes.iconButton} onClick={handleDelete}>
<DeleteIcon className={classes.icon} />
</IconButton>
</div>
</>
);
}
export default DeleteContributorButton;
|
JKusiak/isshu
|
frontend/src/components/Issue/Step/DeleteStepButton.tsx
|
<reponame>JKusiak/isshu
import { IconButton } from '@material-ui/core';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import DeleteIcon from '@material-ui/icons/ClearOutlined';
import { FC, useContext } from 'react';
import { BoardReducerContext } from '../../../api/Board/GetBoard';
import { ActionTypes } from '../../../reducers/BoardReducer';
import { INestedIssue, IStep } from '../../../types/ModelTypes';
const useStyles = makeStyles((theme: Theme) => createStyles({
buttonWrapper: {
marginLeft: 'auto',
},
iconButton: {
justifyContent: 'center',
alignItems: 'center',
},
icon: {
transform: 'scale(0.7)',
color: theme.palette.secondary.main,
},
}));
interface DeleteStepButtonProps {
issue: INestedIssue,
clickedStep: IStep,
updateSteps: () => void,
}
const DeleteStepButton: FC<DeleteStepButtonProps> = (props) => {
const classes = useStyles();
const { dispatch } = useContext(BoardReducerContext);
function handleDelete() {
const updatedSteps = props.issue.steps.filter(step =>
props.issue.steps.indexOf(step) !== props.issue.steps.indexOf(props.clickedStep));
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
modified: {
steps: updatedSteps,
},
};
dispatch({ type: ActionTypes.UpdateIssue, payload: payload });
props.updateSteps();
}
return (
<div className={classes.buttonWrapper}>
<IconButton className={classes.iconButton} onClick={handleDelete}>
<DeleteIcon className={classes.icon} />
</IconButton>
</div>
);
}
export default DeleteStepButton;
|
JKusiak/isshu
|
frontend/src/api/Issue/Attachment/ManageAttachments.tsx
|
<reponame>JKusiak/isshu<filename>frontend/src/api/Issue/Attachment/ManageAttachments.tsx
import axios from 'axios';
import { FC, useContext } from 'react';
import { AuthUserContext } from '../../../App';
import AttachmentsGallery from '../../../components/Issue/Attachment/AttachmentsGallery';
import { ActionTypes } from '../../../reducers/BoardReducer';
import { IAttachment, INestedIssue } from '../../../types/ModelTypes';
import { BoardReducerContext } from '../../Board/GetBoard';
interface UpdateAttachmentsProps {
issue: INestedIssue,
}
const UpdateAttachments: FC<UpdateAttachmentsProps> = (props) => {
const { loggedInUser } = useContext(AuthUserContext);
const { dispatch } = useContext(BoardReducerContext);
function addAttachment(file: string | Blob) {
const requestBody = {
attachments: props.issue.attachments,
}
axios.post(`/issues/update/${props.issue._id}`, requestBody)
.then((resp) => {
const attachments = resp.data.attachments;
const newAttachment = attachments[attachments.length - 1];
uploadImage(file, newAttachment._id, attachments);
}).catch((err) => {
console.log(err);
})
}
function uploadImage(file: string | Blob, attachmentId: string, attachments: [IAttachment]) {
const formData = new FormData();
formData.append('organizationId', loggedInUser.organizationId);
formData.append('directory', `issues/issue-${props.issue._id}`);
formData.append('imageUpload', file);
axios.post(`/uploads/add/${attachmentId}`, formData)
.then(() => {
// payload is dispatched here again to update the new attachment with id from database
// it is done after uploading image to fetch it on render of new attachment
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
modified: {
attachments: attachments,
},
};
dispatch({ type: ActionTypes.UpdateIssue, payload: payload });
}).catch((err) => {
console.log(err);
})
}
function deleteAttachment() {
const requestBody = {
attachments: props.issue.attachments,
}
axios.post(`/issues/update/${props.issue._id}`, requestBody)
.catch((err) => {
console.log(err);
})
}
function deleteImage(clickedAttachment: IAttachment) {
// all the backslashes substituted with %2f as the path is send as one parameter
const path = `uploads%2forganization-${loggedInUser.organizationId}%2fissues%2fissue-${props.issue._id}%2f${clickedAttachment._id}.jpg`;
axios.delete(`/uploads/delete/${path}`)
.catch((err) => {
console.log(err);
})
}
return (
<AttachmentsGallery
issue={props.issue}
addAttachment={addAttachment}
deleteAttachment={deleteAttachment}
deleteImage={deleteImage}
/>
);
}
export default UpdateAttachments;
|
JKusiak/isshu
|
frontend/src/components/Issue/Creator/CreatorText.tsx
|
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import { FC } from 'react';
import { INestedIssue } from '../../../types/ModelTypes';
const useStyles = makeStyles((theme: Theme) => createStyles({
creatorContainer: {
fontSize: '16px',
marginBottom: theme.spacing(4),
},
creatorTitle: {
fontWeight: 'bold',
color: theme.palette.secondary.main,
},
creatorName: {
marginLeft: theme.spacing(2),
color: theme.palette.secondary.main,
}
}));
interface CreatorProps {
issue: INestedIssue,
}
const CreatorText: FC<CreatorProps> = (props) => {
const classes = useStyles();
return (
<div className={classes.creatorContainer}>
<span className={classes.creatorTitle}>Creator</span>
<span className={classes.creatorName}>
{`${props.issue.creator.name} ${props.issue.creator.surname}`}
</span>
</div>
);
}
export default CreatorText;
|
JKusiak/isshu
|
frontend/src/api/Issue/Description/UpdateDescription.tsx
|
<filename>frontend/src/api/Issue/Description/UpdateDescription.tsx
import axios from 'axios';
import React, { FC, useContext, useState } from 'react';
import UpdateDescriptionButton from '../../../components/Issue/Description/UpdateDescriptionButton';
import { ActionTypes } from '../../../reducers/BoardReducer';
import { INestedIssue } from '../../../types/ModelTypes';
import { BoardReducerContext } from '../../Board/GetBoard';
interface UpdateDescriptionProps {
issue: INestedIssue,
}
const UpdateDescription: FC<UpdateDescriptionProps> = (props) => {
const [tempDescription, setTempDescription] = useState<string>(props.issue.description);
const { dispatch } = useContext(BoardReducerContext);
function onSubmit(e: React.SyntheticEvent) {
e.preventDefault();
if (tempDescription === '') return;
const requestBody = {
description: tempDescription,
}
axios.post(`/issues/update/${props.issue._id}`, requestBody)
.catch((err) => {
console.log(err);
})
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
modified: {
description: tempDescription,
},
}
dispatch({ type: ActionTypes.UpdateIssue, payload: payload })
}
return (
<UpdateDescriptionButton
tempDescription={tempDescription}
setTempDescription={setTempDescription}
permDescription={props.issue.description}
onSubmit={onSubmit}
/>
);
}
export default UpdateDescription;
|
JKusiak/isshu
|
frontend/src/api/Project/GetProjectInfoBanner.tsx
|
<gh_stars>0
import axios from "axios";
import { FC, useContext, useEffect, useReducer, useState } from "react";
import { useParams } from "react-router-dom";
import { AuthUserContext } from "../../App";
import ProjectInfoBanner from "../../components/Project/ProjectInfoBanner/ProjectInfoBanner";
import { ActionTypes, projectReducer } from "../../reducers/ProjectReducer";
import { ProjectTemplate } from "../../types/ModelContentTemplate";
import { INestedProject } from "../../types/ModelTypes";
interface GetProjectInfoBannerProps {
project: INestedProject,
}
const GetProjectInfoBanner: FC<GetProjectInfoBannerProps> = (props) => {
const { projectId } = useParams<{ projectId: string }>();
const [projectBannerState, dispatch] = useReducer(projectReducer, ProjectTemplate);
const [file, setFile] = useState<string | Blob>('');
const [imageUrl, setImageUrl] = useState<string | undefined>();
const [imageExists, setImageExists] = useState<boolean>(false);
const { loggedInUser } = useContext(AuthUserContext);
useEffect(() => {
const initialReducerData = {
_id: props.project._id,
name: props.project.name,
description: props.project.description,
dateStart: props.project.dateStart,
dateEnd: props.project.dateEnd,
creator: props.project.creator,
}
dispatch({ type: ActionTypes.FetchData, payload: initialReducerData });
}, [props.project])
// when props are loaded, fetches image from the server
useEffect(() => {
checkIfExists();
}, [props.project]);
// executes uploading image to server when user chooses picture without submit button
useEffect(() => {
if (file !== '') uploadImage();
}, [file]);
function uploadImage() {
const formData = new FormData();
formData.append('organizationId', loggedInUser.organizationId);
formData.append('directory', 'projects-covers');
formData.append('imageUpload', file);
axios.post(`/uploads/add/${props.project._id}`, formData)
.then(() => {
checkIfExists();
}).catch((err) => {
console.log(err);
})
}
function checkIfExists() {
// substitutes backslash (/) with %2f as the whole path is passed as one parameter
const path = `uploads%2forganization-${loggedInUser.organizationId}%2fprojects-covers%2f${props.project._id}.jpg`;
axios.get(`/uploads/get/${path}`)
.then((resp) => {
setImageExists(resp.data);
if (resp.data) {
// ?t= and timestamp added to trick cache into re-downloading image under same path
const adjustedPath = path.replaceAll('%2f', '/') + '?t=' + new Date().getTime();
setImageUrl(`http://localhost:5000/${adjustedPath}`);
}
}).catch((err) => {
console.log(err);
})
}
function updateProject() {
axios.post(`/projects/update/${projectId}`, projectBannerState)
.catch((err) => {
console.log(err);
});
}
return (
<>
<ProjectInfoBanner
projectBannerState={projectBannerState}
dispatch={dispatch}
updateProject={updateProject}
imageExists={imageExists}
bannerPath={imageUrl}
setFile={setFile}
/>
</>
);
}
export default GetProjectInfoBanner;
|
JKusiak/isshu
|
frontend/src/components/Issue/UpdateCompletionButton.tsx
|
<reponame>JKusiak/isshu
import { Button, Card, useTheme } from '@material-ui/core';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import { FC, useContext } from 'react';
import { BoardReducerContext } from '../../api/Board/GetBoard';
import { ActionTypes } from '../../reducers/BoardReducer';
import { INestedIssue } from '../../types/ModelTypes';
const useStyles = makeStyles((theme: Theme) => createStyles({
cardWrapper: {
display: 'flex',
minWidth: '100px',
height: '33px',
backgroundColor: theme.palette.primary.light,
justifyContent: 'center',
alignItems: 'center',
},
button: {
width: '100%',
textTransform: 'none',
fontWeight: 'bold',
fontSize: '14px',
color: theme.palette.secondary.main,
"&:hover": {
fontWeight: 'bold',
}
},
}));
interface UpdateCompletionButtonProps {
issue: INestedIssue,
updateCompletion: () => void,
}
const UpdateCompletionButton: FC<UpdateCompletionButtonProps> = (props) => {
const classes = useStyles();
const { dispatch } = useContext(BoardReducerContext);
const theme = useTheme();
function handleSubmit() {
const isFinished = !props.issue.isFinished;
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
modified: {
isFinished: isFinished,
},
};
dispatch({ type: ActionTypes.UpdateIssue, payload: payload });
props.updateCompletion();
}
return (
<>
<Card className={classes.cardWrapper}>
<Button className={classes.button} onClick={handleSubmit} style={{backgroundColor: props.issue.isFinished ? theme.palette.primary.dark : ''}}>
Complete
</Button>
</Card>
</>
);
}
export default UpdateCompletionButton;
|
JKusiak/isshu
|
frontend/src/components/Issue/Step/IssueStepData.tsx
|
<reponame>JKusiak/isshu<gh_stars>0
import { Card, CardContent, Checkbox, createStyles, makeStyles, Theme, Typography } from '@material-ui/core';
import { FC, useContext } from 'react';
import { Draggable } from 'react-beautiful-dnd';
import { BoardReducerContext } from '../../../api/Board/GetBoard';
import { ActionTypes } from '../../../reducers/BoardReducer';
import { INestedIssue, IStep } from '../../../types/ModelTypes';
import DeleteStepButton from './DeleteStepButton';
const useStyles = makeStyles((theme: Theme) => createStyles({
stepCard: {
width: '100%',
flexShrink: 0,
marginBottom: theme.spacing(1.5),
backgroundColor: theme.palette.primary.light,
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
"&:hover": {
cursor: 'pointer',
boxShadow: theme.shadows[5],
},
"& .MuiCardContent-root": {
padding: theme.spacing(0.2),
},
},
cardContent: {
display: 'flex',
alignItems: 'center',
color: theme.palette.secondary.main,
},
checkbox: {
transform: 'scale(0.7)',
color: theme.palette.secondary.main,
},
})
);
interface IssueStepProps {
issue: INestedIssue,
step: IStep,
index: number,
updateSteps: () => void,
}
const IssueStep: FC<IssueStepProps> = (props) => {
const classes = useStyles();
const { dispatch } = useContext(BoardReducerContext);
function handleCheck(checkedStep: IStep) {
const updatedSteps = props.issue.steps.map((step: IStep) => {
if (props.issue.steps.indexOf(step) === props.issue.steps.indexOf(checkedStep)) {
step.isCompleted = !step.isCompleted;
}
return step;
});
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
modified: {
steps: updatedSteps,
},
};
dispatch({ type: ActionTypes.UpdateIssue, payload: payload });
props.updateSteps();
}
return (
<>
<Draggable draggableId={`${props.issue.steps.indexOf(props.step)}`} index={props.index}>
{(provided) => {
return (
<Card
className={classes.stepCard}
onClick={() => handleCheck(props.step)}
ref={provided.innerRef}
{...provided.draggableProps}
{...provided.dragHandleProps}
style={{
...provided.draggableProps.style
}}
>
<CardContent className={classes.cardContent}>
<Checkbox
className={classes.checkbox}
checked={props.step.isCompleted}
/>
<Typography
component="h5"
variant="h5"
style={{
fontSize: '14px',
textDecoration: props.step.isCompleted ? 'line-through' : 'none',
overflow: 'hidden',
}}
>
{props.step.content}
</Typography>
<DeleteStepButton
updateSteps={props.updateSteps}
issue={props.issue}
clickedStep={props.step}
/>
</CardContent>
</Card>
);
}}
</Draggable>
</>
);
}
export default IssueStep;
|
JKusiak/isshu
|
frontend/src/components/Board/DeleteBoardButton.tsx
|
import { IconButton } from '@material-ui/core';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import DeleteIcon from '@material-ui/icons/CloseOutlined';
import React, { FC, useState } from 'react';
import ConfirmationModal from '../Commons/ConfirmationModal';
const useStyles = makeStyles((theme: Theme) => createStyles({
deleteButton: {
padding: theme.spacing(2),
[theme.breakpoints.down('xs')]: {
paddingRight: 0,
paddingLeft: 0,
},
},
deleteIcon: {
transform: 'scale(2)',
[theme.breakpoints.down('xs')]: {
transform: 'scale(1.4)',
},
color: theme.palette.secondary.main,
},
}));
interface DeleteBoardProps {
deleteBoard: () => void,
}
const DeleteBoardButton: FC<DeleteBoardProps> = (props) => {
const classes = useStyles();
const [openModal, setOpenModal] = useState(false);
return (
<>
<IconButton
className={classes.deleteButton}
aria-label='deleteBoardButton'
onClick={() => setOpenModal(true)}
>
<DeleteIcon className={classes.deleteIcon} />
</IconButton>
<ConfirmationModal
handleConfirm={props.deleteBoard}
open={openModal}
setOpen={setOpenModal}
/>
</>
);
}
export default DeleteBoardButton;
|
JKusiak/isshu
|
frontend/src/api/Project/AddProject.tsx
|
<gh_stars>0
import axios, { AxiosResponse } from 'axios';
import React, { FC, useContext, useReducer, useState } from 'react';
import { useHistory } from "react-router-dom";
import { AuthUserContext } from '../../App';
import AddProjectModal from '../../components/Project/AddProjectModal/AddProjectModal';
import { projectReducer } from '../../reducers/ProjectReducer';
import { ProjectTemplate } from '../../types/ModelContentTemplate';
interface AddProps {
isOpen: boolean,
setIsOpen: React.Dispatch<React.SetStateAction<boolean>>,
}
const AddProject: FC<AddProps> = (props) => {
let history = useHistory();
const [projectState, dispatch] = useReducer(projectReducer, ProjectTemplate);
const [isValid, setIsValid] = useState<boolean>(true);
const [errorText, setErrorText] = useState<string>('');
const { loggedInUser } = useContext(AuthUserContext);
function addProjectToUser(res: AxiosResponse) {
const requestBody = {
projectId: res.data._id,
};
axios.post(`/users/addProject/${loggedInUser._id}`, requestBody)
.then(() => {
props.setIsOpen(false);
history.push(`/project/${requestBody.projectId}`);
}).catch((err) => {
console.log(err);
});
}
function onSubmit(e: React.SyntheticEvent) {
e.preventDefault();
const project = {
...projectState,
creator: loggedInUser._id,
organizationId: loggedInUser.organizationId,
}
axios.post('/projects/add', project)
.then((res) => {
addProjectToUser(res);
}).catch((err) => {
console.log(err);
setErrorText('Project name already taken');
setIsValid(false);
});
}
return (
<AddProjectModal
onSubmit={onSubmit}
projectState={projectState}
dispatch={dispatch}
isOpen={props.isOpen}
setIsOpen={props.setIsOpen}
isValid={isValid}
setIsValid={setIsValid}
errorText={errorText}
setErrorText={setErrorText}
/>
);
}
export default AddProject;
|
JKusiak/isshu
|
frontend/src/components/Tag/IssueTagsGallery.tsx
|
import { Card, CardContent, Typography } from "@material-ui/core";
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import AddIcon from '@material-ui/icons/AddOutlined';
import { FC, Fragment } from "react";
import { INestedIssue, ITag } from "../../types/ModelTypes";
import TagsListModal from "./TagsListModal";
const useStyles = makeStyles((theme: Theme) => createStyles({
tagsContainer: {
display: 'flex',
// not spacing(4) because tag cards need additional margin if the wrap
marginBottom: theme.spacing(3),
flexWrap: 'wrap',
},
tagCard: {
display: 'flex',
flexShrink: 0,
minHeight: '34px',
minWidth: '34px',
marginRight: theme.spacing(1),
marginBottom: theme.spacing(1),
justifyContent: 'center',
alignItems: 'center',
backgroundColor: theme.palette.primary.light,
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
"&:hover": {
cursor: 'pointer',
boxShadow: theme.shadows[5],
},
"& .MuiCardContent-root": {
padding: theme.spacing(1),
},
},
tagName: {
fontSize: '14px',
color: theme.palette.secondary.main,
},
modalButtonIcon: {
fontSize: '15px',
color: theme.palette.secondary.main,
},
})
);
interface TagsGalleryProps {
issue: INestedIssue,
isTagsModalOpen: boolean,
setTagsModalOpen: React.Dispatch<React.SetStateAction<boolean>>,
}
const TagsGallery: FC<TagsGalleryProps> = (props) => {
const classes = useStyles();
function displayTags() {
if (props.issue.tags.length > 0) {
return (props.issue.tags.map((tag: ITag) => {
return (
<Fragment key={tag._id}>
<Card className={classes.tagCard} onClick={() => props.setTagsModalOpen(true)}>
<CardContent>
<Typography className={classes.tagName} component="h5" variant="h5">
{tag.name}
</Typography>
</CardContent>
</Card>
</Fragment>
);
}));
}
}
return (
<>
<div className={classes.tagsContainer}>
{displayTags()}
<Card className={classes.tagCard} onClick={() => props.setTagsModalOpen(true)}>
<AddIcon className={classes.modalButtonIcon} />
</Card>
</div>
<TagsListModal
issue={props.issue}
isTagsModalOpen={props.isTagsModalOpen}
setTagsModalOpen={props.setTagsModalOpen}
/>
</>
);
}
export default TagsGallery;
|
JKusiak/isshu
|
frontend/src/pages/Home/HomePage.tsx
|
import { Button, Card, Divider, useTheme } from "@material-ui/core";
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import { FC, useState } from "react";
import { Link, Route, Switch, useLocation, useRouteMatch } from 'react-router-dom';
import GetArchiveGallery from "../../api/Issue/GetArchiveGallery";
import AddOrganization from "../../api/Organization/AddOrganization";
import ManageOrganizationImage from "../../api/Organization/ManageOrganizationImage";
import UpdateOrganization from "../../api/Organization/UpdateOrganization";
import InvitationsGallery from "../../components/Organization/InvitationsGallery";
import { IOrganization } from "../../types/ModelTypes";
import MembersGalleryPage from "./Subpages/MembersGalleryPage";
import ProjectsGalleryPage from "./Subpages/ProjectsGalleryPage";
const useStyles = makeStyles((theme: Theme) => createStyles({
emptyContainer: {
display: 'flex',
flexDirection: 'column',
height: '90vh',
width: '100%',
justifyContent: 'center',
alignItems: 'center',
},
headerWrapper: {
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
marginTop: theme.spacing(2),
[theme.breakpoints.down('xs')]: {
marginTop: theme.spacing(4),
}
},
errorText: {
display: 'flex',
justifyContent: 'center',
marginTop: theme.spacing(1),
color: 'red',
},
buttonsContainer: {
display: 'flex',
width: '100%',
alignItems: 'center',
justifyContent: 'center',
paddingTop: theme.spacing(2),
paddingBottom: theme.spacing(2),
},
divider: {
[theme.breakpoints.down('xs')]: {
width: '90%',
},
[theme.breakpoints.up('sm')]: {
width: '40%',
},
height: '4px',
marginLeft: 'auto',
marginRight: 'auto',
marginTop: theme.spacing(1),
marginBottom: theme.spacing(1),
background: theme.palette.secondary.main,
opacity: 0.15,
},
extraMarginTop: {
marginTop: theme.spacing(4),
},
extraMarginBottom: {
marginBottom: theme.spacing(4),
},
cardWrapper: {
display: 'flex',
minWidth: '100px',
[theme.breakpoints.down('xs')]: {
minWidth: '70px',
},
backgroundColor: theme.palette.primary.light,
justifyContent: 'center',
alignItems: 'center',
marginLeft: theme.spacing(1),
},
button: {
width: '100%',
textTransform: 'none',
fontWeight: 'bold',
borderRadius: 0,
fontSize: '14px',
color: theme.palette.secondary.main,
},
emptyImageIcon: {
width: 'auto',
height: 'auto',
color: theme.palette.secondary.main,
},
}
));
interface HomePageProps {
organization: IOrganization,
user: any,
}
const HomePage: FC<HomePageProps> = (props) => {
const classes = useStyles();
const [errorText, setErrorText] = useState('');
const path = useLocation().pathname;
const theme = useTheme();
function displayOrganization() {
return (
<>
<div className={classes.headerWrapper}>
<ManageOrganizationImage
organization={props.organization}
user={props.user}
errorText={errorText}
setErrorText={setErrorText}
/>
<UpdateOrganization organization={props.organization} />
</div>
<div className={classes.errorText}>
{errorText}
</div>
<Divider className={`${classes.divider} ${classes.extraMarginTop}`} />
<div className={classes.buttonsContainer}>
<Card className={classes.cardWrapper}>
<Button className={classes.button} component={Link} to='/home/projects' style={{backgroundColor: path === '/home/projects' ? theme.palette.primary.dark : ''}}>
Projects
</Button>
</Card>
<Card className={classes.cardWrapper}>
<Button className={classes.button} component={Link} to='/home/archive' style={{backgroundColor: path === '/home/archive' ? theme.palette.primary.dark : ''}}>
Archive
</Button>
</Card>
<Card className={classes.cardWrapper}>
<Button className={classes.button} component={Link} to='/home/members' style={{backgroundColor: path === '/home/members' ? theme.palette.primary.dark : ''}}>
Members
</Button>
</Card>
</div>
<Divider className={`${classes.divider} ${classes.extraMarginBottom}`} />
<Switch>
<Route path="/home/projects">
<ProjectsGalleryPage projects={props.user.projects} />
</Route>
<Route path="/home/archive">
<GetArchiveGallery user={props.user} />
</Route>
<Route path="/home/members">
<MembersGalleryPage />
</Route>
</Switch>
</>
)
}
function displayWithoutOrganization() {
return (
<>
<div className={classes.emptyContainer}>
<AddOrganization />
<InvitationsGallery user={props.user} />
</div>
</>
)
}
return (
<>
{props.user.organizationId ?
displayOrganization() :
displayWithoutOrganization()
}
</>
);
}
export default HomePage;
|
JKusiak/isshu
|
frontend/src/types/ModelTypes.ts
|
<filename>frontend/src/types/ModelTypes.ts
// type for JWT token
export interface JWTTokenUser {
_id: string,
email: string;
name: string;
surname: string;
organizationId: string;
}
// types for basic database models
export interface IOrganization {
_id: string;
name: string;
archivedIssues: [];
}
export interface IUser {
_id: string;
name: string;
surname: string;
email: string;
password: string;
isAdmin: boolean;
organizationId: string; // ref id
projects: [string]; // ref id
invitations: [string] // ref id
}
export interface IProject {
_id: string;
name: string;
description: string;
dateStart: Date;
dateEnd: Date;
creator: IUser;
organizationId: string;
}
export interface IBoard {
_id: string;
name: string;
projectId: string; // ref id
}
export interface IColumn {
_id: string;
name: string;
boardId: string; // ref id
}
export interface IIssue {
_id: string;
name: string;
description: string;
creator: string; // ref id
columnId: string; // ref id
isFinished: boolean;
attachments: [IAttachment];
messages: [IMessage];
steps: [IStep];
tags: [string]; // ref id
contributors: [string]; // ref id
}
export interface ITag {
_id: string;
name: string;
organizationId: string;
}
export interface IMessage {
_id: string;
content: string;
sender: string;
addTime: Date;
}
export interface IStep {
_id: string;
content: string;
isCompleted: boolean;
}
export interface IAttachment {
_id: string;
name: string;
}
// types with nested subtypes for call on getNestedBoard
// that fetches all data of board and its children based on
// virtual properties to create nested object
export interface INestedMessage {
_id: string;
content: string;
sender: INestedUser;
addTime: Date;
}
export interface INestedUser {
_id: string;
name: string;
surname: string;
organizationId: string;
}
export interface INestedBoard {
_id: string;
name: string;
projectId: string;
columns: [INestedColumn];
}
export interface INestedColumn {
_id: string;
name: string;
boardId: string;
issues: [INestedIssue];
}
export interface INestedIssue {
_id: string;
name: string;
description: string;
creator: INestedUser;
columnId: string;
isFinished: boolean;
attachments: [IAttachment];
messages: [INestedMessage];
steps: [IStep];
tags: [ITag];
contributors: [INestedUser];
}
// types with nested subtypes for GetBoardsGallery and ProjectInfoBanner
export interface INestedProject {
_id: string;
name: string;
description: string;
dateStart: Date;
dateEnd: Date;
creator: INestedUser;
boards: [{
_id: string;
name: string;
projectId: string;
totalIssues: number;
totalCompleted: number;
}]
}
|
JKusiak/isshu
|
frontend/src/components/Issue/Message/AddMessageButton.tsx
|
import { TextField } from "@material-ui/core";
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import React, { FC, useState } from "react";
const useStyles = makeStyles((theme: Theme) => createStyles({
formContainer: {
flexShrink: 0,
width: '100%',
height: 'auto',
marginBottom: theme.spacing(2),
},
inputField: {
width: '100%',
height: 'auto',
"& .MuiOutlinedInput-root": {
color: theme.palette.secondary.main,
height: 'auto',
"& .MuiOutlinedInput-notchedOutline": {
borderRadius: '6px',
borderColor: theme.palette.secondary.light,
},
"&.Mui-focused .MuiOutlinedInput-notchedOutline": {
borderColor: theme.palette.secondary.light,
borderWidth: "2px",
}
},
"& .MuiOutlinedInput-input": {
fontSize: 14,
},
},
})
);
interface AddMessageButtonProps {
handleSubmit: (e: React.SyntheticEvent, messageContent: string) => void,
}
const AddMessageButton: FC<AddMessageButtonProps> = (props) => {
const classes = useStyles();
const [messageContent, setMessageContent] = useState('');
function localSubmit(e: React.SyntheticEvent) {
props.handleSubmit(e, messageContent);
setMessageContent('');
}
return (
<>
<form className={classes.formContainer} onSubmit={localSubmit} autoComplete="off">
<TextField
className={classes.inputField}
required
autoFocus
size="small"
variant='outlined'
name="newComment"
id="newComment"
placeholder="Add message..."
value={messageContent}
autoComplete="new-comment"
onChange={e => {
setMessageContent(e.target.value);
}}
/>
</form>
</>
);
}
export default AddMessageButton;
|
JKusiak/isshu
|
frontend/src/components/Board/GoBackButton.tsx
|
<reponame>JKusiak/isshu
import { IconButton } from '@material-ui/core';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import BackIcon from '@material-ui/icons/ChevronLeftOutlined';
import { useHistory, useParams } from 'react-router-dom';
const useStyles = makeStyles((theme: Theme) => createStyles({
backButton: {
padding: theme.spacing(2),
[theme.breakpoints.down('xs')]: {
paddingRight: 0,
paddingLeft: 0,
},
},
backIcon: {
transform: 'scale(2.5)',
color: theme.palette.secondary.main,
[theme.breakpoints.down('xs')]: {
transform: 'scale(1.8)',
},
},
}));
const GoBackButton = () => {
const classes = useStyles();
const { projectId } = useParams<{ projectId: string }>();
const history = useHistory();
function handleGoBack() {
history.push(`/project/${projectId}`);
}
return (
<IconButton
className={classes.backButton}
aria-label='backToProjectButton'
onClick={handleGoBack}
>
<BackIcon className={classes.backIcon} />
</IconButton>
);
}
export default GoBackButton;
|
JKusiak/isshu
|
frontend/src/pages/Home/Subpages/ArchiveGalleryPage.tsx
|
import { InputAdornment, TextField, Typography } from "@material-ui/core";
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import SearchIcon from '@material-ui/icons/SearchOutlined';
import { FC, Fragment, useState } from "react";
import ArchivedIssueCard from "../../../components/Issue/ArchivedIssueCard";
import { INestedIssue } from "../../../types/ModelTypes";
const useStyles = makeStyles((theme: Theme) => createStyles({
header: {
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
fontWeight: 'bold',
fontSize: '28px',
[theme.breakpoints.down('xs')]: {
fontSize: '22px',
},
color: theme.palette.secondary.main,
marginBottom: theme.spacing(2),
},
searchWrapper: {
display: 'flex',
justifyContent: 'center',
alignItems: 'center',
marginBottom: theme.spacing(5),
},
searchField: {
width: '350px',
"& .MuiOutlinedInput-root": {
color: theme.palette.secondary.main,
"& .MuiOutlinedInput-notchedOutline": {
borderRadius: '10px',
borderColor: theme.palette.secondary.light,
},
"&.Mui-focused .MuiOutlinedInput-notchedOutline": {
borderColor: theme.palette.secondary.light,
borderWidth: "2px",
}
},
},
issuesGrid: {
display: 'grid',
justifyContent: 'center',
gap: theme.spacing(4),
gridTemplateColumns: 'repeat(auto-fill, 400px)',
[theme.breakpoints.down('xs')]: {
gridTemplateColumns: 'repeat(auto-fill, 250px)',
},
marginRight: theme.spacing(8),
marginLeft: theme.spacing(8),
marginBottom: theme.spacing(4),
},
}));
interface ArchiveGalleryProps {
archivedIssues: [INestedIssue];
}
const ArchiveGalleryPage: FC<ArchiveGalleryProps> = (props) => {
const classes = useStyles();
const [query, setQuery] = useState('');
function search(issues: any) {
return issues.filter((issue: any) => {
if (query === '') return issue;
if (issue.name.toLowerCase().includes(query.toLowerCase()) || (issue.description && issue.description.toLowerCase().includes(query.toLowerCase()))) {
return issue;
}
return null;
});
}
function displayIssues() {
return (
search(props.archivedIssues).map((issue: any) => {
return (
<Fragment key={issue._id}>
<ArchivedIssueCard issue={issue} />
</Fragment>
);
})
)
}
return (
<>
<Typography className={classes.header} component="h1" variant="h4">
Archived issues
</Typography>
<div className={classes.searchWrapper}>
<TextField
className={classes.searchField}
placeholder="Search issues..."
variant='outlined'
InputProps={{
endAdornment:
<InputAdornment position="end">
<SearchIcon />
</InputAdornment>
}}
onChange={(e) => setQuery(e.target.value)}
/>
</div>
<div className={classes.issuesGrid}>
{displayIssues()}
</div>
</>
);
}
export default ArchiveGalleryPage;
|
JKusiak/isshu
|
frontend/src/pages/TitlePage.tsx
|
import { Hidden } from '@material-ui/core';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import { useContext } from "react";
import { DarkModeContext, IsLoggedInContext } from '../App';
import RegisterModal from '../components/Authentication/RegisterModal';
import ToProjectsButton from "../components/Authentication/ToProjectsButton";
import Footer from '../layout/Footer';
import TextLogo from '../resources/logo_text.svg';
import DarkTextLogo from '../resources/logo_text_darkmode.svg';
import TitleScreen1 from '../resources/title_screen1.png';
import TitleScreenMobile1 from '../resources/title_screen1_mobile.png';
import TitleScreen2 from '../resources/title_screen2.png';
import TitleScreenMobile2 from '../resources/title_screen2_mobile.png';
import TitleScreen3 from '../resources/title_screen3.png';
import TitleScreenMobile3 from '../resources/title_screen3_mobile.png';
const useStyles = makeStyles((theme: Theme) => createStyles({
container: {
display: 'flex',
flexDirection: 'column',
flexShrink: 0,
alignItems: 'center',
// taking into account height of the navbar
height: `calc(100vh - 68px)`,
},
initialContent: {
display: 'flex',
flexDirection: 'column',
flexShrink: 0,
alignItems: 'center',
justifyContent: 'center',
height: '100%',
},
textLogo: {
width: '35vw',
minWidth: '250px',
height: 'auto',
},
buttons: {
display: 'flex',
justifyContent: 'center',
marginTop: theme.spacing(8),
},
advertsList: {
display: 'flex',
flexDirection: 'column',
[theme.breakpoints.up('sm')]: {
// necessary for placing elements at the ends of card
"&>:nth-child(even)": {
"& $advertTextWrapper": {
marginLeft: 'auto',
}
},
"&>:nth-child(odd)": {
"& $advertTextWrapper": {
marginRight: 'auto',
}
},
},
},
advertBox: {
display: 'flex',
flexShrink: 0,
[theme.breakpoints.down('xs')]: {
flexDirection: 'column',
height: 'auto',
},
alignItems: 'center',
height: '90vh',
width: '80vw',
color: theme.palette.secondary.main,
backgroundColor: theme.palette.primary.main,
border: 'none',
elevation: 0,
},
advertTextWrapper: {
display: 'flex',
flexDirection: 'column',
width: '30vw',
minWidth: '280px',
},
advertHeader: {
fontSize: '36px',
fontWeight: 'bold',
textAlign: 'center',
},
advertText: {
fontSize: '16px',
textAlign: 'center',
marginTop: theme.spacing(2),
[theme.breakpoints.down('xs')]: {
marginBottom: theme.spacing(4),
},
},
cardImage: {
maxWidth: '40vw',
maxHeight: '40vh',
borderRadius: '10px',
boxShadow: theme.shadows[5],
[theme.breakpoints.down('xs')]: {
marginBottom: theme.spacing(16),
maxWidth: '60vw',
maxHeight: '60vh',
},
},
actionCall: {
fontSize: '42px',
fontWeight: 'bold',
color: theme.palette.secondary.main,
textAlign: 'center',
}
}));
const TitlePage = () => {
const classes = useStyles();
const { darkMode } = useContext(DarkModeContext);
const { isLoggedIn } = useContext(IsLoggedInContext);
function buttonToCall() {
return (
<div className={classes.buttons}>
{!isLoggedIn &&
<RegisterModal />
}
{isLoggedIn &&
<ToProjectsButton />
}
</div>
)
}
return (
<div className={classes.container}>
<div className={classes.initialContent}>
<img
className={classes.textLogo}
src={darkMode ? DarkTextLogo : TextLogo}
alt='logo of the website saying "Isshu - minimalistic bug tracker"'>
</img>
{buttonToCall()}
</div>
<div className={classes.advertsList}>
<div className={classes.advertBox}>
<div className={classes.advertTextWrapper}>
<div className={classes.actionCall}>
For teams searching simplicity
</div>
<div className={classes.advertText}>
Isshu offers only tools essential for project management, reducing unnecessary noise.
</div>
</div>
<img
className={classes.cardImage}
src={window.innerWidth < 600 ? TitleScreenMobile1 : TitleScreen1}
alt="Future app screenshot"
/>
</div>
<div className={classes.advertBox}>
<Hidden xsDown implementation="css">
<img
className={classes.cardImage}
src={window.innerWidth < 600 ? TitleScreenMobile2 : TitleScreen2}
alt="Future app screenshot"
/>
</Hidden>
<div className={classes.advertTextWrapper}>
<div className={classes.actionCall}>
Track the essentials
</div>
<div className={classes.advertText}>
All the crucial information, nothing more.
</div>
</div>
<Hidden smUp implementation="css">
<img
className={classes.cardImage}
src={window.innerWidth < 600 ? TitleScreenMobile2 : TitleScreen2}
alt="Future app screenshot"
/>
</Hidden>
</div>
<div className={classes.advertBox}>
<div className={classes.advertTextWrapper}>
<div className={classes.actionCall}>
Adjustable to your needs
</div>
<div className={classes.advertText}>
Make the tool work best for what your team sees fit.
</div>
</div>
<img
className={classes.cardImage}
src={window.innerWidth < 600 ? TitleScreenMobile3 : TitleScreen3}
alt="Future app screenshot"
/>
</div>
</div>
<div className={classes.initialContent}>
<div className={classes.actionCall}>Want to try it out?</div>
{buttonToCall()}
</div>
<Footer />
</div>
);
}
export default TitlePage;
|
JKusiak/isshu
|
frontend/src/types/ModelContentTemplate.ts
|
<filename>frontend/src/types/ModelContentTemplate.ts
// templates used for state hooks to reduce boilerplate code
// as I don't know how to solve it with types
import {
IAttachment,
IBoard,
IColumn,
IIssue,
IMessage,
INestedBoard,
INestedColumn,
INestedIssue,
INestedMessage,
INestedProject,
INestedUser,
IOrganization,
IProject,
IStep,
ITag,
IUser,
JWTTokenUser
} from "./ModelTypes";
export const JWTUserTemplate: JWTTokenUser = {
_id: '',
email: '',
name: '',
surname: '',
organizationId: '',
}
export const UserTemplate: IUser = {
_id: '',
name: '',
surname: '',
email: '',
password: '',
isAdmin: false,
organizationId: '',
projects: [''],
invitations: [''],
};
export const ProjectTemplate: IProject = {
_id: '',
name: '',
description: '',
dateStart: new Date(),
dateEnd: new Date(),
creator: UserTemplate,
organizationId: '',
};
export const BoardTemplate: IBoard = {
_id: '',
name: '',
projectId: '',
};
export const ColumnTemplate: IColumn = {
_id: '',
name: '',
boardId: '',
};
export const TagTemplate: ITag = {
_id: '',
name: '',
organizationId: '',
};
export const MessageTemplate: IMessage = {
_id: '',
content: '',
sender: '',
addTime: new Date(),
}
export const StepTemplate: IStep = {
_id: '',
content: '',
isCompleted: false,
}
export const AttachmentTemplate: IAttachment = {
_id: '',
name: '',
}
export const IssueTemplate: IIssue = {
_id: '',
name: '',
description: '',
creator: '',
contributors: [''],
tags: [''],
attachments: [AttachmentTemplate],
messages: [MessageTemplate],
steps: [StepTemplate],
columnId: '',
isFinished: false,
};
// needed for providing initial value for BoardReducer
export const NestedUserTemplate: INestedUser = {
_id: '',
name: '',
surname: '',
organizationId: '',
}
export const NestedMessageTemplate: INestedMessage = {
_id: '',
content: '',
sender: NestedUserTemplate,
addTime: new Date(),
}
export const NestedIssueTemplate: INestedIssue = {
...IssueTemplate,
tags: [TagTemplate],
contributors: [NestedUserTemplate],
creator: NestedUserTemplate,
messages: [NestedMessageTemplate],
}
export const NestedColumnTemplate: INestedColumn = {
...ColumnTemplate,
issues: [NestedIssueTemplate],
}
export const NestedBoardTemplate: INestedBoard = {
...BoardTemplate,
columns: [NestedColumnTemplate],
}
// needed for GetBoardsGallery and ProjectInfoBanner
export const NestedProjectTemplate: INestedProject = {
_id: '',
name: '',
description: '',
dateStart: new Date(),
dateEnd: new Date(),
creator: NestedUserTemplate,
boards: [{
_id: '',
name: '',
projectId: '',
totalIssues: 0,
totalCompleted: 0,
}]
}
export const OrganizationTemplate: IOrganization = {
_id: '',
name: '',
archivedIssues: [],
}
|
JKusiak/isshu
|
frontend/src/api/Issue/Message/ManageMessages.tsx
|
<reponame>JKusiak/isshu<filename>frontend/src/api/Issue/Message/ManageMessages.tsx
import axios from 'axios';
import { FC } from 'react';
import IssueMessagesGallery from '../../../components/Issue/Message/IssueMessagesGallery';
import { IMessage, INestedIssue } from '../../../types/ModelTypes';
interface UpdateMessagesProps {
issue: INestedIssue,
}
const UpdateMessages: FC<UpdateMessagesProps> = (props) => {
function addMessage() {
const adjustedMessages = props.issue.messages.map(message => {
const changedMessage: IMessage = {
...message,
sender: message.sender._id,
}
return changedMessage;
});
const requestBody = {
messages: adjustedMessages,
}
axios.post(`/issues/update/${props.issue._id}`, requestBody)
.catch((err) => {
console.log(err);
})
}
function deleteMessage() {
const adjustedMessages = props.issue.messages.map(message => {
const changedMessage: IMessage = {
...message,
sender: message.sender._id,
}
return changedMessage;
});
const requestBody = {
messages: adjustedMessages,
}
axios.post(`/issues/update/${props.issue._id}`, requestBody)
.catch((err) => {
console.log(err);
})
}
return (
<IssueMessagesGallery
addMessage={addMessage}
deleteMessage={deleteMessage}
issue={props.issue}
/>
);
}
export default UpdateMessages;
|
JKusiak/isshu
|
frontend/src/hooks/useMountEffect.tsx
|
<reponame>JKusiak/isshu
import { useEffect } from "react";
export const useMountEffect = (fun: any) => {
// eslint-disable-next-line react-hooks/exhaustive-deps
useEffect(fun, []);
}
|
JKusiak/isshu
|
frontend/src/api/Column/DeleteColumn.tsx
|
<reponame>JKusiak/isshu<filename>frontend/src/api/Column/DeleteColumn.tsx
import axios from "axios";
import { FC } from "react";
import DeleteColumnButton from "../../components/Column/DeleteColumnButton";
import { IColumn } from "../../types/ModelTypes";
interface DeleteColumnProps {
column: IColumn,
}
const DeleteColumn: FC<DeleteColumnProps> = (props) => {
function deleteColumn() {
axios.delete(`/columns/delete/${props.column._id}`)
.catch((err) => {
console.log(err);
});
}
return (
<>
<DeleteColumnButton column={props.column} deleteColumn={deleteColumn} />
</>
);
}
export default DeleteColumn;
|
JKusiak/isshu
|
frontend/src/components/Organization/InvitationModal.tsx
|
import { Button, Typography } from '@material-ui/core';
import Backdrop from '@material-ui/core/Backdrop';
import Fade from '@material-ui/core/Fade';
import Modal from '@material-ui/core/Modal';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import React, { FC, useState } from 'react';
import { IOrganization } from '../../types/ModelTypes';
const useStyles = makeStyles((theme: Theme) => createStyles({
modal: {
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
},
paper: {
width: '430px',
height: 'auto',
[theme.breakpoints.down('xs')]: {
width: '95vw',
},
backgroundColor: theme.palette.primary.main,
border: '2px solid',
borderColor: theme.palette.secondary.main,
borderRadius: '10px',
boxShadow: theme.shadows[2],
padding: theme.spacing(2, 4, 3),
},
header: {
display: 'grid',
justifyContent: 'center',
color: theme.palette.secondary.main,
[theme.breakpoints.down('xs')]: {
fontSize: '26px',
},
},
buttonContainer: {
display: 'flex',
width: '100%',
marginTop: theme.spacing(5),
[theme.breakpoints.down('xs')]: {
marginTop: theme.spacing(2),
},
},
button: {
margin: theme.spacing(3, 2, 3),
borderRadius: '10px',
color: theme.palette.secondary.main,
backgroundColor: theme.palette.primary.light,
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
"&:hover": {
cursor: 'pointer',
boxShadow: theme.shadows[5],
backgroundColor: theme.palette.primary.light,
},
},
cardContainer: {
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
height: 70,
width: 500,
[theme.breakpoints.down('xs')]: {
minHeight: 70,
width: 200,
},
borderRadius: '6px',
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
"&:hover": {
boxShadow: theme.shadows[5],
cursor: 'pointer',
},
backgroundColor: theme.palette.primary.light,
marginBottom: theme.spacing(4),
paddingLeft: theme.spacing(2),
paddingRight: theme.spacing(2),
},
text: {
textAlign: 'center',
fontSize: '20px',
color: theme.palette.secondary.main,
overflow: 'hidden',
whiteSpace: 'nowrap',
[theme.breakpoints.down('xs')]: {
fontSize: '16px',
whiteSpace: 'normal',
},
},
org: {
fontWeight: 'bold',
},
}));
interface InvitationModalProps {
invite: IOrganization,
accept: () => void,
}
const InvitationModal: FC<InvitationModalProps> = (props) => {
const classes = useStyles();
const [open, setOpen] = useState<boolean>(false);
function handleOpen(e: React.MouseEvent) {
e.preventDefault();
setOpen(true);
}
return (
<>
<div className={classes.cardContainer} onClick={handleOpen}>
<div className={classes.text}>
You've been invited to join <span className={classes.org}>{props.invite.name}</span>
</div>
</div>
<Modal
className={classes.modal}
open={open}
onClose={() => setOpen(false)}
closeAfterTransition
BackdropComponent={Backdrop}
BackdropProps={{
timeout: 500,
}}
>
<Fade in={open}>
<div className={classes.paper}>
<Typography className={classes.header} component="h1" variant="h4">
Join organization?
</Typography>
<div className={classes.buttonContainer}>
<Button
className={classes.button}
onClick={props.accept}
fullWidth
type="submit"
variant="contained"
color="primary"
>
Yes
</Button>
<Button
className={classes.button}
onClick={() => setOpen(false)}
fullWidth
type="submit"
variant="contained"
color="primary"
>
No
</Button>
</div>
</div>
</Fade>
</Modal>
</>
);
}
export default InvitationModal;
|
JKusiak/isshu
|
frontend/src/components/Authentication/ToProjectsButton.tsx
|
<filename>frontend/src/components/Authentication/ToProjectsButton.tsx
import { Card } from '@material-ui/core';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import { Link } from 'react-router-dom';
const useStyles = makeStyles((theme: Theme) => createStyles({
buttonLink: {
textDecoration: 'none',
},
toProjectsCard: {
display: 'flex',
justifyContent: 'center',
alignItems: 'center',
width: '200px',
height: '40px',
borderRadius: '10px',
background: 'white',
fontSize: '16px',
backgroundColor: theme.palette.primary.light,
color: theme.palette.secondary.main,
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
"&:hover": {
boxShadow: theme.shadows[5],
},
},
}));
function ButtonToProjects() {
const classes = useStyles();
return (
<div>
<Link className={classes.buttonLink} to='/home/projects'>
<Card className={classes.toProjectsCard}>
Your projects
</Card>
</Link>
</div>
);
}
export default ButtonToProjects;
|
JKusiak/isshu
|
frontend/src/components/Organization/AddOrganizationModal.tsx
|
<filename>frontend/src/components/Organization/AddOrganizationModal.tsx
import { Backdrop, Button, Card, CardContent, createStyles, Fade, makeStyles, Modal, TextField, Theme, Typography } from "@material-ui/core";
import { FC, useState } from "react";
const useStyles = makeStyles((theme: Theme) => createStyles({
cardContainer: {
height: '100px',
width: '250px',
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
backgroundColor: theme.palette.primary.light,
"&:hover": {
boxShadow: theme.shadows[5],
cursor: 'pointer',
},
marginBottom: theme.spacing(4),
},
cardText: {
color: theme.palette.secondary.main,
textAlign: 'center',
// fontWeight: 'bold',
},
modal: {
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
},
paper: {
[theme.breakpoints.up('sm')]: {
width: '35vw',
minWidth: '430px',
},
[theme.breakpoints.down('xs')]: {
width: '95vw',
minWidth: 0,
},
height: 'auto',
backgroundColor: theme.palette.primary.main,
border: '2px solid',
borderColor: theme.palette.secondary.main,
borderRadius: '10px',
boxShadow: theme.shadows[2],
padding: theme.spacing(2, 4, 3),
},
header: {
display: 'grid',
justifyContent: 'center',
color: theme.palette.secondary.main,
textAlign: 'center',
marginBottom: theme.spacing(4),
},
form: {
width: '100%',
},
submit: {
margin: theme.spacing(3, 0, 3),
borderRadius: '10px',
color: theme.palette.secondary.main,
backgroundColor: theme.palette.primary.light,
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
"&:hover": {
cursor: 'pointer',
boxShadow: theme.shadows[5],
backgroundColor: theme.palette.primary.light,
},
},
inputField: {
"& .MuiOutlinedInput-root": {
color: theme.palette.secondary.main,
"& .MuiOutlinedInput-notchedOutline": {
borderRadius: '10px',
borderColor: theme.palette.secondary.light,
},
"&.Mui-focused .MuiOutlinedInput-notchedOutline": {
borderColor: theme.palette.secondary.light,
borderWidth: "2px",
}
},
},
})
);
interface AddOrganizationModalProps {
onSubmit: (name: string) => void,
}
const AddOrganizationModal: FC<AddOrganizationModalProps> = (props) => {
const classes = useStyles();
const [isModalOpen, setModalOpen] = useState(false);
const [orgName, setOrgName] = useState('');
function handleSubmit(e: React.SyntheticEvent) {
e.preventDefault();
props.onSubmit(orgName);
setModalOpen(false);
}
return (
<>
<Card className={classes.cardContainer} onClick={() => setModalOpen(true)}>
<CardContent>
<Typography className={classes.cardText} component="h5" variant="h5">
Create your organization
</Typography>
</CardContent>
</Card>
<Modal
aria-labelledby="transition-modal-title"
aria-describedby="transition-modal-description"
className={classes.modal}
open={isModalOpen}
onClose={() => setModalOpen(false)}
closeAfterTransition
BackdropComponent={Backdrop}
BackdropProps={{
timeout: 500,
}}
>
<Fade in={isModalOpen}>
<div className={classes.paper}>
<Typography className={classes.header} component="h1" variant="h4">
Create organization
</Typography>
<form className={classes.form} onSubmit={handleSubmit}>
<TextField
className={classes.inputField}
required
fullWidth
autoFocus
variant="outlined"
name="organizationName"
id="organizationName"
placeholder="Organization Name"
autoComplete="organization-name"
onChange={(e) => {
setOrgName(e.target.value);
}}
/>
<Button
className={classes.submit}
fullWidth
type="submit"
variant="contained"
color="primary"
>
Create
</Button>
</form>
</div>
</Fade>
</Modal>
</>
);
}
export default AddOrganizationModal;
|
JKusiak/isshu
|
frontend/src/components/Organization/AddMemberButton.tsx
|
import { createStyles, makeStyles, TextField, Theme } from '@material-ui/core';
import Autocomplete from '@material-ui/lab/Autocomplete';
import React, { FC, SetStateAction, useState } from 'react';
import { IUser } from '../../types/ModelTypes';
const useStyles = makeStyles((theme: Theme) => createStyles({
searchWrapper: {
display: 'flex',
justifyContent: 'center',
alignItems: 'center',
},
formContainer: {
width: '350px',
marginBottom: theme.spacing(5),
},
autocomplete: {
width: '100%',
height: '100%',
// text within the search
"& .MuiAutocomplete-input": {
fontSize: '16px',
},
"& .MuiAutocomplete-popper.MuiAutocomplete-paper": {
backgroundColor: theme.palette.primary.light,
},
"& .MuiAutocomplete-endAdornment": {
display: 'none',
}
},
inputField: {
"& .MuiOutlinedInput-root": {
color: theme.palette.secondary.main,
"& .MuiOutlinedInput-notchedOutline": {
borderRadius: '10px',
borderColor: theme.palette.secondary.light,
},
"&.Mui-focused .MuiOutlinedInput-notchedOutline": {
borderColor: theme.palette.secondary.light,
borderWidth: "2px",
}
},
},
dropdownPaper: {
backgroundColor: theme.palette.primary.light,
color: theme.palette.secondary.main,
},
contributor: {
display: 'flex',
alignItems: 'center',
color: theme.palette.secondary.main,
},
invitePrompt: {
display: 'flex',
justifyContent: 'center',
alignItems: 'center',
color: 'green',
fontSize: '16px',
fontWeight: 'bold',
marginTop: theme.spacing(5),
}
})
);
interface AddMemberButtonProps {
allUsers: any,
query: string,
setQuery: React.Dispatch<SetStateAction<string>>,
user: IUser,
setUser: React.Dispatch<SetStateAction<IUser>>,
sendMemberInvite: () => void,
}
const AddMemberButton: FC<AddMemberButtonProps> = (props) => {
const classes = useStyles();
const [resetAutocomplete, setResetAutocomplete] = useState<boolean>(false);
const [inviteSent, setInviteSent] = useState(false);
function handleSubmit(e: React.SyntheticEvent) {
e.preventDefault();
if (props.user._id !== '') {
props.sendMemberInvite();
setInviteSent(true);
}
setResetAutocomplete(!resetAutocomplete);
}
return (
<>
<div className={classes.searchWrapper}>
<form className={classes.formContainer} onSubmit={handleSubmit} autoComplete="off">
<Autocomplete
key={resetAutocomplete.toString()}
className={classes.autocomplete}
classes={{ paper: classes.dropdownPaper }}
onInputChange={((e, value) => {
props.setQuery(value);
setInviteSent(false);
})}
open={props.query.length >= 3}
onChange={((e, value) => { props.setUser(value); props.setQuery('') })}
options={props.allUsers}
getOptionLabel={(option: any) => `${option.name} ${option.surname} ${option.email} `}
renderInput={(params) =>
<TextField
className={classes.inputField}
{...params}
placeholder="Search all users..."
variant='outlined'
/>}
/>
{inviteSent &&
<div className={classes.invitePrompt}>Invite sent</div>
}
</form>
</div>
</>
);
}
export default AddMemberButton;
|
JKusiak/isshu
|
frontend/src/pages/Project/ProjectPage.tsx
|
import IconButton from "@material-ui/core/IconButton";
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import MenuIcon from '@material-ui/icons/Menu';
import { useState } from "react";
import { Route, Switch, useRouteMatch } from "react-router-dom";
import GetBoard from "../../api/Board/GetBoard";
import GetBoardsGallery from "../../api/Board/GetBoardsGallery";
import GetUsersGallery from "../../api/User/GetUsersGallery";
const sidebarWidth = 270;
const useStyles = makeStyles((theme: Theme) => createStyles({
root: {
display: 'flex',
width: '100%',
},
sidebar: {
[theme.breakpoints.up('sm')]: {
width: sidebarWidth,
flexShrink: 0,
},
},
pageContent: {
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
marginLeft: 'auto',
marginRight: 'auto',
},
menuButton: {
color: theme.palette.secondary.main,
[theme.breakpoints.up("sm")]: {
display: "none"
},
marginTop: '1em',
marginBottom: '1em',
},
}
));
const ProjectPage = () => {
const classes = useStyles();
const [mobileOpen, setMobileOpen] = useState<boolean>(false);
const { path } = useRouteMatch();
const handleSidebarToggle = () => {
setMobileOpen(!mobileOpen);
};
return (
<div className={classes.root}>
<div className={classes.sidebar}>
<GetUsersGallery mobileOpen={mobileOpen} handleSidebarToggle={handleSidebarToggle} />
</div>
<div className={classes.pageContent}>
<IconButton
className={classes.menuButton}
color="inherit"
aria-label="open drawer"
onClick={() => { handleSidebarToggle() }}
>
<MenuIcon />
</IconButton>
<Switch>
<Route path={`${path}/:boardId`}>
<GetBoard />
</Route>
<Route path={path}>
<GetBoardsGallery />
</Route>
</Switch>
</div>
</div>
);
}
export default ProjectPage;
|
JKusiak/isshu
|
frontend/src/components/Project/ProjectInfoBanner/ProjectInfoBanner.tsx
|
<gh_stars>0
import { Box, ClickAwayListener, Typography } from "@material-ui/core";
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import React, { FC, useState } from "react";
import { Action, ActionTypes } from '../../../reducers/ProjectReducer';
import { IProject } from "../../../types/ModelTypes";
import DateForm from './DateForm';
import DescriptionForm from "./DescriptionForm";
import NameForm from "./NameForm";
import SettingsList from './SettingsList';
const useStyles = makeStyles<Theme, ProjectDataProps>(theme => createStyles({
projectInfoBanner: {
position: 'relative',
overflow: 'hidden',
width: '100%',
height: '30vh',
[theme.breakpoints.down('xs')]: {
height: '40vh',
},
'&::before': {
content: '""', // why for the love of god...
display: 'block',
position: 'absolute',
width: '100%',
height: '100%',
zIndex: -1,
background: ({ bannerPath, imageExists }) => imageExists ? `url(${bannerPath})` : theme.palette.secondary.light,
backgroundSize: 'cover',
filter: 'blur(3px) brightness(75%)',
},
},
gridWrapper: {
display: 'grid',
width: '100%',
height: '100%',
padding: theme.spacing(2),
gridTemplateColumns: '1fr 0.5fr 2fr 0.5fr 1fr',
gridTemplateRows: '0.5fr 1fr 1.5fr 0.5fr 0.5fr 0.5fr',
gridTemplateAreas: `
". . . . settings"
". . projectName . ."
". description description description ."
". description description description creator"
". description description description dateStart"
". . . . dateEnd"`
},
creator: {
gridArea: 'creator',
justifySelf: 'end',
alignSelf: 'center',
color: '#fafafa',
fontWeight: 600,
[theme.breakpoints.down('xs')]: {
fontSize: '12px',
},
[theme.breakpoints.up('sm')]: {
fontSize: '16px',
},
},
dateStart: {
gridArea: 'dateStart',
},
dateEnd: {
gridArea: 'dateEnd',
},
fontColor: {
"& .MuiInputBase-root.Mui-disabled": {
color: '#fafafa',
},
"& .MuiInputBase-root": {
color: 'rgba(255, 255, 255, 0.6)',
},
"& .MuiButtonBase-root.MuiIconButton-root.Mui-disabled": {
color: '#fafafa',
},
"& .MuiButtonBase-root.MuiIconButton-root": {
color: 'rgba(255, 255, 255, 0.6)',
},
},
}
));
interface ProjectDataProps {
projectBannerState: IProject,
dispatch: React.Dispatch<Action>,
updateProject: () => void,
bannerPath: string | undefined,
setFile: React.Dispatch<React.SetStateAction<string | Blob>>,
imageExists: boolean,
}
const ProjectData: FC<ProjectDataProps> = (props) => {
const classes = useStyles(props);
const [isEditing, setIsEditing] = useState(false);
function onSubmit(e: React.SyntheticEvent) {
e.preventDefault();
setIsEditing(false);
props.updateProject();
}
function displayCreator() {
const creator = props.projectBannerState.creator;
return (
<Typography className={`${classes.creator} ${classes.fontColor}`}>
Creator: {creator.name} {creator.surname}
</Typography>
)
}
function handleClickAway(e: React.MouseEvent<Document, MouseEvent>) {
if (isEditing === true) {
setIsEditing(false);
// type casting like this necessary because of insufficient overlap of types
onSubmit(e as unknown as React.SyntheticEvent);
}
}
return (
<ClickAwayListener onClickAway={handleClickAway}>
<Box className={classes.projectInfoBanner}>
<div className={classes.gridWrapper}>
<NameForm
isEditing={isEditing}
value={props.projectBannerState.name}
dispatch={props.dispatch}
actionType={ActionTypes.UpdateName}
onSubmit={onSubmit}
/>
<SettingsList
isEditing={isEditing}
setIsEditing={setIsEditing}
setFile={props.setFile}
/>
<DescriptionForm
isEditing={isEditing}
value={props.projectBannerState.description}
dispatch={props.dispatch}
actionType={ActionTypes.UpdateDescription}
onSubmit={onSubmit}
/>
{displayCreator()}
<div className={classes.dateStart}>
<DateForm
isEditing={isEditing}
value={props.projectBannerState.dateStart}
minDate={new Date('January 1, 1900')}
dispatch={props.dispatch}
actionType={ActionTypes.UpdateDateStart}
/>
</div>
<div className={classes.dateEnd}>
<DateForm
isEditing={isEditing}
value={props.projectBannerState.dateEnd}
minDate={props.projectBannerState.dateStart}
dispatch={props.dispatch}
actionType={ActionTypes.UpdateDateEnd}
/>
</div>
</div>
</Box>
</ClickAwayListener>
);
}
export default ProjectData;
|
JKusiak/isshu
|
frontend/src/components/Column/ColumnNameButton.tsx
|
import { ClickAwayListener, TextField } from '@material-ui/core';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import { FC, useState } from 'react';
const useStyles = makeStyles((theme: Theme) => createStyles({
inputField: {
width: '150px',
"& .MuiOutlinedInput-root": {
color: theme.palette.secondary.main,
"& .MuiOutlinedInput-notchedOutline": {
borderRadius: '6px',
borderColor: theme.palette.secondary.light,
},
"&.Mui-focused .MuiOutlinedInput-notchedOutline": {
borderColor: theme.palette.secondary.light,
borderWidth: "2px",
}
},
"& .MuiOutlinedInput-input": {
marginLeft: theme.spacing(0.5),
fontSize: 15,
padding: 5
},
},
nameText: {
textAlign: 'center',
color: theme.palette.secondary.main,
"&:hover": {
cursor: 'pointer'
}
}
}));
interface ColumnNameButtonProps {
tempColumnName: string,
setTempColumnName: React.Dispatch<React.SetStateAction<string>>,
permColumnName: string,
onSubmit: (e: any) => void,
}
const ColumnNameButton: FC<ColumnNameButtonProps> = (props) => {
const classes = useStyles();
const [updateMode, setUpdateMode] = useState<boolean>(false);
function handleSubmit(e: any) {
if (updateMode) {
props.onSubmit(e);
}
setUpdateMode(false);
}
return (
<ClickAwayListener onClickAway={handleSubmit}>
<div onClick={() => setUpdateMode(true)}>
{updateMode &&
<form onSubmit={handleSubmit} autoComplete="off">
<TextField
className={classes.inputField}
required
autoFocus
size="small"
variant='outlined'
name="columnName"
id="columnName"
value={props.tempColumnName}
autoComplete="column-name"
onChange={e => {
props.setTempColumnName(e.target.value);
}}
/>
</form>
}
{!updateMode &&
<div className={classes.nameText}>{props.permColumnName}</div>
}
</div>
</ClickAwayListener>
);
}
export default ColumnNameButton;
|
JKusiak/isshu
|
frontend/src/components/Issue/AddIssueButton.tsx
|
import { Button, Card, ClickAwayListener, InputBase, Typography } from '@material-ui/core';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import AddIcon from '@material-ui/icons/AddOutlined';
import { FC } from 'react';
const useStyles = makeStyles((theme: Theme) => createStyles({
container: {
width: '100%',
},
card: {
width: '100%',
backgroundColor: theme.palette.primary.light,
boxShadow: theme.shadows[2],
},
form: {
display: 'flex',
flexDirection: 'column',
},
inputField: {
width: 'auto',
padding: theme.spacing(1),
marginLeft: theme.spacing(0.5),
marginTop: theme.spacing(1),
marginBottom: theme.spacing(1),
color: theme.palette.secondary.main,
},
buttonContainer: {
width: '100%',
backgroundColor: theme.palette.primary.main,
justifyContent: 'flex-start',
paddingLeft: 0,
textTransform: 'none',
},
icon: {
fontSize: '25px',
color: theme.palette.secondary.main,
},
text: {
fontSize: '15px',
color: theme.palette.secondary.main,
},
}));
interface AddIssueButtonProps {
onSubmit: (e: React.SyntheticEvent<Element, Event>) => void,
addMode: boolean,
setAddMode: React.Dispatch<React.SetStateAction<boolean>>,
setIssueName: React.Dispatch<React.SetStateAction<string>>,
}
const AddIssueButton: FC<AddIssueButtonProps> = (props) => {
const classes = useStyles();
return (
<>
<ClickAwayListener onClickAway={() => props.setAddMode(false)}>
<div className={classes.container}>
{props.addMode &&
<Card className={classes.card}>
<form className={classes.form} onSubmit={props.onSubmit} autoComplete="off">
<InputBase
className={classes.inputField}
required
autoFocus
fullWidth
name="issueName"
id="issueName"
placeholder="Enter title for the issue"
autoComplete="issue-name"
onChange={e => {
props.setIssueName(e.target.value);
}}
/>
<Button className={classes.buttonContainer} onClick={props.onSubmit}>
<AddIcon className={classes.icon} />
<Typography className={classes.text} component='h6' variant='h6'>
Create issue
</Typography>
</Button>
</form>
</Card>
}
{!props.addMode &&
<Button className={classes.buttonContainer} onClick={(() => props.setAddMode(true))}>
<AddIcon className={classes.icon} />
<Typography className={classes.text} component='h6' variant='h6'>
Create issue
</Typography>
</Button>
}
</div>
</ClickAwayListener>
</>
);
}
export default AddIssueButton;
|
JKusiak/isshu
|
frontend/src/components/Project/ProjectInfoBanner/SettingsList.tsx
|
import { IconButton, Menu, MenuItem } from "@material-ui/core";
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import SettingsIcon from '@material-ui/icons/SettingsOutlined';
import React, { FC, useRef, useState } from "react";
import DeleteProject from '../../../api/Project/DeleteProject';
const useStyles = makeStyles((theme: Theme) => createStyles({
settings: {
gridArea: 'settings',
justifySelf: 'end',
alignSelf: 'start',
maxHeight: '100%',
"& .MuiIconButton-root": {
padding: 0,
},
"&:hover": {
cursor: 'pointer',
}
},
settingsIcon: {
fontSize: '24px',
color: '#fafafa',
},
menuPaper: {
"& .MuiMenu-paper": {
backgroundColor: theme.palette.primary.light,
},
},
menuItem: {
color: theme.palette.secondary.main,
},
}));
interface SettingsProps {
isEditing: boolean,
setIsEditing: React.Dispatch<React.SetStateAction<boolean>>,
setFile: React.Dispatch<React.SetStateAction<string | Blob>>,
}
const SettingsList: FC<SettingsProps> = (props) => {
const classes = useStyles(props);
const imageInputRef = useRef<HTMLInputElement>(null);
const [anchorEl, setAnchorEl] = useState<null | HTMLElement>(null);
const [modalOpen, setModalOpen] = useState(false);
const openList = Boolean(anchorEl);
function handleSettingsOpen(event: React.MouseEvent<HTMLElement>) {
setAnchorEl(event.currentTarget);
};
function handleSettingsClose() {
setAnchorEl(null);
};
function handleEdit() {
props.setIsEditing(!props.isEditing);
handleSettingsClose();
}
function handleChangePicture() {
imageInputRef.current?.click();
}
function handleChooseFile(e: any) {
props.setFile(e.target.files[0]);
}
return (
<div className={classes.settings}>
<IconButton onClick={handleSettingsOpen}>
<SettingsIcon className={classes.settingsIcon} />
</IconButton>
<Menu
className={classes.menuPaper}
id="settings-appbar"
anchorEl={anchorEl}
anchorOrigin={{
vertical: 'bottom',
horizontal: 'center',
}}
getContentAnchorEl={null}
keepMounted
transformOrigin={{
vertical: 'top',
horizontal: 'center',
}}
open={openList}
onClose={handleSettingsClose}
>
<MenuItem className={classes.menuItem} onClick={handleEdit}>
Edit information
</MenuItem>
<MenuItem className={classes.menuItem} onClick={handleChangePicture}>
Change background
</MenuItem>
<MenuItem className={classes.menuItem} onClick={() => { setModalOpen(true) }}>
Delete project
<DeleteProject
open={modalOpen}
setOpen={setModalOpen}
/>
</MenuItem>
<input
style={{ display: 'none' }}
type="file"
onChange={handleChooseFile}
ref={imageInputRef}
/>
</Menu>
</div>
);
}
export default SettingsList;
|
JKusiak/isshu
|
frontend/src/api/Project/DeleteProject.tsx
|
<filename>frontend/src/api/Project/DeleteProject.tsx
import axios from 'axios';
import { FC } from 'react';
import { useHistory, useParams } from "react-router-dom";
import ConfirmationModal from '../../components/Commons/ConfirmationModal';
interface DeleteProjectProps {
open: boolean,
setOpen: React.Dispatch<React.SetStateAction<boolean>>,
}
const DeleteProject: FC<DeleteProjectProps> = (props) => {
const { projectId } = useParams<{ projectId: string }>();
let history = useHistory();
function deleteProject() {
axios.delete(`/projects/delete/${projectId}`)
.catch((err) => {
console.log(err);
});
history.push(`/home/projects`);
}
return (
<>
<ConfirmationModal
handleConfirm={deleteProject}
open={props.open}
setOpen={props.setOpen}
/>
</>
);
}
export default DeleteProject;
|
JKusiak/isshu
|
frontend/src/api/Issue/ManageCompletion.tsx
|
<reponame>JKusiak/isshu
import axios from 'axios';
import { FC } from 'react';
import UpdateCompletionButton from '../../components/Issue/UpdateCompletionButton';
import { INestedIssue } from '../../types/ModelTypes';
interface ManageCompletionProps {
issue: INestedIssue,
}
const ManageCompletion: FC<ManageCompletionProps> = (props) => {
function updateCompletion() {
const isFinished = props.issue.isFinished;
const requestBody = {
isFinished: isFinished,
}
axios.post(`/issues/update/${props.issue._id}`, requestBody)
.catch((err) => {
console.log(err);
})
}
return (
<UpdateCompletionButton
issue={props.issue}
updateCompletion={updateCompletion}
/>
);
}
export default ManageCompletion;
|
JKusiak/isshu
|
frontend/src/pages/UserPage.tsx
|
<filename>frontend/src/pages/UserPage.tsx
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import GetData from "../api/User/GetData";
import GetUserIssues from "../api/User/GetUserIssues";
const useStyles = makeStyles((theme: Theme) => createStyles({
root: {
display: 'grid',
placeItems: 'center',
marginTop: theme.spacing(2),
},
}));
const UserPage = () => {
const classes = useStyles();
return (
<div className={classes.root}>
<GetData />
<GetUserIssues />
</div>
);
}
export default UserPage;
|
JKusiak/isshu
|
frontend/src/api/Organization/DeleteMember.tsx
|
<reponame>JKusiak/isshu<gh_stars>0
import axios from "axios";
import { FC } from "react";
import DeleteMemberButton from "../../components/Organization/DeleteMemberButton";
import { INestedUser } from "../../types/ModelTypes";
interface DeleteMemberProps {
member: INestedUser,
}
const DeleteMember: FC<DeleteMemberProps> = (props) => {
function deleteMember() {
const requestBody = {
organizationId: null,
projects: [],
};
axios.post(`/users/update/${props.member._id}`, requestBody)
.catch((err) => {
console.log(err);
});
}
return (
<>
<DeleteMemberButton clickedMember={props.member} deleteMember={deleteMember} />
</>
);
}
export default DeleteMember;
|
JKusiak/isshu
|
frontend/src/api/Organization/ManageMembers.tsx
|
<filename>frontend/src/api/Organization/ManageMembers.tsx
import axios from "axios";
import { useContext, useEffect, useState } from "react";
import { AuthUserContext } from "../../App";
import AddMemberButton from "../../components/Organization/AddMemberButton";
import { UserTemplate } from "../../types/ModelContentTemplate";
import { IUser } from "../../types/ModelTypes";
const GetAllUsers = () => {
const [allUsers, setAllUsers] = useState([]);
const [query, setQuery] = useState('');
const [addedUser, setAddedUser] = useState<IUser>(UserTemplate);
const { loggedInUser } = useContext(AuthUserContext);
const queryTreshold = query.length >= 3;
useEffect(() => {
fetchAllUsers();
}, [queryTreshold])
// fetching users that do not belong to any organization
function fetchAllUsers() {
axios.get(`/users/`)
.then(resp => {
setAllUsers(resp.data);
}).catch((err) => {
console.log(err);
});
}
function sendMemberInvite() {
// check to see if already got invite to avoid sending twice
if (addedUser.invitations.some(invite => invite === loggedInUser.organizationId)) return;
const requestBody = {
invitations: [...addedUser.invitations, loggedInUser.organizationId]
}
axios.post(`/users/update/${addedUser._id}`, requestBody)
.catch((err) => {
console.log(err);
});
}
return (
<>
<AddMemberButton
allUsers={allUsers}
user={addedUser}
setUser={setAddedUser}
query={query}
setQuery={setQuery}
sendMemberInvite={sendMemberInvite}
/>
</>
);
}
export default GetAllUsers;
|
JKusiak/isshu
|
frontend/src/api/User/GetUserIssues.tsx
|
<reponame>JKusiak/isshu
import axios from "axios";
import { useEffect, useState } from "react";
import { useParams } from "react-router-dom";
import UserIssuesGallery from "../../components/User/UserIssuesGallery";
import { NestedIssueTemplate } from "../../types/ModelContentTemplate";
import { INestedIssue } from "../../types/ModelTypes";
const GetUserIssues = () => {
const { userId } = useParams<{ userId: string }>();
const [issuesCreated, setCreated] = useState<[INestedIssue]>([NestedIssueTemplate]);
const [issuesTaken, setTaken] = useState<[INestedIssue]>([NestedIssueTemplate]);
const [isLoadedCreated, setLoadedCreated] = useState<boolean>(false);
const [isLoadedTaken, setLoadedTaken] = useState<boolean>(false);
// issues created by user
useEffect(() => {
axios.get(`/issues/getIssuesCreator/${userId}`)
.then(resp => {
setCreated(resp.data);
setLoadedCreated(true);
}).catch((err) => {
console.log(err);
});
}, [userId]);
// issues taken by user
useEffect(() => {
axios.get(`/issues/getIssuesContributor/${userId}`)
.then(resp => {
setTaken(resp.data);
setLoadedTaken(true);
}).catch((err) => {
console.log(err);
});
}, [userId]);
return (
<>
{isLoadedCreated && isLoadedTaken &&
<UserIssuesGallery issuesTaken={issuesTaken} issuesCreated={issuesCreated} />
}
</>
);
}
export default GetUserIssues;
|
JKusiak/isshu
|
frontend/src/api/Organization/AddOrganization.tsx
|
<filename>frontend/src/api/Organization/AddOrganization.tsx<gh_stars>0
import axios from 'axios';
import { useContext } from 'react';
import { AuthUserContext } from '../../App';
import AddOrganizationModal from '../../components/Organization/AddOrganizationModal';
import { IUser } from '../../types/ModelTypes';
const AddOrganization = () => {
const { loggedInUser, setLoggedInUser } = useContext(AuthUserContext);
function onSubmit(orgName: string) {
const requestBody = {
name: orgName,
};
axios.post('/organization/add', requestBody)
.then((res) => {
updateUserOrganization(res.data._id);
}).catch((err) => {
console.log(err);
});
}
function updateUserOrganization(orgId: String) {
const requestBody = {
organizationId: orgId,
};
axios.post(`/users/update/${loggedInUser._id}`, requestBody)
.then((res) => {
updateToken(res.data);
}).catch((err) => {
console.log(err);
})
}
function updateToken(user: IUser) {
const requestBody = {
_id: user._id,
email: user.email,
name: user.name,
surname: user.surname,
organizationId: user.organizationId,
}
axios.post(`/login/newOrganization/`, requestBody)
.then((res) => {
localStorage.setItem('token', res.data.token);
setLoggedInUser(requestBody);
window.location.reload();
}).catch((err) => {
console.log(err);
})
}
return (
<>
<AddOrganizationModal
onSubmit={onSubmit}
/>
</>
);
}
export default AddOrganization;
|
JKusiak/isshu
|
frontend/src/reducers/ProjectReducer.tsx
|
import { IProject } from "../types/ModelTypes";
export enum ActionTypes {
FetchData = 'FETCH DATA',
UpdateName = 'UPDATE NAME',
UpdateDescription = 'UPDATE DESCRIPTION',
UpdateDateStart = 'UPDATE DATE START',
UpdateDateEnd = 'UPDATE DATE END',
}
export type Action = {
type: ActionTypes,
payload: any,
}
export const projectReducer = (state: IProject, action: Action) => {
const { type, payload } = action;
switch (type) {
case ActionTypes.FetchData:
return payload;
case ActionTypes.UpdateName:
return {
...state,
name: payload,
}
case ActionTypes.UpdateDescription:
return {
...state,
description: payload,
}
case ActionTypes.UpdateDateStart:
return {
...state,
dateStart: payload,
}
case ActionTypes.UpdateDateEnd:
return {
...state,
dateEnd: payload,
}
default:
return state
}
}
|
JKusiak/isshu
|
frontend/src/components/Issue/Name/NameText.tsx
|
<filename>frontend/src/components/Issue/Name/NameText.tsx
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import CheckIcon from '@material-ui/icons/Check';
import { FC } from 'react';
import { INestedIssue } from '../../../types/ModelTypes';
const useStyles = makeStyles((theme: Theme) => createStyles({
nameText: {
display: 'flex',
width: '100%',
alignItems: 'center',
fontWeight: 'bold',
fontSize: '24px',
color: theme.palette.secondary.main,
"&:hover": {
cursor: 'pointer'
},
overflow: 'hidden',
marginBottom: theme.spacing(2),
},
}));
interface NameProps {
issue: INestedIssue,
permName: string,
}
const NameText: FC<NameProps> = (props) => {
const classes = useStyles();
return (
<div
className={classes.nameText}
style={{
textDecoration: props.issue.isFinished ? 'line-through' : 'none',
}}>
{props.permName}
{props.issue.isFinished && <CheckIcon />}
</div>
);
}
export default NameText;
|
JKusiak/isshu
|
frontend/src/components/Tag/AddTagButton.tsx
|
import { ClickAwayListener, IconButton, InputBase } from '@material-ui/core';
import Card from '@material-ui/core/Card';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import AddIcon from '@material-ui/icons/AddOutlined';
import { FC, useState } from 'react';
const useStyles = makeStyles((theme: Theme) => createStyles({
addTagButtonWrapper: {
display: 'flex',
justifyContent: 'center',
alignItems: 'center',
"& .MuiPaper-root": {
maxWidth: '45%',
}
},
card: {
backgroundColor: theme.palette.primary.light,
},
iconButton: {
padding: theme.spacing(1.2),
justifyContent: 'center',
alignItems: 'center',
},
icon: {
fontSize: '15px',
color: theme.palette.secondary.main,
},
form: {
display: 'flex',
justifyContent: 'center',
alignItems: 'center',
},
inputField: {
width: 'auto',
color: theme.palette.secondary.main,
"& .MuiInputBase-input": {
marginLeft: theme.spacing(0.5),
fontSize: 15,
padding: 5,
},
}
}));
interface AddTagButtonProps {
addTag: (e: React.SyntheticEvent, newTagName: string) => void,
}
const AddTagButton: FC<AddTagButtonProps> = (props) => {
const classes = useStyles();
const [addMode, setAddMode] = useState<boolean>(false);
const [newTagName, setNewTagName] = useState<string>('');
function handleSubmit(e: any) {
e.preventDefault();
if (newTagName !== '') {
props.addTag(e, newTagName);
}
setAddMode(false);
}
return (
<>
<div className={classes.addTagButtonWrapper} onClick={() => setAddMode(true)}>
<ClickAwayListener onClickAway={() => setAddMode(false)}>
<Card className={classes.card}>
{addMode &&
<form className={classes.form} onSubmit={handleSubmit} autoComplete="off">
<InputBase
className={classes.inputField}
required
autoFocus
name="tagName"
id="tagName"
placeholder="Tag name"
autoComplete="tag-name"
inputProps={{ style: {} }}
onChange={e => {
setNewTagName(e.target.value);
}}
/>
<IconButton type="submit">
<AddIcon className={classes.icon} />
</IconButton>
</form>
}
{!addMode &&
<IconButton className={classes.iconButton}>
<AddIcon className={classes.icon} />
</IconButton>
}
</Card>
</ClickAwayListener>
</div>
</>
);
}
export default AddTagButton;
|
JKusiak/isshu
|
frontend/src/api/Organization/ManageOrganizationImage.tsx
|
import axios from "axios";
import React, { FC, useEffect, useState } from "react";
import OrganizationImage from "../../components/Organization/OrganizationImage";
import { IOrganization } from "../../types/ModelTypes";
interface ManageOrganizationImageProps {
organization: IOrganization,
user: any,
errorText: string,
setErrorText: React.Dispatch<React.SetStateAction<string>>,
}
const ManageOrganizationImage: FC<ManageOrganizationImageProps> = (props) => {
const [file, setFile] = useState<string | Blob>('');
const [imageExists, setImageExists] = useState<boolean>(false);
const [imageUrl, setImageUrl] = useState<string>('');
// when props are loaded, fetches image from the server
useEffect(() => {
checkIfExists();
}, [props.organization]);
// executes uploading image to server when user chooses picture without submit button
useEffect(() => {
if (file !== '') uploadImage();
}, [file]);
function uploadImage() {
const formData = new FormData();
formData.append('organizationId', props.organization._id);
formData.append('directory', 'logo');
formData.append('imageUpload', file);
axios.post(`/uploads/add/${props.organization._id}`, formData)
.then(() => {
checkIfExists();
props.setErrorText('');
}).catch(() => {
props.setErrorText('Please upload in .jpg format and under 1MB file size');
})
}
function checkIfExists() {
// substitutes backslash (/) with %2f as the whole path is passed as one parameter
const path = `uploads%2forganization-${props.organization._id}%2flogo%2f${props.organization._id}.jpg`;
axios.get(`/uploads/get/${path}`)
.then((resp) => {
setImageExists(resp.data);
if (resp.data) {
// ?t= and timestamp added to trick cache into re-downloading image under same path
const adjustedPath = path.replaceAll('%2f', '/') + '?t=' + new Date().getTime();
setImageUrl(`http://localhost:5000/${adjustedPath}`);
}
}).catch((err) => {
console.log(err);
})
}
return (
<>
<OrganizationImage
imageExists={imageExists}
setFile={setFile}
imageUrl={imageUrl}
/>
</>
);
}
export default ManageOrganizationImage;
|
JKusiak/isshu
|
frontend/src/components/Issue/Description/DescriptionText.tsx
|
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import { FC } from 'react';
const useStyles = makeStyles((theme: Theme) => createStyles({
descriptionText: {
textAlign: 'start',
color: theme.palette.secondary.main,
"&:hover": {
cursor: 'pointer'
}
},
}));
interface DescriptionProps {
permDescription: string,
}
const DescriptionText: FC<DescriptionProps> = (props) => {
const classes = useStyles();
return (
<>
<div className={classes.descriptionText}>
{props.permDescription ? props.permDescription : 'Add description...'}
</div>
</>
);
}
export default DescriptionText;
|
JKusiak/isshu
|
frontend/src/api/Authentication/Register.tsx
|
import axios from 'axios';
import { useState } from 'react';
import { useHistory } from 'react-router-dom';
import RegisterForm from '../../components/Authentication/RegisterForm';
const Register = () => {
const [isValid, setIsValid] = useState<boolean>(true);
const [errorText, setErrorText] = useState<string>('');
const [isSent, setIsSent] = useState<boolean>(false);
const history = useHistory();
function registerUser(user: any) {
axios.post('/users/add', user)
.then(() => {
setIsSent(true);
setTimeout(() => { history.push('/login') }, 1000);
})
.catch((err) => {
setIsValid(false);
setErrorText('Email already taken');
});
}
return (
<>
<RegisterForm
registerUser={registerUser}
isValid={isValid}
setIsValid={setIsValid}
isSent={isSent}
setIsSent={setIsSent}
errorText={errorText}
setErrorText={setErrorText}
/>
</>
);
}
export default Register;
|
JKusiak/isshu
|
frontend/src/components/Issue/Contributor/IssueContributorsGallery.tsx
|
import { createStyles, makeStyles, TextField, Theme, Typography } from '@material-ui/core';
import Autocomplete from '@material-ui/lab/Autocomplete';
import React, { FC, Fragment, useContext, useState } from 'react';
import { BoardReducerContext } from '../../../api/Board/GetBoard';
import { ActionTypes } from '../../../reducers/BoardReducer';
import { UserTemplate } from '../../../types/ModelContentTemplate';
import { INestedIssue, INestedUser, IUser } from '../../../types/ModelTypes';
import DeleteContributorButton from './DeleteContributorButton';
const useStyles = makeStyles((theme: Theme) => createStyles({
contributorsContainer: {
marginBottom: theme.spacing(4),
},
headline: {
fontSize: '16px',
fontWeight: 'bold',
color: theme.palette.secondary.main,
marginBottom: theme.spacing(1),
},
formContainer: {
marginBottom: theme.spacing(2),
},
autocomplete: {
width: '100%',
height: '100%',
// text within the search
"& .MuiAutocomplete-input": {
fontSize: '14px',
},
"& .MuiAutocomplete-popper.MuiAutocomplete-paper": {
// "& *": {
backgroundColor: theme.palette.primary.light,
// }
},
"& .MuiAutocomplete-endAdornment": {
"& *": {
color: theme.palette.secondary.main,
}
}
},
inputField: {
"& .MuiOutlinedInput-root": {
color: theme.palette.secondary.main,
"& .MuiOutlinedInput-notchedOutline": {
borderRadius: '10px',
borderColor: theme.palette.secondary.light,
},
"&.Mui-focused .MuiOutlinedInput-notchedOutline": {
borderColor: theme.palette.secondary.light,
borderWidth: "2px",
}
},
},
dropdownPaper: {
backgroundColor: theme.palette.primary.light,
color: theme.palette.secondary.main,
},
contributor: {
display: 'flex',
alignItems: 'center',
color: theme.palette.secondary.main,
},
})
);
interface IssueContributorsGalleryProps {
projectContributors: [IUser],
issue: INestedIssue,
updateContributors: () => void,
}
const IssueContributorsGallery: FC<IssueContributorsGalleryProps> = (props) => {
const classes = useStyles();
const [newContributor, setNewContributor] = useState<INestedUser | null>(UserTemplate);
const [resetAutocomplete, setResetAutocomplete] = useState<boolean>(false);
const { dispatch } = useContext(BoardReducerContext);
const issueContributorsToId = props.issue.contributors.map(contributor => contributor._id);
function displayIssueContributors() {
return (props.issue.contributors.map((contributor: INestedUser, index: number) => {
return (
<Fragment key={index}>
<div className={classes.contributor}>
{`${contributor.name} ${contributor.surname}`}
<DeleteContributorButton
issue={props.issue}
clickedContributor={contributor}
updateContributors={props.updateContributors}
/>
</div>
</Fragment>
);
}));
}
function handleSubmit(e: React.SyntheticEvent) {
e.preventDefault();
let issueContributors: (INestedUser | null)[] = [...props.issue.contributors];
if (issueContributors[issueContributors.length - 1] !== newContributor) {
issueContributors = [...props.issue.contributors, newContributor];
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
modified: {
contributors: issueContributors,
},
}
dispatch({ type: ActionTypes.UpdateIssue, payload: payload })
props.updateContributors();
}
setResetAutocomplete(!resetAutocomplete);
}
return (
<div className={classes.contributorsContainer}>
<Typography className={classes.headline} component="h5" variant="h5">
Contributors
</Typography>
<form className={classes.formContainer} onSubmit={handleSubmit} autoComplete="off">
<Autocomplete
key={resetAutocomplete.toString()}
className={classes.autocomplete}
classes={{ paper: classes.dropdownPaper }}
id="contributors-to-ticket"
options={props.projectContributors}
getOptionLabel={option => `${option.name} ${option.surname}`}
getOptionDisabled={(option) => issueContributorsToId.includes(option._id)}
onChange={(e, value) => setNewContributor(value)}
renderInput={(params) =>
<TextField
className={classes.inputField}
{...params}
placeholder="Search contributors..."
variant='outlined'
/>}
/>
</form>
{displayIssueContributors()}
</div>
);
}
export default IssueContributorsGallery;
|
JKusiak/isshu
|
frontend/src/components/Organization/OrganizationImage.tsx
|
import { createStyles, makeStyles, Theme } from "@material-ui/core";
import ImagePlaceholder from '@material-ui/icons/ImageOutlined';
import React, { FC, useRef } from "react";
const useStyles = makeStyles((theme: Theme) => createStyles({
image: {
display: 'flex',
width: '150px',
height: '150px',
[theme.breakpoints.down('sm')]: {
width: '120px',
height: '120px',
},
justifyContent: 'center',
alignItems: 'center',
marginLeft: theme.spacing(4),
boxShadow: theme.shadows[2],
"&:hover": {
cursor: 'pointer',
boxShadow: theme.shadows[5],
opacity: 0.7,
},
},
})
);
interface OrganizationImageProps {
imageExists: boolean,
setFile: React.Dispatch<React.SetStateAction<string | Blob>>,
imageUrl: string,
}
const OrganizationImage: FC<OrganizationImageProps> = (props) => {
const imageInputRef = useRef<HTMLInputElement>(null);
const classes = useStyles();
// ref that allows to treat an image like an upload button
function handleImageClick() {
imageInputRef.current?.click();
}
function handleChooseFile(e: any) {
props.setFile(e.target.files[0]);
}
return (
<>
<input
style={{ display: 'none' }}
type="file"
onChange={handleChooseFile}
ref={imageInputRef}
/>
{props.imageExists &&
<img
className={classes.image}
src={props.imageUrl}
onClick={handleImageClick}
alt='organization logo'
/>
}
{!props.imageExists &&
<ImagePlaceholder
className={classes.image}
onClick={handleImageClick}
/>
}
</>
);
}
export default OrganizationImage;
|
JKusiak/isshu
|
frontend/src/components/User/UserIssueCard.tsx
|
<reponame>JKusiak/isshu
import { Card, createStyles, makeStyles, Theme } from "@material-ui/core";
import { FC, useState } from "react";
import { INestedIssue } from "../../types/ModelTypes";
import IssueModal from "../Issue/IssueModal";
const useStyles = makeStyles((theme: Theme) => createStyles({
issueCard: {
height: '60px',
width: '400px',
marginLeft: 'auto',
marginRight: 'auto',
maxWidth: '70%',
padding: theme.spacing(2),
boxShadow: theme.shadows[2],
background: theme.palette.primary.light,
"&:hover": {
cursor: 'pointer',
boxShadow: theme.shadows[5],
},
fontSize: '16px',
marginBottom: theme.spacing(2),
}
})
);
interface UserIssueCardProps {
issue: INestedIssue,
}
const UserIssuesCard: FC<UserIssueCardProps> = (props) => {
const classes = useStyles();
const [isModalOpen, setModalOpen] = useState(false);
return (
<>
<Card className={classes.issueCard} onClick={() => setModalOpen(true)}>
{props.issue.name}
</Card>
<IssueModal
issue={props.issue}
isIssueModalOpen={isModalOpen}
setIssueModalOpen={setModalOpen}
displayOnly={true}
/>
</>
);
}
export default UserIssuesCard;
|
JKusiak/isshu
|
frontend/src/components/Project/ProjectInfoBanner/DateForm.tsx
|
import DateFnsUtils from '@date-io/date-fns';
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import { KeyboardDatePicker, MuiPickersUtilsProvider } from '@material-ui/pickers';
import React, { FC } from "react";
import { Action, ActionTypes } from "../../../reducers/ProjectReducer";
const useStyles = makeStyles((theme: Theme) => createStyles({
dateForm: {
justifySelf: 'end',
alignSelf: 'center',
"& .MuiButtonBase-root": {
padding: 0,
}
},
dateStyle: {
[theme.breakpoints.down('xs')]: {
fontSize: '14px',
},
[theme.breakpoints.up('sm')]: {
fontSize: '16px',
},
},
fontColor: {
"& .MuiInputBase-root.Mui-disabled": {
color: '#fafafa',
},
"& .MuiInputBase-root": {
color: 'rgba(255, 255, 255, 0.6)',
},
"& .MuiButtonBase-root.MuiIconButton-root.Mui-disabled": {
color: '#fafafa',
},
"& .MuiButtonBase-root.MuiIconButton-root": {
color: 'rgba(255, 255, 255, 0.6)',
},
},
}));
interface DateFormProps {
isEditing: boolean,
value: Date,
minDate: Date,
dispatch: React.Dispatch<Action>,
actionType: ActionTypes,
}
const DateForm: FC<DateFormProps> = (props) => {
const classes = useStyles(props);
return (
<form className={classes.dateForm}>
<MuiPickersUtilsProvider utils={DateFnsUtils}>
<KeyboardDatePicker
className={classes.fontColor}
format='dd MMMM yyyy'
variant="inline"
id="date"
disabled={!props.isEditing}
InputProps={{
disableUnderline: true,
classes: {
input: classes.dateStyle,
},
}}
inputProps={{ min: 0, style: { textAlign: 'end' } }}
minDate={props.minDate}
value={props.value || ''}
onChange={newDate => { props.dispatch({ type: props.actionType, payload: newDate }) }}
/>
</MuiPickersUtilsProvider>
</form>
);
}
export default DateForm;
|
JKusiak/isshu
|
frontend/src/components/User/PersonalData.tsx
|
<filename>frontend/src/components/User/PersonalData.tsx
import { createStyles, makeStyles, Theme } from "@material-ui/core/styles";
import { FC, useState } from "react";
import ManageUserImage from "../../api/User/ManageUserImage";
import { IUser } from "../../types/ModelTypes";
const useStyles = makeStyles((theme: Theme) => createStyles({
userData: {
display: 'flex',
flexWrap: 'wrap',
justifyContent: 'center',
marginTop: theme.spacing(2),
marginBottom: theme.spacing(8),
},
userCredentials: {
display: 'flex',
flexDirection: 'column',
justifyContent: 'center',
[theme.breakpoints.down('xs')]: {
alignItems: 'center',
marginTop: theme.spacing(2),
},
width: 'auto',
color: theme.palette.secondary.main,
},
dataPoint: {
wordWrap: 'break-word',
fontSize: "16px",
fontWeight: 'bold',
"&:not(:last-child)": {
marginBottom: theme.spacing(2),
},
}
}));
interface PersonalDataProps {
user: IUser;
}
const PersonalData: FC<PersonalDataProps> = (props) => {
const classes = useStyles();
const [errorText, setErrorText] = useState('');
return (
<div className={classes.userData}>
<ManageUserImage
setErrorText={setErrorText}
user={props.user}
/>
<div className={classes.userCredentials}>
<div className={classes.dataPoint}>Name: {props.user.name}</div>
<div className={classes.dataPoint}>Surname: {props.user.surname}</div>
<div className={classes.dataPoint}>Email: {props.user.email}</div>
</div>
{errorText}
</div>
);
}
export default PersonalData;
|
JKusiak/isshu
|
frontend/src/components/Authentication/RegisterModal.tsx
|
import { Card } from '@material-ui/core';
import Backdrop from '@material-ui/core/Backdrop';
import Fade from '@material-ui/core/Fade';
import Modal from '@material-ui/core/Modal';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import { useState } from 'react';
import Register from '../../api/Authentication/Register';
const useStyles = makeStyles((theme: Theme) => createStyles({
registerButton: {
display: 'flex',
justifyContent: 'center',
alignItems: 'center',
width: '200px',
height: '40px',
borderRadius: '10px',
fontSize: '16px',
color: theme.palette.secondary.main,
backgroundColor: theme.palette.primary.light,
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
"&:hover": {
cursor: 'pointer',
boxShadow: theme.shadows[5],
},
},
modal: {
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
},
paper: {
width: '40vw',
minWidth: '430px',
height: 'auto',
[theme.breakpoints.down('xs')]: {
minWidth: '90vw',
height: '75vh',
overflow: 'scroll',
},
backgroundColor: theme.palette.primary.main,
border: '2px solid',
borderColor: theme.palette.secondary.main,
borderRadius: '10px',
boxShadow: theme.shadows[2],
padding: theme.spacing(2, 4, 3),
},
}));
const RegisterModal = () => {
const classes = useStyles();
const [open, setOpen] = useState<boolean>(false);
const handleOpen = () => {
setOpen(true);
};
const handleClose = () => {
setOpen(false);
};
return (
<>
<Card className={classes.registerButton} onClick={handleOpen}>
Get started
</Card>
<Modal
className={classes.modal}
open={open}
onClose={handleClose}
closeAfterTransition
BackdropComponent={Backdrop}
BackdropProps={{
timeout: 500,
}}
>
<Fade in={open}>
<div className={classes.paper}>
<Register />
</div>
</Fade>
</Modal>
</>
);
}
export default RegisterModal;
|
JKusiak/isshu
|
frontend/src/components/Commons/ConfirmationModal.tsx
|
import { Button, Typography } from '@material-ui/core';
import Backdrop from '@material-ui/core/Backdrop';
import Fade from '@material-ui/core/Fade';
import Modal from '@material-ui/core/Modal';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import React, { FC } from 'react';
const useStyles = makeStyles((theme: Theme) => createStyles({
modal: {
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
},
paper: {
width: '330px',
height: 'auto',
backgroundColor: theme.palette.primary.main,
border: '2px solid',
borderColor: theme.palette.secondary.main,
borderRadius: '10px',
boxShadow: theme.shadows[2],
padding: theme.spacing(2, 4, 3),
},
header: {
display: 'grid',
justifyContent: 'center',
color: theme.palette.secondary.main,
},
form: {
display: 'flex',
width: '100%',
marginTop: theme.spacing(5),
},
button: {
margin: theme.spacing(3, 2, 3),
borderRadius: '10px',
color: theme.palette.secondary.main,
backgroundColor: theme.palette.primary.light,
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
"&:hover": {
cursor: 'pointer',
boxShadow: theme.shadows[5],
backgroundColor: theme.palette.primary.light,
},
},
}));
interface ConfirmationProps {
handleConfirm: () => void,
open: boolean,
setOpen: React.Dispatch<React.SetStateAction<boolean>>,
}
const ConfirmationModal: FC<ConfirmationProps> = (props) => {
const classes = useStyles();
function handleYes() {
props.setOpen(false);
props.handleConfirm();
}
return (
<>
<Modal
aria-labelledby="transition-modal-title"
aria-describedby="transition-modal-description"
className={classes.modal}
open={props.open}
onClose={() => {props.setOpen(false)}}
closeAfterTransition
BackdropComponent={Backdrop}
BackdropProps={{
timeout: 500,
}}
>
<Fade in={props.open}>
<div className={classes.paper}>
<Typography className={classes.header} component="h1" variant="h4">
Are you sure?
</Typography>
<div className={classes.form}>
<Button
className={classes.button}
onClick={handleYes}
fullWidth
type="submit"
variant="contained"
color="primary"
>
Yes
</Button>
<Button
className={classes.button}
onClick={() => {props.setOpen(false)}}
fullWidth
type="submit"
variant="contained"
color="primary"
>
No
</Button>
</div>
</div>
</Fade>
</Modal>
</>
);
}
export default ConfirmationModal;
|
JKusiak/isshu
|
frontend/src/components/Authentication/Login.test.tsx
|
import axios from 'axios';
import { mount, shallow, render } from 'enzyme';
import React from 'react';
import LoginForm from './LoginForm';
describe('Login hooks and input fields connection', () => {
const mockFunction = jest.fn();
const initEmailValue = '';
const setEmail = jest.fn();
const useStateSpy = jest.spyOn(React, 'useState');
useStateSpy.mockImplementation(() => [initEmailValue, setEmail] as any);
const loginComponent = shallow(
<LoginForm
loginUser={mockFunction}
isValid={true}
setIsValid={mockFunction}
/>
)
const newEmailValue = '<EMAIL>';
const emailInput = loginComponent.find('[name="email"]');
it('should change hook state on user input', () => {
emailInput.simulate('change', { target: { value: newEmailValue}});
expect(setEmail).toHaveBeenCalledWith(newEmailValue);
})
})
// jest.mock('axios');
// const mockedAxios = axios as jest.Mocked<typeof axios>;
// describe('Login API', () => {
// it("should authenticate user", async () => {
// const credentials = {
// email: '<EMAIL>',
// password: '<PASSWORD>!',
// }
// mockedAxios.post.mockResolvedValueOnce(credentials);
// axios.post('/login', credentials)
// .then((res) => {
// expect(res.statusCode).toBe(200)
// }).catch((err) => {
// console.log(err);
// setIsValid(false);
// });
// const response = await request(app).post("/authenticate").send({
// username: "Ola",
// password: "<PASSWORD>"
// })
// expect(response.body.token).toBeTruthy()
// expect(response.body.state).toBeTruthy()
// expect(response.body.state.session.authenticated).toEqual("AUTHENTICATED")
// })
// })
|
JKusiak/isshu
|
frontend/src/components/Issue/Attachment/EnlargedAttachmentModal.tsx
|
<reponame>JKusiak/isshu
import { Card, CardMedia, IconButton } from '@material-ui/core';
import Backdrop from '@material-ui/core/Backdrop';
import Fade from '@material-ui/core/Fade';
import Modal from '@material-ui/core/Modal';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import DeleteIcon from '@material-ui/icons/ClearOutlined';
import { FC, useContext, useState } from 'react';
import { BoardReducerContext } from '../../../api/Board/GetBoard';
import { AuthUserContext } from '../../../App';
import { ActionTypes } from '../../../reducers/BoardReducer';
import { IAttachment, INestedIssue } from '../../../types/ModelTypes';
const useStyles = makeStyles((theme: Theme) => createStyles({
cardWrapper: {
display: 'flex',
flexDirection: 'column',
flexGrow: 0,
width: '142px',
marginRight: theme.spacing(2),
},
attachmentCard: {
display: 'flex',
flexShrink: 0,
height: '80px',
width: '142px',
justifyContent: 'center',
alignItems: 'center',
backgroundColor: theme.palette.primary.light,
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
"&:hover": {
boxShadow: theme.shadows[5],
cursor: 'pointer',
},
// marginBottom: theme.spacing(2),
},
attachmentText: {
height: '15px',
marginLeft: theme.spacing(1),
marginRight: theme.spacing(1),
marginBottom: theme.spacing(2),
fontSize: '10px',
color: theme.palette.secondary.main,
overflow: 'hidden',
},
image: {
width: '100%',
height: '100%',
},
modal: {
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
},
modalImage: {
maxWidth: '90vw',
maxHeight: '90vh',
border: '2px solid',
borderColor: theme.palette.secondary.main,
borderRadius: '10px',
},
deleteButton: {
left: '90%',
bottom: '70%',
width: '25px',
borderRadius: '50%',
background: theme.palette.primary.light,
padding: 2,
},
deleteIcon: {
fontSize: '18px',
color: theme.palette.secondary.main,
},
}));
interface EnlargedAttachmentModalProps {
issue: INestedIssue,
clickedAttachment: IAttachment,
deleteAttachment: () => void,
deleteImage: (clickedAttachment: IAttachment) => void,
}
const EnlargedAttachmentModal: FC<EnlargedAttachmentModalProps> = (props) => {
const classes = useStyles();
const [open, setOpen] = useState<boolean>(false);
const { loggedInUser } = useContext(AuthUserContext);
const { dispatch } = useContext(BoardReducerContext);
function deleteAttachment() {
const updatedAttachments = props.issue.attachments.filter(attachment =>
props.issue.attachments.indexOf(attachment) !== props.issue.attachments.indexOf(props.clickedAttachment));
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
modified: {
attachments: updatedAttachments,
},
};
dispatch({ type: ActionTypes.UpdateIssue, payload: payload });
props.deleteAttachment();
props.deleteImage(props.clickedAttachment);
}
return (
<>
<div className={classes.cardWrapper}>
<Card className={classes.attachmentCard} >
<CardMedia
className={classes.image}
image={`http://localhost:5000/uploads/organization-${loggedInUser.organizationId}/issues/issue-${props.issue._id}/${props.clickedAttachment._id}.jpg`}
title="Attachment miniature picture"
onClick={() => setOpen(true)}
/>
</Card>
<IconButton className={classes.deleteButton} onClick={deleteAttachment}>
<DeleteIcon className={classes.deleteIcon} />
</IconButton>
<div className={classes.attachmentText}>
{props.clickedAttachment.name}
</div>
</div>
<Modal
className={classes.modal}
open={open}
onClose={() => setOpen(false)}
closeAfterTransition
BackdropComponent={Backdrop}
BackdropProps={{
timeout: 500,
}}
>
<Fade in={open}>
<img
className={classes.modalImage}
src={`http://localhost:5000/uploads/organization-${loggedInUser.organizationId}/issues/issue-${props.issue._id}/${props.clickedAttachment._id}.jpg`}
alt='Attachment enlarged'
/>
</Fade>
</Modal>
</>
);
}
export default EnlargedAttachmentModal;
|
JKusiak/isshu
|
frontend/src/api/Issue/GetArchiveGallery.tsx
|
import axios from "axios";
import { FC, useState } from "react";
import { useMountEffect } from "../../hooks/useMountEffect";
import ArchiveGallery from "../../pages/Home/Subpages/ArchiveGalleryPage";
import { NestedIssueTemplate } from "../../types/ModelContentTemplate";
import { INestedIssue, IUser } from "../../types/ModelTypes";
interface GetArchiveGalleryProps {
user: IUser,
}
const GetArchiveGallery: FC<GetArchiveGalleryProps> = (props) => {
const [archivedIssues, setArchivedIssues] = useState<[INestedIssue]>([NestedIssueTemplate]);
useMountEffect(fetchArchive);
function fetchArchive() {
axios.get(`/organization/archive/${props.user.organizationId}`)
.then((res) => {
if (res.data.archivedIssues) {
setArchivedIssues(res.data.archivedIssues);
}
}).catch((err) => {
console.log(err);
});
}
return (
<>
<ArchiveGallery archivedIssues={archivedIssues} />
</>
);
}
export default GetArchiveGallery;
|
JKusiak/isshu
|
frontend/src/layout/Navbar.tsx
|
<gh_stars>0
import { Button, Menu, MenuItem } from '@material-ui/core';
import AppBar from '@material-ui/core/AppBar';
import IconButton from '@material-ui/core/IconButton';
import { makeStyles } from '@material-ui/core/styles';
import Toolbar from '@material-ui/core/Toolbar';
import Tooltip from '@material-ui/core/Tooltip';
import ProfileIcon from '@material-ui/icons/AccountCircleOutlined';
import AddProjectIcon from '@material-ui/icons/AddBoxOutlined';
import DarkModeOn from '@material-ui/icons/Brightness2';
import DarkModeOff from '@material-ui/icons/Brightness2Outlined';
import HomeIcon from '@material-ui/icons/HomeOutlined';
import React, { useContext, useState } from 'react';
import { Link } from 'react-router-dom';
import AddProject from '../api/Project/AddProject';
import { AuthUserContext, DarkModeContext, IsLoggedInContext } from '../App';
import Icon from '../resources/icon.svg';
import DarkIcon from '../resources/icon_darkmode.svg';
import Logo from '../resources/logo.svg';
import DarkLogo from '../resources/logo_darkmode.svg';
const useStyles = makeStyles((theme) => ({
appbar: {
height: theme.spacing(8.5),
boxShadow: theme.shadows[5],
zIndex: 100,
backgroundColor: theme.palette.primary.light,
},
toolbar: {
position: "sticky",
top: 0,
[theme.breakpoints.down('xs')]: {
padding: 0,
},
},
linkWrapper: {
padding: 0,
// added to compensate for padding of buttons on the right
marginLeft: theme.spacing(1.5),
},
logoIcon: {
height: 75,
width: 75
},
logo: {
height: 75,
[theme.breakpoints.down('xs')]: {
display: 'none',
},
padding: theme.spacing(2.3),
marginLeft: theme.spacing(2),
},
buttonsContainer: {
marginLeft: 'auto',
[theme.breakpoints.down('xs')]: {
marginRight: theme.spacing(1),
},
},
homeIcon: {
fontSize: '28px',
color: theme.palette.secondary.main,
},
addProjectIcon: {
fontSize: '26px',
color: theme.palette.secondary.main,
},
profileIcon: {
fontSize: '24px',
color: theme.palette.secondary.main,
},
navbarTextButton: {
fontSize: '16px',
[theme.breakpoints.down('xs')]: {
fontSize: '12px',
minWidth: 'auto',
},
color: theme.palette.secondary.main,
'&:hover': {
fontWeight: 600
}
},
darkModeButton: {
transform: 'rotate(20deg) scale(0.9)',
color: theme.palette.secondary.main,
[theme.breakpoints.down('xs')]: {
transform: 'rotate(20deg) scale(0.7)',
padding: 0,
},
},
menu: {
"& .MuiMenu-paper": {
backgroundColor: theme.palette.primary.light,
},
},
menuItem: {
color: theme.palette.secondary.main,
},
darkModeMenu: {
transform: 'rotate(20deg) scale(0.9)',
display: 'flex',
marginLeft: theme.spacing(1),
alignItems: 'center',
},
offset: theme.mixins.toolbar,
}));
const Navbar = () => {
const classes = useStyles();
const [anchorEl, setAnchorEl] = useState<null | HTMLElement>(null);
const openList = Boolean(anchorEl);
const [modalOpen, setModalOpen] = useState(false);
const { darkMode, setDarkMode } = useContext(DarkModeContext);
const { isLoggedIn, setLoggedIn } = useContext(IsLoggedInContext);
const { loggedInUser } = useContext(AuthUserContext);
const isInOrganization = loggedInUser.organizationId === null;
const handleMenu = (event: React.MouseEvent<HTMLElement>) => {
setAnchorEl(event.currentTarget);
};
const handleClose = () => {
setAnchorEl(null);
};
const handleLogout = () => {
handleClose();
localStorage.removeItem('token');
setLoggedIn(false);
};
const handleDarkMode = () => {
setDarkMode(!darkMode);
const boolToString = darkMode ? 'false' : 'true';
localStorage.setItem('darkMode', boolToString);
}
return (
<>
<div className={classes.offset} />
<AppBar elevation={0} className={classes.appbar} >
<Toolbar className={classes.toolbar}>
<Link className={classes.linkWrapper} to={isLoggedIn ? '/home/projects' : '/'}>
<img className={classes.logoIcon} src={darkMode ? DarkIcon : Icon} alt='site icon' />
<img className={classes.logo} src={darkMode ? DarkLogo : Logo} alt='site logo' />
</Link>
<div className={classes.buttonsContainer}>
{!isLoggedIn && (
<>
<Button className={classes.navbarTextButton} component={Link} to="/">
Home
</Button>
<Button className={classes.navbarTextButton} component={Link} to="/login">
Login
</Button>
<Button className={classes.navbarTextButton} component={Link} to="/register">
Register
</Button>
<IconButton className={classes.darkModeButton} onClick={handleDarkMode}>
{darkMode ? <DarkModeOn /> : <DarkModeOff />}
</IconButton>
</>
)}
{isLoggedIn && (
<>
<Tooltip title="Home" aria-label="projects" placement="bottom" enterDelay={500} leaveDelay={200}>
<IconButton aria-label="projects" component={Link} to="/home/projects">
<HomeIcon className={classes.homeIcon} />
</IconButton>
</Tooltip>
<Tooltip title="Add project" aria-label="add project" placement="bottom" enterDelay={500} leaveDelay={200}>
{// span here necessary to still display tooltip even if the button is disabled
}
<span>
<IconButton
aria-label="add project"
disabled={isInOrganization}
onClick={() => setModalOpen(true)}
>
<AddProjectIcon className={classes.addProjectIcon} />
</IconButton>
</span>
</Tooltip>
<AddProject
isOpen={modalOpen}
setIsOpen={setModalOpen}
/>
<Tooltip title="Your profile" aria-label="user profile" placement="bottom" enterDelay={500} leaveDelay={200}>
<IconButton aria-label="user profile" onClick={handleMenu}>
<ProfileIcon className={classes.profileIcon} />
</IconButton>
</Tooltip>
<Menu
className={classes.menu}
id="menu-appbar"
anchorEl={anchorEl}
anchorOrigin={{
vertical: 'bottom',
horizontal: 'center',
}}
getContentAnchorEl={null}
keepMounted
transformOrigin={{
vertical: 'top',
horizontal: 'center',
}}
open={openList}
onClose={handleClose}
>
<MenuItem
className={classes.menuItem}
onClick={handleClose}
component={Link}
to={`/user/${loggedInUser._id}`}
>
Profile
</MenuItem>
<MenuItem
className={classes.menuItem}
onClick={handleDarkMode}
>
Dark mode
<div className={classes.darkModeMenu}>
{darkMode ? <DarkModeOn /> : <DarkModeOff />}
</div>
</MenuItem>
<MenuItem
className={classes.menuItem}
onClick={handleLogout}
component={Link}
to="/"
>
Logout
</MenuItem>
</Menu>
</>
)}
</div>
</Toolbar>
</AppBar>
</>
);
}
export default Navbar;
|
JKusiak/isshu
|
frontend/src/components/Issue/Step/AddStepButton.tsx
|
<filename>frontend/src/components/Issue/Step/AddStepButton.tsx
import { ClickAwayListener, IconButton, InputBase } from '@material-ui/core';
import Card from '@material-ui/core/Card';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import AddIcon from '@material-ui/icons/AddOutlined';
import { FC, useContext, useState } from 'react';
import { BoardReducerContext } from '../../../api/Board/GetBoard';
import { ActionTypes } from '../../../reducers/BoardReducer';
import { INestedIssue } from '../../../types/ModelTypes';
const useStyles = makeStyles((theme: Theme) => createStyles({
buttonWrapper: {
display: 'flex',
width: '100%',
justifyContent: 'center',
alignItems: 'center',
},
card: {
backgroundColor: theme.palette.primary.light,
},
iconButton: {
justifyContent: 'center',
alignItems: 'center',
},
icon: {
transform: 'scale(0.7)',
color: theme.palette.secondary.main,
},
form: {
display: 'flex',
justifyContent: 'center',
alignItems: 'center',
},
inputField: {
width: 'auto',
marginLeft: theme.spacing(1),
color: theme.palette.secondary.main,
}
}));
interface AddStepButtonProps {
issue: INestedIssue,
updateSteps: () => void,
}
const AddStepButton: FC<AddStepButtonProps> = (props) => {
const classes = useStyles();
const [addMode, setAddMode] = useState<boolean>(false);
const [stepContent, setStepContent] = useState<string>('');
const { dispatch } = useContext(BoardReducerContext);
function handleSubmit(e: any) {
e.preventDefault();
if (stepContent !== '') {
const newStep = {
content: stepContent,
isCompleted: false,
};
const updatedSteps = [...props.issue.steps, newStep];
const payload = {
columnId: props.issue.columnId,
issueId: props.issue._id,
modified: {
steps: updatedSteps,
},
};
dispatch({ type: ActionTypes.UpdateIssue, payload: payload });
props.updateSteps();
setStepContent('');
}
setAddMode(false);
}
return (
<>
<div className={classes.buttonWrapper} onClick={() => setAddMode(true)}>
<ClickAwayListener onClickAway={() => setAddMode(false)}>
<Card className={classes.card}>
{addMode &&
<form className={classes.form} onSubmit={handleSubmit} autoComplete="off">
<InputBase
className={classes.inputField}
required
autoFocus
name="setContent"
id="stepContent"
placeholder="Step content"
autoComplete="step-content"
onChange={e => {
setStepContent(e.target.value);
}}
/>
<IconButton type="submit">
<AddIcon className={classes.icon} />
</IconButton>
</form>
}
{!addMode &&
<IconButton className={classes.iconButton}>
<AddIcon className={classes.icon} />
</IconButton>
}
</Card>
</ClickAwayListener>
</div>
</>
);
}
export default AddStepButton;
|
JKusiak/isshu
|
frontend/src/components/Authentication/LoginForm.tsx
|
<gh_stars>0
import Button from '@material-ui/core/Button';
import Grid from '@material-ui/core/Grid';
import Link from '@material-ui/core/Link';
import { createStyles, makeStyles, Theme } from '@material-ui/core/styles';
import TextField from '@material-ui/core/TextField';
import Typography from '@material-ui/core/Typography';
import React, { FC, useState } from 'react';
import { Link as RouterLink } from 'react-router-dom';
const useStyles = makeStyles((theme: Theme) => createStyles({
header: {
display: 'grid',
justifyContent: 'center',
marginBottom: theme.spacing(5),
color: theme.palette.secondary.main,
},
form: {
width: '100%',
},
submitButton: {
margin: theme.spacing(3, 0, 3),
borderRadius: '10px',
fontSize: '16px',
textTransform: 'none',
color: theme.palette.secondary.main,
backgroundColor: theme.palette.primary.light,
transition: 'all .12s linear',
boxShadow: theme.shadows[2],
"&:hover": {
cursor: 'pointer',
boxShadow: theme.shadows[5],
backgroundColor: theme.palette.primary.light,
},
},
inputField: {
"& .MuiOutlinedInput-root": {
color: theme.palette.secondary.main,
"& .MuiOutlinedInput-notchedOutline": {
borderRadius: '10px',
borderColor: theme.palette.secondary.light,
},
"&.Mui-focused .MuiOutlinedInput-notchedOutline": {
borderColor: theme.palette.secondary.light,
borderWidth: "2px",
}
},
},
wrongInput: {
color: "#C62828",
textAlign: "center",
}
}));
interface LoginProps {
loginUser: (credentials: any) => void,
isValid: boolean,
setIsValid: React.Dispatch<React.SetStateAction<boolean>>,
}
const LoginForm: FC<LoginProps> = (props) => {
const classes = useStyles();
const [email, setEmail] = React.useState<string>('');
const [password, setPassword] = React.useState<string>('');
function onSubmit(e: React.SyntheticEvent) {
e.preventDefault();
const credentials = {
email: email,
password: password,
}
props.loginUser(credentials);
}
return (
<>
<Typography className={classes.header} component="h1" variant="h4">
Sign in
</Typography>
<form className={classes.form} onSubmit={onSubmit} autoComplete="off">
<Grid container spacing={3}>
<Grid item xs={12}>
<TextField
className={classes.inputField}
required
fullWidth
autoFocus
variant="outlined"
name="email"
id="email"
placeholder="Email Address"
autoComplete="email-address"
onChange={e => {
setEmail(e.target.value);
props.setIsValid(true);
}}
/>
</Grid>
<Grid item xs={12}>
<TextField
className={classes.inputField}
required
fullWidth
variant="outlined"
name="password"
id="password"
placeholder="Password"
autoComplete="password"
type="password"
onChange={e => {
setPassword(e.target.value);
props.setIsValid(true);
}}
/>
</Grid>
</Grid>
{!props.isValid && <div className={classes.wrongInput}><p>Invalid username or password</p></div>}
<Button
className={classes.submitButton}
fullWidth
type="submit"
>
Sign in
</Button>
<Grid container justify="flex-end">
<Grid item>
<Link component={RouterLink} to='/register' color='secondary'>
{"Don't have an account? Register here"}
</Link>
</Grid>
</Grid>
</form>
</>
);
}
export default LoginForm;
|
marlosirapuan/cra-template-typescript-standard-prettier
|
template/src/routes/Route.tsx
|
import {
RouteProps as ReactRouteProps,
Route as ReactRoute,
Redirect
} from 'react-router-dom'
interface RouteProps extends ReactRouteProps {
isPrivate?: boolean
component: React.ComponentType
}
export const Route = ({
isPrivate = false,
component: Component,
...rest
}: RouteProps): JSX.Element => {
// your can put your logic here to check if user is authenticated
// with prop isPrivate and handle const below
const authenticated = false
return (
<ReactRoute
{...rest}
render={({ location: from }) => {
return isPrivate === authenticated ? (
<Component />
) : (
<Redirect
to={{
pathname: isPrivate ? '/' : '/restrict',
state: { from }
}}
/>
)
}}
/>
)
}
|
marlosirapuan/cra-template-typescript-standard-prettier
|
template/src/pages/index.tsx
|
<filename>template/src/pages/index.tsx
export { Home } from './Home/Home'
export { About } from './About/About'
export { Restrict } from './Restrict/Restrict'
|
marlosirapuan/cra-template-typescript-standard-prettier
|
template/src/routes/index.tsx
|
<filename>template/src/routes/index.tsx
import React from 'react'
import { Switch } from 'react-router-dom'
import { Route } from './Route'
import { Home, About } from 'pages'
export const Routes = (): JSX.Element => (
<Switch>
<Route path="/" exact component={Home} />
<Route path="/about" component={About} />
</Switch>
)
|
alex3683/mobx-react-lite
|
src/index.ts
|
<gh_stars>0
import "./assertEnvironment"
import { unstable_batchedUpdates as batch } from "./utils/reactBatchedUpdates"
import { observerBatching } from "./observerBatching"
observerBatching(batch)
export { isUsingStaticRendering, useStaticRendering } from "./staticRendering"
export { observer, IObserverOptions } from "./observer"
export { useObserver, ForceUpdateHook, IUseObserverOptions } from "./useObserver"
export { Observer } from "./ObserverComponent"
export { useForceUpdate } from "./utils"
export { useAsObservableSource } from "./useAsObservableSource"
export { useLocalStore } from "./useLocalStore"
export { useQueuedForceUpdate, useQueuedForceUpdateBlock } from "./useQueuedForceUpdate"
export { isObserverBatched, observerBatching } from "./observerBatching"
|
alex3683/mobx-react-lite
|
src/observerBatching.ts
|
import { configure } from "mobx"
import { getGlobal, getSymbol } from "./utils"
const observerBatchingConfiguredSymbol = getSymbol("observerBatching")
export function defaultNoopBatch(callback: () => void) {
callback()
}
export function observerBatching(reactionScheduler: any) {
if (!reactionScheduler) {
reactionScheduler = defaultNoopBatch
if ("production" !== process.env.NODE_ENV) {
console.warn(
"[MobX] Failed to get unstable_batched updates from react-dom / react-native"
)
}
}
configure({ reactionScheduler })
getGlobal()[observerBatchingConfiguredSymbol] = true
}
export const isObserverBatched = () => !!getGlobal()[observerBatchingConfiguredSymbol]
|
PhilStainer/philstainer.io
|
__tests__/testUtils.ts
|
import {ComponentType} from 'react'
import {render, RenderResult} from '@testing-library/react'
type Props = {
children: JSX.Element
}
const Providers = ({children}: Props) => {
return children
}
const customRender = (ui: JSX.Element, options = {}): RenderResult =>
render(ui, {wrapper: Providers as ComponentType, ...options})
export * from '@testing-library/react'
export {customRender as render}
|
PhilStainer/philstainer.io
|
pages/404.tsx
|
import {Layout} from '@/components/Layout'
import Link from 'next/link'
export const NotFound = (): JSX.Element => {
return (
<Layout title="404 - <NAME>">
<div className="flex flex-col justify-center items-center w-full max-w-3xl mx-auto mb-10 md:mb-20">
<svg
xmlns="http://www.w3.org/2000/svg"
className="h-36 md:h-48 text-blue-400 mx-auto mb-2"
viewBox="0 0 20 20"
fill="currentColor"
>
<path
fillRule="evenodd"
d="M10 18a8 8 0 100-16 8 8 0 000 16zM7 9a1 1 0 100-2 1 1 0 000 2zm7-1a1 1 0 11-2 0 1 1 0 012 0zm-7.536 5.879a1 1 0 001.415 0 3 3 0 014.242 0 1 1 0 001.415-1.415 5 5 0 00-7.072 0 1 1 0 000 1.415z"
clipRule="evenodd"
/>
</svg>
<h1 className="font-bold text-3xl md:text-6xl mb-5 text-gray-900 dark:text-gray-100">
404 - Page not found
</h1>
<p className="leading-7 font-light text-sm text-gray-600 dark:text-gray-300 mb-5">
Oops sorry...
</p>
<Link href="/">
<a className="p-2 sm:p-3 w-64 font-bold bg-gray-100 dark:bg-gray-800 text-center rounded-md text-gray-900 dark:text-gray-100">
Return Home
</a>
</Link>
</div>
</Layout>
)
}
export default NotFound
|
PhilStainer/philstainer.io
|
cypress/integration/index.spec.ts
|
describe('home page', () => {
it('navigates', () => {
cy.visit('/')
cy.contains('Hi there')
})
})
|
PhilStainer/philstainer.io
|
pages/blog/[slug].tsx
|
import {BlogLayout} from '@/components/BlogLayout'
import {MDXComponents} from '@/components/MDXComponents'
import {getFileBySlug, getFiles} from '@/lib/mdx'
import {GetStaticPathsResult, GetStaticPropsResult} from 'next'
import {MDXRemote} from 'next-mdx-remote'
import {BlogPost} from 'types/BlogPost'
export const Blog = ({mdxSource, frontMatter}: BlogPost): JSX.Element => {
return (
<BlogLayout frontMatter={frontMatter}>
<MDXRemote {...mdxSource} components={MDXComponents} />
</BlogLayout>
)
}
export const getStaticPaths = async (): Promise<GetStaticPathsResult> => {
const posts = await getFiles('blog')
return {
paths: posts.map(post => ({
params: {
slug: post.replace(/\.mdx/, '')
}
})),
fallback: false
}
}
type StaticProps = {
params: {
slug: string
}
}
export const getStaticProps = async ({
params
}: StaticProps): Promise<GetStaticPropsResult<BlogPost>> => {
const post = await getFileBySlug('blog', params.slug)
return {props: post}
}
export default Blog
|
PhilStainer/philstainer.io
|
utils/copyToClipboard.ts
|
<filename>utils/copyToClipboard.ts
export const copyToClipboard = (text: string): Promise<void> =>
new Promise((resolve, reject) => {
if (navigator?.clipboard) {
const cb = navigator.clipboard
cb.writeText(text).then(resolve).catch(reject)
} else {
try {
const body = document.querySelector('body')
const textarea = document.createElement('textarea')
body?.appendChild(textarea)
textarea.value = text
textarea.select()
document.execCommand('copy')
body?.removeChild(textarea)
resolve()
} catch (e) {
reject(e)
}
}
})
|
PhilStainer/philstainer.io
|
__tests__/components/BlogLayout.test.tsx
|
<filename>__tests__/components/BlogLayout.test.tsx
jest.mock('next/router', () => ({useRouter: () => ({asPath: ''})}))
import {BlogLayout} from '@/components/BlogLayout'
import {render, screen} from '@/__tests__/testUtils'
test('should render blog layout', () => {
const frontMatter = {
title: 'title',
publishedAt: '2021-01-01',
summary: 'summary',
image: '',
slug: 'test blog',
wordCount: 5,
readingTime: {text: '5 min read'},
}
render(
<BlogLayout frontMatter={frontMatter}>
<p>Blog Content</p>
</BlogLayout>
)
const title = screen.getByRole('heading', {name: frontMatter.title})
const date = screen.getByText(/january 01, 2021/i)
const readingTime = screen.getByText(/5 min read/i)
const children = screen.getByText(/blog content/i)
const discussUrl = screen.getByRole('link', {
name: /discuss on twitter/i,
}) as HTMLAnchorElement
const editUrl = screen.getByRole('link', {
name: /edit on github/i,
}) as HTMLAnchorElement
expect(title).toBeInTheDocument()
expect(date).toBeInTheDocument()
expect(readingTime).toBeInTheDocument()
expect(children).toBeInTheDocument()
const slugUrl = encodeURIComponent(frontMatter.slug)
expect(discussUrl.href).toContain(slugUrl)
expect(editUrl.href).toContain(slugUrl)
})
|
PhilStainer/philstainer.io
|
types/BlogPost.ts
|
import {MDXRemoteSerializeResult} from 'next-mdx-remote'
import {Post} from './Post'
export type BlogPost = {
mdxSource: MDXRemoteSerializeResult
frontMatter: Post
}
|
PhilStainer/philstainer.io
|
components/MDXComponents.tsx
|
import Image from 'next/image'
import {CustomLink} from './CustomLink'
import {Pre} from './Pre'
export const MDXComponents = {
Image,
a: CustomLink,
pre: Pre,
}
|
PhilStainer/philstainer.io
|
@types/mdx-prism.d.ts
|
declare module 'mdx-prism'
|
PhilStainer/philstainer.io
|
components/ThemeButton.tsx
|
<reponame>PhilStainer/philstainer.io
import {useState, useEffect} from 'react'
import {useTheme} from 'next-themes'
export const ThemeButton = (): JSX.Element => {
const [mounted, setMounted] = useState(false)
const {setTheme, resolvedTheme} = useTheme()
// When mounted on client
useEffect(() => setMounted(true), [])
const isDarkMode = resolvedTheme === 'dark'
return (
<button
aria-label="Toggle Theme"
type="button"
className="z-20 w-10 h-10 bg-gray-300 text-gray-900 rounded-sm overflow-hidden outline-none focus:outline-none focus:ring-2 focus:ring-gray-800 md:rounded-br-full md:fixed md:w-16 md:h-16 md:-top-0 md:-left-0 md:rounded-br-full dark:bg-gray-600 dark:text-gray-200 dark:focus:text-white dark:focus:ring-gray-200"
onClick={() => setTheme(isDarkMode ? 'light' : 'dark')}
>
<div className="relative h-full flex items-center justify-center rounded-sm md:rounded-br-full outline-none">
{mounted && (
<svg
xmlns="http://www.w3.org/2000/svg"
viewBox="0 0 24 24"
fill="currentColor"
stroke="currentColor"
className="w-4 h-4 md:absolute md:bottom-8 md:right-8"
>
<path
strokeLinecap="round"
strokeLinejoin="round"
strokeWidth={2}
d={
isDarkMode
? 'M12 3v1m0 16v1m9-9h-1M4 12H3m15.364 6.364l-.707-.707M6.343 6.343l-.707-.707m12.728 0l-.707.707M6.343 17.657l-.707.707M16 12a4 4 0 11-8 0 4 4 0 018 0z'
: 'M20.354 15.354A9 9 0 018.646 3.646 9.003 9.003 0 0012 21a9.003 9.003 0 008.354-5.646z'
}
/>
</svg>
)}
</div>
</button>
)
}
|
PhilStainer/philstainer.io
|
pages/index.tsx
|
<gh_stars>0
import Link from 'next/link'
import {Layout} from '@/components/Layout'
import {Project} from '@/components/Project'
import {getFilesMatter} from '@/lib/mdx'
import {GetStaticProps} from 'next'
import {BlogPost} from '@/components/BlogPost'
import {Post} from 'types/Post'
type Props = {
posts: Post[]
}
export const Home = ({posts}: Props): JSX.Element => {
const latestPosts = posts
.filter(post => Number(new Date()) >= Number(new Date(post.publishedAt)))
.sort(
(a, b) =>
Number(new Date(b.publishedAt)) - Number(new Date(a.publishedAt))
)
.slice(0, 3)
return (
<Layout>
<div className="flex flex-col justify-center items-start w-full max-w-3xl mx-auto">
<section className="mb-16 md:mb-20">
<div className="font-light text-gray-600 dark:text-gray-300 mb-3">
Hi, I’m
</div>
<h1 className="font-bold text-4xl md:text-6xl mb-4 text-gray-900 dark:text-gray-100">
<NAME>
</h1>
<h2 className="leading-7 font-light text-gray-600 dark:text-gray-300 mb-5">
I’m a full stack developer with a passion for creating and clean
code.
<br />
Currently working at the NHS as a full stack developer.
</h2>
<p className="prose dark:prose-dark font-light text-gray-600 dark:text-gray-300">
Check out some of my <a href="#projects">projects</a>, or read{' '}
<Link href="/blog">articles</Link> I’ve written.
</p>
</section>
{latestPosts.length > 0 && (
<section className="mb-10 w-full">
<h3
id="posts"
className="font-bold text-2xl md:text-4xl mb-6 text-gray-900 dark:text-gray-100"
>
Latest Posts
</h3>
{latestPosts.map(post => (
<BlogPost key={post.slug} {...post} />
))}
</section>
)}
<section className="w-full">
<h3
id="projects"
className="font-bold text-2xl md:text-4xl mb-6 text-gray-900 dark:text-gray-100"
>
Projects
</h3>
<Project
title="philstainer.io"
description="My personal site and blog."
href="https://philstainer.io"
source="https://github.com/PhilStainer/philstainer.io"
tags={['next.js', 'tailwind']}
/>
<Project
title="Full stack shop"
description="Online store with login and checkout"
source="https://github.com/PhilStainer/fullstack-shop"
tags={['next.js', 'graphql', 'docker']}
/>
</section>
</div>
</Layout>
)
}
export const getStaticProps: GetStaticProps = async () => {
const posts = await getFilesMatter('blog')
return {props: {posts}}
}
export default Home
|
PhilStainer/philstainer.io
|
__tests__/components/CustomLink.test.tsx
|
<reponame>PhilStainer/philstainer.io
import {CustomLink} from '@/components/CustomLink'
import {render, screen} from '@/__tests__/testUtils'
test('should render next link when href startsWith / or #', () => {
render(<CustomLink href="/test" />)
const link = screen.getByRole('link') as HTMLAnchorElement
expect(link.target).toBe('')
})
test('should render a link when href is external', () => {
render(<CustomLink href="https://www.google.com" />)
const link = screen.getByRole('link') as HTMLAnchorElement
expect(link.target).toBe('_blank')
})
|
PhilStainer/philstainer.io
|
pages/blog.tsx
|
import {BlogPost} from '@/components/BlogPost'
import {Layout} from '@/components/Layout'
import {getFilesMatter} from '@/lib/mdx'
import {GetStaticProps} from 'next'
import {Post} from 'types/Post'
type Props = {
posts: Post[]
}
export const Blog = ({posts}: Props): JSX.Element => {
const filteredPosts = posts
.filter(post => Number(new Date()) >= Number(new Date(post.publishedAt)))
.sort(
(a, b) =>
Number(new Date(b.publishedAt)) - Number(new Date(a.publishedAt))
)
return (
<Layout>
<div className="flex flex-col justify-center items-start w-full max-w-3xl mx-auto">
<h1 className="font-bold text-2xl md:text-4xl mb-6 text-gray-900 dark:text-gray-100">
Blog
</h1>
{!filteredPosts.length && (
<p className="text-gray-900 dark:text-gray-100">No posts found.</p>
)}
{filteredPosts.map(post => (
<BlogPost key={post.slug} {...post} />
))}
</div>
</Layout>
)
}
export const getStaticProps: GetStaticProps = async () => {
const posts = await getFilesMatter('blog')
return {props: {posts}}
}
export default Blog
|
PhilStainer/philstainer.io
|
__tests__/lib/mdx.test.ts
|
<gh_stars>0
jest.mock('fs')
jest.mock('gray-matter')
jest.mock('next-mdx-remote/serialize')
import fs from 'fs'
import {join} from 'path'
import matter from 'gray-matter'
import readingTime from 'reading-time'
import {serialize} from 'next-mdx-remote/serialize'
import {getFiles, getFileBySlug, getFilesMatter, basePath} from '@/lib/mdx'
const dir = 'test'
const path = join(basePath, dir)
describe('getFiles', () => {
test('should return files from dir', async () => {
await getFiles(dir)
expect(fs.readdirSync).toHaveBeenCalledWith(path)
})
})
describe('getFileBySlug', () => {
const slug = 'blog-post'
const dir = 'posts'
const parsedFile = {
data: {
title: 'title',
publishedAt: '2021-01-01',
summary: 'summary',
image: '',
},
content: 'content',
}
afterEach(() => jest.clearAllMocks())
test('should get file from data/dir when slug', async () => {
;(matter as any).mockReturnValueOnce(parsedFile)
await getFileBySlug(dir, slug)
expect(fs.readFileSync).toHaveBeenCalledWith(
join(basePath, dir, `${slug}.mdx`),
'utf8'
)
})
test('should get file from data when no slug', async () => {
;(matter as any).mockReturnValueOnce(parsedFile)
await getFileBySlug(slug)
expect(fs.readFileSync).toHaveBeenCalledWith(
join(basePath, `${slug}.mdx`),
'utf8'
)
})
test('should parse and serialize markdown file and return post', async () => {
const mdxSource = 'mdxSource'
;(matter as any).mockReturnValueOnce(parsedFile)
;(serialize as any).mockReturnValueOnce(mdxSource)
const post = await getFileBySlug(dir, slug)
expect(matter).toHaveBeenCalled()
expect(serialize).toHaveBeenCalled()
expect(serialize).toBeCalledWith(parsedFile.content, expect.anything())
expect(post).toStrictEqual({
mdxSource,
frontMatter: {
...parsedFile.data,
slug,
wordCount: mdxSource.split(/\s+/gu).length,
readingTime: readingTime(parsedFile.content),
},
})
})
})
describe('getFilesMatter', () => {
test('should parse and return all markdown files', async () => {
const fileName = 'blog-post-1.mdx'
const parsedFile = {
data: {
title: 'title',
publishedAt: '2021-01-01',
summary: 'summary',
image: '',
},
content: 'content',
}
;(fs.readdirSync as jest.Mock).mockReturnValueOnce([fileName])
;(matter as any).mockReturnValueOnce(parsedFile)
const files = await getFilesMatter(dir)
const returnedFile = {
title: parsedFile.data.title,
publishedAt: parsedFile.data.publishedAt,
summary: parsedFile.data.summary,
image: parsedFile.data.image,
slug: fileName.replace('.mdx', ''),
readingTime: readingTime(parsedFile.content),
}
expect(files).toEqual([returnedFile])
})
})
|
PhilStainer/philstainer.io
|
components/Project.tsx
|
export type Props = {
title: string
description: string
href?: string
source?: string
tags?: string[]
}
export const Project = ({
title,
description,
href,
source,
tags,
}: Props): JSX.Element => {
return (
<div className="block mb-7 space-y-2">
<div className="flex justify-between items-center text-gray-900 dark:text-gray-100">
<h4 className="text-xl md:text-2xl tracking-tight">
<span>{title}</span>
</h4>
</div>
{tags && (
<div className="flex items-center uppercase tracking-wide text-xs space-x-2">
<div className="text-gray-600 dark:text-gray-400">Built with</div>
{tags.map(tag => (
<div
key={tag}
data-testid="tag"
className="text-xs text-green-800 dark:text-green-100 bg-green-100 dark:bg-green-800 rounded-full py-1 px-2.5"
>
{tag}
</div>
))}
</div>
)}
<p className="leading-5 text-gray-600 dark:text-gray-300">
{description}
</p>
<div className="flex space-x-2">
{href && (
<a
href={href}
aria-label="View Site"
title="View Site"
target="_blank"
rel="noopener noreferrer"
className="text-xs text-gray-600 dark:text-gray-400 bg-gray-100 dark:bg-gray-800 hover:bg-gray-200 dark:hover:bg-gray-700 rounded focus:outline-none focus:ring-2 focus:ring-gray-800 dark:focus:ring-gray-200 transition p-2"
>
<svg
xmlns="http://www.w3.org/2000/svg"
className="h-5 w-5"
viewBox="0 0 20 20"
fill="currentColor"
>
<path d="M11 3a1 1 0 100 2h2.586l-6.293 6.293a1 1 0 101.414 1.414L15 6.414V9a1 1 0 102 0V4a1 1 0 00-1-1h-5z" />
<path d="M5 5a2 2 0 00-2 2v8a2 2 0 002 2h8a2 2 0 002-2v-3a1 1 0 10-2 0v3H5V7h3a1 1 0 000-2H5z" />
</svg>
</a>
)}
{source && (
<a
href={source}
aria-label="Source Code"
title="View Source Code"
target="_blank"
rel="noopener noreferrer"
className="text-xs text-gray-600 dark:text-gray-400 bg-gray-100 dark:bg-gray-800 hover:bg-gray-200 dark:hover:bg-gray-700 rounded focus:outline-none focus:ring-2 focus:ring-gray-800 dark:focus:ring-gray-200 transition p-2"
>
<svg
xmlns="http://www.w3.org/2000/svg"
className="h-5 w-5"
viewBox="0 0 20 20"
fill="currentColor"
>
<path
fillRule="evenodd"
d="M12.316 3.051a1 1 0 01.633 1.265l-4 12a1 1 0 11-1.898-.632l4-12a1 1 0 011.265-.633zM5.707 6.293a1 1 0 010 1.414L3.414 10l2.293 2.293a1 1 0 11-1.414 1.414l-3-3a1 1 0 010-1.414l3-3a1 1 0 011.414 0zm8.586 0a1 1 0 011.414 0l3 3a1 1 0 010 1.414l-3 3a1 1 0 11-1.414-1.414L16.586 10l-2.293-2.293a1 1 0 010-1.414z"
clipRule="evenodd"
/>
</svg>
</a>
)}
</div>
</div>
)
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.