repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
Accessible-Concepts/scrumlr.io
|
src/api/column.ts
|
import {StatusResponse} from "types";
import {AddColumnRequest, EditColumnRequest} from "types/column";
import {callAPI} from "api/callApi";
export const ColumnAPI = {
/**
* Adds a column with the specified name and configuration to a board.
*
* @param boardId the board id
* @param column contains
* name: the column name
* color: the column color
* hidden: flag whether the column should be displayed to all users or hidden from basic users
*
* @returns status and (error-)description of request
*/
addColumn: (boardId: string, column: AddColumnRequest) => callAPI<{boardId: string; column: AddColumnRequest}, StatusResponse>("addColumn", {boardId, column}),
/**
* Deletes a column with the specified id.
*
* @param boardId the board id
* @param columnId the column id
*
* @returns a {status, description} object
*/
deleteColumn: (boardId: string, columnId: string) => callAPI<{boardId: string; columnId: string}, StatusResponse>("deleteColumn", {boardId, columnId}),
/**
* Edit a column with the specified id.
*
* @param boardId the board id
* @param column contains
* columnId: the column id
* name: new name to set (optional)
* color: new column color to set (optional)
* hidden: flag to set whether this columns should be visible to all basic users (optional)
*
* @returns a {status, description} object
*/
editColumn: (boardId: string, column: EditColumnRequest) => callAPI<{boardId: string; column: EditColumnRequest}, StatusResponse>("editColumn", {boardId, column}),
};
|
Accessible-Concepts/scrumlr.io
|
src/components/Avatar/types.ts
|
export const AVATAR_SKIN_COLORS = ["Tanned", "Yellow", "Pale", "Light", "Brown", "DarkBrown", "Black"] as const;
export type AvatarSkinColor = typeof AVATAR_SKIN_COLORS[number];
export const AVATAR_TOP_TYPES = [
"Eyepatch",
"Hat",
"Hijab",
"LongHairBigHair",
"LongHairBob",
"LongHairBun",
"LongHairCurly",
"LongHairCurvy",
"LongHairDreads",
"LongHairFrida",
"LongHairFro",
"LongHairFroBand",
"LongHairMiaWallace",
"LongHairNotTooLong",
"LongHairShavedSides",
"LongHairStraight",
"LongHairStraight2",
"LongHairStraightStrand",
"NoHair",
"ShortHairDreads01",
"ShortHairDreads02",
"ShortHairFrizzle",
"ShortHairShaggyMullet",
"ShortHairShortCurly",
"ShortHairShortFlat",
"ShortHairShortRound",
"ShortHairShortWaved",
"ShortHairSides",
"ShortHairTheCaesar",
"ShortHairTheCaesarSidePart",
"Turban",
"WinterHat1",
"WinterHat2",
"WinterHat3",
"WinterHat4",
] as const;
export type AvatarTopType = typeof AVATAR_TOP_TYPES[number];
export const AVATAR_CLOTHE_COLORS = [
"Black",
"Blue01",
"Blue02",
"Blue03",
"Gray01",
"Gray02",
"Heather",
"PastelBlue",
"PastelGreen",
"PastelOrange",
"PastelRed",
"PastelYellow",
"Pink",
"Red",
"White",
];
export type AvatarClotheColor = typeof AVATAR_CLOTHE_COLORS[number];
export const AVATAR_GRAPHIC_TYPES = ["Bat", "Cumbia", "Deer", "Diamond", "Hola", "Pizza", "Resist", "Selena", "Bear", "SkullOutline", "Skull"] as const;
export type AvatarGraphicType = typeof AVATAR_GRAPHIC_TYPES[number];
export const AVATAR_CLOTHE_TYPES = ["BlazerShirt", "BlazerSweater", "CollarSweater", "GraphicShirt", "Hoodie", "Overall", "ShirtCrewNeck", "ShirtScoopNeck", "ShirtVNeck"] as const;
export type AvatarClotheType = typeof AVATAR_CLOTHE_TYPES[number];
export const AVATAR_HAIR_COLORS = ["Auburn", "Black", "Blonde", "BlondeGolden", "Brown", "BrownDark", "PastelPink", "Blue", "Platinum", "Red", "SilverGray"] as const;
export type AvatarHairColor = typeof AVATAR_HAIR_COLORS[number];
export const AVATAR_FACIAL_HAIR_COLORS = ["Auburn", "Black", "Blonde", "BlondeGolden", "Brown", "BrownDark", "Platinum", "Red"] as const;
export type AvatarFacialHairColor = typeof AVATAR_FACIAL_HAIR_COLORS[number];
export const AVATAR_FACIAL_HAIR_TYPES = ["Blank", "BeardMedium", "BeardLight", "BeardMajestic", "MoustacheFancy", "MoustacheMagnum"] as const;
export type AvatarFacialHairType = typeof AVATAR_FACIAL_HAIR_TYPES[number];
export const AVATAR_ACCESSORIES_TYPES = ["Blank", "Kurt", "Prescription01", "Prescription02", "Round", "Sunglasses", "Wayfarers"] as const;
export type AvatarAccessoriesType = typeof AVATAR_ACCESSORIES_TYPES[number];
export const AVATAR_EYE_TYPES = ["Close", "Cry", "Default", "Dizzy", "EyeRoll", "Happy", "Hearts", "Side", "Squint", "Surprised", "Wink", "WinkWacky"] as const;
export type AvatarEyeType = typeof AVATAR_EYE_TYPES[number];
export const AVATAR_EYEBROW_TYPES = [
"Angry",
"AngryNatural",
"Default",
"DefaultNatural",
"FlatNatural",
"FrownNatural",
"RaisedExcited",
"RaisedExcitedNatural",
"SadConcerned",
"SadConcernedNatural",
"UnibrowNatural",
"UpDown",
"UpDownNatural",
] as const;
export type AvatarEyebrowType = typeof AVATAR_EYEBROW_TYPES[number];
export const AVATAR_MOUTH_TYPES = ["Concerned", "Default", "Disbelief", "Eating", "Grimace", "Sad", "ScreamOpen", "Serious", "Smile", "Tongue", "Twinkle", "Vomit"] as const;
export type AvatarMouthType = typeof AVATAR_MOUTH_TYPES[number];
|
Accessible-Concepts/scrumlr.io
|
src/components/NoteInput/index.ts
|
export * from "./NoteInput";
|
Accessible-Concepts/scrumlr.io
|
server/src/cloud/voteConfiguration.ts
|
<filename>server/src/cloud/voteConfiguration.ts
import {StatusResponse} from "types";
import {requireValidBoardAdmin, getAdminRoleName, getMemberRoleName} from "./permission";
import {api, newObject} from "./util";
export type EditableVoteConfigurationAttributes = {
voteLimit: number;
allowMultipleVotesPerNote: boolean;
showVotesOfOtherUsers: boolean;
};
export type VoteConfiguration = {boardId: string} & Partial<EditableVoteConfigurationAttributes>;
export const initializeVoteConfigurationFunctions = () => {
/**
* Add vote configurtaions for each voting iteration.
*/
api<{voteConfiguration: VoteConfiguration}, StatusResponse>("addVoteConfiguration", async (user, request) => {
await requireValidBoardAdmin(user, request.voteConfiguration.boardId);
const board = await new Parse.Query("Board").get(request.voteConfiguration.boardId, {useMasterKey: true});
// Check if the board exists
if (!board) {
return {status: "Error", description: `Board '${request.voteConfiguration.boardId}' does not exist`};
}
// Voting iteraion will incremented after pressing the start voting phase button
const voteConfiguration = newObject(
"VoteConfiguration",
{
board: Parse.Object.extend("Board").createWithoutData(request.voteConfiguration.boardId),
votingIteration: (await board.get("votingIteration")) + 1,
voteLimit: request.voteConfiguration.voteLimit,
allowMultipleVotesPerNote: request.voteConfiguration.allowMultipleVotesPerNote,
showVotesOfOtherUsers: request.voteConfiguration.showVotesOfOtherUsers,
},
{
readRoles: [getMemberRoleName(request.voteConfiguration.boardId), getAdminRoleName(request.voteConfiguration.boardId)],
writeRoles: [getAdminRoleName(request.voteConfiguration.boardId)],
}
);
await voteConfiguration.save(null, {useMasterKey: true});
return {status: "Success", description: "Your vote configuration has been added"};
});
};
|
Accessible-Concepts/scrumlr.io
|
src/routes/LoginBoard/LoginBoard.tsx
|
<filename>src/routes/LoginBoard/LoginBoard.tsx<gh_stars>0
import {Link, useNavigate} from "react-router-dom";
import {getRandomName} from "constants/name";
import {AuthenticationManager} from "utils/authentication/AuthenticationManager";
import {Toast} from "utils/Toast";
import {useState} from "react";
import {LoginProviders} from "components/LoginProviders";
import {Trans, useTranslation} from "react-i18next";
import {useLocation} from "react-router";
import {HeroIllustration} from "components/HeroIllustration";
import {ScrumlrLogo} from "components/ScrumlrLogo";
import {ReactComponent as RefreshIcon} from "assets/icon-refresh.svg";
import "./LoginBoard.scss";
import {TextInputAction} from "components/TextInputAction";
import {Button} from "../../components/Button";
import {TextInput} from "../../components/TextInput";
import {TextInputLabel} from "../../components/TextInputLabel";
import {ValidationError} from "../../components/ValidationError";
export const LoginBoard = () => {
const {t} = useTranslation();
const location = useLocation();
const navigate = useNavigate();
const [displayName, setDisplayName] = useState(getRandomName());
const [termsAccepted, setTermsAccepted] = useState(false);
const [submitted, setSubmitted] = useState(false);
// anonymous sign in and redirection to board path that is in history
async function handleLogin() {
if (termsAccepted) {
await AuthenticationManager.signInAnonymously(displayName);
try {
navigate(location.state.from.pathname);
} catch (err) {
Toast.error(t("LoginBoard.errorOnRedirect"));
}
}
setSubmitted(true);
}
// https://dribbble.com/shots/7757250-Sign-up-revamp
return (
<div className="login-board">
<div className="login-board__dialog">
<div className="login-board__form-wrapper">
<div className="login-board__form">
<Link to="/">
<ScrumlrLogo className="login-board__logo" accentColorClassNames={["accent-color--blue", "accent-color--purple", "accent-color--lilac", "accent-color--pink"]} />
</Link>
<h1>{t("LoginBoard.title")}</h1>
<LoginProviders originURL={location.state.from.pathname} />
<hr className="login-board__divider" data-label="or" />
<fieldset className="login-board__fieldset">
<legend className="login-board__fieldset-legend">{t("LoginBoard.anonymousLogin")}</legend>
<div className="login-board__username">
<TextInputLabel label={t("LoginBoard.username")} htmlFor="login-board__username" />
<TextInput
id="login-board__username"
value={displayName}
onChange={(e) => setDisplayName(e.target.value)}
onKeyDown={(e: React.KeyboardEvent<HTMLInputElement>) => {
if (e.key === "Enter") {
handleLogin();
}
}}
maxLength={20}
aria-invalid={!displayName}
actions={
<TextInputAction title={t("LoginBoard.generateRandomName")} onClick={() => setDisplayName(getRandomName())}>
<RefreshIcon />
</TextInputAction>
}
/>
</div>
{!displayName && <ValidationError>{t("LoginBoard.usernameValidationError")}</ValidationError>}
<label className="login-board__form-element login-board__terms">
<input type="checkbox" className="login-board__checkbox" defaultChecked={termsAccepted} onChange={() => setTermsAccepted(!termsAccepted)} />
<span className="login-board__terms-label">
<Trans
i18nKey="LoginBoard.acceptTerms"
components={{
terms: <Link to="/legal/termsAndConditions" target="_blank" />,
privacy: <Link to="/legal/privacyPolicy" target="_blank" />,
}}
/>
</span>
</label>
</fieldset>
{submitted && !termsAccepted && <ValidationError>{t("LoginBoard.termsValidationError")}</ValidationError>}
<Button className="login-board__anonymous-login-button" color="primary" onClick={handleLogin}>
{t("LoginBoard.login")}
</Button>
</div>
</div>
<HeroIllustration className="login-board__illustration" />
</div>
</div>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/routes/ScrollToTop.tsx
|
<reponame>Accessible-Concepts/scrumlr.io
import {useLocation} from "react-router";
import {useLayoutEffect} from "react";
const ScrollToTop = () => {
const location = useLocation();
useLayoutEffect(() => {
// scroll to top on route change
window.scrollTo(0, 0);
}, [location.pathname]);
return null;
};
export default ScrollToTop;
|
Accessible-Concepts/scrumlr.io
|
src/components/MenuBars/MenuItem/variants/TimerToggleButton.tsx
|
import {useState} from "react";
import store, {useAppSelector} from "store";
import {ActionFactory} from "store/action";
import Dropdown from "components/Dropdown";
import {DropdownToggleButton} from "components/MenuBars/MenuItem/DropdownToggleButton";
import {ReactComponent as TimerIcon} from "assets/icon-timer.svg";
import "./TimerToggleButton.scss";
import {useTranslation} from "react-i18next";
import {TabIndex} from "constants/tabIndex";
type TimerToggleButtonProps = {
tabIndex?: number;
};
export const TimerToggleButton = (props: TimerToggleButtonProps) => {
const {t} = useTranslation();
const timer = useAppSelector((state) => state.board.data?.timerUTCEndTime);
const [customTime, setCustomTime] = useState(10);
const [tabable, setTabable] = useState(false);
const onClick = (minutes: number) => {
store.dispatch(ActionFactory.setTimer(new Date(new Date().getTime() + minutes * 60 * 1000)));
};
const focusOnTab = (tabIndex: number) => {
if (tabable) {
return props.tabIndex ? props.tabIndex + tabIndex : TabIndex.default;
}
return TabIndex.disabled;
};
return (
<DropdownToggleButton
active={timer !== undefined}
tabIndex={props.tabIndex ?? TabIndex.default}
setTabable={setTabable}
direction="left"
label={t("TimerToggleButton.label")}
icon={TimerIcon}
>
<Dropdown className="timer__dropdown">
<Dropdown.Main>
<Dropdown.ItemButton tabIndex={focusOnTab(1)} className="timer-dropdown__item-button" onClick={() => onClick(1)} onTouchEnd={() => onClick(1)}>
<label>{t("TimerToggleButton.1min")}</label>
<div>1</div>
</Dropdown.ItemButton>
<Dropdown.ItemButton tabIndex={focusOnTab(2)} className="timer-dropdown__item-button" onClick={() => onClick(3)} onTouchEnd={() => onClick(3)}>
<label>{t("TimerToggleButton.3min")}</label>
<div>3</div>
</Dropdown.ItemButton>
<Dropdown.ItemButton tabIndex={focusOnTab(3)} className="timer-dropdown__item-button" onClick={() => onClick(5)} onTouchEnd={() => onClick(5)}>
<label>{t("TimerToggleButton.5min")}</label>
<div>5</div>
</Dropdown.ItemButton>
<Dropdown.ItemButton tabIndex={focusOnTab(4)} className="timer-dropdown__item-button" onClick={() => onClick(customTime)} onTouchEnd={() => onClick(customTime)}>
<label>{t("TimerToggleButton.customTime")}</label>
<button
onClick={(e) => {
e.stopPropagation();
setCustomTime((prev) => Math.min(++prev, 59));
}}
onTouchEnd={(e) => {
e.preventDefault();
e.stopPropagation();
setCustomTime((prev) => Math.min(++prev, 59));
}}
tabIndex={focusOnTab(7)}
className="timer-dropdown__time-button"
>
+
</button>
<input tabIndex={focusOnTab(6)} value={customTime} onClick={(e) => e.stopPropagation()} onChange={(e) => setCustomTime(Math.min(parseInt(e.target.value, 10), 59))} />
<button
onClick={(e) => {
e.stopPropagation();
setCustomTime((prev) => Math.max(--prev, 0));
}}
onTouchEnd={(e) => {
e.preventDefault();
e.stopPropagation();
setCustomTime((prev) => Math.max(--prev, 0));
}}
tabIndex={focusOnTab(5)}
className="timer-dropdown__time-button"
>
-
</button>
</Dropdown.ItemButton>
</Dropdown.Main>
{timer != null && (
<Dropdown.Footer>
<Dropdown.ItemButton
tabIndex={focusOnTab(8)}
className="timer-dropdown__item-button"
onClick={() => store.dispatch(ActionFactory.cancelTimer())}
onTouchEnd={() => store.dispatch(ActionFactory.cancelTimer())}
>
<label>{t("TimerToggleButton.cancelTimer")}</label>
<div>x</div>
</Dropdown.ItemButton>
</Dropdown.Footer>
)}
</Dropdown>
</DropdownToggleButton>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/components/HeroIllustration/index.ts
|
export * from "./HeroIllustration";
|
Accessible-Concepts/scrumlr.io
|
src/store/action/__tests__/joinRequest.test.ts
|
<gh_stars>10-100
import {AssertTypeEqual} from "testUtils";
import {JoinRequestClientModel} from "types/joinRequest";
import {JoinRequestActionFactory, JoinRequestActionType, JoinRequestReduxAction} from "../joinRequest";
import {ReduxAction} from "../index";
describe("joinRequest actions", () => {
const id = "joinRequestId";
const boardId = "boardId";
const userId = "userId";
const userIds = ["userId1", "userId2"];
const joinRequest: JoinRequestClientModel = {
id,
boardId,
userId,
status: "accepted",
displayName: "displayName",
};
test("equal number of action types and factory functions", () => {
expect(Object.keys(JoinRequestActionType).length).toEqual(Object.keys(JoinRequestActionFactory).length);
});
describe("acceptJoinRequests", () => {
test("type is listed in joinRequest redux actions", () => {
const assertion: AssertTypeEqual<ReturnType<typeof JoinRequestActionFactory.acceptJoinRequests>, JoinRequestReduxAction> = true;
expect(assertion).toBeTruthy();
});
test("type is listed in general redux actions", () => {
const assertion: AssertTypeEqual<ReturnType<typeof JoinRequestActionFactory.acceptJoinRequests>, ReduxAction> = true;
expect(assertion).toBeTruthy();
});
test("should dispatch correct action object", () => {
const action = JoinRequestActionFactory.acceptJoinRequests(boardId, userIds);
expect(action).toEqual({
type: JoinRequestActionType.AcceptJoinRequests,
boardId,
userIds,
});
});
});
describe("rejectJoinRequests", () => {
test("type is listed in joinRequest redux actions", () => {
const assertion: AssertTypeEqual<ReturnType<typeof JoinRequestActionFactory.rejectJoinRequests>, JoinRequestReduxAction> = true;
expect(assertion).toBeTruthy();
});
test("type is listed in general redux actions", () => {
const assertion: AssertTypeEqual<ReturnType<typeof JoinRequestActionFactory.rejectJoinRequests>, ReduxAction> = true;
expect(assertion).toBeTruthy();
});
test("should dispatch correct action object", () => {
const action = JoinRequestActionFactory.rejectJoinRequests(boardId, userIds);
expect(action).toEqual({
type: JoinRequestActionType.RejectJoinRequests,
boardId,
userIds,
});
});
});
describe("initializeJoinRequests", () => {
test("type is listed in joinRequest redux actions", () => {
const assertion: AssertTypeEqual<ReturnType<typeof JoinRequestActionFactory.initializeJoinRequests>, JoinRequestReduxAction> = true;
expect(assertion).toBeTruthy();
});
test("type is listed in general redux actions", () => {
const assertion: AssertTypeEqual<ReturnType<typeof JoinRequestActionFactory.initializeJoinRequests>, ReduxAction> = true;
expect(assertion).toBeTruthy();
});
test("should dispatch correct action object", () => {
const action = JoinRequestActionFactory.initializeJoinRequests([joinRequest]);
expect(action).toEqual({
type: JoinRequestActionType.InitializeJoinRequests,
joinRequests: [joinRequest],
});
});
});
describe("createJoinRequest", () => {
test("type is listed in joinRequest redux actions", () => {
const assertion: AssertTypeEqual<ReturnType<typeof JoinRequestActionFactory.createJoinRequest>, JoinRequestReduxAction> = true;
expect(assertion).toBeTruthy();
});
test("type is listed in general redux actions", () => {
const assertion: AssertTypeEqual<ReturnType<typeof JoinRequestActionFactory.createJoinRequest>, ReduxAction> = true;
expect(assertion).toBeTruthy();
});
test("should dispatch correct action object", () => {
const action = JoinRequestActionFactory.createJoinRequest(joinRequest);
expect(action).toEqual({
type: JoinRequestActionType.CreateJoinRequest,
joinRequest,
});
});
});
describe("updateJoinRequest", () => {
test("type is listed in joinRequest redux actions", () => {
const assertion: AssertTypeEqual<ReturnType<typeof JoinRequestActionFactory.updateJoinRequest>, JoinRequestReduxAction> = true;
expect(assertion).toBeTruthy();
});
test("type is listed in general redux actions", () => {
const assertion: AssertTypeEqual<ReturnType<typeof JoinRequestActionFactory.updateJoinRequest>, ReduxAction> = true;
expect(assertion).toBeTruthy();
});
test("should dispatch correct action object", () => {
const action = JoinRequestActionFactory.updateJoinRequest(joinRequest);
expect(action).toEqual({
type: JoinRequestActionType.UpdateJoinRequest,
joinRequest,
});
});
});
});
|
Accessible-Concepts/scrumlr.io
|
src/components/Request/__tests__/Request.test.tsx
|
<filename>src/components/Request/__tests__/Request.test.tsx
import {fireEvent, getByText} from "@testing-library/react";
import {Request} from "components/Request";
import store from "store";
import {ActionFactory} from "store/action";
import {render} from "testUtils";
jest.mock("store", () => ({
dispatch: jest.fn(),
}));
describe("JoinRequest", () => {
const createJoinRequest = (numRequests: number) => {
const joinRequests = [];
for (let i = 0; i < numRequests; i += 1) {
joinRequests.push({
id: `id-${i}`,
userId: `userId-${i}`,
displayName: `displayName-${i}`,
boardId: `boardId-${i}`,
status: "pending" as const,
});
}
return <Request joinRequests={joinRequests} raisedHands={[]} users={[]} boardId="boardId" />;
};
describe("should render correctly", () => {
test("on single join request", () => {
const {container} = render(createJoinRequest(1));
expect(container.firstChild).toMatchSnapshot();
});
test("on multiple join requests", () => {
const {container} = render(createJoinRequest(3));
expect(container.firstChild).toMatchSnapshot();
});
});
describe("should call store.dispatch correctly", () => {
test("single join request should call rejectJoinRequest correctly", () => {
const {container} = render(createJoinRequest(1));
fireEvent.click(getByText(container, "Reject"));
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.rejectJoinRequests("boardId", ["userId-0"]));
});
test("single join request should call acceptJoinRequest correctly", () => {
const {container} = render(createJoinRequest(1));
fireEvent.click(getByText(container, "Accept"));
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.acceptJoinRequests("boardId", ["userId-0"]));
});
test("multiple join request should call acceptJoinRequests correctly", () => {
const {container} = render(createJoinRequest(3));
fireEvent.click(getByText(container, "Accept all")!);
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.acceptJoinRequests("boardId-0", ["userId-0", "userId-1", "userId-2"]));
});
test("multiple join request should call rejectJoinRequests correctly", () => {
const {container} = render(createJoinRequest(3));
fireEvent.click(getByText(container, "Reject all")!);
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.rejectJoinRequests("boardId-0", ["userId-0", "userId-1", "userId-2"]));
});
test("multiple join request should call rejectJoinRequests in requests list item correctly", () => {
const {container} = render(createJoinRequest(3));
const figures = container.querySelectorAll(".join-request__requests-figure");
for (let i = 0; i < figures.length; i += 1) {
fireEvent.click(figures[i].children[2]);
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.rejectJoinRequests(`boardId-${i}`, [`userId-${i}`]));
}
});
test("multiple join request should call acceptJoinRequests in requests list item correctly", () => {
const {container} = render(createJoinRequest(3));
const figures = container.querySelectorAll(".join-request__requests-figure");
for (let i = 0; i < figures.length; i += 1) {
fireEvent.click(figures[i].children[3]);
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.acceptJoinRequests(`boardId-${i}`, [`userId-${i}`]));
}
});
});
});
|
Accessible-Concepts/scrumlr.io
|
src/components/TextInputAction/index.ts
|
export * from "./TextInputAction";
|
Accessible-Concepts/scrumlr.io
|
src/components/BoardHeader/HeaderMenu/BoardOptions/ShowHiddenColumnsOption.tsx
|
import store, {useAppSelector} from "store";
import {ApplicationState} from "types/store";
import {ActionFactory} from "store/action";
import "../BoardSettings/BoardSettings.scss";
import Parse from "parse";
import {useTranslation} from "react-i18next";
import {BoardOption} from "./BoardOption";
import {BoardOptionButton} from "./BoardOptionButton";
import {BoardOptionToggle} from "./BoardOptionToggle";
export const ShowHiddenColumnsOption = () => {
const {t} = useTranslation();
const state = useAppSelector((applicationState: ApplicationState) => ({
board: applicationState.board.data!,
user: applicationState.users.all.find((user) => user.id === Parse.User.current()!.id),
userConfiguration: applicationState.board.data?.userConfigurations.find((configuration) => configuration.id === Parse.User.current()!.id),
}));
return (
<BoardOption data-testid="column">
<BoardOptionButton
label={state.userConfiguration?.showHiddenColumns ? t("ShowHiddenColumnsOption.hide") : t("ShowHiddenColumnsOption.show")}
onClick={() => {
store.dispatch(ActionFactory.editUserConfiguration({showHiddenColumns: !state.userConfiguration?.showHiddenColumns}));
}}
>
<BoardOptionToggle active={Boolean(state.userConfiguration?.showHiddenColumns)} />
</BoardOptionButton>
</BoardOption>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/store/middleware/vote.ts
|
import {AnyAction, Dispatch, MiddlewareAPI} from "redux";
import {ApplicationState} from "types/store";
import {API} from "api";
import {Toast} from "utils/Toast";
import {StatusResponse} from "types";
import Parse from "parse";
import {ActionType, ReduxAction} from "../action";
export const passVoteMiddlware = async (stateAPI: MiddlewareAPI<Dispatch<AnyAction>, ApplicationState>, dispatch: Dispatch, action: ReduxAction) => {
if (action.type === ActionType.AddVote) {
// Check client side if we reached the limit
const boardId = stateAPI.getState().board.data!.id;
const user = Parse.User.current()!.id;
const {length} = stateAPI.getState().votes.filter((v) => v.user === user);
const allowed = stateAPI.getState().voteConfiguration.voteLimit;
if (length <= allowed) {
const response = (await API.addVote(boardId, action.note)) as StatusResponse;
stateAPI.getState().votes.filter((v) => v.user === user);
if (response.status === "Error") {
Toast.error(response.description);
}
}
}
if (action.type === ActionType.DeleteVote) {
const boardId = stateAPI.getState().board.data!.id;
API.deleteVote(boardId, action.note);
}
};
|
Accessible-Concepts/scrumlr.io
|
src/components/DotButton/index.ts
|
<reponame>Accessible-Concepts/scrumlr.io<gh_stars>10-100
export * from "./DotButton";
|
Accessible-Concepts/scrumlr.io
|
src/components/MenuBars/MenuItem/index.ts
|
export * from "./MenuButton";
export * from "./MenuToggle";
|
Accessible-Concepts/scrumlr.io
|
src/store/middleware/__tests__/vote.test.ts
|
<reponame>Accessible-Concepts/scrumlr.io
import {passVoteMiddlware} from "store/middleware/vote";
import {ActionFactory} from "store/action";
import {API} from "api";
import {MiddlewareAPI} from "redux";
import {mocked} from "ts-jest/utils";
import {User} from "parse";
const mockedUser = mocked(User, true);
jest.mock("api", () => ({
API: {
addVote: jest.fn(),
deleteVote: jest.fn(),
},
}));
beforeEach(() => {
(API.addVote as jest.Mock).mockClear();
(API.addVote as jest.Mock).mockReturnValue({status: "Success"});
mockedUser.current = jest.fn(() => ({id: "testId"} as never));
});
const stateAPI = {
getState: () => ({
board: {
data: {
id: "boardId",
},
},
votes: [{user: "testId"}],
voteConfiguration: {
voteLimit: 5,
},
}),
};
describe("vote middleware", () => {
test("add vote", () => {
passVoteMiddlware(stateAPI as MiddlewareAPI, jest.fn(), ActionFactory.addVote("noteId"));
expect(API.addVote).toHaveBeenCalledWith("boardId", "noteId");
});
test("delete vote", () => {
passVoteMiddlware(stateAPI as MiddlewareAPI, jest.fn(), ActionFactory.deleteVote("noteId"));
expect(API.deleteVote).toHaveBeenCalledWith("boardId", "noteId");
});
});
|
Accessible-Concepts/scrumlr.io
|
src/components/BoardUsers/UserAvatar.tsx
|
<filename>src/components/BoardUsers/UserAvatar.tsx
import "./BoardUser.scss";
import classNames from "classnames";
import {ReactComponent as IconCheck} from "assets/icon-check.svg";
import {Avatar} from "../Avatar";
import {Badge} from "../Badge";
export interface UserAvatarProps {
className?: string;
avatarClassName?: string;
id: string;
name: string;
avatar?: string;
ready?: boolean;
badgeText?: string;
}
export const UserAvatar = ({name, badgeText, id, ready, avatar, className, avatarClassName}: UserAvatarProps) => (
<div className={classNames("user-avatar", className)} title={name}>
{avatar ? <img src={avatar} className={avatarClassName} alt={name} /> : <Avatar seed={id} className={avatarClassName} />}
{ready && <IconCheck className="user-avatar__ready" />}
{badgeText && <Badge text={badgeText} />}
</div>
);
|
Accessible-Concepts/scrumlr.io
|
src/types/__tests__/note.test.ts
|
<gh_stars>0
import {mapNoteServerToClientModel, NoteClientModel, NoteServerModel} from "../note";
describe("Note types", () => {
test("mapNoteServerToClientModel", async () => {
const map = {
author: {id: "5"} as unknown as Parse.Object,
parent: {id: "5"} as unknown as Parse.Object,
columnId: "test_columnId",
positionInStack: 5,
text: "test_text",
focus: false,
createdAt: new Date(1234),
updatedAt: new Date(1234),
};
const serverModel = {
id: "5",
get: (s: string) => map[s],
} as unknown as NoteServerModel;
const clientModel: NoteClientModel = mapNoteServerToClientModel(serverModel);
expect(clientModel.id).toEqual(serverModel.id);
expect(clientModel.columnId).toEqual(serverModel.get("columnId"));
expect(clientModel.text).toEqual(serverModel.get("text"));
expect(clientModel.focus).toEqual(serverModel.get("focus"));
expect(clientModel.createdAt).toEqual(serverModel.get("createdAt"));
expect(clientModel.updatedAt).toEqual(serverModel.get("updatedAt"));
expect(clientModel.author).toEqual(serverModel.get("author").id);
expect(clientModel.parentId).toEqual(serverModel.get("parent").id);
expect(clientModel.positionInStack).toEqual(serverModel.get("positionInStack"));
expect(clientModel.dirty).toEqual(false);
});
});
|
Accessible-Concepts/scrumlr.io
|
src/components/Badge/Badge.tsx
|
<filename>src/components/Badge/Badge.tsx
import "./Badge.scss";
type BadgeProps = {
text: string;
};
export const Badge = ({text}: BadgeProps) => (
<div className="badge">
<span>{text}</span>
</div>
);
|
Accessible-Concepts/scrumlr.io
|
src/components/Dropdown/DropdownFooter.tsx
|
<gh_stars>10-100
import React from "react";
import classNames from "classnames";
import {DropdownProps} from "./DropdownProps";
export const DropdownFooter: React.FC<DropdownProps> = ({className, children, ...other}) => (
<div className={classNames("dropdown__footer", className)} {...other}>
<ul>{children}</ul>
</div>
);
|
Accessible-Concepts/scrumlr.io
|
server/src/cloud/permission.ts
|
<filename>server/src/cloud/permission.ts
export const getAdminRoleName = (boardId: string) => {
return `admin_of_${boardId}`;
}
export const getMemberRoleName = (boardId: string) => {
return `member_of_${boardId}`;
}
export const isAdmin = async (user: Parse.User, boardId: string) => {
const adminRoleQuery = new Parse.Query(Parse.Role);
adminRoleQuery.equalTo('name', getAdminRoleName(boardId));
adminRoleQuery.equalTo('users', user);
return Boolean(await adminRoleQuery.first({ useMasterKey: true }));
}
export const isOnline = (user: Parse.User, boardId: string) => {
return (user.get('boards') as string[])?.indexOf(boardId) >= 0;
}
export const isMember = async (user: Parse.User, boardId: string) => {
const adminRoleQuery = new Parse.Query(Parse.Role);
adminRoleQuery.equalTo('name', getAdminRoleName(boardId));
adminRoleQuery.equalTo('users', user);
const memberRoleQuery = new Parse.Query(Parse.Role);
memberRoleQuery.equalTo('name', getMemberRoleName(boardId));
memberRoleQuery.equalTo('users', user);
const combinedQuery = Parse.Query.or(adminRoleQuery, memberRoleQuery).limit(1);
return Boolean(await combinedQuery.first({ useMasterKey: true }));
}
export const requireValidBoardMember = async (user: Parse.User, boardId: string) => {
if (!await isMember(user, boardId)) {
throw new Error(`User ${user} is not permitted to access board '${boardId}'`);
}
}
export const requireValidBoardAdmin = async (user: Parse.User, boardId: string) => {
if (!await isAdmin(user, boardId)) {
throw new Error(`User ${user} is not permitted to access board '${boardId}'`);
}
}
|
Accessible-Concepts/scrumlr.io
|
src/components/BoardUsers/BoardUsers.tsx
|
<gh_stars>0
import "./BoardUsers.scss";
import Parse from "parse";
import {useAppSelector} from "store";
import {useEffect, useState} from "react";
import {UserAvatar} from "./UserAvatar";
const getWindowDimensions = () => {
const {innerWidth: width, innerHeight: height} = window;
return {
width,
height,
};
};
export const BoardUsers = () => {
const [windowDimensions, setWindowDimensions] = useState(getWindowDimensions());
useEffect(() => {
function handleResize() {
setWindowDimensions(getWindowDimensions());
}
window.addEventListener("resize", handleResize);
return () => window.removeEventListener("resize", handleResize);
}, []);
let NUM_OF_DISPLAYED_USERS;
if (windowDimensions.width < 768) {
NUM_OF_DISPLAYED_USERS = 1;
} else if (windowDimensions.width < 1024) {
NUM_OF_DISPLAYED_USERS = 2;
} else {
NUM_OF_DISPLAYED_USERS = 4;
}
const users = useAppSelector((state) => state.users.all);
const currentUser = Parse.User.current();
const me = users.find((user) => user.id === currentUser!.id);
const them = users.filter((user) => user.id !== currentUser!.id && user.online);
const usersToShow = them.splice(0, them.length > NUM_OF_DISPLAYED_USERS ? NUM_OF_DISPLAYED_USERS - 1 : NUM_OF_DISPLAYED_USERS);
return (
<ul className="board-users">
{them.length > 0 && (
<li className="rest-users">
<div className="rest-users__count">{them.length}</div>
</li>
)}
{usersToShow.map((user) => (
<li key={user.id}>
<UserAvatar id={user.id} ready={user.ready} name={user.displayName} />
</li>
))}
{!!me && <UserAvatar id={me.id} ready={me.ready} name={me.displayName} />}
</ul>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/store/middleware/__tests__/joinRequest.test.ts
|
import {API} from "api";
import {passJoinRequestMiddleware} from "store/middleware/joinRequest";
import {ActionFactory} from "store/action";
import {MiddlewareAPI} from "redux";
jest.mock("api", () => ({
API: {
acceptJoinRequests: jest.fn(),
rejectJoinRequests: jest.fn(),
},
}));
beforeEach(() => {
(API.acceptJoinRequests as jest.Mock).mockClear();
(API.rejectJoinRequests as jest.Mock).mockClear();
});
describe("joinRequest middleware", () => {
test("acceptJoinRequest", () => {
passJoinRequestMiddleware({} as MiddlewareAPI, jest.fn(), ActionFactory.acceptJoinRequests("boardId", ["userId"]));
expect(API.acceptJoinRequests).toHaveBeenCalledWith("boardId", ["userId"]);
});
test("rejectJoinRequest", () => {
passJoinRequestMiddleware({} as MiddlewareAPI, jest.fn(), ActionFactory.rejectJoinRequests("boardId", ["userId"]));
expect(API.rejectJoinRequests).toHaveBeenCalledWith("boardId", ["userId"]);
});
});
|
Accessible-Concepts/scrumlr.io
|
src/utils/timer.ts
|
import {callAPI} from "api/callApi";
/**
* Calculates the difference between the local browser time and the server
* time in milliseconds.
*
* @returns a negative number if server is ahead, positive otherwise
*/
export const getBrowserServerTimeDifference = async () => {
const serverTime: string = await callAPI("getServerTime", {});
return Date.parse(new Date().toUTCString()) - Date.parse(serverTime);
};
|
Accessible-Concepts/scrumlr.io
|
src/components/ErrorPage/ErrorPage.tsx
|
<reponame>Accessible-Concepts/scrumlr.io<filename>src/components/ErrorPage/ErrorPage.tsx<gh_stars>10-100
import "./ErrorPage.scss";
import {useNavigate} from "react-router-dom";
import {useTranslation} from "react-i18next";
import {Button} from "components/Button";
export interface ErrorPageProps {
errorMessage: string;
originURL: string;
}
export const ErrorPage = ({errorMessage, originURL}: ErrorPageProps) => {
const {t} = useTranslation();
const navigate = useNavigate();
const redirect = (newURL: string) => () => {
navigate(newURL);
};
return (
<section className="error-page">
<span>{errorMessage}</span>
<Button data-testid="home-button" onClick={redirect("/")}>
{t("ErrorPage.navigateHome")}
</Button>
<button data-testid="back-button" onClick={redirect(originURL)}>
{t("ErrorPage.navigateBack")}
</button>
</section>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/components/Votes/VoteButtons/RemoveVoteButton.tsx
|
<gh_stars>0
import store from "store";
import {ActionFactory} from "store/action";
import {DotButton} from "components/DotButton";
import "./RemoveVoteButton.scss";
import classNames from "classnames";
import {VoteClientModel} from "types/vote";
import {FC} from "react";
type RemoveVoteProps = {
noteId: string;
activeVoting: boolean;
votes: VoteClientModel[];
ownVotes: VoteClientModel[];
tabIndex: number;
};
export const RemoveVoteButton: FC<RemoveVoteProps> = ({noteId, activeVoting, votes, ownVotes, tabIndex}) => {
const deleteVote = () => {
store.dispatch(ActionFactory.deleteVote(noteId));
};
return (
<DotButton
tabIndex={tabIndex}
className={classNames("vote-button-remove", {"vote-button-remove--own-vote": ownVotes.length > 0})}
disabled={!activeVoting}
onClick={deleteVote}
>
<span className="vote-button-remove__folded-corner" />
<span>{votes.length.toString()}</span>
</DotButton>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/components/Dropdown/DropdownProps.ts
|
<reponame>Accessible-Concepts/scrumlr.io<gh_stars>10-100
export type DropdownProps = {
className?: string;
tabIndex?: number;
[key: string]: unknown;
};
|
Accessible-Concepts/scrumlr.io
|
src/components/NoteDialog/NoteDialogComponents/NoteDialogNoteComponents/index.ts
|
<gh_stars>10-100
import {NoteDialogNoteFooter as Footer} from "./NoteDialogNoteFooter";
import {NoteDialogNoteContent as Content} from "./NoteDialogNoteContent";
import {NoteDialogNoteOptions as Options} from "./NoteDialogOptions";
export const NoteDialogNoteComponents = {
Content,
Options,
Footer,
};
|
Accessible-Concepts/scrumlr.io
|
src/routes/AuthRedirect/index.ts
|
export * from "./AuthRedirect";
|
Accessible-Concepts/scrumlr.io
|
src/api/voteConfiguration.ts
|
<reponame>Accessible-Concepts/scrumlr.io
import {VoteConfiguration} from "types/voteConfiguration";
import {callAPI} from "api/callApi";
export const VoteConfigurationAPI = {
/**
* Adds a vote configuration to a board.
*
* @param voteConfiguration the current vote configuration
*
* @returns `true` if the operation succeeded or throws an error otherwise
*/
addVoteConfiguration: (voteConfiguration: VoteConfiguration) => callAPI("addVoteConfiguration", {voteConfiguration}),
};
|
Accessible-Concepts/scrumlr.io
|
src/routes/RequireAuthentication.tsx
|
<reponame>Accessible-Concepts/scrumlr.io<filename>src/routes/RequireAuthentication.tsx
import {Navigate} from "react-router-dom";
import Parse from "parse";
import {useLocation} from "react-router";
import {useEffect, useState, FC} from "react";
import {LoadingScreen} from "../components/LoadingScreen";
export const RequireAuthentication: FC = ({children}) => {
const location = useLocation();
const [verifiedSession, setVerifiedSession] = useState<boolean | undefined>(undefined);
useEffect(() => {
Parse.Session.current()
.then(() => {
setVerifiedSession(true);
})
.catch(() => {
setVerifiedSession(false);
});
}, []);
if (verifiedSession === undefined) {
// wait while session needs to be verified
return <LoadingScreen />;
}
if (verifiedSession) {
// eslint-disable-next-line react/jsx-no-useless-fragment
return <>{children}</>;
}
return <Navigate to="/login" state={{from: location}} />;
};
export default RequireAuthentication;
|
Accessible-Concepts/scrumlr.io
|
src/components/BoardHeader/HeaderMenu/BoardOptions/BoardOptionToggle.tsx
|
<reponame>Accessible-Concepts/scrumlr.io<gh_stars>10-100
import {FC} from "react";
import classNames from "classnames";
import "./BoardOptionToggle.scss";
export interface BoardOptionToggleProps {
active: boolean;
}
export const BoardOptionToggle: FC<BoardOptionToggleProps> = ({active}) => (
<div className="board-option-toggle">
<div className={classNames("board-option-toggle__switch", {"board-option-toggle__switch--left": !active}, {"board-option-toggle__switch--right": active})} />
</div>
);
|
Accessible-Concepts/scrumlr.io
|
src/types/__tests__/joinRequest.test.ts
|
import {mapJoinRequestServerToClientModel, JoinRequestClientModel, JoinRequestServerModel} from "../joinRequest";
describe("JoinRequest types", () => {
test("mapJoinRequestServerToClientModel", async () => {
const mapUser = {
displayName: "test_displayName",
};
const map = {
user: {
id: "5",
get: (s: string) => mapUser[s],
} as unknown as Parse.Object,
board: {id: "5"} as unknown as Parse.Object,
status: "pending",
};
const serverModel = {
id: "5",
get: (s: string) => map[s],
} as unknown as JoinRequestServerModel;
const clientModel: JoinRequestClientModel = mapJoinRequestServerToClientModel(serverModel);
expect(clientModel.id).toEqual(serverModel.id);
expect(clientModel.userId).toEqual(serverModel.get("user").id);
expect(clientModel.boardId).toEqual(serverModel.get("board").id);
expect(clientModel.status).toEqual(serverModel.get("status"));
expect(clientModel.displayName).toEqual(serverModel.get("user").get("displayName"));
});
});
|
Accessible-Concepts/scrumlr.io
|
server/src/types/user.ts
|
<reponame>Accessible-Concepts/scrumlr.io
export type UserConfigurations = {
[userId: string]: {
showHiddenColumns: boolean;
};
};
|
Accessible-Concepts/scrumlr.io
|
src/store/reducer/vote.ts
|
import {VoteClientModel} from "types/vote";
import {ActionType, ReduxAction} from "store/action";
import Parse from "parse";
// eslint-disable-next-line default-param-last
export const voteReducer = (state: VoteClientModel[] = [], action: ReduxAction): VoteClientModel[] => {
switch (action.type) {
case ActionType.CreatedVote: {
const newState = [...state];
const foundExistingVoteIndex = newState.findIndex(
(vote) => !vote.id && vote.note === action.vote.note && vote.user === action.vote.user && vote.votingIteration === action.vote.votingIteration
);
if (foundExistingVoteIndex >= 0) {
newState.splice(foundExistingVoteIndex, 1, action.vote);
} else {
newState.push(action.vote);
}
return newState;
}
case ActionType.AddVote: {
const localVote: VoteClientModel = {
note: action.note,
board: action.boardId,
user: Parse.User.current()!.id,
votingIteration: action.votingIteration,
};
return [...state, localVote];
}
case ActionType.DeletedVote: {
return state.filter((vote) => vote.id !== action.voteId);
}
case ActionType.InitializeVotes: {
return [...action.votes];
}
default: {
return state;
}
}
};
|
Accessible-Concepts/scrumlr.io
|
src/utils/Toast.tsx
|
<reponame>Accessible-Concepts/scrumlr.io<gh_stars>10-100
import {toast, ToastOptions} from "react-toastify";
import "react-toastify/dist/ReactToastify.css";
const toastConfig: ToastOptions = {
position: "bottom-right",
autoClose: 3000,
hideProgressBar: true,
closeOnClick: true,
};
/**
* Display success message via toast.
*
* @param text Success message.
*/
function success(text: string) {
toast.success(text, toastConfig);
}
/**
* Display error message via toast.
*
* @param text Error message.
*/
function error(text: string) {
toast.error(text, toastConfig);
}
export const Toast = {
success,
error,
};
|
Accessible-Concepts/scrumlr.io
|
src/components/NoteInput/__tests__/NoteInput.test.tsx
|
import {fireEvent, render} from "testUtils";
import {NoteInput} from "components/NoteInput";
import store from "store";
import {ActionFactory} from "store/action";
const createNoteInput = (columnId: string, maxNoteLength: number) => <NoteInput columnId={columnId} maxNoteLength={maxNoteLength} />;
jest.mock("store", () => ({
...jest.requireActual("store"),
dispatch: jest.fn(),
}));
describe("Note Input", () => {
beforeEach(() => {
window.IntersectionObserver = jest.fn(
() =>
({
observe: jest.fn(),
disconnect: jest.fn(),
} as unknown as IntersectionObserver)
);
});
test("should render correctly", () => {
const {container} = render(createNoteInput("TestID", 1024));
expect(container.firstChild).toMatchSnapshot();
});
test("note length", () => {
const {container} = render(createNoteInput("TestID", 5));
// less works as expected
fireEvent.change(container.querySelector(".note-input__input")!, {target: {value: "1234"}});
fireEvent.keyDown(container.querySelector(".note-input__input")!, {key: "Enter", code: "Enter", charCode: 13});
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.addNote("TestID", "1234"));
// Exact works as expected
fireEvent.change(container.querySelector(".note-input__input")!, {target: {value: "12345"}});
fireEvent.keyDown(container.querySelector(".note-input__input")!, {key: "Enter", code: "Enter", charCode: 13});
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.addNote("TestID", "12345"));
// More than the limit works as expected
fireEvent.change(container.querySelector(".note-input__input")!, {target: {value: "123456"}});
fireEvent.keyDown(container.querySelector(".note-input__input")!, {key: "Enter", code: "Enter", charCode: 13});
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.addNote("TestID", "12345"));
});
});
|
Accessible-Concepts/scrumlr.io
|
src/components/LoginProviders/LoginProviders.tsx
|
import {AuthenticationManager} from "utils/authentication/AuthenticationManager";
import {useTranslation} from "react-i18next";
import {ReactComponent as GoogleIcon} from "assets/icon-google.svg";
import {ReactComponent as GitHubIcon} from "assets/icon-github.svg";
import {ReactComponent as MicrosoftIcon} from "assets/icon-microsoft.svg";
import "./LoginProviders.scss";
import {Button} from "../Button";
export interface LoginProvidersProps {
originURL?: string;
}
// TODO: Include after deployment: <button onClick={() => AuthenticationManager.signInWithAuthProvider("apple")}>Sign in with Apple</button>
export const LoginProviders = ({originURL = window.location.href}) => {
const {t} = useTranslation();
const signIn = (provider: string) => async () => {
await AuthenticationManager.signInWithAuthProvider(provider, originURL);
};
return (
<div className="login-providers">
<Button id="google" className="login-providers__button" onClick={signIn("google")} leftIcon={<GoogleIcon className="login-providers__icon" />}>
{t("LoginProviders.signInWithGoogle")}
</Button>
<Button id="github" className="login-providers__button" onClick={signIn("github")} leftIcon={<GitHubIcon className="login-providers__icon" />} hideLabel>
{t("LoginProviders.signInWithGitHub")}
</Button>
<Button id="microsoft" className="login-providers__button" onClick={signIn("microsoft")} leftIcon={<MicrosoftIcon className="login-providers__icon" />} hideLabel>
{t("LoginProviders.signInWithMicrosoft")}
</Button>
</div>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/utils/authentication/__tests__/authentification.test.ts
|
import {waitFor} from "@testing-library/react";
import {mocked} from "ts-jest/utils";
import {Attributes, User} from "parse";
import {API} from "api";
import {AuthenticationManager} from "../AuthenticationManager";
jest.mock("parse");
jest.mock("api");
const mockedUser = mocked(User, true);
const mockedSignIn = mocked(API.signIn);
describe("AuthenticationManager", () => {
test("signInAnonymously", async () => {
const user = {
linkWith: jest.fn().mockReturnValue(Promise.resolve(true)),
set: jest.fn(),
};
mockedUser.mockImplementation(() => user as unknown as User<Attributes>);
const result = await AuthenticationManager.signInAnonymously("test", "url");
waitFor(() => {
expect(result).toEqual(true);
expect(user.set).toBeCalledWith("displayName", "test");
expect(user.set).toBeCalledWith("photoURL", "url");
});
});
test("signInAnonymouslyWithError", async () => {
const user = {
linkWith: jest.fn().mockImplementation(() => {
throw new Error("Something bad happened");
}),
set: jest.fn(),
};
mockedUser.mockImplementation(() => user as unknown as User<Attributes>);
expect(await AuthenticationManager.signInAnonymously("test", "url")).toBeNull();
});
test("signInWithAuthProvider", async () => {
const url = "http://localhost/";
mockedSignIn.mockImplementation((authProvider: string, originURL: string) => originURL);
await AuthenticationManager.signInWithAuthProvider("test", url);
await waitFor(() => {
expect(mockedSignIn).toBeCalledTimes(1);
expect(mockedSignIn).toBeCalledWith("test", url);
expect(window.location.href).toEqual(url);
});
});
});
|
Accessible-Concepts/scrumlr.io
|
src/components/BoardHeader/HeaderMenu/BoardOptions/index.ts
|
import {ShowAuthorOption} from "./ShowAuthorOption";
import {ShowHiddenColumnsOption} from "./ShowHiddenColumnsOption";
import {DeleteBoardOption} from "./DeleteBoardOption";
import {ExportBoardOption} from "./ExportBoardOption";
import {ShowOtherUsersNotesOption} from "./ShowOtherUsersNotesOption";
import {ShareQrCodeOption} from "./ShareQrCodeOption";
export const BoardOption = {
ShowAuthorOption,
ShowHiddenColumnsOption,
DeleteBoardOption,
ExportBoardOption,
ShowOtherUsersNotesOption,
ShareQrCodeOption,
};
|
Accessible-Concepts/scrumlr.io
|
src/routes/Homepage/InovexAnchor/InovexAnchor.tsx
|
<gh_stars>10-100
import {FC} from "react";
import InovexLogo from "assets/icon-inovex.svg";
import "./InovexAnchor.scss";
export const InovexAnchor: FC = ({children}) => (
<a href="https://www.inovex.de/" target="_blank" className="inovex-anchor" rel="noreferrer">
<img src={InovexLogo} className="inovex-anchor__logo" alt="inovex" />
{children}
</a>
);
|
Accessible-Concepts/scrumlr.io
|
src/__tests__/locales.test.ts
|
<filename>src/__tests__/locales.test.ts
import fs from "fs";
import {join} from "path";
describe("locales", () => {
const translation = JSON.parse(fs.readFileSync(join(__dirname, "../../public/locales/en/translation.json")).toString());
fs.readdirSync(join(__dirname, "../../public/locales/"))
.filter((dir) => dir !== "en")
.forEach((languageCode) => {
const anotherTranslation = JSON.parse(fs.readFileSync(join(__dirname, "../../public/locales/", languageCode, "translation.json")).toString());
const keys = Object.keys(translation);
keys.forEach((key) => {
test(`key '${key}' should be defined for lang '${languageCode}' in translation`, () => {
expect(anotherTranslation[key]).toBeDefined();
});
});
keys.forEach((key) => {
test(`keys for key '${key}' should be complete for lang '${languageCode}'`, () => {
expect(Object.keys(translation[key])).toEqual(Object.keys(anotherTranslation[key]));
});
});
});
});
|
Accessible-Concepts/scrumlr.io
|
src/store/reducer/note.ts
|
<reponame>Accessible-Concepts/scrumlr.io
import Parse from "parse";
import {NoteClientModel} from "types/note";
import {ActionType, ReduxAction} from "store/action";
// eslint-disable-next-line default-param-last
export const noteReducer = (state: NoteClientModel[] = [], action: ReduxAction): NoteClientModel[] => {
switch (action.type) {
case ActionType.AddNote: {
const localNote: NoteClientModel = {
columnId: action.columnId,
text: action.text,
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
author: Parse.User.current()!.id,
focus: false,
dirty: true,
positionInStack: -1,
};
return [...state, localNote];
}
case ActionType.CreatedNote: {
const newState = [...state];
const foundExistingNoteIndex = newState.findIndex((note) => !note.id && note.text === action.note.text);
if (foundExistingNoteIndex >= 0) {
newState.splice(foundExistingNoteIndex, 1, action.note);
} else {
newState.push(action.note);
}
return newState;
}
case ActionType.DeleteNote: {
return state.filter((note) => note.id !== action.noteId);
}
case ActionType.EditNote: {
const noteIndex = state.findIndex((note) => note.id === action.note.id);
const newState: NoteClientModel[] = state;
newState.splice(noteIndex, 1, {
...state[noteIndex],
...action.note,
dirty: true,
});
return newState;
}
case ActionType.UpdatedNote: {
const noteIndex = state.findIndex((note) => note.id === action.note.id);
if (noteIndex >= 0) {
const newState = [...state];
newState.splice(noteIndex, 1, action.note);
return newState;
}
return state;
}
case ActionType.DragNote: {
const dragedOn = state.find((note) => note.id === action.note.dragOnId);
const note = state.find((noteInList) => noteInList.id === action.note.id);
const childNotes = (state.filter((noteInList) => noteInList.parentId === action.note.id) as NoteClientModel[]) ?? [];
if (dragedOn) {
const childNotesDragedOn = (state.filter((noteInList) => noteInList.parentId === action.note.dragOnId) as NoteClientModel[]) ?? [];
dragedOn!.parentId = action.note.id;
dragedOn!.positionInStack = childNotes.length + 1;
childNotesDragedOn
.sort((a, b) => a.positionInStack - b.positionInStack)
.forEach((child, index) => {
child.parentId = action.note.id;
child.positionInStack = index + childNotes.length + 2;
});
note!.positionInStack = 0;
}
if (action.note.columnId) {
note!.columnId = action.note.columnId;
childNotes.forEach((childNote) => {
childNote.columnId = action.note.columnId!;
});
}
return state;
}
case ActionType.UnstackNote: {
const unstack = state.find((note) => note.id === action.note.id);
unstack!.parentId = undefined;
unstack!.positionInStack = -1;
const childNotes = (state.filter((note) => note.parentId === action.note.parentId) as NoteClientModel[]) ?? [];
if (childNotes.length === 0) {
const parent = state.find((note) => note.id === action.note.parentId);
parent!.positionInStack = -1;
}
return state;
}
case ActionType.InitializeNotes: {
return [...action.notes];
}
default: {
return state;
}
}
};
|
Accessible-Concepts/scrumlr.io
|
src/store/reducer/__tests__/vote.test.ts
|
<reponame>Accessible-Concepts/scrumlr.io
import {ApplicationState} from "types/store";
import {VoteClientModel} from "types/vote";
import {voteReducer} from "store/reducer/vote";
import {ActionFactory} from "store/action";
describe("vote reducer", () => {
let initialState: ApplicationState;
beforeEach(() => {
initialState = {
voteConfiguration: {boardId: "test_board", votingIteration: 0, voteLimit: 0, allowMultipleVotesPerNote: false, showVotesOfOtherUsers: true},
board: {status: "unknown"},
users: {admins: [], basic: [], all: [], usersMarkedReady: []},
notes: [],
votes: [],
joinRequests: [],
};
});
test("create vote", () => {
const vote = {
id: "test_id",
board: "test_board",
note: "test_note",
user: "test_user",
votingIteration: 1,
} as VoteClientModel;
const newState = voteReducer(initialState.votes, ActionFactory.createdVote(vote));
expect(newState).toEqual([vote]);
});
test("delete vote", () => {
const vote = {
id: "test_id",
board: "test_board",
note: "test_note",
user: "test_user",
votingIteration: 1,
} as VoteClientModel;
let newState = voteReducer(initialState.votes, ActionFactory.createdVote(vote));
expect(newState).toEqual([vote]);
newState = voteReducer(initialState.votes, ActionFactory.deletedVote("test_id"));
expect(newState).toEqual([]);
});
test("initialize votes", () => {
const vote = {
id: "test_id",
board: "test_board",
note: "test_note",
user: "test_user",
votingIteration: 1,
} as VoteClientModel;
const newState = voteReducer(initialState.votes, ActionFactory.initializeVotes([vote, vote]));
expect(newState).toEqual([vote, vote]);
});
});
|
Accessible-Concepts/scrumlr.io
|
src/store/middleware/users.ts
|
<gh_stars>0
import {AnyAction, Dispatch, MiddlewareAPI} from "redux";
import {ApplicationState} from "types/store";
import {API} from "api";
import Parse from "parse";
import {Toast} from "utils/Toast";
import {ActionType, ReduxAction} from "../action";
export const passUsersMiddleware = (stateAPI: MiddlewareAPI<Dispatch<AnyAction>, ApplicationState>, dispatch: Dispatch, action: ReduxAction) => {
if (action.type === ActionType.ChangePermission) {
const boardId = stateAPI.getState().board.data!.id;
API.changePermission(action.userId, boardId, action.moderator);
} else if (action.type === ActionType.EditUserConfiguration) {
const boardId = stateAPI.getState().board.data!.id;
API.editUserConfiguration(boardId, action.userConfigurationRequest);
} else if (action.type === ActionType.SetUserReadyStatus) {
const boardId = stateAPI.getState().board.data!.id;
API.setReadyStatus(boardId, action.ready);
} else if (action.type === ActionType.SetRaisedHandStatus) {
const boardId = stateAPI.getState().board.data!.id;
API.setRaisedHandStatus(boardId, action.configuration);
} else if (action.type === ActionType.UpdatedBoard) {
const onlineUsers = stateAPI.getState().users.all.filter((user) => user.online === true);
if (onlineUsers.length > 1) {
const unreadyUsers = onlineUsers.filter((user) => user.ready === false);
if (unreadyUsers.length === 1 && unreadyUsers[0].id === Parse.User.current()!.id) {
Toast.error(`You are the last one not ready yet, hurry-up!`);
}
}
}
};
|
Accessible-Concepts/scrumlr.io
|
src/store/action/__tests__/users.test.ts
|
import {UsersActionFactory, UsersActionType, UsersReduxAction} from "store/action/users";
import {ReduxAction} from "store/action";
import {EditUserConfigurationRequest, UserClientModel, UserServerModel} from "types/user";
import {AssertTypeEqual} from "testUtils";
describe("users actions", () => {
test("equal number of action types and factory functions", () => {
expect(Object.keys(UsersActionType).length).toEqual(Object.keys(UsersActionFactory).length);
});
describe("set users", () => {
test("type is listed in users redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.setUsers>, UsersReduxAction> = true;
expect(assertion).toBe(true);
});
test("type is listed in general redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.setUsers>, ReduxAction> = true;
expect(assertion).toBe(true);
});
test("created action", () => {
const user: UserClientModel = {
id: "id",
displayName: "<NAME>",
admin: true,
updatedAt: new Date("2020-11-30"),
createdAt: new Date("2020-11-30"),
ready: true,
online: false,
};
const action = UsersActionFactory.setUsers([user], true);
expect(action).toEqual({
type: "@@SCRUMLR/setUsers",
users: [user],
admin: true,
});
});
});
describe("set user status", () => {
test("type is listed in users redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.setUserStatus>, UsersReduxAction> = true;
expect(assertion).toBe(true);
});
test("type is listed in general redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.setUserStatus>, ReduxAction> = true;
expect(assertion).toBe(true);
});
test("created action", () => {
const user: UserClientModel = {
id: "id",
displayName: "<NAME>",
admin: true,
updatedAt: new Date("2020-11-30"),
createdAt: new Date("2020-11-30"),
ready: true,
online: false,
};
const action = UsersActionFactory.setUserStatus(user.id, true);
expect(action).toEqual({
type: "@@SCRUMLR/setUserStatus",
userId: user.id,
status: true,
});
});
});
describe("set user ready status", () => {
test("type is listed in users redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.setUserReadyStatus>, UsersReduxAction> = true;
expect(assertion).toBe(true);
});
test("type is listed in general redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.setUserReadyStatus>, ReduxAction> = true;
expect(assertion).toBe(true);
});
test("created action", () => {
const action = UsersActionFactory.setUserReadyStatus(true);
expect(action).toEqual({
type: "@@SCRUMLR/setUserReadyStatus",
ready: true,
});
});
});
describe("set raised hand status", () => {
test("type is listed in users redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.setRaisedHandStatus>, UsersReduxAction> = true;
expect(assertion).toBe(true);
});
test("type is listed in general redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.setRaisedHandStatus>, ReduxAction> = true;
expect(assertion).toBe(true);
});
test("created action", () => {
const action = UsersActionFactory.setRaisedHandStatus({userId: ["1234"], raisedHand: true});
expect(action).toEqual({
type: "@@SCRUMLR/setRaisedHandStatus",
configuration: {
userId: ["1234"],
raisedHand: true,
},
});
});
});
describe("update user", () => {
test("type is listed in users redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.updateUser>, UsersReduxAction> = true;
expect(assertion).toBe(true);
});
test("type is listed in general redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.updateUser>, ReduxAction> = true;
expect(assertion).toBe(true);
});
test("created action", () => {
const user: UserServerModel = {
objectId: "id",
displayName: "<NAME>",
updatedAt: new Date("2020-11-30"),
createdAt: new Date("2020-11-30"),
};
const action = UsersActionFactory.updateUser(user);
expect(action).toEqual({
type: "@@SCRUMLR/updateUser",
user,
});
});
});
describe("change permission", () => {
test("type is listed in users redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.changePermission>, UsersReduxAction> = true;
expect(assertion).toBe(true);
});
test("type is listed in general redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.changePermission>, ReduxAction> = true;
expect(assertion).toBe(true);
});
test("created action", () => {
const action = UsersActionFactory.changePermission("id", false);
expect(action).toEqual({
type: "@@SCRUMLR/changePermission",
userId: "id",
moderator: false,
});
});
});
describe("edit user configuration", () => {
test("type is listed in users redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.editUserConfiguration>, UsersReduxAction> = true;
expect(assertion).toBe(true);
});
test("type is listed in general redux actions", () => {
// testing type equality here will not report an error at runtime but cause problems with typescript
const assertion: AssertTypeEqual<ReturnType<typeof UsersActionFactory.editUserConfiguration>, ReduxAction> = true;
expect(assertion).toBe(true);
});
test("created action", () => {
const request: EditUserConfigurationRequest = {showHiddenColumns: true};
const action = UsersActionFactory.editUserConfiguration(request);
expect(action).toEqual({
type: "@@SCRUMLR/editUserConfiguration",
userConfigurationRequest: {
showHiddenColumns: true,
},
});
});
});
});
|
Accessible-Concepts/scrumlr.io
|
src/components/BoardHeader/HeaderMenu/BoardOptions/DeleteBoardOption.tsx
|
import store, {useAppSelector} from "store";
import {ApplicationState} from "types/store";
import {ActionFactory} from "store/action";
import {ReactComponent as DeleteIcon} from "assets/icon-delete.svg";
import "../BoardSettings/BoardSettings.scss";
import classNames from "classnames";
import {TabIndex} from "constants/tabIndex";
import {useTranslation} from "react-i18next";
import {BoardOption} from "./BoardOption";
import {BoardOptionButton} from "./BoardOptionButton";
import "./DeleteBoardOption.scss";
export type DeleteProps = {
onClick: () => void;
expand: boolean;
};
export const DeleteBoardOption = (props: DeleteProps) => {
const {t} = useTranslation();
const state = useAppSelector((applicationState: ApplicationState) => ({
board: applicationState.board.data!,
}));
return (
<BoardOption data-testid="delete">
<BoardOptionButton label={t("DeleteBoardOption.button")} icon={DeleteIcon} isExpandable onClick={props.onClick} />
<div className={classNames("delete-board-option__container", {"delete-board-option__container--visible": props.expand})}>
<label className="delete-board-option__warning-label">{t("DeleteBoardOption.warning")}</label>
<button
className="delete-board-option__delete-board"
onClick={() => store.dispatch(ActionFactory.deleteBoard(state.board!.id))}
tabIndex={props.expand ? TabIndex.default : TabIndex.disabled}
>
{t("DeleteBoardOption.button")}
</button>
</div>
</BoardOption>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/api/index.ts
|
<gh_stars>10-100
import {AuthAPI} from "api/auth";
import {BoardAPI} from "api/board";
import {NoteAPI} from "api/note";
import {ColumnAPI} from "api/column";
import {VoteAPI} from "api/vote";
import {VoteConfigurationAPI} from "api/voteConfiguration";
import {UserAPI} from "api/user";
/** This class lists all API functions of the server. */
export const API = {
...AuthAPI,
...BoardAPI,
...ColumnAPI,
...NoteAPI,
...UserAPI,
...VoteAPI,
...VoteConfigurationAPI,
};
|
Accessible-Concepts/scrumlr.io
|
src/components/CookieNotice/CookiePolicy.tsx
|
import "./CookiePolicy.scss";
import {Portal} from "components/Portal";
import {useTranslation} from "react-i18next";
import {marked} from "marked";
interface CookiePolicyProps {
decline: () => void;
accept: () => void;
onClose: () => void;
show: boolean;
darkBackground: boolean;
}
export const CookiePolicy = ({decline, accept, onClose, show, darkBackground}: CookiePolicyProps) => {
const {t} = useTranslation();
if (!show) {
return null;
}
const body = marked.parse(t("CookiePolicy.body") as string);
return (
<Portal onClose={onClose} darkBackground={darkBackground}>
<div className="cookie-policy">
<div className="cookie-policy__title">
<h1>{t("CookiePolicy.title")}</h1>
</div>
<div
className="cookie-policy__body"
// eslint-disable-next-line react/no-danger
dangerouslySetInnerHTML={{__html: body}}
/>
<div className="cookie-policy__footer">
<button className="cookie-policy__button-decline" type="button" onClick={decline}>
{t("CookiePolicy.decline")}
</button>
<button className="cookie-policy__button-accept" type="button" onClick={accept}>
{t("CookiePolicy.accept")}
</button>
</div>
</div>
</Portal>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/components/Note/__tests__/Note.test.tsx
|
import {fireEvent} from "@testing-library/react";
import {Note} from "components/Note";
import {User} from "parse";
import {wrapWithTestBackend} from "react-dnd-test-utils";
import {Provider} from "react-redux";
import configureStore from "redux-mock-store";
import store from "store";
import {ActionFactory} from "store/action";
import {mocked} from "ts-jest/utils";
import {VoteClientModel} from "types/vote";
import {render} from "testUtils";
const mockStore = configureStore();
const mockedUser = mocked(User, true);
jest.mock("store", () => ({
...jest.requireActual("store"),
dispatch: jest.fn(),
}));
type TestProps = {
text: string;
authorId: string;
showAuthors: boolean;
votes: VoteClientModel[];
focus: boolean;
moderation: {userId: string; status: boolean};
currentUserIsModerator: boolean;
};
const defaultVotes = [
{
id: "test-vote-0",
board: "test-board",
note: "test-id",
user: "test-user-1",
votingIteration: 1,
},
{
id: "test-vote-1",
board: "test-board",
note: "test-id",
user: "test-user-2",
votingIteration: 1,
},
{
id: "test-vote-2",
board: "test-board",
note: "test-id",
user: "test-user-2",
votingIteration: 1,
},
];
const createNote = (props: Partial<TestProps>) => {
const initialState = {
board: {
data: {
columns: [{id: "test_column", name: "test_header", hidden: false}],
},
},
notes: [],
users: {
admins: [
{
id: "jkKqOUgt3hEDvl7CWcBokVOGs6AzINon",
displayName: "<NAME>",
admin: true,
createdAt: "2021-08-11T10:45:41.640Z",
updatedAt: "2021-08-11T10:52:21.558Z",
online: true,
},
],
basic: [],
all: [],
},
voteConfiguration: {
voteLimit: 10,
},
};
const mockedStore = mockStore(initialState);
const [NoteContext] = wrapWithTestBackend(Note);
return (
<Provider store={mockedStore}>
<NoteContext
key=""
noteId="0"
text={props.text || "Test Text"}
authorId={props.authorId || "Test Author"}
columnId=""
columnName=""
columnColor=""
activeVoting
showAuthors={props.showAuthors || false}
votes={props.votes || defaultVotes}
allVotesOfUser={[]}
childrenNotes={[
{id: "1", columnId: "test_column", text: "", author: "", parentId: "0", dirty: true, authorName: "", votes: [], focus: false, positionInStack: 0},
{id: "2", columnId: "test_column", text: "", author: "", parentId: "0", dirty: true, authorName: "", votes: [], focus: false, positionInStack: 0},
]}
authorName=""
activeModeration={props.moderation || {userId: "Test Author", status: false}}
focus={props.focus || false}
currentUserIsModerator={props.currentUserIsModerator || false}
/>
</Provider>
);
};
describe("Note", () => {
beforeEach(() => {
window.IntersectionObserver = jest.fn(
() =>
({
observe: jest.fn(),
disconnect: jest.fn(),
} as unknown as IntersectionObserver)
);
});
describe("should render correctly", () => {
beforeEach(() => {
mockedUser.current = jest.fn(() => ({id: "Test Author"} as never));
});
test("note__root is present", () => {
const {container} = render(createNote({showAuthors: true}));
expect(container.firstChild).toHaveClass("note__root");
});
test("note is present", () => {
const {container} = render(createNote({showAuthors: true}));
expect(container.querySelector(".note__root")!.firstChild).toHaveClass("note");
});
test("note--own-card is present", () => {
const {container} = render(createNote({showAuthors: true}));
expect(container.querySelector(".note__root")!.firstChild).toHaveClass("note--own-card");
});
test("note--own-card is not present", () => {
const {container} = render(createNote({showAuthors: true, authorId: "Test Author 2"}));
expect(container.querySelector(".note__root")!.firstChild).not.toHaveClass("note--own-card");
});
test("note content is present", () => {
const {container} = render(createNote({showAuthors: true}));
expect(container.querySelector(".note")?.firstChild).toHaveClass("note__content");
});
test("note text is present", () => {
const {container} = render(createNote({showAuthors: true}));
expect(container.querySelector(".note__content")?.firstChild).toHaveClass("note__text");
});
test("note text has correct text", () => {
const {container} = render(createNote({showAuthors: true}));
expect(container.firstChild).toHaveTextContent("Test Text");
});
test("note footer is present", () => {
const {container} = render(createNote({showAuthors: true}));
expect(container.querySelector(".note")?.lastChild).toHaveClass("note__footer");
});
test("note author is present", () => {
const {container} = render(createNote({showAuthors: true}));
expect(container.querySelector(".note__footer")?.firstChild).toHaveClass("note__author");
});
test("note author is hidden", () => {
const {container} = render(createNote({showAuthors: false}));
expect(container.querySelector(".note__footer")).not.toHaveClass("note__author");
});
test("note author name is present", () => {
const {container} = render(createNote({showAuthors: true}));
expect(container.querySelector(".note__author")?.lastChild).toHaveClass("note__author-name");
});
});
describe("should have correct style", () => {
test("show note with correct style", () => {
const {container} = render(createNote({showAuthors: true}));
expect(container.firstChild).toMatchSnapshot();
});
});
describe("should have note in stack", () => {
test("check div with class name note__in-stack", () => {
const {container} = render(createNote({showAuthors: true}));
expect(container.querySelector(".note__root")!.lastChild).toHaveClass("note__in-stack");
});
});
describe("Test amount of visible votes", () => {
test("test-user-1 has one vote during vote phase", () => {
mockedUser.current = jest.fn(() => ({id: "test-user-1"} as never));
const {container} = render(createNote({showAuthors: true, authorId: "test-user-1"}));
expect((container.querySelector(".dot-button")?.lastChild as HTMLSpanElement).innerHTML).toEqual("3");
});
test("test-user-2 has two votes during vote phase", () => {
mockedUser.current = jest.fn(() => ({id: "test-user-2"} as never));
const {container} = render(createNote({showAuthors: true, authorId: "test-user-2"}));
expect((container.querySelector(".dot-button")?.lastChild as HTMLSpanElement).innerHTML).toEqual("3");
});
test("test-user-1 can see three votes", () => {
mockedUser.current = jest.fn(() => ({id: "test-user-1"} as never));
const {container} = render(createNote({showAuthors: true, authorId: "test-user-1"}));
expect((container.querySelector(".dot-button")?.lastChild as HTMLSpanElement).innerHTML).toEqual("3");
});
test("test-user-2 can see three votes", () => {
mockedUser.current = jest.fn(() => ({id: "test-user-2"} as never));
const {container} = render(createNote({showAuthors: true, authorId: "test-user-2"}));
expect((container.querySelector(".dot-button")?.lastChild as HTMLSpanElement).innerHTML).toEqual("3");
});
});
describe("Test NoteDialog created/not created", () => {
beforeEach(() => {
const portal = global.document.createElement("div");
portal.setAttribute("id", "portal");
global.document.querySelector("body")!.appendChild(portal);
});
test("NoteDialog is present: snapshot", () => {
const {container} = render(createNote({showAuthors: true, focus: true, moderation: {userId: "Test Author", status: true}}), {
container: global.document.querySelector("#portal")!,
});
expect(container).toMatchSnapshot();
});
test("NoteDialog is present: class", () => {
const {container} = render(createNote({showAuthors: true, focus: true, moderation: {userId: "Test Author", status: true}}), {
container: global.document.querySelector("#portal")!,
});
expect(container.querySelector(".note-dialog")).not.toBeNull();
});
test("NoteDialog is not present: snapshot", () => {
const {container} = render(createNote({showAuthors: true}), {
container: global.document.querySelector("#portal")!,
});
expect(container).toMatchSnapshot();
});
test("NoteDialog isn't present: class", () => {
const {container} = render(createNote({showAuthors: true}), {
container: global.document.querySelector("#portal")!,
});
expect(container.querySelector(".note-dialog")).toBeNull();
});
});
describe("note clicked during moderation phase", () => {
beforeEach(() => {
const portal = global.document.createElement("div");
portal.setAttribute("id", "portal");
global.document.querySelector("body")!.appendChild(portal);
});
test("Note should be focused", () => {
mockedUser.current = jest.fn(() => ({id: "Test Author"} as never));
const {container} = render(createNote({showAuthors: true, focus: false, moderation: {userId: "Test Author", status: true}, currentUserIsModerator: true}));
fireEvent.click(container.querySelector(".note__root")!);
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.editNote({id: "0", focus: true}));
});
test("Note shouldn't be focused", () => {
const {container} = render(createNote({showAuthors: true, focus: true, moderation: {userId: "Test Author", status: true}, currentUserIsModerator: false}));
fireEvent.click(container.querySelector(".note__root")!);
expect(store.dispatch).not.toBeCalled();
});
});
});
|
Accessible-Concepts/scrumlr.io
|
src/i18nTest.ts
|
import {join} from "path";
import i18n from "i18next";
import {initReactI18next} from "react-i18next";
import Backend from "i18next-fs-backend";
i18n
.use(Backend)
.use(initReactI18next)
.init({
backend: {
loadPath: join(__dirname, "../public/locales/en/translation.json"),
},
initImmediate: false,
lng: "en",
debug: false,
react: {
useSuspense: false,
wait: false,
},
});
export default i18n;
|
Accessible-Concepts/scrumlr.io
|
src/components/PassphraseDialog/__tests__/PassphraseDialog.test.tsx
|
<gh_stars>10-100
import {fireEvent, waitFor} from "@testing-library/react";
import {render} from "testUtils";
import {PassphraseDialog} from "../PassphraseDialog";
describe("<PassphraseDialog />", () => {
test("snapshot test", () => {
const {container} = render(<PassphraseDialog onSubmit={jest.fn()} />);
expect(container.firstChild).toMatchSnapshot();
});
describe("passphrase input", () => {
test("submit is disabled while passphrase is empty", () => {
const {container} = render(<PassphraseDialog onSubmit={jest.fn()} />);
expect(container.querySelector(".passphrase-dialog__submit-button")!.hasAttribute("disabled")).toBeTruthy();
});
test("submit is available if passphrase is set", async () => {
const {container} = render(<PassphraseDialog onSubmit={jest.fn()} />);
fireEvent.change(container.querySelector("#password-dialog__password")!, {target: {value: "1234"}});
await waitFor(() => {
expect(container.querySelector(".passphrase-dialog__submit-button")!.hasAttribute("disabled")).toBeFalsy();
});
});
});
describe("visibility toggle", () => {
test("passphrase is not visible in default state", () => {
const {container} = render(<PassphraseDialog onSubmit={jest.fn()} />);
expect(container.querySelector("#password-dialog__password")!.getAttribute("type")).toEqual("password");
});
test("passphrase is visible on visibility toggle", async () => {
const {container} = render(<PassphraseDialog onSubmit={jest.fn()} />);
fireEvent.click(container.querySelector('button[aria-label="Toggle passphrase visibility"]')!);
await waitFor(() => {
expect(container.querySelector("#password-dialog__password")!.getAttribute("type")).toEqual("text");
});
});
});
describe("manual verification hint", () => {
test("manual verification is visible", () => {
const {container} = render(<PassphraseDialog onSubmit={jest.fn()} />);
expect(container.querySelector(".passphrase-dialog__manual-verification")).toBeNull();
});
test("manual verification is not visible", () => {
const {container} = render(<PassphraseDialog onSubmit={jest.fn()} />);
expect(container.querySelector(".passphrase-dialog__manual-verification")).toBeDefined();
});
});
});
|
Accessible-Concepts/scrumlr.io
|
src/store/middleware/__tests__/users.test.ts
|
<gh_stars>0
import {ActionFactory} from "store/action";
import {API} from "api";
import {MiddlewareAPI} from "redux";
import {passUsersMiddleware} from "store/middleware/users";
import {Toast} from "utils/Toast";
import {BoardClientModel} from "types/board";
import {User} from "parse";
import {mocked} from "ts-jest/utils";
const stateAPI = {
getState: () => ({
board: {
data: {
id: "boardId",
},
},
users: {
all: [
{
id: "1",
displayName: "<NAME>",
admin: true,
createdAt: new Date(),
updatedAt: new Date(),
ready: false,
online: true,
},
{
id: "2",
displayName: "<NAME>",
admin: false,
createdAt: new Date(),
updatedAt: new Date(),
ready: true,
online: true,
},
],
},
}),
};
jest.mock("parse");
jest.mock("api", () => ({
API: {
editUserConfiguration: jest.fn(),
setReadyStatus: jest.fn(),
setRaisedHandStatus: jest.fn(),
},
}));
const mockedUser = mocked(User, true);
describe("users middleware", () => {
test("edit user configurations", () => {
passUsersMiddleware(
stateAPI as MiddlewareAPI,
jest.fn(),
ActionFactory.editUserConfiguration({
showHiddenColumns: true,
})
);
expect(API.editUserConfiguration).toHaveBeenCalledWith("boardId", {
showHiddenColumns: true,
});
});
test("set user ready status", () => {
passUsersMiddleware(stateAPI as MiddlewareAPI, jest.fn(), ActionFactory.setUserReadyStatus(true));
expect(API.setReadyStatus).toHaveBeenCalledWith("boardId", true);
});
test("set raised hand status", () => {
passUsersMiddleware(stateAPI as MiddlewareAPI, jest.fn(), ActionFactory.setRaisedHandStatus({userId: [], raisedHand: false}));
expect(API.setRaisedHandStatus).toHaveBeenCalledWith("boardId", {userId: [], raisedHand: false});
});
test("last unready user gets hurry-up notification", () => {
const spy = jest.spyOn(Toast, "error");
mockedUser.current = jest.fn(() => ({id: "1"} as never));
passUsersMiddleware(stateAPI as MiddlewareAPI, jest.fn(), ActionFactory.updatedBoard({} as BoardClientModel));
expect(spy).toHaveBeenCalled();
});
});
|
Accessible-Concepts/scrumlr.io
|
src/store/reducer/__tests__/users.test.ts
|
<reponame>Accessible-Concepts/scrumlr.io<filename>src/store/reducer/__tests__/users.test.ts
import {UsersState} from "types/store";
import {usersReducer} from "store/reducer/users";
import {ActionFactory} from "store/action";
import {UserClientModel} from "types/user";
import {User} from "parse";
import {mocked} from "ts-jest/utils";
import {BoardClientModel} from "../../../types/board";
jest.mock("parse");
const mockedUser = mocked(User, true);
const createUser = (id: string, name: string, admin: boolean, ready = false): UserClientModel => ({
id,
displayName: name,
admin,
createdAt: new Date(),
updatedAt: new Date(),
ready,
online: true,
raisedHand: false,
});
describe("users reducer", () => {
let initialState: UsersState;
beforeEach(() => {
initialState = {
admins: [],
basic: [],
all: [],
usersMarkedReady: [],
usersRaisedHands: [],
};
});
test("add admins", () => {
const admin = createUser("1", "<NAME>", true);
const newState = usersReducer(initialState, ActionFactory.setUsers([admin], true));
expect(newState.admins).toEqual([admin]);
expect(newState.all).toEqual([admin]);
expect(newState.basic).toEqual([]);
});
test("add basic", () => {
const user = createUser("2", "<NAME>", false);
const newState = usersReducer(initialState, ActionFactory.setUsers([user], false));
expect(newState.basic).toEqual([user]);
expect(newState.all).toEqual([user]);
expect(newState.admins).toEqual([]);
});
test("merge admins and basic users", () => {
const admin = createUser("1", "<NAME>", true);
const user = createUser("2", "<NAME>", false);
const state1 = usersReducer(initialState, ActionFactory.setUsers([user], false));
const state2 = usersReducer(state1, ActionFactory.setUsers([admin], true));
expect(state2.admins).toEqual([admin]);
expect(state2.basic).toEqual([user]);
expect(state2.all).toContainEqual(admin);
expect(state2.all).toContainEqual(user);
});
test("set user status correctly offline/online", () => {
const user = createUser("1", "<NAME>", false);
const state1 = usersReducer(initialState, ActionFactory.setUsers([user], false));
expect(state1.all.find((u) => u.id === user.id)?.online).toBe(true);
const state2 = usersReducer(state1, ActionFactory.setUserStatus(user.id, false));
expect(state2.all.find((u) => u.id === user.id)?.online).toBe(false);
const state3 = usersReducer(state2, ActionFactory.setUserStatus(user.id, true));
expect(state3.all.find((u) => u.id === user.id)?.online).toBe(true);
});
describe("readiness of users", () => {
test("set user as ready", () => {
mockedUser.current = jest.fn(() => ({id: "1"} as never));
const user = createUser("1", "<NAME>", false, false);
const state1 = usersReducer(initialState, ActionFactory.setUsers([user], false));
expect(state1.usersMarkedReady).toHaveLength(0);
const state2 = usersReducer(state1, ActionFactory.setUserReadyStatus(true));
expect(state2.usersMarkedReady).toHaveLength(1);
expect(state2.all[0].ready).toBeTruthy();
});
test("updated board will update ready status of users", () => {
const user = createUser("1", "<NAME>", false, false);
const state1 = usersReducer(initialState, ActionFactory.setUsers([user], false));
expect(state1.usersMarkedReady).toHaveLength(0);
const state2 = usersReducer(
state1,
ActionFactory.updatedBoard({
usersMarkedReady: ["1"],
} as BoardClientModel)
);
expect(state2.usersMarkedReady).toHaveLength(1);
expect(state2.all[0].ready).toBeTruthy();
});
});
});
|
Accessible-Concepts/scrumlr.io
|
src/components/MenuBars/MenuItem/variants/ThemeToggleButton.tsx
|
import {useEffect, useState} from "react";
import classNames from "classnames";
import "../MenuItem.scss";
import {TabIndex} from "constants/tabIndex";
import {ReactComponent as LightMode} from "assets/icon-lightmode.svg";
import {ReactComponent as DarkMode} from "assets/icon-darkmode.svg";
import {useTranslation} from "react-i18next";
type ThemeToggleButtonProps = {
direction: "left" | "right";
disabled?: boolean;
tabIndex?: number;
};
export const ThemeToggleButton = (props: ThemeToggleButtonProps) => {
const [touchHover, setTouchHover] = useState(false);
const [theme, setTheme] = useState(document.documentElement.getAttribute("theme"));
const {t} = useTranslation();
useEffect(() => {
document.documentElement.setAttribute("theme", theme!);
localStorage.setItem("theme", theme!);
}, [theme]);
return (
<button
disabled={props.disabled}
className={classNames("menu-item", `menu-item--${props.direction}`, {
"menu-item--touch-hover": touchHover,
})}
onClick={() => {
if (document.getElementsByClassName("menu-item--touch-hover").length === 0) {
setTheme((prev) => (prev === "light" ? "dark" : "light"));
}
}}
onTouchEnd={(e) => {
if (!touchHover && document.getElementsByClassName("menu-item--touch-hover").length === 0) {
e.preventDefault();
window.addEventListener("click", () => setTouchHover(false), {once: true});
setTouchHover(true);
}
if (touchHover) {
e.preventDefault();
setTouchHover(false);
setTheme((prev) => (prev === "light" ? "dark" : "light"));
}
}}
tabIndex={props.tabIndex ?? TabIndex.default}
>
<div className="menu-item__tooltip">
<span className="tooltip__text">{t("MenuBars.themeToggle")}</span>
</div>
{theme === "light" && <DarkMode className="menu-item__icon" />}
{theme === "dark" && <LightMode className="menu-item__icon" />}
</button>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/store/middleware/__tests__/voteConfiguration.test.ts
|
import {passVoteConfigurationMiddlware} from "store/middleware/voteConfiguration";
import {ActionFactory} from "store/action";
import {API} from "api";
import {MiddlewareAPI} from "redux";
jest.mock("api", () => ({
API: {
addVoteConfiguration: jest.fn(),
},
}));
beforeEach(() => {
(API.addVoteConfiguration as jest.Mock).mockClear();
(API.addVoteConfiguration as jest.Mock).mockReturnValue({status: "Success"});
});
const stateAPI = {
getState: () => ({
board: {
data: {
id: "boardId",
},
},
}),
};
describe("voteConfiguration middleware", () => {
test("add voteConfiguration", () => {
passVoteConfigurationMiddlware(
stateAPI as MiddlewareAPI,
jest.fn(),
ActionFactory.addVoteConfiguration({
boardId: "boardId",
voteLimit: 5,
allowMultipleVotesPerNote: true,
showVotesOfOtherUsers: false,
})
);
expect(API.addVoteConfiguration).toHaveBeenCalledWith({
boardId: "boardId",
voteLimit: 5,
allowMultipleVotesPerNote: true,
showVotesOfOtherUsers: false,
});
});
});
|
Accessible-Concepts/scrumlr.io
|
src/store/action/index.ts
|
import {BoardActionFactory, BoardActionType, BoardReduxAction} from "./board";
import {NoteActionFactory, NoteActionType, NoteReduxAction} from "./note";
import {VoteActionFactory, VoteActionType, VoteReduxAction} from "./vote";
import {UsersActionFactory, UsersActionType, UsersReduxAction} from "./users";
import {ColumnActionFactory, ColumnActionType, ColumnReduxAction} from "./column";
import {JoinRequestActionFactory, JoinRequestActionType, JoinRequestReduxAction} from "./joinRequest";
import {VoteConfigurationActionFactory, VoteConfigurationActionType, VoteConfigurationReduxAction} from "./voteConfiguration";
/** This object lists all internal Redux Action types. */
export const ActionType = {
...BoardActionType,
...ColumnActionType,
...NoteActionType,
...UsersActionType,
...JoinRequestActionType,
...VoteActionType,
...VoteConfigurationActionType,
};
/** Factory or creator class of internal Redux actions. */
export const ActionFactory = {
...BoardActionFactory,
...ColumnActionFactory,
...NoteActionFactory,
...UsersActionFactory,
...JoinRequestActionFactory,
...VoteActionFactory,
...VoteConfigurationActionFactory,
};
/** The types of all application internal redux actions. */
export type ReduxAction = BoardReduxAction | ColumnReduxAction | NoteReduxAction | UsersReduxAction | JoinRequestReduxAction | VoteReduxAction | VoteConfigurationReduxAction;
|
Accessible-Concepts/scrumlr.io
|
src/store/reducer/board.ts
|
/* eslint-disable @typescript-eslint/no-non-null-assertion */
import isEqual from "lodash/isEqual";
import {BoardState} from "types/store";
import {ActionType, ReduxAction} from "store/action";
import {Toast} from "utils/Toast";
import i18n from "i18next";
// eslint-disable-next-line default-param-last
export const boardReducer = (state: BoardState = {status: "unknown"}, action: ReduxAction): BoardState => {
switch (action.type) {
case ActionType.InitializeBoard: {
return {
status: "ready",
data: action.board,
};
}
case ActionType.EditBoard: {
// Moderator started voting phase - notification to moderator (user who started the voting)
if (action.board.voting) {
Toast.success(i18n.t(action.board.voting === "active" ? "Toast.votingStarted" : "Toast.votingFinished"));
}
// Moderator started moderation phase - notification to moderator (user who started the moderation phase)
if (action.board.moderation) {
Toast.success(i18n.t(action.board.moderation.status === "active" ? "Toast.focusModeStart" : "Toast.focusModeFinished"));
}
return {
status: state.status,
data: {
...state.data!,
...action.board,
accessPolicy: (action.board.accessPolicy?.type || state.data?.accessPolicy)!,
dirty: true,
},
};
}
case ActionType.DeleteBoard: {
document.location.pathname = "/";
return state;
}
case ActionType.AddColumn: {
return {
status: state.status,
data: {
...state.data!,
columns: [
...state.data!.columns,
{
name: action.column.name,
color: action.column.color,
hidden: action.column.hidden,
},
],
dirty: true,
},
};
}
case ActionType.EditColumn: {
const newColumns = [...state.data!.columns];
const columnIndex = newColumns.findIndex((column) => column.columnId === action.column.columnId);
const column = newColumns[columnIndex];
newColumns.splice(columnIndex, 1, {
...column,
name: action.column.name || column.name,
color: action.column.color || column.color,
hidden: action.column.hidden === undefined ? column.hidden : action.column.hidden,
});
return {
status: state.status,
data: {
...state.data!,
columns: newColumns,
dirty: true,
},
};
}
case ActionType.DeleteColumn: {
const newColumns = [...state.data!.columns];
const columnIndex = newColumns.findIndex((column) => column.columnId === action.columnId);
newColumns.splice(columnIndex, 1);
return {
status: state.status,
data: {
...state.data!,
columns: newColumns,
dirty: true,
},
};
}
case ActionType.UpdatedBoard: {
// Voting notification
if (state.data?.voting !== action.board.voting) {
if (action.board.voting === "active") {
Toast.success(i18n.t("Toast.votingPhaseStarted"));
} else {
Toast.error(i18n.t("Toast.votingPhaseEnded"));
}
}
// Moderation notification
if (state.data?.moderation.status !== action.board.moderation.status) {
if (action.board.moderation.status === "active") {
Toast.success(i18n.t("Toast.moderationStarted"));
} else {
Toast.error(i18n.t("Toast.moderationEnded"));
}
}
// Timer notification
if (state.data?.timerUTCEndTime?.getTime() !== action.board.timerUTCEndTime?.getTime()) {
if (action.board.timerUTCEndTime) {
Toast.success(i18n.t("Toast.timerStarted"));
} else if (state.data!.timerUTCEndTime!.getTime() <= new Date().getTime()) {
Toast.error(i18n.t("Toast.timerEnded"));
} else {
Toast.error(i18n.t("Toast.timerCancelled"));
}
}
if (!state.data?.dirty) {
return {
status: state.status,
data: action.board,
};
}
const stateColumns = state.data.columns.map((column) => ({name: column.name, hidden: column.hidden})).sort((a, b) => a.name.localeCompare(b.name));
const actionColumns = action.board.columns.map((column) => ({name: column.name, hidden: column.hidden})).sort((a, b) => a.name.localeCompare(b.name));
const stateUserConfigurations = state.data.userConfigurations.map((user) => ({user: user.id})).sort((a, b) => a.user.localeCompare(b.user));
const actionUserConfigurations = action.board.userConfigurations.map((user) => ({user: user.id})).sort((a, b) => a.user.localeCompare(b.user));
// check if current model from server equals local copy
if (
(action.board.name === undefined || state.data.name === action.board.name) &&
(action.board.accessPolicy === undefined || state.data.accessPolicy === action.board.accessPolicy) &&
(action.board.encryptedContent === undefined || state.data.encryptedContent === action.board.encryptedContent) &&
(action.board.showAuthors === undefined || state.data.showAuthors === action.board.showAuthors) &&
(action.board.timerUTCEndTime === undefined || state.data.timerUTCEndTime === action.board.timerUTCEndTime) &&
(action.board.voting === undefined || state.data.voting === action.board.voting) &&
(action.board.showNotesOfOtherUsers === undefined || state.data.showNotesOfOtherUsers === action.board.showNotesOfOtherUsers) &&
isEqual(stateColumns, actionColumns) &&
isEqual(stateUserConfigurations, actionUserConfigurations)
) {
return {
status: state.status,
data: action.board,
};
}
return state;
}
case ActionType.PendingBoardAccessConfirmation:
case ActionType.JoinBoard: {
return {
status: "pending",
};
}
case ActionType.PermittedBoardAccess: {
return {
status: "accepted",
};
}
case ActionType.RejectedBoardAccess: {
return {
status: "rejected",
};
}
case ActionType.PassphraseChallengeRequired: {
return {
status: "passphrase_required",
};
}
case ActionType.IncorrectPassphrase: {
return {
status: "incorrect_passphrase",
};
}
default: {
return state;
}
}
};
|
Accessible-Concepts/scrumlr.io
|
src/components/TextInputAction/TextInputAction.tsx
|
import classNames from "classnames";
import {ButtonHTMLAttributes, DetailedHTMLProps, FC} from "react";
import "./TextInputAction.scss";
export interface TextInputActionProps extends DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement> {
title: string;
}
export const TextInputAction: FC<TextInputActionProps> = ({title, className, children, ...other}) => (
<button type="button" className={classNames("text-input-action", className)} aria-label={title} title={title} {...other}>
{children}
</button>
);
|
Accessible-Concepts/scrumlr.io
|
src/constants/tabIndex.ts
|
<filename>src/constants/tabIndex.ts<gh_stars>10-100
export enum TabIndex {
disabled = -1,
default = 0,
BoardHeader = 1,
Column = 200,
UserMenu = 300,
AdminMenu = 400,
Note = 500,
Timer = 5000,
}
|
Accessible-Concepts/scrumlr.io
|
src/routes/NewBoard/index.ts
|
<gh_stars>10-100
export * from "./NewBoard";
|
Accessible-Concepts/scrumlr.io
|
src/components/Infobar/index.ts
|
export * from "./Infobar";
|
Accessible-Concepts/scrumlr.io
|
src/components/LoginProviders/__tests__/LoginProviders.test.tsx
|
<reponame>Accessible-Concepts/scrumlr.io
import {fireEvent} from "@testing-library/react";
import {AuthenticationManager} from "utils/authentication/AuthenticationManager";
import {LoginProviders} from "components/LoginProviders";
import {render} from "testUtils";
describe("check for all provider buttons", () => {
test("google sign in", () => {
const {container} = render(<LoginProviders />);
expect(container.querySelector("#google")).toBeInTheDocument();
});
test("github sign in", () => {
const {container} = render(<LoginProviders />);
expect(container.querySelector("#github")).toBeInTheDocument();
});
test("microsoft sign in", () => {
const {container} = render(<LoginProviders />);
expect(container.querySelector("#microsoft")).toBeInTheDocument();
});
describe("click-handler", () => {
const signInSpy = jest.spyOn(AuthenticationManager, "signInWithAuthProvider");
test("google sign in", () => {
const {container} = render(<LoginProviders />);
const button = container.querySelector("#google");
fireEvent.click(button!);
expect(signInSpy).toHaveBeenCalledWith("google", expect.anything());
});
test("github sign in", () => {
const {container} = render(<LoginProviders />);
const button = container.querySelector("#github");
fireEvent.click(button!);
expect(signInSpy).toHaveBeenCalledWith("github", expect.anything());
});
test("microsoft sign in", () => {
const {container} = render(<LoginProviders />);
const button = container.querySelector("#microsoft");
fireEvent.click(button!);
expect(signInSpy).toHaveBeenCalledWith("microsoft", expect.anything());
});
});
});
|
Accessible-Concepts/scrumlr.io
|
src/store/reducer/__tests__/joinRequest.test.ts
|
<reponame>Accessible-Concepts/scrumlr.io
import {JoinRequestClientModel} from "types/joinRequest";
import {joinRequestReducer} from "store/reducer/joinRequest";
import {ActionFactory} from "store/action";
const createJoinRequest = (id: string): JoinRequestClientModel => ({
id,
boardId: "boardId",
userId: "userId",
status: "accepted",
displayName: "displayName",
});
describe("joinRequest reducer", () => {
let initialState: JoinRequestClientModel[];
beforeEach(() => {
initialState = [createJoinRequest("1"), createJoinRequest("2")];
});
test("createJoinRequest", () => {
const joinRequest = createJoinRequest("3");
const newState = joinRequestReducer(initialState, ActionFactory.createJoinRequest(joinRequest));
expect(newState.length).toEqual(3);
const newJoinRequest = newState.find((jr) => jr.id === "3");
expect(newJoinRequest?.boardId).toEqual("boardId");
expect(newJoinRequest?.userId).toEqual("userId");
expect(newJoinRequest?.status).toEqual("accepted");
});
test("updateJoinRequest", () => {
const updatedJoinRequest = createJoinRequest("1");
updatedJoinRequest.status = "rejected";
const newState = joinRequestReducer(initialState, ActionFactory.updateJoinRequest(updatedJoinRequest));
expect(newState.map((joinRequest) => joinRequest.status)).toEqual(["rejected", "accepted"]);
});
test("initializeJoinRequests", () => {
const state = joinRequestReducer([], ActionFactory.initializeJoinRequests(initialState));
expect(state).toEqual(initialState);
});
});
|
Accessible-Concepts/scrumlr.io
|
src/components/BoardHeader/HeaderMenu/__tests__/HeaderMenu.test.tsx
|
import {fireEvent, waitFor} from "@testing-library/react";
import {wrapWithTestBackend} from "react-dnd-test-utils";
import {Provider} from "react-redux";
import configureStore from "redux-mock-store";
import store from "store";
import {ActionFactory} from "store/action";
import {exportAsJSON, exportAsCSV} from "utils/export";
import {User} from "parse";
import {screen} from "@testing-library/dom";
import {HeaderMenu} from "components/BoardHeader/HeaderMenu";
import {mocked} from "ts-jest/utils";
import {render} from "testUtils";
const mockStore = configureStore();
const mockedUser = mocked(User, true);
mockedUser.current = jest.fn(() => ({id: "test"} as never));
Object.assign(navigator, {
clipboard: {
writeText: () => {},
},
});
jest.mock("store", () => ({
...jest.requireActual("store"),
dispatch: jest.fn(),
}));
jest.mock("utils/export", () => ({
...jest.requireActual("utils/export"),
exportAsJSON: jest.fn(),
exportAsCSV: jest.fn(),
exportAsCSVZip: jest.fn(),
}));
jest.mock("file-saver", () => ({saveAs: jest.fn()}));
const initialState = {
board: {
data: {
name: "board",
showAuthors: true,
joinConfirmationRequired: true,
id: "boardId",
userConfigurations: [
{
id: "test",
showHiddenColumns: true,
},
],
},
},
users: {
all: [
{
id: "test",
displayName: "<NAME>",
admin: false,
updatedAt: new Date("2020-11-30"),
createdAt: new Date("2020-11-30"),
online: false,
},
],
},
};
const createHeaderMenu = (currentUserIsModerator: boolean) => {
const mockedStore = mockStore(initialState);
const [HeaderMenuContext] = wrapWithTestBackend(HeaderMenu);
return (
<Provider store={mockedStore}>
<HeaderMenuContext open onClose={() => undefined} currentUserIsModerator={currentUserIsModerator} />
</Provider>
);
};
describe("<HeaderMenu/>", () => {
beforeEach(() => {
mockedUser.current = jest.fn(() => ({id: "test"} as never));
const portal = global.document.createElement("div");
portal.setAttribute("id", "portal");
global.document.querySelector("body")!.appendChild(portal);
});
describe("should render correctly", () => {
test("moderator", () => {
const {container} = render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(container).toMatchSnapshot();
});
test("user", () => {
const {container} = render(createHeaderMenu(false), {container: global.document.querySelector("#portal")!});
expect(container).toMatchSnapshot();
});
test("count of menu items for basic users", () => {
const {container} = render(createHeaderMenu(false), {container: global.document.querySelector("#portal")!});
expect(container.querySelector(".header-menu")?.children.length).toEqual(3);
});
test("tests count of menu items for moderators", () => {
const {container} = render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(container.querySelector(".header-menu")?.children.length).toEqual(7);
});
describe("BoardOption.ShowAuthorOption", () => {
test("Click on hide authors", async () => {
render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("author")).not.toBeNull();
const button = screen.getByTestId("author")!.querySelector("button")!;
expect(button).toHaveClass("board-option-button");
fireEvent.click(button);
await waitFor(() => {
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.editBoard({id: "boardId", showAuthors: false}));
});
});
test("Hide authors has correct label", () => {
render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("author")).not.toBeNull();
const label = screen.getByTestId("author")!.querySelector("span")!;
expect(label).toHaveClass("board-option-button__label");
expect(label.innerHTML).toEqual("Hide authors of card");
});
});
describe("BoardOption.ShowNotesOfOtherUserOption", () => {
test("Click on hide notes", async () => {
render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("note")).not.toBeNull();
const button = screen.getByTestId("note")!.querySelector("button")!;
expect(button).toHaveClass("board-option-button");
fireEvent.click(button);
await waitFor(() => {
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.editBoard({id: "boardId", showNotesOfOtherUsers: true}));
});
});
test("Hide notes has correct label", () => {
render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("note")).not.toBeNull();
const label = screen.getByTestId("note")!.querySelector("span")!;
expect(label).toHaveClass("board-option-button__label");
expect(label.innerHTML).toEqual("Show notes of other users");
});
});
describe("BoardOption.ShowHiddenColumnsOption", () => {
test("Click on hide columns", async () => {
render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("column")).not.toBeNull();
const button = screen.getByTestId("column")!.querySelector("button")!;
expect(button).toHaveClass("board-option-button");
fireEvent.click(button);
await waitFor(() => {
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.editUserConfiguration({showHiddenColumns: false}));
});
});
test("Hide columns has correct label", () => {
render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("column")).not.toBeNull();
const label = screen.getByTestId("column")!.querySelector("span")!;
expect(label).toHaveClass("board-option-button__label");
expect(label.innerHTML).toEqual("Hide columns");
});
});
describe("BoardOption.ShareQrCodeOption", () => {
test("Click on share board container", async () => {
const {container} = render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("qrcode")).not.toBeNull();
const button = screen.getByTestId("qrcode")!.querySelector("button")!;
expect(button).toHaveClass("board-option-button");
fireEvent.click(button);
await waitFor(() => {
expect(container.querySelector(".share-qr-code-option__container")).toHaveClass("share-qr-code-option__container--visible");
});
});
test("Click on copy share link", async () => {
const {container} = render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("qrcode")).not.toBeNull();
let button = screen.getByTestId("qrcode")!.querySelector("button")!;
expect(button).toHaveClass("board-option-button");
fireEvent.click(button);
await waitFor(() => {
expect(container.querySelector(".share-qr-code-option__container")).toHaveClass("share-qr-code-option__container--visible");
});
jest.spyOn(navigator.clipboard, "writeText");
button = screen.getByTestId("qrcode")!.querySelector(".share-qr-code-option__container--visible")!.querySelector("button")!;
expect(button).toHaveClass("share-qr-code-option__copy-to-clipboard");
fireEvent.click(button);
await waitFor(() => {
expect(navigator.clipboard.writeText).toHaveBeenCalledWith(document.location.href);
});
});
});
describe("BoardOption.DeleteBoardOption", () => {
test("Click on delete board container", async () => {
const {container} = render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("delete")).not.toBeNull();
const button = screen.getByTestId("delete")!.querySelector("button")!;
expect(button).toHaveClass("board-option-button");
fireEvent.click(button);
await waitFor(() => {
expect(container.querySelector(".delete-board-option__container")).toHaveClass("delete-board-option__container--visible");
});
});
test("Click on delete button", async () => {
const {container} = render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("delete")).not.toBeNull();
let button = screen.getByTestId("delete")!.querySelector("button")!;
expect(button).toHaveClass("board-option-button");
fireEvent.click(button);
await waitFor(() => {
expect(container.querySelector(".delete-board-option__container")).toHaveClass("delete-board-option__container--visible");
});
button = screen.getByTestId("delete")!.querySelector(".delete-board-option__container--visible")!.querySelector("button")!;
expect(button).toHaveClass("delete-board-option__delete-board");
fireEvent.click(button);
await waitFor(() => {
expect(store.dispatch).toHaveBeenCalledWith(ActionFactory.deleteBoard("boardId"));
});
});
test("Click on delete board", async () => {
const {container} = render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("delete")).not.toBeNull();
const button = screen.getByTestId("delete")!.querySelector("button")!;
expect(button).toHaveClass("board-option-button");
fireEvent.click(button);
await waitFor(() => {
expect(container.querySelector(".delete-board-option__container")).toHaveClass("delete-board-option__container--visible");
});
});
});
describe("BoardOption.ExportBoardOption", () => {
test("Click on export board container", async () => {
const {container} = render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("export")).not.toBeNull();
const button = screen.getByTestId("export")!.querySelector("button")!;
expect(button).toHaveClass("board-option-button");
fireEvent.click(button);
await waitFor(() => {
expect(container.querySelector(".export-board-option__container")).toHaveClass("export-board-option__container--visible");
});
});
});
describe("blob download", () => {
test("json function called", async () => {
render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("export-json")).not.toBeNull();
const button = screen.getByTestId("export-json")!;
fireEvent.click(button);
await waitFor(() => {
expect(exportAsJSON).toBeCalled();
});
});
test("csv function called", async () => {
render(createHeaderMenu(true), {container: global.document.querySelector("#portal")!});
expect(screen.getByTestId("export-csv")).not.toBeNull();
const button = screen.getByTestId("export-csv")!;
fireEvent.click(button);
await waitFor(() => {
expect(exportAsCSV).toBeCalled();
});
});
});
});
});
|
Accessible-Concepts/scrumlr.io
|
src/components/NoteDialog/NoteDialogComponents/NoteDialogNoteComponents/NoteDialogOptions/NoteDialogDeleteNoteButton.tsx
|
import {ReactComponent as DeleteIcon} from "assets/icon-delete.svg";
import {DotButton} from "components/DotButton";
import {TabIndex} from "constants/tabIndex";
import {FC} from "react";
import store from "store";
import {ActionFactory} from "store/action";
import "./NoteDialogDeleteNoteButton.scss";
import {useTranslation} from "react-i18next";
type NoteDialogDeleteNoteProps = {
noteId?: string;
onDeleteOfParent: () => void;
};
export const NoteDialogDeleteNoteButton: FC<NoteDialogDeleteNoteProps> = ({noteId, onDeleteOfParent}: NoteDialogDeleteNoteProps) => {
const {t} = useTranslation();
const onDelete = (id: string) => {
store.dispatch(ActionFactory.deleteNote(id));
};
return (
<DotButton
onClick={() => {
onDelete(noteId!);
onDeleteOfParent();
}}
className="note-dialog__note-option__remove"
tabIndex={TabIndex.default}
title={t("NoteDialogDeleteNoteButton.title")}
>
<DeleteIcon className="note-dialog__note-option__remove-icon" />
</DotButton>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/components/Timer/__tests__/Timer.test.tsx
|
<reponame>Accessible-Concepts/scrumlr.io<gh_stars>10-100
import {render} from "testUtils";
import {Timer} from "components/Timer";
import {mocked} from "ts-jest/utils";
import {useAppSelector} from "store";
jest.mock("store");
const mockedUseAppSelector = mocked(useAppSelector);
describe("Timer", () => {
test("should render correctly", () => {
mockedUseAppSelector.mockResolvedValue({} as never);
const {container} = render(<Timer endTime={new Date(new Date().getTime() + 3 * 60000)} />, {container: document.getElementById("root")!});
expect(container.firstChild).toMatchSnapshot();
});
test("should have cancel button if user is moderator", () => {
mockedUseAppSelector.mockResolvedValue({} as never);
const {container} = render(<Timer endTime={new Date(new Date().getTime() + 3 * 60000)} />, {container: document.getElementById("root")!});
expect(container.firstChild).toContainElement(container.getElementsByTagName("button")[0]);
});
test("should have expired class if timer is over", () => {
mockedUseAppSelector.mockResolvedValue({} as never);
const {container} = render(<Timer endTime={new Date(new Date().getTime())} />, {container: document.getElementById("root")!});
expect(container.firstChild).toHaveClass("timer--expired");
});
});
|
Accessible-Concepts/scrumlr.io
|
server/src/cloud/util.ts
|
<filename>server/src/cloud/util.ts
export interface ParseObjectParams {
[key: string]: any;
}
export const api = <RequestData extends ParseObjectParams = ParseObjectParams, ResponseType = void>(
name: string,
call: (user: Parse.User, request: RequestData) => ResponseType | Promise<ResponseType>
) => {
Parse.Cloud.define<(params: RequestData) => ResponseType | Promise<ResponseType>>(name, (request) => {
if (!request.user) {
throw new Error("Not authorized");
}
return call(request.user, request.params);
});
};
export const publicApi = <RequestData extends ParseObjectParams = ParseObjectParams, ResponseType = void>(
name: string,
call: (request: RequestData) => ResponseType | Promise<ResponseType>
): void => {
Parse.Cloud.define<(params: RequestData) => ResponseType | Promise<ResponseType>>(name, (request) => call(request.params));
};
export interface ACL {
readRoles?: string[];
writeRoles?: string[];
}
export const newObject = (className: string, data: ParseObjectParams, acl: ACL) => {
const object = new Parse.Object(className, data);
const objectACL = new Parse.ACL();
objectACL.setPublicReadAccess(false);
objectACL.setPublicWriteAccess(false);
acl.readRoles?.forEach((role) => {
objectACL.setRoleReadAccess(role, true);
});
acl.writeRoles?.forEach((role) => {
objectACL.setRoleWriteAccess(role, true);
});
object.setACL(objectACL);
return object;
};
|
Accessible-Concepts/scrumlr.io
|
src/components/Votes/VoteDisplay/index.ts
|
<reponame>Accessible-Concepts/scrumlr.io
export * from "./VoteDisplay";
|
Accessible-Concepts/scrumlr.io
|
src/components/NoteDialog/NoteDialogComponents/NoteDialogHeader.tsx
|
<filename>src/components/NoteDialog/NoteDialogComponents/NoteDialogHeader.tsx
import {FC} from "react";
import "./NoteDialogHeader.scss";
type NoteDialogHeaderProps = {
columnName: string;
};
export const NoteDialogHeader: FC<NoteDialogHeaderProps> = ({columnName}: NoteDialogHeaderProps) => <h2 className="note-dialog__header">{columnName}</h2>;
|
Accessible-Concepts/scrumlr.io
|
src/store/reducer/__tests__/note.test.ts
|
import {NoteClientModel} from "types/note";
import {noteReducer} from "store/reducer/note";
import {ActionFactory} from "store/action";
const COLUMN_ID = "column";
const AUTHOR_ID = "<NAME>";
const NOTE_TEXT = "Hello world";
jest.mock("parse", () => ({
User: {
current: () => ({
id: AUTHOR_ID,
}),
},
}));
const createServerNote = (id: string, parent?: string, posInStack?: number, text: string = NOTE_TEXT): NoteClientModel => ({
id,
columnId: COLUMN_ID,
text,
author: AUTHOR_ID,
createdAt: new Date(),
updatedAt: new Date(),
dirty: false,
focus: false,
positionInStack: posInStack ?? -1,
parentId: parent,
});
describe("note reducer", () => {
let initialState: NoteClientModel[];
beforeEach(() => {
initialState = [createServerNote("1"), createServerNote("2")];
});
test("add note", () => {
const newState = noteReducer(initialState, ActionFactory.addNote(COLUMN_ID, NOTE_TEXT));
expect(newState.length).toEqual(3);
const newNote = newState.find((note) => note.id === undefined);
expect(newNote?.columnId).toEqual(COLUMN_ID);
expect(newNote?.author).toEqual(AUTHOR_ID);
expect(newNote?.text).toEqual(NOTE_TEXT);
expect(newNote?.dirty).toBe(true);
});
test("created note from server", () => {
const newState = noteReducer(initialState, ActionFactory.createdNote(createServerNote("3")));
expect(newState.length).toEqual(3);
});
describe("sync server note with local note", () => {
test("created note synced locally", () => {
const stateWithLocalNote = noteReducer(initialState, ActionFactory.addNote(COLUMN_ID, NOTE_TEXT));
const newState = noteReducer(stateWithLocalNote, ActionFactory.createdNote(createServerNote("3")));
expect(newState.length).toEqual(3);
expect(newState.filter((note) => Boolean(note.id)).length).toEqual(3);
});
test("created two notes and one is synced locally", () => {
const stateWithLocalNote1 = noteReducer(initialState, ActionFactory.addNote(COLUMN_ID, NOTE_TEXT));
const stateWithLocalNote2 = noteReducer(stateWithLocalNote1, ActionFactory.addNote(COLUMN_ID, NOTE_TEXT));
const newState = noteReducer(stateWithLocalNote2, ActionFactory.createdNote(createServerNote("3")));
expect(newState.length).toEqual(4);
expect(newState.filter((note) => Boolean(note.id)).length).toEqual(3);
});
});
test("delete note", () => {
const state3Notes = noteReducer(initialState, ActionFactory.createdNote(createServerNote("3")));
const newState = noteReducer(state3Notes, ActionFactory.deleteNote("2"));
expect(newState.map((note) => note.id)).toEqual(["1", "3"]);
});
test("edit note", () => {
const newState = noteReducer(initialState, ActionFactory.editNote({id: "1", text: "New text"}));
expect(newState.length).toEqual(2);
expect(newState.find((note) => note.text === "New text")).toBeDefined();
});
test("unstack note", () => {
const newState = noteReducer([createServerNote("1", "2", 1, "test"), createServerNote("2", undefined, 0, "test")], ActionFactory.unstackNote({id: "1", parentId: "2"}));
expect(newState.find((note) => note.id === "1")).toBeDefined();
expect(newState.find((note) => note.id === "1")?.positionInStack).toBe(-1);
expect(newState.find((note) => note.id === "2")?.positionInStack).toBe(-1);
});
test("drag note", () => {
const newState = noteReducer([createServerNote("1", undefined, -1, "test"), createServerNote("2", undefined, -1, "test")], ActionFactory.dragNote({id: "1", dragOnId: "2"}));
expect(newState.find((note) => note.id === "1")?.positionInStack).toBe(0);
expect(newState.find((note) => note.id === "2")?.positionInStack).toBe(1);
expect(newState.find((note) => note.id === "2")?.parentId).toBe("1");
});
test("drag note in other column", () => {
const newState = noteReducer(
[createServerNote("1", undefined, -1, "test"), createServerNote("2", undefined, -1, "test")],
ActionFactory.dragNote({id: "1", dragOnId: "2", columnId: "test-column"})
);
expect(newState.find((note) => note.id === "1")?.positionInStack).toBe(0);
expect(newState.find((note) => note.id === "2")?.positionInStack).toBe(1);
expect(newState.find((note) => note.id === "2")?.parentId).toBe("1");
expect(newState.find((note) => note.id === "1")?.columnId).toBe("test-column");
});
describe("sync server note with edited local note", () => {
test("edited note synced locally", () => {
const editedState = noteReducer(initialState, ActionFactory.editNote({id: "1", text: "New text"}));
const newState = noteReducer(editedState, ActionFactory.updatedNote(createServerNote("1", undefined, undefined, "New text")));
const note = newState.find((n) => n.id === "1");
expect(note?.dirty).toBe(false);
});
});
test("initialize note", () => {
const state = noteReducer([], ActionFactory.initializeNotes(initialState));
expect(state).toEqual(initialState);
});
});
|
Accessible-Concepts/scrumlr.io
|
src/components/AppInfo/AppInfo.tsx
|
import {FC} from "react";
import {ReactComponent as GitHubIcon} from "assets/icon-github.svg";
import "./AppInfo.scss";
import classNames from "classnames";
import {useTranslation} from "react-i18next";
export interface AppInfoProps {
className?: string;
}
export const AppInfo: FC<AppInfoProps> = ({className}) => {
const {t} = useTranslation();
return (
<a target="_blank" href="https://github.com/inovex/scrumlr.io/releases" aria-label={t("AppInfo.version")} className={classNames("app-info", className)} rel="noreferrer">
<GitHubIcon className="app-info__icon" aria-hidden />
<span>{process.env.REACT_APP_VERSION}</span>
</a>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/constants/__tests__/name.test.ts
|
<gh_stars>10-100
import {getInitials} from "constants/name";
describe("initials", () => {
test("name without spaces", () => {
expect(getInitials("andiKandi")).toEqual("an");
});
test("name with one space", () => {
expect(getInitials("<NAME>")).toEqual("aK");
});
test("name with multiple spaces", () => {
expect(getInitials("<NAME>")).toEqual("aK");
});
test("name with special characters", () => {
expect(getInitials("<NAME>")).toEqual("JB");
});
});
|
Accessible-Concepts/scrumlr.io
|
src/components/Dropdown/Dropdown.tsx
|
import React from "react";
import classNames from "classnames";
import "./Dropdown.scss";
import {DropdownItemButton, DropdownItemButtonProps} from "./DropdownItemButton";
import {DropdownMain} from "./DropdownMain";
import {DropdownFooter} from "./DropdownFooter";
import {DropdownItem} from "./DropdownItem";
import {DropdownProps} from "./DropdownProps";
type DropdownSubcomponents = {
Main: React.FC<DropdownProps>;
Footer: React.FC<DropdownProps>;
Item: React.FC<DropdownProps>;
ItemButton: React.FC<DropdownItemButtonProps>;
};
const Dropdown: React.FC<DropdownProps> & DropdownSubcomponents = ({className, children, ...other}) => (
<menu className={classNames("dropdown", className)} {...other}>
{children}
</menu>
);
Dropdown.Main = DropdownMain;
Dropdown.Footer = DropdownFooter;
Dropdown.Item = DropdownItem;
Dropdown.ItemButton = DropdownItemButton;
export default Dropdown;
|
Accessible-Concepts/scrumlr.io
|
server/src/cloud/board.ts
|
<filename>server/src/cloud/board.ts
import {newObjectId} from "parse-server/lib/cryptoUtils";
import {StatusResponse} from "types";
import {UserConfigurations} from "types/user";
import * as crypto from "crypto";
import {getAdminRoleName, getMemberRoleName, isMember, isOnline, requireValidBoardAdmin} from "./permission";
import {api} from "./util";
import {serverConfig} from "../index";
import Color, {isOfTypeColor} from "../util/Color";
interface JoinBoardResponse {
status: "accepted" | "passphrase_required" | "incorrect_passphrase" | "rejected" | "pending";
joinRequestReference?: string;
}
const goOnline = (user: Parse.User, boardId: string) => {
user.add("boards", boardId);
user.save(null, {useMasterKey: true});
};
const addAsMember = async (user: Parse.User, boardId: string) => {
const memberRoleQuery = new Parse.Query(Parse.Role);
memberRoleQuery.equalTo("name", getMemberRoleName(boardId));
const memberRole = await memberRoleQuery.first({useMasterKey: true});
if (memberRole) {
goOnline(user, boardId);
memberRole.getUsers().add(user);
return memberRole.save(null, {useMasterKey: true});
}
throw new Error(`No roles for board '${boardId}' found`);
};
const addToModerators = async (user: Parse.User, boardId: string) => {
const adminRoleQuery = new Parse.Query(Parse.Role);
adminRoleQuery.equalTo("name", getAdminRoleName(boardId));
const adminRole = await adminRoleQuery.first({useMasterKey: true});
if (adminRole) {
adminRole.getUsers().add(user);
return adminRole.save(null, {useMasterKey: true});
}
throw new Error(`No roles for board '${boardId}' found`);
};
const removeFromModerators = async (user: Parse.User, boardId: string) => {
const adminRoleQuery = new Parse.Query(Parse.Role);
adminRoleQuery.equalTo("name", getAdminRoleName(boardId));
const adminRole = await adminRoleQuery.first({useMasterKey: true});
if (adminRole) {
adminRole.getUsers().remove(user);
return adminRole.save(null, {useMasterKey: true});
}
throw new Error(`No roles for board '${boardId}' found`);
};
const AccessPolicyType = {
Public: "Public" as const,
ByPassphrase: "ByPassphrase" as const,
ManualVerification: "ManualVerification" as const,
};
type AccessPolicy = {
type: keyof typeof AccessPolicyType;
passphrase?: string;
};
type AccessPolicyByPassphrase = AccessPolicy & {
passphrase: string;
salt: string;
};
const convertToAccessPolicyByPassphrase = (accessPolicy: AccessPolicy): AccessPolicyByPassphrase => {
const salt = crypto.randomBytes(32).toString("hex");
const passphrase = crypto
.createHash("sha256")
.update(accessPolicy.passphrase + salt)
.digest("base64");
return {
type: accessPolicy.type,
salt,
passphrase,
};
};
const respondToJoinRequest = async (currentUser: Parse.User, users: string[], board: string, manipulate: (object: Parse.Object) => void) => {
await requireValidBoardAdmin(currentUser, board);
const BoardClass = Parse.Object.extend("Board");
const joinRequestQuery = new Parse.Query("JoinRequest");
joinRequestQuery.equalTo("board", BoardClass.createWithoutData(board));
joinRequestQuery.containedIn(
"user",
users.map((userId) => Parse.User.createWithoutData(userId))
);
joinRequestQuery.find({useMasterKey: true}).then(async (pendingJoinRequests) => {
pendingJoinRequests.forEach(
(joinRequest) => {
manipulate(joinRequest);
},
{useMasterKey: true}
);
await Parse.Object.saveAll(pendingJoinRequests, {useMasterKey: true});
});
};
export interface CreateBoardRequest {
columns: {
name: string;
color: Color;
hidden: boolean;
}[];
name?: string;
encryptedContent?: boolean;
accessPolicy: AccessPolicy;
}
export type EditableBoardAttributes = {
name: string;
showAuthors?: boolean;
timerUTCEndTime?: Date;
accessPolicy?: AccessPolicy;
voting?: "active" | "disabled";
votingIteration: number;
showNotesOfOtherUsers: boolean;
moderation?: {userId?: string; status: "active" | "disabled"};
};
export type EditBoardRequest = {id: string} & Partial<EditableBoardAttributes>;
export type DeleteBoardRequest = {boardId: string};
export interface JoinRequestResponse {
board: string;
users: string[];
}
export interface JoinBoardRequest {
boardId: string;
passphrase?: string;
}
export const initializeBoardFunctions = () => {
api<CreateBoardRequest, string>("createBoard", async (user, request) => {
const board = new Parse.Object("Board");
const columns = request.columns.reduce((acc, current) => {
if (!isOfTypeColor(current.color)) {
throw new Error(`color ${current.color} is not allowed for columns`);
}
acc[newObjectId(serverConfig.objectIdSize)] = {
name: current.name,
color: current.color,
hidden: current.hidden,
};
return acc;
}, {});
const userConfigurations: UserConfigurations = {};
userConfigurations[user.id] = {showHiddenColumns: true};
let {accessPolicy} = request;
if (accessPolicy.type === AccessPolicyType.ByPassphrase) {
accessPolicy = convertToAccessPolicyByPassphrase(accessPolicy);
}
const savedBoard = await board.save({...request, accessPolicy, columns, owner: user, userConfigurations}, {useMasterKey: true});
const adminRoleACL = new Parse.ACL();
adminRoleACL.setPublicReadAccess(false);
adminRoleACL.setPublicWriteAccess(false);
adminRoleACL.setWriteAccess(user, true);
const adminRole = new Parse.Role(getAdminRoleName(board.id), adminRoleACL);
adminRoleACL.setRoleWriteAccess(adminRole, true);
adminRoleACL.setRoleReadAccess(adminRole, true);
adminRoleACL.setRoleReadAccess(getMemberRoleName(board.id), true);
adminRole.getUsers().add(user);
const memberRoleACL = new Parse.ACL();
memberRoleACL.setPublicReadAccess(false);
memberRoleACL.setPublicWriteAccess(false);
memberRoleACL.setRoleWriteAccess(adminRole, true);
memberRoleACL.setRoleReadAccess(adminRole, true);
const memberRole = new Parse.Role(getMemberRoleName(board.id), memberRoleACL);
memberRoleACL.setRoleReadAccess(memberRole, true);
await memberRole.save(null, {useMasterKey: true});
await addAsMember(user, savedBoard.id);
adminRole.getRoles().add(memberRole);
await adminRole.save(null, {useMasterKey: true});
const boardACL = new Parse.ACL();
boardACL.setRoleWriteAccess(adminRole, true);
boardACL.setRoleReadAccess(adminRole, true);
boardACL.setRoleReadAccess(memberRole, true);
savedBoard.setACL(boardACL);
return (await savedBoard.save(null, {useMasterKey: true})).id;
});
api<JoinBoardRequest, JoinBoardResponse>("joinBoard", async (user, request) => {
const boardQuery = new Parse.Query<Parse.Object>("Board");
const board = await boardQuery.get(request.boardId, {
useMasterKey: true,
});
if (!board) {
throw new Error(`Board '${request.boardId}' not found`);
}
if (await isMember(user, request.boardId)) {
// handle browser refresh
if (!isOnline(user, request.boardId)) {
goOnline(user, request.boardId);
}
return {
status: "accepted",
};
}
const accessPolicy = board.get("accessPolicy");
if (accessPolicy.type !== AccessPolicyType.Public) {
if (accessPolicy.type === AccessPolicyType.ByPassphrase) {
if (!request.passphrase) {
return {
status: "passphrase_required",
};
}
const passphrase = crypto
.createHash("sha256")
.update(request.passphrase + accessPolicy.salt)
.digest("base64");
if (passphrase !== accessPolicy.passphrase) {
return {
status: "incorrect_passphrase",
};
}
}
if (accessPolicy.type === AccessPolicyType.ManualVerification) {
const BoardClass = Parse.Object.extend("Board");
const boardReference = BoardClass.createWithoutData(request.boardId);
const joinRequestQuery = new Parse.Query("JoinRequest");
joinRequestQuery.equalTo("board", boardReference);
joinRequestQuery.equalTo("user", user);
const joinRequestQueryResult = await joinRequestQuery.first({
useMasterKey: true,
});
if (joinRequestQueryResult) {
if (joinRequestQueryResult.get("status") === "accepted") {
await addAsMember(user, request.boardId);
return {
status: "accepted",
joinRequestReference: joinRequestQueryResult.id,
accessKey: joinRequestQueryResult.get("accessKey"),
};
}
return {
status: joinRequestQueryResult.get("status"),
joinRequestReference: joinRequestQueryResult.id,
accessKey: joinRequestQueryResult.get("accessKey"),
};
}
const joinRequest = new Parse.Object("JoinRequest");
joinRequest.set("user", user);
joinRequest.set("board", boardReference);
const joinRequestACL = new Parse.ACL();
joinRequestACL.setReadAccess(user.id, true);
joinRequestACL.setRoleReadAccess(getAdminRoleName(request.boardId), true);
joinRequestACL.setRoleWriteAccess(getAdminRoleName(request.boardId), true);
joinRequest.setACL(joinRequestACL);
const savedJoinRequest = await joinRequest.save(null, {
useMasterKey: true,
});
return {
status: "pending",
joinRequestReference: savedJoinRequest.id,
};
}
}
const userConfigurations: UserConfigurations = await board.get("userConfigurations");
userConfigurations[user.id] = {showHiddenColumns: true};
board.set("userConfigurations", userConfigurations);
await board.save(null, {useMasterKey: true});
await addAsMember(user, request.boardId);
return {status: "accepted"};
});
api<JoinRequestResponse, boolean>("acceptUsers", async (user, request) => {
await respondToJoinRequest(user, request.users, request.board, (object) => {
object.set("status", "accepted");
// object.set('accessKey', params.accessKey);
});
return true;
});
api<JoinRequestResponse, boolean>("rejectUsers", async (user, request) => {
await respondToJoinRequest(user, request.users, request.board, (object) => {
object.set("status", "rejected");
});
return true;
});
api<{board: EditBoardRequest}, boolean>("editBoard", async (user, request) => {
await requireValidBoardAdmin(user, request.board.id);
if (Object.keys(request.board).length <= 1) {
throw new Error(`No fields to edit defined in edit request of board '${request.board.id}'`);
}
const boardQuery = new Parse.Query(Parse.Object.extend("Board"));
const board = await boardQuery.get(request.board.id, {useMasterKey: true});
if (!board) {
throw new Error(`Board ${request.board.id} not found`);
}
if (request.board.showAuthors != null) {
board.set("showAuthors", request.board.showAuthors);
}
if (request.board.timerUTCEndTime) {
board.set("timerUTCEndTime", request.board.timerUTCEndTime);
}
if (request.board.name) {
board.set("name", request.board.name);
}
if (request.board.accessPolicy != null) {
if (request.board.accessPolicy.type === AccessPolicyType.ByPassphrase) {
board.set("accessPolicy", convertToAccessPolicyByPassphrase(request.board.accessPolicy));
} else {
board.set("accessPolicy", request.board.accessPolicy);
}
}
if (request.board.voting) {
if (request.board.voting === "active") {
board.set("votingIteration", board.get("votingIteration") + 1);
}
board.set("voting", request.board.voting);
}
if (request.board.moderation) {
board.set("moderation", request.board.moderation);
if (request.board.moderation.status === "disabled") {
const notesQuery = new Parse.Query("Note");
notesQuery.equalTo("board", board);
if ((await notesQuery.count()) > 0) {
notesQuery.first({useMasterKey: true}).then(async (note) => {
note.set("focus", false);
await note.save(null, {useMasterKey: true});
});
}
}
}
if (request.board.showNotesOfOtherUsers != undefined) {
board.set("showNotesOfOtherUsers", request.board.showNotesOfOtherUsers);
}
await board.save(null, {useMasterKey: true});
return true;
});
api<DeleteBoardRequest, boolean>("deleteBoard", async (user, request) => {
await requireValidBoardAdmin(user, request.boardId);
const boardQuery = new Parse.Query(Parse.Object.extend("Board"));
const board = await boardQuery.get(request.boardId, {useMasterKey: true});
const noteQuery = new Parse.Query(Parse.Object.extend("Note"));
noteQuery.equalTo("board", board);
const notes = await noteQuery.findAll({useMasterKey: true});
await Parse.Object.destroyAll(notes, {useMasterKey: true});
const voteQuery = new Parse.Query("Vote");
voteQuery.equalTo("board", board);
const votes = await voteQuery.findAll({useMasterKey: true});
await Parse.Object.destroyAll(votes, {useMasterKey: true});
const joinRequestQuery = new Parse.Query("JoinRequest");
joinRequestQuery.equalTo("board", board);
const joinRequests = await joinRequestQuery.findAll({useMasterKey: true});
await Parse.Object.destroyAll(joinRequests, {useMasterKey: true});
const voteConfigurationQuery = new Parse.Query("VoteConfiguration");
voteConfigurationQuery.equalTo("board", board);
const voteConfigurations = await voteConfigurationQuery.findAll({useMasterKey: true});
await Parse.Object.destroyAll(voteConfigurations, {useMasterKey: true});
const adminRoleQuery = new Parse.Query(Parse.Role);
adminRoleQuery.equalTo("name", `admin_of_${request.boardId}`);
const adminRoles = await adminRoleQuery.findAll({useMasterKey: true});
await Parse.Object.destroyAll(adminRoles, {useMasterKey: true});
const memberRoleQuery = new Parse.Query(Parse.Role);
memberRoleQuery.equalTo("name", `member_of_${request.boardId}`);
const memberRoles = await memberRoleQuery.findAll({useMasterKey: true});
await Parse.Object.destroyAll(memberRoles, {useMasterKey: true});
await board.destroy({useMasterKey: true});
return true;
});
type ChangePermissionRequest = {
userId: string;
boardId: string;
moderator: boolean;
};
api<ChangePermissionRequest, StatusResponse>("changePermission", async (user, request) => {
await requireValidBoardAdmin(user, request.boardId);
if (request.moderator) {
await addToModerators(Parse.User.createWithoutData(request.userId), request.boardId);
return {status: "Success", description: "User was successfully added to the list of moderators"};
}
// Make sure that moderators cannot remove themselfs from the list of moderators
if (request.userId === user.id) {
return {status: "Error", description: "You cannot remove yourself from the list of moderators"};
}
// Make sure that the board creator cannot get removed from the list of moderators)
const board = await new Parse.Query("Board").get(request.boardId, {useMasterKey: true});
if (request.userId === board.get("owner").id) {
return {status: "Error", description: "The creator of the board cannot be removed from the list of moderators"};
}
await removeFromModerators(Parse.User.createWithoutData(request.userId), request.boardId);
return {status: "Success", description: "User was successfully removed from the list of moderators"};
});
/**
* Cancel voting
*/
api<{boardId: string}, StatusResponse>("cancelVoting", async (user, request) => {
await requireValidBoardAdmin(user, request.boardId);
const board = await new Parse.Query("Board").get(request.boardId, {useMasterKey: true});
// Check if the board exists
if (!board) {
return {status: "Error", description: `Board '${request.boardId}' does not exist`};
}
// Check if the board exists
if ((await board.get("voting")) === "disabled") {
return {status: "Error", description: `Voting is already disabled`};
}
const votingIteration = await board.get("votingIteration");
const voteConfigurationQuery = new Parse.Query("VoteConfiguration");
voteConfigurationQuery.equalTo("board", board);
// Voting iteraion already incremented
const voteConfiguration = await voteConfigurationQuery.equalTo("votingIteration", votingIteration).first({useMasterKey: true});
await voteConfiguration.destroy({useMasterKey: true});
const voteQuery = new Parse.Query("Vote");
voteQuery.equalTo("board", board);
voteQuery.equalTo("votingIteration", votingIteration);
const votes = await voteQuery.findAll({useMasterKey: true});
await Parse.Object.destroyAll(votes, {useMasterKey: true});
// add new value canceled?
board.set("voting", "disabled");
await board.save(null, {useMasterKey: true});
return {status: "Success", description: "Current voting phase was canceled"};
});
api<{endDate: Date; boardId: string}, StatusResponse>("setTimer", async (user, request) => {
await requireValidBoardAdmin(user, request.boardId);
const board = await new Parse.Query("Board").get(request.boardId, {useMasterKey: true});
if (!board) {
return {status: "Error", description: `Board '${request.boardId}' does not exist`};
}
board.set("timerUTCEndTime", request.endDate);
await board.save(null, {useMasterKey: true});
return {status: "Success", description: "Timer was successfully set"};
});
api<{boardId: string}, StatusResponse>("cancelTimer", async (user, request) => {
await requireValidBoardAdmin(user, request.boardId);
const board = await new Parse.Query("Board").get(request.boardId, {useMasterKey: true});
if (!board) {
return {status: "Error", description: `Board '${request.boardId}' does not exist`};
}
board.unset("timerUTCEndTime");
await board.save(null, {useMasterKey: true});
return {status: "Success", description: "Timer was successfully removed"};
});
api<{}, string>("getServerTime", async (user, request) => new Date().toUTCString());
};
|
Accessible-Concepts/scrumlr.io
|
src/components/LoginProviders/index.ts
|
<reponame>Accessible-Concepts/scrumlr.io<filename>src/components/LoginProviders/index.ts
export * from "./LoginProviders";
|
Accessible-Concepts/scrumlr.io
|
src/types/__tests__/voteConfiguration.test.ts
|
<gh_stars>0
import {mapVoteConfigurationServerToClientModel, VoteConfigurationServerModel, VoteConfigurationClientModel} from "../voteConfiguration";
describe("VoteConfiguration types", () => {
test("mapVoteConfigurationServerToClientModel", async () => {
const map = {
board: {id: "5"} as unknown as Parse.Object,
votingIteration: 0,
voteLimit: 0,
allowMultipleVotesPerNote: false,
showVotesOfOtherUsers: false,
};
const serverModel = {
get: (s: string) => map[s],
} as unknown as VoteConfigurationServerModel;
const clientModel: VoteConfigurationClientModel = mapVoteConfigurationServerToClientModel(serverModel);
expect(clientModel.boardId).toEqual(serverModel.get("board").id);
expect(clientModel.votingIteration).toEqual(serverModel.get("votingIteration"));
expect(clientModel.voteLimit).toEqual(serverModel.get("voteLimit"));
expect(clientModel.allowMultipleVotesPerNote).toEqual(serverModel.get("allowMultipleVotesPerNote"));
expect(clientModel.showVotesOfOtherUsers).toEqual(serverModel.get("showVotesOfOtherUsers"));
});
});
|
Accessible-Concepts/scrumlr.io
|
src/components/BoardHeader/ParticipantsList/index.ts
|
export * from "./ParticipantsList";
|
Accessible-Concepts/scrumlr.io
|
src/components/Dropdown/DropdownMain.tsx
|
import React from "react";
import classNames from "classnames";
import {DropdownProps} from "./DropdownProps";
export const DropdownMain: React.FC<DropdownProps> = ({className, children, ...other}) => (
<div className={classNames("dropdown__main", className)} {...other}>
<ul>{children}</ul>
</div>
);
|
Accessible-Concepts/scrumlr.io
|
src/api/user.ts
|
import {EditUserConfigurationRequest, RaisedHandRequest} from "types/user";
import {callAPI} from "api/callApi";
export const UserAPI = {
/**
* Changes the permissions of a participant.
*
* @param userId the identifier of the user whose permissions are being changed
* @param boardId the identifier of the board
* @param moderator the flag whether the user receives or loses moderator permissions
* @returns a {status, description} object
*/
changePermission: (userId: string, boardId: string, moderator: boolean) => callAPI("changePermission", {userId, boardId, moderator}),
/**
* Changes the configuration of a user.
*
* @param boardId the identifier of the board
* @param userConfiguration user configuration which needs to be changed
* @returns a {status, description} object
*/
editUserConfiguration: (boardId: string, userConfiguration: EditUserConfigurationRequest) => callAPI("editUserConfiguration", {boardId, userConfiguration}),
/**
* Set the ready state of a user
*
* @param boardId the identifier of the board
* @param ready the ready state of the user
* @returns a {status, description} object
*/
setReadyStatus: (boardId: string, ready: boolean) => callAPI("setReadyStatus", {boardId, ready}),
/**
* Set the raised hand state of a user
*
* @param boardId the identifier of the board
* @param configuration contains a list of users and updates the raisedHand status
* @returns a {status, description} object
*/
setRaisedHandStatus: (boardId: string, configuration: RaisedHandRequest) => callAPI("setRaisedHandStatus", {boardId, configuration}),
};
|
Accessible-Concepts/scrumlr.io
|
src/components/ValidationError/ValidationError.tsx
|
import "./ValidationError.scss";
import {FC} from "react";
export const ValidationError: FC = ({children}) => (
<span role="alert" className="validation-error">
{children}
</span>
);
|
Accessible-Concepts/scrumlr.io
|
src/store/action/voteConfiguration.ts
|
import {VoteConfiguration, VoteConfigurationClientModel} from "types/voteConfiguration";
export const VoteConfigurationActionType = {
AddVoteConfiguration: "@@SCRUMLR/addVoteConfiguration" as const,
AddedVoteConfiguration: "@@SCRUMLR/addedVoteConfiguration" as const,
RemovedVoteConfiguration: "@@SCRUMLR/removedVoteConfiguration" as const,
InitializeVoteConfiguration: "@@SCRUMLR/initializeVoteConfiguration" as const,
};
export const VoteConfigurationActionFactory = {
/**
* Creates an action which should be dispatched when the user wants to add a vote configuration.
*
* @param voteConfiguration the current vote configuration
*/
addVoteConfiguration: (voteConfiguration: VoteConfiguration) => ({
type: VoteConfigurationActionType.AddVoteConfiguration,
voteConfiguration,
}),
/**
* Creates an action which should be dispatched when a new vote configuration was created on the server.
*
* @param voteConfiguration the vote configuration added on the server
*/
addedVoteConfiguration: (voteConfiguration: VoteConfigurationClientModel) => ({
type: VoteConfigurationActionType.AddedVoteConfiguration,
voteConfiguration,
}),
/**
* Creates an action which should be dispatched when a new vote configuration was removed on the server.
*
* @param voteConfiguration the vote configuration added on the server
*/
removedVoteConfiguration: (voteConfiguration: VoteConfigurationClientModel) => ({
type: VoteConfigurationActionType.RemovedVoteConfiguration,
voteConfiguration,
}),
/**
* Creates an action which should be dispatched when the server returns the las vote configuration
*
* @param voteConfiguration current vote configuration (e.g. a user can join during voting phase)
*/
initializeVoteConfiguration: (voteConfiguration: VoteConfigurationClientModel) => ({
type: VoteConfigurationActionType.InitializeVoteConfiguration,
voteConfiguration,
}),
};
export type VoteConfigurationReduxAction =
| ReturnType<typeof VoteConfigurationActionFactory.addVoteConfiguration>
| ReturnType<typeof VoteConfigurationActionFactory.addedVoteConfiguration>
| ReturnType<typeof VoteConfigurationActionFactory.removedVoteConfiguration>
| ReturnType<typeof VoteConfigurationActionFactory.initializeVoteConfiguration>;
|
Accessible-Concepts/scrumlr.io
|
src/utils/random.ts
|
const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
export const generateRandomString = (lenght = 8) => {
let result = "";
for (let i = 0; i < lenght; i++) {
result += ALPHABET.charAt(Math.floor(Math.random() * ALPHABET.length));
}
return result;
};
|
Accessible-Concepts/scrumlr.io
|
src/components/BoardHeader/BoardHeader.tsx
|
<gh_stars>0
import {VFC, useState} from "react";
import {ReactComponent as LockIcon} from "assets/icon-lock.svg";
import {ReactComponent as SettingsIcon} from "assets/icon-settings.svg";
import {BoardUsers} from "components/BoardUsers";
import store, {useAppSelector} from "store";
import {ScrumlrLogo} from "components/ScrumlrLogo";
import {HeaderMenu} from "components/BoardHeader/HeaderMenu";
import {ParticipantsList} from "components/BoardHeader/ParticipantsList";
import {Link} from "react-router-dom";
import "./BoardHeader.scss";
import {useTranslation} from "react-i18next";
import {TabIndex} from "constants/tabIndex";
import {ActionFactory} from "store/action";
import {shallowEqual} from "react-redux";
export interface BoardHeaderProps {
currentUserIsModerator: boolean;
}
export const BoardHeader: VFC<BoardHeaderProps> = (props) => {
const {t} = useTranslation();
const state = useAppSelector(
(rootState) => ({
name: rootState.board.data?.name,
accessPolicy: rootState.board.data?.accessPolicy === "Public" ? t("Board.publicSession") : t("Board.privateSession"),
}),
shallowEqual
);
const [showMenu, setShowMenu] = useState(false);
const [showParticipants, setShowParticipants] = useState(false);
return (
<header className="board-header">
<Link to="/" aria-label="Return to homepage">
<button tabIndex={TabIndex.BoardHeader} className="board-header__link" onClick={() => store.dispatch(ActionFactory.leaveBoard())}>
<ScrumlrLogo className="board-header__logo" accentColorClassNames={["accent-color--blue", "accent-color--purple", "accent-color--lilac", "accent-color--pink"]} />
</button>
</Link>
<div className="board-header__name-and-settings">
<button
className="board-header_name-and-settings-button"
onClick={() => {
setShowMenu(!showMenu);
}}
aria-haspopup
aria-pressed={showMenu}
tabIndex={TabIndex.BoardHeader + 1}
>
<div className="board-header__access-policy-status">
<LockIcon className="board-header__access-policy-status-icon" title={state.accessPolicy} />
<span>{state.accessPolicy}</span>
</div>
<div className="board-header__name-container">
<h1 className="board-header__name">{state.name || "scrumlr.io"}</h1>
<SettingsIcon className="board-header__settings-icon" />
</div>
</button>
</div>
<button
aria-label={t("BoardHeader.showParticipants")}
tabIndex={TabIndex.BoardHeader + 2}
aria-haspopup
aria-pressed={showParticipants}
className="board-header__users"
onClick={() => setShowParticipants(!showParticipants)}
>
<BoardUsers />
</button>
<HeaderMenu open={showMenu} onClose={() => setShowMenu(false)} currentUserIsModerator={props.currentUserIsModerator} />
{/* Only render the participants if the users have loaded (this reduces unnecessary rerendering) */}
<ParticipantsList open={showParticipants} onClose={() => setShowParticipants(false)} currentUserIsModerator={props.currentUserIsModerator} />
</header>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/components/TextInput/TextInput.tsx
|
<filename>src/components/TextInput/TextInput.tsx
import {Children, cloneElement, DetailedHTMLProps, FC, InputHTMLAttributes, ReactElement, ReactNode} from "react";
import classNames from "classnames";
import "./TextInput.scss";
export interface TextInputProps extends DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> {
type?: "text" | "password";
rightAdornment?: ReactElement;
leftAdornment?: ReactElement;
actions?: ReactNode;
}
export const TextInput: FC<TextInputProps> = ({className, leftAdornment, rightAdornment, actions, type = "text", ...other}) => {
if (!(leftAdornment || rightAdornment || actions)) {
return <input className={classNames("text-input", className)} type={type} {...other} />;
}
if (leftAdornment) {
const iconProps = Children.only(leftAdornment)?.props;
leftAdornment = cloneElement(leftAdornment!, {className: classNames(iconProps?.className, "text-input__adornment", "text-input__adornment--left")});
}
if (rightAdornment) {
const iconProps = Children.only(rightAdornment)?.props;
rightAdornment = cloneElement(rightAdornment!, {className: classNames(iconProps?.className, "text-input__adornment", "text-input__adornment--right")});
}
return (
<div className="text-input__container">
<div className="text-input__input-wrapper">
{leftAdornment}
<input
className={classNames("text-input", {"text-input--adornment-left": Boolean(leftAdornment), "text-input--adornment-right": Boolean(rightAdornment)}, className)}
type={type}
{...other}
/>
{rightAdornment}
</div>
<div className="text-input__actions">{actions}</div>
</div>
);
};
|
Accessible-Concepts/scrumlr.io
|
src/components/Votes/VoteButtons/AddVoteButton.tsx
|
<gh_stars>0
import store, {useAppSelector} from "store";
import {ActionFactory} from "store/action";
import {DotButton} from "components/DotButton";
import "./AddVoteButton.scss";
import "./VoteButton.scss";
import {ReactComponent as PlusIcon} from "assets/icon-add.svg";
import {FC} from "react";
import {ApplicationState} from "types/store";
type AddVoteProps = {
noteId: string;
tabIndex: number;
disabled: boolean;
};
export const AddVoteButton: FC<AddVoteProps> = ({noteId, tabIndex, disabled}) => {
const state = useAppSelector((applicationState: ApplicationState) => ({
id: applicationState.board.data!.id,
votingIteration: applicationState.voteConfiguration.votingIteration,
}));
const addVote = () => {
store.dispatch(ActionFactory.addVote(noteId, state.id, state.votingIteration));
};
return (
<DotButton tabIndex={tabIndex} className="vote-button-add" onClick={addVote} disabled={disabled}>
<PlusIcon className="vote-button-add__icon" />
</DotButton>
);
};
|
luis-ing/Prueba_Desarrollo
|
node_modules/timeago.js/lib/utils/date.d.ts
|
<reponame>luis-ing/Prueba_Desarrollo
/**
* Created by hustcc on 18/5/20.
* Contract: <EMAIL>
*/
import { LocaleFunc, TDate } from '../interface';
/**
* format Date / string / timestamp to timestamp
* @param input
* @returns {*}
*/
export declare function toDate(input?: Date | string | number): Date;
/**
* format the diff second to *** time ago, with setting locale
* @param diff
* @param localeFunc
* @returns
*/
export declare function formatDiff(diff: number, localeFunc: LocaleFunc): string;
/**
* calculate the diff second between date to be formatted an now date.
* @param date
* @param relativeDate
* @returns {number}
*/
export declare function diffSec(date: TDate, relativeDate: TDate): number;
/**
* nextInterval: calculate the next interval time.
* - diff: the diff sec between now and date to be formatted.
*
* What's the meaning?
* diff = 61 then return 59
* diff = 3601 (an hour + 1 second), then return 3599
* make the interval with high performance.
**/
export declare function nextInterval(diff: number): number;
|
luis-ing/Prueba_Desarrollo
|
node_modules/timeago.js/lib/format.d.ts
|
import { Opts, TDate } from './interface';
/**
* format a TDate into string
* @param date
* @param locale
* @param opts
*/
export declare const format: (date: TDate, locale?: string, opts?: Opts) => string;
|
luis-ing/Prueba_Desarrollo
|
node_modules/timeago.js/lib/utils/dom.d.ts
|
<reponame>luis-ing/Prueba_Desarrollo
/**
* get the datetime attribute, `datetime` are supported.
* @param node
* @returns {*}
*/
export declare function getDateAttribute(node: HTMLElement): string;
/**
* set the node attribute, native DOM
* @param node
* @param timerId
* @returns {*}
*/
export declare function setTimerId(node: HTMLElement, timerId: number): void;
/**
* get the timer id
* @param node
*/
export declare function getTimerId(node: HTMLElement): number;
|
luis-ing/Prueba_Desarrollo
|
node_modules/timeago.js/lib/register.d.ts
|
/**
* Created by hustcc on 18/5/20.
* Contract: <EMAIL>
*/
import { LocaleFunc } from './interface';
/**
* register a locale
* @param locale
* @param func
*/
export declare const register: (locale: string, func: LocaleFunc) => void;
/**
* get a locale, default is en_US
* @param locale
* @returns {*}
*/
export declare const getLocale: (locale: string) => LocaleFunc;
|
luis-ing/Prueba_Desarrollo
|
node_modules/timeago.js/lib/lang/zh_TW.d.ts
|
<reponame>luis-ing/Prueba_Desarrollo
export default function (number: number, index: number): [string, string];
|
luis-ing/Prueba_Desarrollo
|
node_modules/timeago.js/lib/interface.d.ts
|
export declare type LocaleFunc = (diff: number, idx: number, totalSec?: number) => [string, string];
export declare type LocaleMap = Record<string, LocaleFunc>;
export declare type TDate = Date | string | number;
export declare type TimerPool = Record<number, number>;
/**
* render / format options
*/
export declare type Opts = {
/** the relative date */
readonly relativeDate?: TDate;
/** the realtime */
readonly minInterval?: number;
};
|
luis-ing/Prueba_Desarrollo
|
node_modules/timeago.js/lib/realtime.d.ts
|
import { Opts } from './interface';
/**
* cancel a timer or all timers
* @param node - node hosting the time string
*/
export declare function cancel(node?: HTMLElement): void;
/**
* render a dom realtime
* @param nodes
* @param locale
* @param opts
*/
export declare function render(nodes: HTMLElement | HTMLElement[] | NodeList, locale?: string, opts?: Opts): HTMLElement[];
|
luis-ing/Prueba_Desarrollo
|
node_modules/timeago.js/lib/lang/zh_CN.d.ts
|
export default function (diff: number, idx: number): [string, string];
|
luis-ing/Prueba_Desarrollo
|
node_modules/timeago.js/lib/lang/index.d.ts
|
export { default as ar } from './ar';
export { default as be } from './be';
export { default as bg } from './bg';
export { default as bn_IN } from './bn_IN';
export { default as ca } from './ca';
export { default as de } from './de';
export { default as el } from './el';
export { default as en_short } from './en_short';
export { default as en_US } from './en_US';
export { default as es } from './es';
export { default as eu } from './eu';
export { default as fa } from './fa';
export { default as fi } from './fi';
export { default as fr } from './fr';
export { default as gl } from './gl';
export { default as he } from './he';
export { default as hi_IN } from './hi_IN';
export { default as hu } from './hu';
export { default as id_ID } from './id_ID';
export { default as it } from './it';
export { default as ja } from './ja';
export { default as ko } from './ko';
export { default as ml } from './ml';
export { default as my } from './my';
export { default as nb_NO } from './nb_NO';
export { default as nl } from './nl';
export { default as nn_NO } from './nn_NO';
export { default as pl } from './pl';
export { default as pt_BR } from './pt_BR';
export { default as ro } from './ro';
export { default as ru } from './ru';
export { default as sq } from './sq';
export { default as sr } from './sr';
export { default as sv } from './sv';
export { default as ta } from './ta';
export { default as th } from './th';
export { default as tr } from './tr';
export { default as uk } from './uk';
export { default as vi } from './vi';
export { default as zh_CN } from './zh_CN';
export { default as zh_TW } from './zh_TW';
|
turkaytunc/redux-like
|
src/state-store/reducers/userReducer.ts
|
<gh_stars>1-10
import { UserActions } from '../actions/UserActions';
import { IUser } from '../interfaces/IUser';
export const userReducer = (state: IUser[], action: UserActions): IUser[] => {
switch (action.type) {
case 'ADD_USER': {
const { id, name, isAdmin } = action.payload;
return [...state, { id, name, isAdmin }];
}
case 'REMOVE_USER': {
const id = action.payload;
return [...state.filter((e) => e.id !== id)];
}
default:
return state;
}
};
|
turkaytunc/redux-like
|
src/App.tsx
|
import React from 'react';
import './app.scss';
import PostList from './components/post-list/PostList';
import UserList from './components/user-list/UserList';
function App(): JSX.Element {
return (
<main className="App">
<UserList />
<br />
<hr />
<br />
<PostList />
</main>
);
}
export default App;
|
turkaytunc/redux-like
|
src/state-store/actions/PostActions.ts
|
<reponame>turkaytunc/redux-like
import { IPost } from '../interfaces/IPost';
export type PostActions =
| {
type: 'ADD_POST';
payload: IPost;
}
| {
type: 'REMOVE_POST';
payload: number;
};
|
turkaytunc/redux-like
|
src/state-store/reducers/postReducer.ts
|
<gh_stars>1-10
import { PostActions } from '../actions/PostActions';
import { IPost } from '../interfaces/IPost';
export const postReducer = (state: IPost[], action: PostActions): IPost[] => {
switch (action.type) {
case 'ADD_POST':
const { userId, id, title, body } = action.payload;
return [...state, { userId, id, title, body }];
case 'REMOVE_POST':
return [...state.filter((e) => e.id !== action.payload)];
default:
return state;
}
};
|
turkaytunc/redux-like
|
src/components/user-list/UserList.tsx
|
import React, { FC } from 'react';
import { Store } from '../../state-store/Store';
const UserList: FC = () => {
const { state, dispatch } = React.useContext(Store);
const [userInput, setUserInput] = React.useState('');
const addUser = () => {
dispatch({
type: 'ADD_USER',
payload: JSON.parse(userInput),
});
};
const deleteUser = (id: number) => {
dispatch({
type: 'REMOVE_USER',
payload: id,
});
};
return (
<div className="user-container">
<input
type="text"
value={userInput}
onChange={(e: React.ChangeEvent<HTMLInputElement>) => setUserInput(e.target.value)}
/>
<button onClick={() => addUser()}>Add User</button>
{state.users.map((e) => (
<div key={e.id}>
<div>userName: {e.name}</div>
<div>userRole: {e.isAdmin ? 'Admin' : 'Pleb'}</div>
<button onClick={() => deleteUser(e.id)} style={{ fontSize: '2em' }}>
×
</button>
</div>
))}
</div>
);
};
export default UserList;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.