repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
raulrozza/Gametask_Mobile | src/modules/selectedGame/infra/repositories/ActivitiesRepository.ts | <filename>src/modules/selectedGame/infra/repositories/ActivitiesRepository.ts<gh_stars>0
import IActivity from 'modules/selectedGame/domain/entities/IActivity';
import IActivitiesRepository from 'modules/selectedGame/domain/repositories/IActivitiesRepository';
import makeHttpProvider from 'shared/infra/providers/factories/makeHttpProvider';
export default class ActivitiesRepository implements IActivitiesRepository {
private httpProvider = makeHttpProvider();
public async findAll(): Promise<IActivity[]> {
return this.httpProvider.get('activities');
}
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/PlayerProfile/components/AchievementCard/styles.ts | import { AchievementImage } from 'modules/selectedGame/view/components';
import { Typography } from 'shared/view/components';
import styled, { css } from 'styled-components/native';
interface AchievementContainerProps {
obtained: boolean;
}
export const Container = styled.View<AchievementContainerProps>`
justify-content: center;
align-items: center;
width: 50%;
padding: ${({ theme }) => theme.layout.spacing(2)};
${({ obtained }) =>
!obtained &&
css`
opacity: 0.3;
`}
`;
export const Image = styled(AchievementImage)`
height: 96px;
width: 96px;
border-radius: 48px;
margin-bottom: ${({ theme }) => theme.layout.spacing(2)};
`;
export const Text = styled(Typography)`
font-weight: bold;
color: ${({ theme }) => theme.palette.secondary.main};
text-align: center;
`;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/Ranking/components/EmptyList/styles.ts | <filename>src/modules/selectedGame/view/pages/Ranking/components/EmptyList/styles.ts
import styled from 'styled-components/native';
export const Container = styled.View`
width: 100%;
padding: ${({ theme }) => theme.layout.spacing(2)};
border-width: 1px;
border-color: ${({ theme }) => theme.palette.primary.dark};
border-radius: 12px;
flex-direction: row;
margin-bottom: ${({ theme }) => theme.layout.spacing(1)};
align-items: center;
background-color: ${({ theme }) => theme.palette.primary.light};
`;
export const Text = styled.Text`
color: ${({ theme }) => theme.palette.primary.contrast};
margin: ${({ theme }) => theme.layout.spacing(2, 0)};
text-align: center;
`;
|
raulrozza/Gametask_Mobile | src/modules/authentication/infra/controllers/useLoginController.ts | <filename>src/modules/authentication/infra/controllers/useLoginController.ts<gh_stars>0
import { useCallback, useMemo, useState } from 'react';
import IUserLoginDTO from 'modules/authentication/domain/dtos/IUserLoginDTO';
import makeLogUserService from 'modules/authentication/services/factories/makeLogUserService';
import { useSessionContext, useToastContext } from 'shared/view/contexts';
interface UseLoginController {
(): {
loading: boolean;
onSubmit: (values: IUserLoginDTO) => Promise<void>;
};
}
const useLoginController: UseLoginController = () => {
const [loading, setLoading] = useState(false);
const loginService = useMemo(() => makeLogUserService(), []);
const session = useSessionContext();
const toast = useToastContext();
const onSubmit = useCallback(
async (values: IUserLoginDTO) => {
setLoading(true);
const { token, error } = await loginService.execute(values);
if (error) {
toast.showError(error);
return setLoading(false);
}
if (token) return await session.login(token);
},
[loginService, session, toast],
);
return {
loading,
onSubmit,
};
};
export default useLoginController;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/Activities/components/EmptyList/index.tsx | import React from 'react';
import { Container, Text } from './styles';
const EmptyList: React.FC = () => (
<Container>
<Text>
Não há nenhuma atividade cadastrada. Fale com os administradores para que
você possa começar a pontuar!
</Text>
</Container>
);
export default EmptyList;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/infra/controllers/useRequestActivityController.ts | import { useCallback, useMemo, useState } from 'react';
import IRequestActivityDTO from 'modules/selectedGame/domain/dtos/IRequestActivityDTO';
import makeRequestActivityService from 'modules/selectedGame/services/factories/makeRequestActivityService';
import { useSessionContext, useToastContext } from 'shared/view/contexts';
interface UseRequestActivityController {
loading: boolean;
requestActivity(values: IRequestActivityDTO): Promise<boolean>;
}
export default function useRequestActivityController(): UseRequestActivityController {
const [loading, setLoading] = useState(false);
const requestActivityService = useMemo(
() => makeRequestActivityService(),
[],
);
const session = useSessionContext();
const toast = useToastContext();
const requestActivity = useCallback(
async (values: IRequestActivityDTO) => {
setLoading(true);
const response = await requestActivityService.execute(values);
setLoading(false);
if (response.shouldLogout) {
session.logout();
return false;
}
if (response.error) {
toast.showError(response.error);
return false;
}
return true;
},
[requestActivityService, session, toast],
);
return {
loading,
requestActivity,
};
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/services/factories/makeGetAchievementsService.ts | <gh_stars>0
import makeAchievementsRepository from 'modules/selectedGame/infra/repositories/factories/makeAchievementsRepository';
import GetAchievementsService from 'modules/selectedGame/services/GetAchievementsService';
export default function makeGetAchievementsService(): GetAchievementsService {
const repository = makeAchievementsRepository();
return new GetAchievementsService(repository);
}
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/view/pages/Lobby/components/ModalContent/hooks/useCodeScannerPermission.ts | <reponame>raulrozza/Gametask_Mobile
import { BarCodeScanner } from 'expo-barcode-scanner';
import { useEffect, useState } from 'react';
type IPermission = 'waiting' | 'granted' | 'ungranted';
export default function useCodeScannerPermission(): IPermission {
const [hasPermission, setHasPermission] = useState<IPermission>('waiting');
useEffect(() => {
(async () => {
const { status } = await BarCodeScanner.requestPermissionsAsync();
setHasPermission(status === 'granted' ? 'granted' : 'ungranted');
})();
}, []);
return hasPermission;
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/services/factories/makeUpdatePlayerTitleUseCase.ts | <filename>src/modules/selectedGame/services/factories/makeUpdatePlayerTitleUseCase.ts
import makePlayersRepository from 'modules/selectedGame/infra/repositories/factories/makePlayersRepository';
import UpdatePlayerTitleUseCase from 'modules/selectedGame/services/UpdatePlayerTitleUseCase';
export default function makeUpdatePlayerTitleUseCase(): UpdatePlayerTitleUseCase {
const repository = makePlayersRepository();
return new UpdatePlayerTitleUseCase(repository);
}
|
raulrozza/Gametask_Mobile | src/shared/infra/providers/factories/makeStorageProvider.ts | import IStorageProvider from 'shared/domain/providers/IStorageProvider';
import AsyncStorageProvider from 'shared/infra/providers/AsyncStorageProvider';
export default function makeStorageProvider(): IStorageProvider {
const storageProvider = new AsyncStorageProvider();
return storageProvider;
}
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/view/pages/Lobby/components/GameInfo/styles.ts | <reponame>raulrozza/Gametask_Mobile
import styled from 'styled-components/native';
import GameImage from 'modules/chooseGame/view/components/GameImage';
import DefaultButton from 'shared/view/components/Button';
export const Container = styled.View`
width: 100%;
height: 120px;
flex-direction: row;
align-items: center;
background-color: ${({ theme }) => theme.palette.primary.main};
padding: ${({ theme }) => theme.layout.spacing(2)};
margin-bottom: ${({ theme }) => theme.layout.spacing(2)};
border-radius: ${({ theme }) => theme.layout.borderRadius.small};
`;
export const Image = styled(GameImage)`
height: 92px;
width: 92px;
border-radius: 46px;
margin-right: ${({ theme }) => theme.layout.spacing(2)};
`;
export const Info = styled.View`
flex: 1;
height: 100%;
`;
export const Title = styled.Text`
color: ${({ theme }) => theme.palette.secondary.dark};
text-align: left;
font-size: 18px;
font-family: ${({ theme }) => theme.typography.family.title.bold};
font-size: 24px;
`;
export const Description = {
Container: styled.ScrollView``,
Text: styled.Text`
font-size: 12px;
`,
};
export const Button = styled(DefaultButton)`
width: 80px;
margin-top: ${({ theme }) => theme.layout.spacing(1)};
`;
|
raulrozza/Gametask_Mobile | src/shared/domain/providers/IHTTPProvider.ts | <filename>src/shared/domain/providers/IHTTPProvider.ts<gh_stars>0
interface IRequestConfig {
params?: any;
headers?: any;
}
export default interface IHTTPProvider {
addHeader(key: string, value: string): void;
removeHeader(key: string): void;
delete<T = unknown>(path: string, config?: IRequestConfig): Promise<T>;
get<T = unknown>(path: string, config?: IRequestConfig): Promise<T>;
patch<T = unknown>(
path: string,
body?: unknown,
config?: IRequestConfig,
): Promise<T>;
post<T = unknown>(
path: string,
body?: unknown,
config?: IRequestConfig,
): Promise<T>;
put<T = unknown>(
path: string,
body?: unknown,
config?: IRequestConfig,
): Promise<T>;
}
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/domain/repositories/IPlayersRepository.ts | <gh_stars>0
import IPlayer from 'shared/domain/entities/IPlayer';
export default interface IPlayersRepository {
create(gameId: string): Promise<void>;
findAll(): Promise<IPlayer[]>;
}
|
raulrozza/Gametask_Mobile | src/shared/infra/routes/public.tsx | import AuthenticationRoutes from 'modules/authentication/infra/routes';
import React from 'react';
const PublicRoutes: React.FC = () => <AuthenticationRoutes />;
export default PublicRoutes;
|
raulrozza/Gametask_Mobile | src/shared/view/contexts/index.ts | export * from './SessionContext';
export * from './ThemeContext';
export * from './ToastContext';
|
raulrozza/Gametask_Mobile | src/shared/view/contexts/ThemeContext/implementations/StyledComponentsThemeContext/helpers/index.ts | <reponame>raulrozza/Gametask_Mobile
export { default as getNewPalette } from './getNewPalette';
|
raulrozza/Gametask_Mobile | src/modules/authentication/view/pages/Login/components/LoginForm/index.tsx | <filename>src/modules/authentication/view/pages/Login/components/LoginForm/index.tsx
import React from 'react';
import { Formik } from 'formik';
import useLoginController from 'modules/authentication/infra/controllers/useLoginController';
import LoginSchema from 'modules/authentication/view/validation/Login';
import { Input, SubmitButton } from 'shared/view/components';
import Form from '../Form';
import { confirmTextStyle } from './styles';
const initialValues = {
email: '',
password: '',
};
interface LoginFormProps {
active: boolean;
}
const LoginForm: React.FC<LoginFormProps> = ({ active }) => {
const { loading, onSubmit } = useLoginController();
return (
<Formik
initialValues={initialValues}
validationSchema={LoginSchema}
onSubmit={onSubmit}
>
<Form active={active}>
<Input
name="email"
placeholder="E-mail"
textContentType="emailAddress"
autoCapitalize="none"
keyboardType="email-address"
required
/>
<Input
name="password"
textContentType="password"
placeholder="Senha"
secureTextEntry
required
/>
<SubmitButton loading={loading} textStyle={confirmTextStyle}>
Entrar
</SubmitButton>
</Form>
</Formik>
);
};
export default LoginForm;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/Feed/components/FeedPost/styles.ts | import { UserImage } from 'modules/selectedGame/view/components';
import { Typography } from 'shared/view/components';
import styled from 'styled-components/native';
export const Container = styled.View`
margin: ${({ theme }) => theme.layout.spacing(2)};
padding: ${({ theme }) => theme.layout.spacing(2)};
border-radius: ${({ theme }) => theme.layout.borderRadius.small};
background-color: ${({ theme }) => theme.palette.gray[0]};
overflow: hidden;
`;
export const Content = styled.View`
flex-direction: row;
justify-content: flex-start;
`;
export const Image = styled(UserImage)`
height: 48px;
width: 48px;
border-radius: 24px;
margin-right: ${({ theme }) => theme.layout.spacing(2)};
`;
export const Info = styled.View`
background-color: blue;
`;
export const Row = styled.View`
flex: 1;
`;
export const Meta = {
Container: styled.View`
width: 100%;
margin-top: ${({ theme }) => theme.layout.spacing(1)};
flex-direction: row;
justify-content: flex-end;
`,
Text: styled(Typography)`
color: ${({ theme }) => theme.palette.gray[300]};
font-style: italic;
`,
};
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/Activities/components/EmptyList/styles.ts | import { transparentize } from 'polished';
import styled from 'styled-components/native';
export const Container = styled.View`
padding: ${({ theme }) => theme.layout.spacing(2)};
margin: ${({ theme }) => theme.layout.spacing(1)};
margin-bottom: ${({ theme }) => theme.layout.spacing(4)};
flex-direction: row;
border-color: ${({ theme }) => theme.palette.secondary.dark};
border-width: 1px;
border-radius: ${({ theme }) => theme.layout.borderRadius.small};
background-color: ${({ theme }) =>
transparentize(0, theme.palette.secondary.contrast)};
`;
export const Text = styled.Text`
color: ${({ theme }) => theme.palette.secondary.dark};
text-align: center;
margin: ${({ theme }) => theme.layout.spacing(2, 0)};
`;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/Ranking/components/RankingPosition/index.tsx | <reponame>raulrozza/Gametask_Mobile
import React from 'react';
import { IPosition } from 'modules/selectedGame/domain/entities/ILeaderboard';
import { RankChip } from 'modules/selectedGame/view/components';
import { getTextColor } from 'shared/view/helpers';
import { Container, Icon, Image, PositionBlock, Text } from './styles';
interface RankingPositionProps {
item: IPosition;
index: number;
}
const RankingPosition: React.FC<RankingPositionProps> = ({ item, index }) => (
<Container>
<Image image={item.player.user.profile_url} />
{index < 3 ? (
<Icon name="trophy" index={index} />
) : (
<PositionBlock>
<Text.Position>{`${index + 1}º`}</Text.Position>
</PositionBlock>
)}
<Text.Bold>{item.experience} XP</Text.Bold>
{item.player.rank && (
<RankChip
backgroundColor={item.player.rank.color}
color={getTextColor(item.player.rank.color)}
>
{item.player.rank.tag}
</RankChip>
)}
<Text.Name>
{item.player.user.firstname}
{item.player.user.lastname && ` ${item.player.user.lastname}`}
{item.player.currentTitle && `, ${item.player.currentTitle.name}`}
</Text.Name>
</Container>
);
export default RankingPosition;
|
raulrozza/Gametask_Mobile | src/modules/authentication/domain/repositories/IUsersRepository.ts | import IUserLoginDTO from 'modules/authentication/domain/dtos/IUserLoginDTO';
import IUserSignupDTO from 'modules/authentication/domain/dtos/IUserSignupDTO';
import IUserAuthentication from 'modules/authentication/domain/entities/IUserAuthentication';
import IUser from 'shared/domain/entities/IUser';
export default interface IUsersRepository {
create(values: IUserSignupDTO): Promise<IUser>;
validate(credentials: IUserLoginDTO): Promise<IUserAuthentication>;
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/Feed/components/AchievementFeed/index.tsx | <gh_stars>0
import React from 'react';
import IFeedPost from 'modules/selectedGame/domain/entities/IFeedPost';
import FeedText from '../FeedText';
import RankTag from '../RankTag';
interface AchievementFeedProps {
post: IFeedPost;
}
const AchievementFeed: React.FC<AchievementFeedProps> = ({ post }) => (
<FeedText.Text>
<RankTag rank={post.player.rank} />{' '}
<FeedText.Name>
{post.player.user.firstname}
{post.player.user.lastname && ` ${post.player.user.lastname}`}
{post.player.currentTitle && `, ${post.player.currentTitle?.name}`}
</FeedText.Name>{' '}
desbloqueou a conquista{' '}
<FeedText.Activity>{post.achievement?.name}</FeedText.Activity>
{post.achievement?.title?.name && (
<>
, recebendo o título{' '}
<FeedText.Bold>{post.achievement.title.name}</FeedText.Bold>
</>
)}
!
</FeedText.Text>
);
export default AchievementFeed;
|
raulrozza/Gametask_Mobile | App.tsx | /* eslint-disable camelcase */
import React from 'react';
// Routes
import AppView from 'shared/view';
const App: React.FC = () => <AppView />;
export default App;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/PlayerProfile/components/Header/styles.ts | <reponame>raulrozza/Gametask_Mobile
import styled from 'styled-components/native';
export const Container = styled.View`
width: 100%;
background-color: ${({ theme }) => theme.palette.primary.main};
border-style: solid;
border-bottom-width: 4px;
border-bottom-color: ${({ theme }) => theme.palette.primary.dark};
`;
export const Name = styled.Text`
width: 100%;
padding: ${({ theme }) => theme.layout.spacing(4)};
color: ${({ theme }) => theme.palette.primary.contrast};
font-weight: bold;
font-size: 24px;
`;
export const Title = styled.Text`
font-size: 20px;
color: ${({ theme }) => theme.palette.secondary.main};
`;
|
raulrozza/Gametask_Mobile | src/modules/authentication/domain/entities/IUserAuthentication.ts | export default interface IUserAuthentication {
token: 'string';
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/services/UpdatePlayerTitleUseCase.ts | <reponame>raulrozza/Gametask_Mobile
import IUpdateTitleDTO from 'modules/selectedGame/domain/dtos/IUpdateTitleDTO';
import IPlayersRepository from 'modules/selectedGame/domain/repositories/IPlayersRepository';
interface IExecute {
shouldLogout?: boolean;
error?: string;
}
export default class UpdatePlayerTitleUseCase {
constructor(private playersRepository: IPlayersRepository) {}
public async execute({
titleId,
playerId,
}: IUpdateTitleDTO): Promise<IExecute> {
try {
await this.playersRepository.updateCurrentTitle(playerId, titleId);
return {};
} catch (error) {
return {
error: (error as any).message,
shouldLogout: (error as any).shouldLogout,
};
}
}
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/Feed/components/ActivityFeed/index.tsx | <gh_stars>0
import React from 'react';
import IFeedPost from 'modules/selectedGame/domain/entities/IFeedPost';
import FeedText from '../FeedText';
import RankTag from '../RankTag';
interface ActivityFeedProps {
post: IFeedPost;
}
const ActivityFeed: React.FC<ActivityFeedProps> = ({ post }) => (
<FeedText.Text>
<RankTag rank={post.player.rank} />{' '}
<FeedText.Name>
{post.player.user.firstname}
{post.player.user.lastname && ` ${post.player.user.lastname}`}
{post.player.currentTitle && `, ${post.player.currentTitle?.name}`}
</FeedText.Name>{' '}
ganhou <FeedText.Bold>{post.activity?.experience} XP</FeedText.Bold> por{' '}
<FeedText.Activity>{post.activity?.name}</FeedText.Activity>!
</FeedText.Text>
);
export default ActivityFeed;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/infra/controllers/useGetAchievementsController.ts | <filename>src/modules/selectedGame/infra/controllers/useGetAchievementsController.ts
import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import IAchievement from 'modules/selectedGame/domain/entities/IAchievement';
import makeGetAchievementsService from 'modules/selectedGame/services/factories/makeGetAchievementsService';
import { useSessionContext } from 'shared/view/contexts';
import { useToastContext } from 'shared/view/contexts';
interface UseGetAchievementsController {
loading: boolean;
achievements: IAchievement[];
getAchievements(): Promise<void>;
}
export default function useGetAchievementsController(): UseGetAchievementsController {
const [loading, setLoading] = useState(true);
const [achievements, setAchievements] = useState<IAchievement[]>([]);
const mounted = useRef(false);
const getAchievementsService = useMemo(
() => makeGetAchievementsService(),
[],
);
const session = useSessionContext();
const toast = useToastContext();
const getAchievements = useCallback(async () => {
setLoading(true);
const response = await getAchievementsService.execute();
if (!mounted.current) return;
setLoading(false);
if (response.shouldLogout) return session.logout();
if (response.error) return toast.showError(response.error);
if (response.achievements) setAchievements(response.achievements);
}, [getAchievementsService, session, toast]);
useEffect(() => {
mounted.current = true;
getAchievements();
return () => {
mounted.current = false;
};
}, [getAchievements]);
return {
loading,
achievements,
getAchievements,
};
}
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/view/pages/Lobby/components/Footer/styles.ts | import { FontAwesome } from '@expo/vector-icons';
import { RectButton } from 'react-native-gesture-handler';
import styled from 'styled-components/native';
import { Typography } from 'shared/view/components';
export const Row = styled.View`
flex-direction: row;
align-items: center;
justify-content: space-evenly;
height: 48px;
padding: ${({ theme }) => theme.layout.spacing(2, 4)};
background-color: ${({ theme }) => theme.palette.primary.main};
`;
export const Button = {
Wrapper: styled(RectButton)`
flex-direction: row;
align-items: center;
padding: ${({ theme }) => theme.layout.spacing(1)};
`,
Icon: styled(FontAwesome)`
color: ${({ theme }) => theme.palette.secondary.dark};
font-size: 24px;
margin-right: ${({ theme }) => theme.layout.spacing(1)};
`,
Text: styled(Typography)`
color: ${({ theme }) => theme.palette.secondary.dark};
font-size: 18px;
`,
};
|
raulrozza/Gametask_Mobile | src/shared/infra/providers/AsyncStorageProvider.ts | import AsyncStorage from '@react-native-community/async-storage';
import IStorageProvider from 'shared/domain/providers/IStorageProvider';
export default class AsyncStorageProvider implements IStorageProvider {
public async clear(): Promise<void> {
return AsyncStorage.clear();
}
public async delete(key: string): Promise<void> {
return AsyncStorage.removeItem(key);
}
public async get<T = unknown>(key: string): Promise<T | null> {
const stringifiedData = await AsyncStorage.getItem(key);
if (!stringifiedData) return null;
return JSON.parse(stringifiedData);
}
public async store(key: string, data: unknown): Promise<void> {
const stringifiedData = JSON.stringify(data);
return AsyncStorage.setItem(key, stringifiedData);
}
}
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/infra/controllers/useGetGameController.ts | <reponame>raulrozza/Gametask_Mobile
import { useCallback, useEffect, useMemo, useState } from 'react';
import makeGetGameService from 'modules/chooseGame/services/factories/makeGetGameService';
import { useSessionContext } from 'shared/view/contexts';
import { useToastContext } from 'shared/view/contexts';
import IGame from 'shared/domain/entities/IGame';
interface GameParams {
gameId: string;
}
interface UseGetGameController {
loading: boolean;
game: IGame;
getGame(id: string): Promise<void>;
}
export default function useGetGameController({
gameId,
}: GameParams): UseGetGameController {
const [loading, setLoading] = useState(true);
const [game, setGame] = useState<IGame>({} as IGame);
const getGameService = useMemo(() => makeGetGameService(), []);
const session = useSessionContext();
const toast = useToastContext();
const getGame = useCallback(
async (id: string) => {
setLoading(true);
const response = await getGameService.execute(id);
setLoading(false);
if (response.shouldLogout) return session.logout();
if (response.error) return toast.showError(response.error);
if (response.game) setGame(response.game);
},
[getGameService, session, toast],
);
useEffect(() => {
getGame(gameId);
}, [getGame]); // eslint-disable-line react-hooks/exhaustive-deps
return {
loading,
game,
getGame,
};
}
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/infra/providers/CryptoJSCryptoProvider.ts | import crypto from 'react-native-crypto-js';
import ICryptoProvider from 'modules/chooseGame/domain/providers/ICryptoProvider';
const SECRET = process.env.REACT_NATIVE_SECRET || '';
export default class CryptoJDCryptoProvider implements ICryptoProvider {
public decrypt<T = unknown>(encrypted: string): T | undefined {
try {
const decryptedCode = crypto.AES.decrypt(encrypted, SECRET);
return JSON.parse(decryptedCode.toString(crypto.enc.Utf8));
} catch {
return undefined;
}
}
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/components/AchievementImage/index.tsx | import React from 'react';
import { Image, ImageStyle, StyleProp } from 'react-native';
interface AchievementImageProps {
image?: string;
style?: StyleProp<ImageStyle>;
}
const AchievementImage: React.FC<AchievementImageProps> = ({
image,
style,
}) => {
return (
<Image
style={style}
source={
image
? {
uri: image,
}
: require('assets/img/achievements/placeholder.png')
}
/>
);
};
export default AchievementImage;
|
raulrozza/Gametask_Mobile | src/shared/view/components/Input/index.tsx | import React, { useState } from 'react';
import { TextInputProps } from 'react-native';
import { useField } from 'formik';
import { darken } from 'polished';
import { useThemeContext } from 'shared/view/contexts';
import { Container, ErrorField, ErrorFieldText, StyledInput } from './styles';
interface InputProps {
name: string;
fullWidth?: boolean;
required?: boolean;
textContentType?: TextInputProps['textContentType'];
keyboardType?: TextInputProps['keyboardType'];
placeholder?: TextInputProps['placeholder'];
autoCapitalize?: TextInputProps['autoCapitalize'];
secureTextEntry?: TextInputProps['secureTextEntry'];
multiline?: boolean;
}
const Input: React.FC<InputProps> = ({
name,
required,
fullWidth = false,
...props
}) => {
const [focused, setFocus] = useState(false);
const [field, meta, helpers] = useField(name);
const { theme } = useThemeContext();
const placeholder =
props.placeholder && `${props.placeholder}${required ? ' *' : ''}`;
return (
<Container fullWidth={fullWidth}>
<StyledInput
onBlur={() => {
setFocus(false);
helpers.setTouched(true);
}}
onFocus={() => setFocus(true)}
onChangeText={helpers.setValue}
focused={focused}
placeholderTextColor={darken(0.4, theme.palette.primary.main)}
value={field.value}
{...props}
placeholder={placeholder}
/>
{meta.touched && meta.error && (
<ErrorField>
<ErrorFieldText>{meta.error}</ErrorFieldText>
</ErrorField>
)}
</Container>
);
};
export default Input;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/Feed/components/EmptyList/index.tsx | import React from 'react';
import { Container, Text } from './styles';
const EmptyList: React.FC = () => (
<Container>
<Text>Parece que ninguém realizou nenhuma atividade ainda...</Text>
</Container>
);
export default EmptyList;
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/services/GetUserService.ts | <gh_stars>0
import IUsersRepository from 'modules/chooseGame/domain/repositories/IUsersRepository';
import IUser from 'shared/domain/entities/IUser';
interface IExecute {
user?: IUser;
shouldLogout?: boolean;
error?: string;
}
export default class GetUserService {
constructor(private usersRepository: IUsersRepository) {}
public async execute(id: string): Promise<IExecute> {
try {
const user = await this.usersRepository.findById(id);
return { user };
} catch (error) {
return {
error: error.message,
shouldLogout: error.shouldLogout,
};
}
}
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/PlayerProfile/index.tsx | <reponame>raulrozza/Gametask_Mobile
import React, { useCallback, useMemo } from 'react';
import { ActivityIndicator, SafeAreaView } from 'react-native';
import { useFocusEffect } from '@react-navigation/core';
import { isEmpty } from 'lodash';
import { ThemeProvider } from 'styled-components';
import useFindPlayerController from 'modules/selectedGame/infra/controllers/useFindPlayerController';
import { PlayerProfileContext } from 'modules/selectedGame/view/contexts';
import { useThemeContext } from 'shared/view/contexts';
import { AchievementList, BasicLevelInfo, Header, Options } from './components';
import { Container } from './styles';
const PlayerProfile: React.FC = () => {
const { loading, player, getPlayer } = useFindPlayerController();
const { theme, createPallete } = useThemeContext();
const rankTheme = useMemo(
() =>
loading || !player?.rank?.color
? theme
: {
...theme,
palette: createPallete({
primary: player.rank.color,
secondary: theme.palette.primary.main,
}),
},
[player, createPallete, theme, loading],
);
useFocusEffect(
useCallback(() => {
if (!player.id) return;
getPlayer(player.id);
}, [getPlayer]), // eslint-disable-line react-hooks/exhaustive-deps
);
if (loading || isEmpty(player)) return <ActivityIndicator />;
return (
<SafeAreaView>
<ThemeProvider theme={rankTheme}>
<PlayerProfileContext player={player}>
<Container>
<Header />
<BasicLevelInfo />
<AchievementList />
<Options />
</Container>
</PlayerProfileContext>
</ThemeProvider>
</SafeAreaView>
);
};
export default PlayerProfile;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/services/RequestAchievementUnlockService.ts | import IRequestAchievementDTO from 'modules/selectedGame/domain/dtos/IRequestAchievementDTO';
import IRequestsRepository from 'modules/selectedGame/domain/repositories/IRequestsRepository';
interface IExecute {
shouldLogout?: boolean;
error?: string;
}
export default class RequestAchievementUnlockService {
constructor(private requestsRepository: IRequestsRepository) {}
public async execute(payload: IRequestAchievementDTO): Promise<IExecute> {
try {
await this.requestsRepository.achievement(payload);
return {};
} catch (error) {
return {
error: error.message,
shouldLogout: error.shouldLogout,
};
}
}
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/services/factories/makeGetFeedPostsService.ts | import makeFeedPostsRepository from 'modules/selectedGame/infra/repositories/factories/makeFeedPostsRepository';
import GetFeedPostsService from 'modules/selectedGame/services/GetFeedPostsService';
export default function makeGetFeedPostsService(): GetFeedPostsService {
const repository = makeFeedPostsRepository();
return new GetFeedPostsService(repository);
}
|
raulrozza/Gametask_Mobile | src/shared/domain/providers/ISessionContext.ts | <reponame>raulrozza/Gametask_Mobile
interface ITheme {
primary: string;
secondary: string;
}
interface ISwitchGameParams {
gameId: string;
theme: ITheme;
playerId: string;
}
export default interface ISessionContext {
playerId: string;
userToken: string | null;
userData: { id: string; name: string; profile_url?: string };
selectedGame: string | null;
loading: boolean;
login(token: string): Promise<void>;
logout(): Promise<void>;
switchGame(params?: ISwitchGameParams): Promise<void>;
}
|
raulrozza/Gametask_Mobile | src/shared/view/contexts/ToastContext/hooks/useToastContext.ts | import { createContext, useContext } from 'react';
import { isEmpty } from 'lodash';
import IToastContext from 'shared/domain/providers/IToastContext';
export const ToastContextProvider = createContext<IToastContext>(
{} as IToastContext,
);
const useToastContext = (): IToastContext => {
const toastProvider = useContext(ToastContextProvider);
if (isEmpty(toastProvider))
throw new Error(
'useToastContext should be called inside a ToastContextProvider',
);
return toastProvider;
};
export default useToastContext;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/RequestActivity/components/Footer/styles.ts | <reponame>raulrozza/Gametask_Mobile
import styled from 'styled-components/native';
export const Container = styled.View`
width: 100%;
flex-direction: row;
justify-content: space-around;
margin-top: ${({ theme }) => theme.layout.spacing(2)};
`;
export const Back = styled.TouchableOpacity`
border-width: 1px;
padding: ${({ theme }) => theme.layout.spacing(2)};
border-radius: ${({ theme }) => theme.layout.borderRadius.small};
border-color: ${({ theme }) => theme.palette.secondary.main};
width: 100px;
align-items: center;
`;
|
raulrozza/Gametask_Mobile | src/modules/authentication/view/pages/Login/styles.ts | <gh_stars>0
import { Typography } from 'shared/view/components';
import styled from 'styled-components/native';
export const HomePage = styled.ScrollView.attrs(() => ({
contentContainerStyle: {
flex: 1,
justifyContent: 'center',
alignItems: 'center',
},
}))`
background-color: ${({ theme }) => theme.palette.primary.dark};
`;
export const TitleContainer = styled.View`
width: 100%;
height: 20%;
justify-content: center;
align-items: center;
`;
export const Title = {
View: styled.View`
background-color: ${({ theme }) => theme.palette.secondary.dark};
padding: ${({ theme }) => theme.layout.spacing(2, 5)};
border-radius: ${({ theme }) => theme.layout.borderRadius.medium};
width: 300px;
`,
Text: styled(Typography)`
text-align: center;
color: ${({ theme }) => theme.palette.secondary.contrast};
font-weight: bold;
font-size: 24px;
`,
};
export const FormContainer = styled.View`
height: 80%;
`;
export const Container = styled.View`
background-color: ${({ theme }) => theme.palette.primary.main};
border-radius: 3px;
flex: 1;
margin: ${({ theme }) => theme.layout.spacing(0, 4, 4)};
`;
export const FormToggle = styled.View`
width: 100%;
height: 60px;
flex-direction: row;
`;
interface ActiveItemProps {
active: boolean;
}
export const ToggleButton = {
Button: styled.TouchableOpacity<ActiveItemProps>`
width: 50%;
padding: ${({ theme }) => theme.layout.spacing(2)};
justify-content: center;
align-items: center;
background-color: ${({ theme, active }) =>
active ? theme.palette.primary.main : theme.palette.secondary.main};
`,
Text: styled(Typography)<ActiveItemProps>`
font-size: 20px;
font-weight: bold;
color: ${({ theme, active }) =>
active ? theme.palette.secondary.main : theme.palette.secondary.contrast};
`,
};
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/domain/entities/IFeedPost.ts | <reponame>raulrozza/Gametask_Mobile
import IAchievement from 'modules/selectedGame/domain/entities/IAchievement';
import IActivity from 'modules/selectedGame/domain/entities/IActivity';
import IPlayer from 'shared/domain/entities/IPlayer';
import IRank from 'shared/domain/entities/IRank';
interface IFeedPost {
id: string;
player: IPlayer;
type: 'achievement' | 'activity' | 'level' | 'rank';
activity?: IActivity;
achievement?: IAchievement;
level: {
level: number;
requiredExperience: number;
title?: string;
};
rank: IRank;
date: string;
}
export default IFeedPost;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/services/GetActivitiesService.ts | <filename>src/modules/selectedGame/services/GetActivitiesService.ts
import IActivity from 'modules/selectedGame/domain/entities/IActivity';
import IActivitiesRepository from 'modules/selectedGame/domain/repositories/IActivitiesRepository';
interface IExecute {
activities?: IActivity[];
shouldLogout?: boolean;
error?: string;
}
export default class GetActivitiesService {
constructor(private activitesRepository: IActivitiesRepository) {}
public async execute(): Promise<IExecute> {
try {
const activities = await this.activitesRepository.findAll();
return { activities };
} catch (error) {
return {
error: error.message,
shouldLogout: error.shouldLogout,
};
}
}
}
|
raulrozza/Gametask_Mobile | src/config/errors/apiCodes.ts | const codes: Record<number, string> = {
100: 'E-mail indisponível',
101: 'Você já está cadastrado neste jogo',
102: 'Você já requisitou esta conquista',
103: 'Houve um erro com sua requisição',
104: 'O dado enviado é inválido',
200: 'Usuário ou senha incorretos',
201: 'Não é possível remover um título que um jogador já possua',
202: 'Usuário não encontrado',
203: 'Você já possui esta conquista',
300: 'Houve um problema com a requisição.',
403: 'Você não tem permissão para realizar esta ação',
404: 'Não foi possível encontrar o recurso',
500: 'Houve um problema. Tente novamente mais tarde',
};
export default codes;
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/view/components/GameImage/index.tsx | <reponame>raulrozza/Gametask_Mobile<filename>src/modules/chooseGame/view/components/GameImage/index.tsx
import React from 'react';
import { Image, ImageStyle, StyleProp } from 'react-native';
interface GameImageProps {
url?: string;
style?: StyleProp<ImageStyle>;
}
const GameImage: React.FC<GameImageProps> = ({ url, style }) => {
return (
<Image
style={style}
source={
url
? {
uri: url,
}
: require('assets/img/games/placeholder.png')
}
/>
);
};
export default GameImage;
|
raulrozza/Gametask_Mobile | src/shared/view/index.tsx | <filename>src/shared/view/index.tsx
import 'react-native-gesture-handler';
import React from 'react';
import { RecoilRoot } from 'recoil';
import Routes from 'shared/infra/routes';
import FontLoader from 'shared/view/global/FontLoader';
import AppContainer from './AppContainer';
const AppView: React.FC = () => (
<RecoilRoot>
<FontLoader>
<AppContainer>
<Routes />
</AppContainer>
</FontLoader>
</RecoilRoot>
);
export default AppView;
|
raulrozza/Gametask_Mobile | src/modules/authentication/view/pages/Login/index.tsx | <reponame>raulrozza/Gametask_Mobile
import React, { useState } from 'react';
import { LoginForm, SignupForm } from './components';
import {
HomePage,
TitleContainer,
Title,
FormContainer,
Container,
FormToggle,
ToggleButton,
} from './styles';
const Login: React.FC = () => {
const [formToggle, setFormToggle] = useState(true);
return (
<HomePage>
<TitleContainer>
<Title.View>
<Title.Text variant="title" fontBold="bold">
GAMETASK
</Title.Text>
</Title.View>
</TitleContainer>
<FormContainer>
<Container>
<FormToggle>
<ToggleButton.Button
active={formToggle}
onPress={() => setFormToggle(true)}
>
<ToggleButton.Text active={formToggle}>Entre</ToggleButton.Text>
</ToggleButton.Button>
<ToggleButton.Button
active={!formToggle}
onPress={() => setFormToggle(false)}
>
<ToggleButton.Text active={!formToggle}>
Cadastre-se
</ToggleButton.Text>
</ToggleButton.Button>
</FormToggle>
<LoginForm active={formToggle} />
<SignupForm active={!formToggle} />
</Container>
</FormContainer>
</HomePage>
);
};
export default Login;
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/view/pages/Lobby/components/Footer/index.tsx | import React from 'react';
import { useNavigation } from '@react-navigation/native';
import { useSessionContext } from 'shared/view/contexts';
import { Row, Button } from './styles';
interface FooterProps {
showModal: () => void;
}
const Footer: React.FC<FooterProps> = ({ showModal }) => {
const { logout } = useSessionContext();
const { navigate } = useNavigation();
return (
<Row>
<Button.Wrapper onPress={() => navigate('Profile')}>
<Button.Icon name="gear" />
<Button.Text>Usuário</Button.Text>
</Button.Wrapper>
<Button.Wrapper onPress={showModal}>
<Button.Icon name="plus" />
<Button.Text>Novo</Button.Text>
</Button.Wrapper>
<Button.Wrapper>
<Button.Icon name="sign-out" onPress={logout} />
<Button.Text>Sair</Button.Text>
</Button.Wrapper>
</Row>
);
};
export default Footer;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/domain/repositories/IAchievementsRepository.ts | import IAchievement from 'modules/selectedGame/domain/entities/IAchievement';
export default interface IAchievementsRepository {
findAll(): Promise<IAchievement[]>;
}
|
raulrozza/Gametask_Mobile | src/shared/view/components/Button/styles.ts | <reponame>raulrozza/Gametask_Mobile
import {
DefaultTheme,
FlattenInterpolation,
ThemeProps,
} from 'styled-components';
import styled, { css } from 'styled-components/native';
import Typography from 'shared/view/components/Typography';
// Libs
import { RectButton } from 'react-native-gesture-handler';
export interface StyledButtonProps {
outline: boolean;
disabled?: boolean;
}
export const StyledContainer = styled.View<StyledButtonProps>`
${({ theme, outline, disabled = false }) => css`
${outline
? css`
background-color: ${theme.palette.primary.main};
color: ${theme.palette.secondary.main};
`
: css`
background-color: ${theme.palette.secondary.main};
color: ${theme.palette.secondary.contrast};
`}
border-radius: ${theme.layout.borderRadius.small};
line-height: 24px;
font-size: 16px;
height: ${theme.layout.spacing(10)};
border-width: 1px;
border-color: ${theme.palette.secondary.main};
align-items: stretch;
justify-content: center;
min-width: 80px;
${disabled &&
css`
opacity: 0.5;
`}
`}
`;
export const RectContainer = styled(RectButton)`
min-width: 80px;
`;
export const TouchableContainer = styled.TouchableOpacity`
min-width: 80px;
`;
interface TextProps {
outline: boolean;
textStyle?: FlattenInterpolation<ThemeProps<DefaultTheme>>;
}
export const Text = styled(Typography)<TextProps>`
${({ theme, outline, textStyle }) => css`
text-align: center;
color: ${outline
? theme.palette.secondary.main
: theme.palette.secondary.contrast};
${textStyle}
`}
`;
|
raulrozza/Gametask_Mobile | src/shared/view/contexts/SessionContext/implementations/DefaultSessionContext/index.tsx | <filename>src/shared/view/contexts/SessionContext/implementations/DefaultSessionContext/index.tsx
import React, { useCallback, useEffect, useMemo, useState } from 'react';
import ISessionContext from 'shared/domain/providers/ISessionContext';
import makeHttpProvider from 'shared/infra/providers/factories/makeHttpProvider';
import makeJwtProvider from 'shared/infra/providers/factories/makeJwtProvider';
import makeStorageProvider from 'shared/infra/providers/factories/makeStorageProvider';
import { SessionContextProvider } from 'shared/view/contexts/SessionContext/hooks/useSessionContext';
import { useThemeContext } from 'shared/view/contexts/ThemeContext';
const USER_STORAGE_KEY = '@GameTask/token';
const GAME_STORAGE_KEY = '@GameTask/game';
const PLAYER_ID_STORAGE_KEY = '@GameTask/playerId';
const USER_HEADER_KEY = 'Authorization';
const GAME_HEADER_KEY = 'x-game-id';
interface IUserData {
id: string;
name: string;
profile_url?: string;
}
const DefaultSessionContext: React.FC = ({ children }) => {
const [userToken, setUserToken] = useState<string | null>(null);
const [userData, setUserData] = useState<IUserData>({} as IUserData);
const [playerId, setPlayerId] = useState('');
const [selectedGame, setSelectedGame] = useState<string | null>(null);
const [loading, setLoading] = useState(true);
const theme = useThemeContext();
const storage = useMemo(() => makeStorageProvider(), []);
const http = useMemo(() => makeHttpProvider(), []);
const jwt = useMemo(() => makeJwtProvider(), []);
const addAuthenticationHeader = useCallback(
(token: string) => http.addHeader(USER_HEADER_KEY, `Bearer ${token}`),
[http],
);
const decodeToken = useCallback(
(token: string) => jwt.decode<IUserData>(token),
[jwt],
);
useEffect(() => {
Promise.all([
storage.get<string>(USER_STORAGE_KEY),
storage.get<string>(GAME_STORAGE_KEY),
storage.get<string>(PLAYER_ID_STORAGE_KEY),
]).then(async ([token, game, playerId]) => {
const userData = await decodeToken(String(token));
if (userData) setUserData(userData);
setUserToken(token);
setSelectedGame(game);
setPlayerId(String(playerId));
if (token) addAuthenticationHeader(token);
if (game) http.addHeader(GAME_HEADER_KEY, game);
setLoading(false);
});
}, [addAuthenticationHeader, decodeToken, http, storage]);
const login = useCallback<ISessionContext['login']>(
async token => {
const userData = await decodeToken(String(token));
if (userData) setUserData(userData);
addAuthenticationHeader(token);
setUserToken(token);
await storage.store(USER_STORAGE_KEY, token);
},
[addAuthenticationHeader, decodeToken, storage],
);
const logout = useCallback<ISessionContext['logout']>(async () => {
await theme.switchTheme();
setUserToken(null);
setSelectedGame(null);
setPlayerId('');
http.removeHeader(USER_HEADER_KEY);
http.removeHeader(GAME_HEADER_KEY);
await storage.delete(USER_STORAGE_KEY);
await storage.delete(GAME_STORAGE_KEY);
}, [http, storage, theme]);
const switchGame = useCallback<ISessionContext['switchGame']>(
async params => {
if (params) {
const { gameId, theme: newTheme, playerId } = params;
http.addHeader(GAME_HEADER_KEY, gameId);
setSelectedGame(gameId);
setPlayerId(playerId);
if (newTheme) await theme.switchTheme(newTheme);
await storage.store(GAME_STORAGE_KEY, gameId);
setPlayerId(String(playerId));
await storage.store(PLAYER_ID_STORAGE_KEY, playerId);
return;
}
await theme.switchTheme();
setSelectedGame(null);
setPlayerId('');
http.removeHeader(GAME_HEADER_KEY);
await storage.delete(GAME_STORAGE_KEY);
await storage.delete(PLAYER_ID_STORAGE_KEY);
},
[http, storage, theme],
);
return (
<SessionContextProvider.Provider
value={{
playerId,
userToken,
userData,
selectedGame,
loading,
login,
logout,
switchGame,
}}
>
{children}
</SessionContextProvider.Provider>
);
};
export default DefaultSessionContext;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/components/index.ts | <gh_stars>0
export { default as AchievementImage } from './AchievementImage';
export { default as RankChip } from './RankChip';
export { default as UserImage } from './UserImage';
|
raulrozza/Gametask_Mobile | src/shared/view/contexts/SessionContext/index.ts | <filename>src/shared/view/contexts/SessionContext/index.ts
import useSessionContext from 'shared/view/contexts/SessionContext/hooks/useSessionContext';
import SessionContext from 'shared/view/contexts/SessionContext/implementations/DefaultSessionContext';
export { SessionContext, useSessionContext };
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/domain/repositories/IUsersRepository.ts | <filename>src/modules/chooseGame/domain/repositories/IUsersRepository.ts
import IUser from 'shared/domain/entities/IUser';
export interface IUpdateParams {
firstname: string;
lastname?: string;
image?: string;
}
export default interface IUsersRepository {
findById(id: string): Promise<IUser>;
update(data: IUpdateParams): Promise<void>;
}
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/services/FetchPlayersService.ts | import IPlayersRepository from 'modules/chooseGame/domain/repositories/IPlayersRepository';
import IPlayer from 'shared/domain/entities/IPlayer';
interface IExecute {
players?: IPlayer[];
shouldLogout?: boolean;
error?: string;
}
export default class FetchPlayersService {
constructor(private playersRepository: IPlayersRepository) {}
public async execute(): Promise<IExecute> {
try {
const players = await this.playersRepository.findAll();
return { players };
} catch (error) {
return {
error: error.message,
shouldLogout: error.shouldLogout,
};
}
}
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/infra/repositories/RequestsRepository.ts | import IRequestAchievementDTO from 'modules/selectedGame/domain/dtos/IRequestAchievementDTO';
import IRequestActivityDTO from 'modules/selectedGame/domain/dtos/IRequestActivityDTO';
import IRequestsRepository from 'modules/selectedGame/domain/repositories/IRequestsRepository';
import makeHttpProvider from 'shared/infra/providers/factories/makeHttpProvider';
export default class RequestsRepository implements IRequestsRepository {
private httpProvider = makeHttpProvider();
public async achievement({
id,
information,
playerId,
}: IRequestAchievementDTO): Promise<void> {
return this.httpProvider.post(`players/${playerId}/achievements`, {
information,
achievement: id,
requestDate: new Date(),
});
}
public async activity({
id,
information,
playerId,
completionDate,
}: IRequestActivityDTO): Promise<void> {
return this.httpProvider.post(`players/${playerId}/activities`, {
activity: id,
completionDate,
requestDate: new Date(),
information,
});
}
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/RequestAchievementUnlock/styles.ts | <reponame>raulrozza/Gametask_Mobile<filename>src/modules/selectedGame/view/pages/RequestAchievementUnlock/styles.ts
import { Button, SubmitButton, Typography } from 'shared/view/components';
import styled from 'styled-components/native';
export const Container = styled.ScrollView.attrs(() => ({
contentContainerStyle: {
alignItems: 'center',
justifyContent: 'flex-start',
},
}))`
flex: 1;
background-color: ${({ theme }) => theme.palette.primary.main};
`;
export const Title = styled(Typography)`
font-weight: bold;
font-size: 24px;
color: ${({ theme }) => theme.palette.secondary.main};
width: 100%;
padding: ${({ theme }) => theme.layout.spacing(1)};
text-align: center;
text-transform: capitalize;
`;
export const Form = styled.View`
width: 100%;
padding: ${({ theme }) => theme.layout.spacing(4)};
`;
export const Footer = {
Container: styled.View`
width: 100%;
flex-direction: row;
justify-content: space-around;
margin-top: ${({ theme }) => theme.layout.spacing(2)};
`,
Back: styled(Button)`
border-width: 1px;
border-radius: 5px;
width: 100px;
`,
Button: styled(SubmitButton)`
border-radius: 5px;
width: 100px;
align-items: center;
`,
};
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/infra/controllers/useGetFeedPostsController.ts | import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import IFeedPost from 'modules/selectedGame/domain/entities/IFeedPost';
import makeGetFeedPostsService from 'modules/selectedGame/services/factories/makeGetFeedPostsService';
import { useSessionContext } from 'shared/view/contexts';
import { useToastContext } from 'shared/view/contexts';
interface UseGetFeedPostsController {
loading: boolean;
posts: IFeedPost[];
getPosts(): Promise<void>;
}
export default function useGetFeedPostsController(): UseGetFeedPostsController {
const [loading, setLoading] = useState(true);
const [posts, setFeedPosts] = useState<IFeedPost[]>([]);
const mounted = useRef(false);
const getFeedPostsService = useMemo(() => makeGetFeedPostsService(), []);
const session = useSessionContext();
const toast = useToastContext();
const getPosts = useCallback(async () => {
setLoading(true);
const response = await getFeedPostsService.execute();
if (!mounted.current) return;
setLoading(false);
if (response.shouldLogout) return session.logout();
if (response.error) return toast.showError(response.error);
if (response.posts) setFeedPosts(response.posts);
}, [getFeedPostsService, session, toast]);
useEffect(() => {
mounted.current = true;
getPosts();
return () => {
mounted.current = false;
};
}, [getPosts]);
return {
loading,
posts,
getPosts,
};
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/infra/repositories/FeedPostsRepository.ts | <reponame>raulrozza/Gametask_Mobile<filename>src/modules/selectedGame/infra/repositories/FeedPostsRepository.ts
import IFeedPost from 'modules/selectedGame/domain/entities/IFeedPost';
import IFeedPostsRepository from 'modules/selectedGame/domain/repositories/IFeedPostsRepository';
import makeHttpProvider from 'shared/infra/providers/factories/makeHttpProvider';
export default class FeedPostsRepository implements IFeedPostsRepository {
private httpProvider = makeHttpProvider();
public async findAll(): Promise<IFeedPost[]> {
return this.httpProvider.get('feed');
}
}
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/infra/repositories/factories/makeUsersRepository.ts | <filename>src/modules/chooseGame/infra/repositories/factories/makeUsersRepository.ts
import IUsersRepository from 'modules/chooseGame/domain/repositories/IUsersRepository';
import UsersRepository from 'modules/chooseGame/infra/repositories/UsersRepository';
export default function makeUsersRepository(): IUsersRepository {
return new UsersRepository();
}
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/view/pages/Lobby/components/ModalContent/hooks/index.ts | <reponame>raulrozza/Gametask_Mobile<gh_stars>0
export { default as useCodeScannerPermission } from './useCodeScannerPermission';
|
raulrozza/Gametask_Mobile | src/config/theme/index.ts | <gh_stars>0
import layout from './layout';
import palette from './palette';
import typography from './typography';
const theme = {
palette,
layout,
typography,
};
export default theme;
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/view/pages/Lobby/components/GameInfo/index.tsx | <reponame>raulrozza/Gametask_Mobile
import React, { useCallback } from 'react';
import IPlayer from 'shared/domain/entities/IPlayer';
import { useSessionContext } from 'shared/view/contexts';
import { Button, Container, Description, Info, Image, Title } from './styles';
interface GameInfoProps {
player: IPlayer;
}
const GameInfo: React.FC<GameInfoProps> = ({ player }) => {
const { switchGame } = useSessionContext();
const handleGoToGame = useCallback(
() =>
switchGame({
gameId: player.game.id,
theme: player.game.theme,
playerId: player.id,
}),
[switchGame, player],
);
return (
<Container>
<Image url={player.game.image_url} />
<Info>
<Title>{player.game.name} </Title>
<Description.Container>
<Description.Text>{player.game.description}</Description.Text>
</Description.Container>
<Button outline onPress={handleGoToGame}>
Entrar
</Button>
</Info>
</Container>
);
};
export default GameInfo;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/infra/controllers/useGetActivitiesController.ts | import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import IActivity from 'modules/selectedGame/domain/entities/IActivity';
import makeGetActivitiesService from 'modules/selectedGame/services/factories/makeGetActivitiesService';
import { useSessionContext, useToastContext } from 'shared/view/contexts';
interface UseGetActivitiesController {
loading: boolean;
activities: IActivity[];
getActivities(): Promise<void>;
}
export default function useGetActivitiesController(): UseGetActivitiesController {
const [loading, setLoading] = useState(true);
const [activities, setActivities] = useState<IActivity[]>([]);
const mounted = useRef(false);
const getActivitiesService = useMemo(() => makeGetActivitiesService(), []);
const session = useSessionContext();
const toast = useToastContext();
const getActivities = useCallback(async () => {
setLoading(true);
const response = await getActivitiesService.execute();
if (!mounted.current) return;
setLoading(false);
if (response.shouldLogout) return session.logout();
if (response.error) return toast.showError(response.error);
if (response.activities) setActivities(response.activities);
}, [getActivitiesService, session, toast]);
useEffect(() => {
mounted.current = true;
getActivities();
return () => {
mounted.current = false;
};
}, [getActivities]);
return {
loading,
activities,
getActivities,
};
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/PlayerProfile/components/TitleSelect/index.tsx | <filename>src/modules/selectedGame/view/pages/PlayerProfile/components/TitleSelect/index.tsx
import React, { useState } from 'react';
import useUpdateTitleController from 'modules/selectedGame/infra/controllers/useUpdateTitleController';
import { usePlayerProfileContext } from 'modules/selectedGame/view/contexts';
import { Container, Select } from './styles';
const TitleSelect: React.FC = () => {
const { player } = usePlayerProfileContext();
const { updateTitle } = useUpdateTitleController();
const [currentTitle, setCurrentTitle] = useState<string | undefined>(
player.currentTitle?.id,
);
const onTitleUpdate = (value: unknown) => {
const newValue = typeof value === 'string' ? value : undefined;
setCurrentTitle(newValue);
updateTitle({ playerId: player.id, titleId: newValue });
};
if (!player.titles) return null;
return (
<Container>
<Select selectedValue={currentTitle} onValueChange={onTitleUpdate}>
<Select.Item label="Escolha um título..." value={null} />
{player.titles.map(title => (
<Select.Item key={title.id} label={title.name} value={title.id} />
))}
</Select>
</Container>
);
};
export default TitleSelect;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/Activities/components/ActivityCard/index.tsx | <reponame>raulrozza/Gametask_Mobile
import React from 'react';
import IActivity from 'modules/selectedGame/domain/entities/IActivity';
import { useNavigation } from '@react-navigation/native';
import {
Container,
Description,
Experience,
InfoContainer,
Title,
} from './styles';
interface ActivityCardProps {
activity: IActivity;
}
const ActivityCard: React.FC<ActivityCardProps> = ({ activity }) => {
const { navigate } = useNavigation();
return (
<Container onTouchEnd={() => navigate('requestActivity', { activity })}>
<InfoContainer>
<Title variant="title">{activity.name}</Title>
<Description>{activity.description}</Description>
</InfoContainer>
<Experience.Container>
<Experience.Text>{activity.experience} XP</Experience.Text>
</Experience.Container>
</Container>
);
};
export default ActivityCard;
|
raulrozza/Gametask_Mobile | src/shared/view/helpers/index.ts | export { default as getTextColor } from './getTextColor';
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/infra/controllers/useUpdateUserController.ts | <reponame>raulrozza/Gametask_Mobile<filename>src/modules/chooseGame/infra/controllers/useUpdateUserController.ts
import makeUpdateUserService from 'modules/chooseGame/services/factories/makeUpdateUserService';
import { useCallback, useMemo, useState } from 'react';
import { useSessionContext } from 'shared/view/contexts';
import { useToastContext } from 'shared/view/contexts';
interface IUpdateValues {
firstname: string;
lastname?: string;
image?: string;
}
interface UseUpdateUserController {
loading: boolean;
updateUser(values: IUpdateValues): Promise<boolean>;
}
export default function useUpdateUserController(): UseUpdateUserController {
const [loading, setLoading] = useState(false);
const updateUserService = useMemo(() => makeUpdateUserService(), []);
const session = useSessionContext();
const toast = useToastContext();
const updateUser = useCallback<UseUpdateUserController['updateUser']>(
async values => {
setLoading(true);
const response = await updateUserService.execute(values);
setLoading(false);
if (response.shouldLogout) {
session.logout();
return false;
}
if (response.error) {
toast.showError(response.error);
return false;
}
return true;
},
[updateUserService, session, toast],
);
return {
loading,
updateUser,
};
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/Ranking/index.tsx | <gh_stars>0
import React, { useCallback, useMemo } from 'react';
import { FlatList } from 'react-native-gesture-handler';
import { EmptyList, RankingPosition } from './components';
import useGetCurrentLeaderboardController from 'modules/selectedGame/infra/controllers/useGetCurrentLeaderboardController';
import { Container } from './styles';
import { useFocusEffect } from '@react-navigation/native';
const Ranking: React.FC = () => {
const {
loading,
leaderboard,
getLeaderboard,
} = useGetCurrentLeaderboardController();
useFocusEffect(
useCallback(() => {
getLeaderboard();
}, [getLeaderboard]),
);
const orderedPositions = useMemo(
() => leaderboard?.position.sort((a, b) => b.experience - a.experience),
[leaderboard],
);
return (
<Container>
<FlatList
refreshing={loading}
style={{ width: '100%' }}
contentContainerStyle={{
width: '100%',
}}
data={orderedPositions}
keyExtractor={item => item.player.id}
ListEmptyComponent={() => <EmptyList />}
renderItem={({ item, index }) => (
<RankingPosition item={item} index={index} />
)}
/>
</Container>
);
};
export default Ranking;
|
raulrozza/Gametask_Mobile | src/shared/view/components/Input/styles.ts | <filename>src/shared/view/components/Input/styles.ts
import { darken } from 'polished';
import styled, { css } from 'styled-components/native';
interface ContainerProps {
fullWidth: boolean;
}
export const Container = styled.View<ContainerProps>`
width: ${({ fullWidth }) => (fullWidth ? '100%' : '80%')};
margin-bottom: ${({ theme }) => theme.layout.spacing(2)};
`;
interface StyledInputProps {
focused: boolean;
multiline?: boolean;
}
export const StyledInput = styled.TextInput<StyledInputProps>`
width: 100%;
${({ theme, focused, multiline }) => css`
border-radius: ${theme.layout.borderRadius.small};
padding: ${theme.layout.spacing(0, 3)};
font-family: ${theme.typography.family.content.main};
background-color: ${theme.palette.gray['0']};
border: 1px solid
${focused
? theme.palette.secondary.main
: darken(0.1, theme.palette.primary.dark)};
color: ${theme.palette.primary.contrast};
height: ${multiline ? '72px' : '36px '};
`}
`;
export const ErrorField = styled.View`
background-color: 'rgb(253, 57, 57)';
padding: ${({ theme }) => theme.layout.spacing(2, 1, 0.5)};
margin: ${({ theme }) => theme.layout.spacing(-1, 0, 2)};
border-radius: ${({ theme }) => theme.layout.borderRadius.small};
z-index: -5;
`;
export const ErrorFieldText = styled.Text`
color: #fff;
font-family: ${({ theme }) => theme.typography.family.content.main};
`;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/RequestActivity/components/DateInput/styles.ts | <filename>src/modules/selectedGame/view/pages/RequestActivity/components/DateInput/styles.ts<gh_stars>0
import { Typography } from 'shared/view/components';
import styled, { css } from 'styled-components/native';
interface DateInputTextProps {
date: boolean;
}
export const Container = styled.View`
margin-bottom: ${({ theme }) => theme.layout.spacing(2)};
`;
export const Picker = styled.View`
width: 100%;
${({ theme }) => css`
border-radius: ${theme.layout.borderRadius.small};
padding: ${theme.layout.spacing(3)};
background-color: ${theme.palette.gray['0']};
border: 1px solid ${theme.palette.primary.dark};
`}
`;
export const Text = styled(Typography)<DateInputTextProps>`
color: ${({ theme, date }) =>
date ? theme.palette.primary.contrast : theme.palette.primary.dark};
`;
export const ErrorField = styled.View`
background-color: 'rgb(253, 57, 57)';
padding: ${({ theme }) => theme.layout.spacing(2, 1, 0.5)};
margin: ${({ theme }) => theme.layout.spacing(-1, 0, 2)};
border-radius: ${({ theme }) => theme.layout.borderRadius.small};
z-index: -5;
`;
export const ErrorFieldText = styled.Text`
color: #fff;
font-family: ${({ theme }) => theme.typography.family.content.main};
`;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/infra/repositories/factories/makeActivitiesRepository.ts | import IActivitiesRepository from 'modules/selectedGame/domain/repositories/IActivitiesRepository';
import ActivitiesRepository from 'modules/selectedGame/infra/repositories/ActivitiesRepository';
export default function makeActivitiesRepository(): IActivitiesRepository {
return new ActivitiesRepository();
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/RequestActivity/styles.ts | <filename>src/modules/selectedGame/view/pages/RequestActivity/styles.ts
import styled from 'styled-components/native';
import { Typography } from 'shared/view/components';
export const Container = styled.ScrollView.attrs(() => ({
contentContainerStyle: {
alignItems: 'center',
justifyContent: 'flex-start',
},
}))`
flex: 1;
background-color: ${({ theme }) => theme.palette.primary.main};
`;
export const Title = styled(Typography)`
font-weight: bold;
font-size: 24px;
color: ${({ theme }) => theme.palette.secondary.main};
width: 100%;
padding: ${({ theme }) => theme.layout.spacing(1)};
text-align: center;
text-transform: capitalize;
`;
export const Paragraph = styled(Typography)`
text-align: center;
color: ${({ theme }) => theme.palette.primary.contrast};
width: 100%;
margin: ${({ theme }) => theme.layout.spacing(4, 0)};
padding: ${({ theme }) => theme.layout.spacing(0, 4)};
`;
export const Info = styled(Typography)`
text-align: center;
color: ${({ theme }) => theme.palette.primary.contrast};
width: 100%;
padding: ${({ theme }) => theme.layout.spacing(0, 4)};
font-style: italic;
`;
export const Form = styled.View`
width: 100%;
padding: ${({ theme }) => theme.layout.spacing(4)};
`;
|
raulrozza/Gametask_Mobile | src/shared/domain/providers/IThemeContext.ts | import { DefaultTheme } from 'styled-components';
export interface ISwitchThemeArgs {
primary: string;
secondary: string;
}
export default interface IThemeContext {
theme: DefaultTheme;
switchTheme: (theme?: ISwitchThemeArgs) => Promise<void>;
createPallete: (theme: ISwitchThemeArgs) => DefaultTheme['palette'];
}
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/view/pages/Lobby/index.tsx | <filename>src/modules/chooseGame/view/pages/Lobby/index.tsx
import React, { useState } from 'react';
import { Modal } from 'react-native';
import { useRoute, RouteProp } from '@react-navigation/native';
import { FlatList } from 'react-native-gesture-handler';
import useFetchPlayersController from 'modules/chooseGame/infra/controllers/useFetchPlayersController';
import { RefreshControl } from 'shared/view/components';
import { EmptyList, Footer, GameInfo, ModalContent } from './components';
// Libs
// Style
import { Container, Title } from './styles';
type ParamList = {
Lobby: {
newGame?: string;
};
};
export type LobbyParams = RouteProp<ParamList, 'Lobby'>;
const Lobby: React.FC = () => {
const { params } = useRoute<LobbyParams>();
const { loading, players, fetchPlayers } = useFetchPlayersController(
params?.newGame,
);
const [modalVisible, setModalVisible] = useState(false);
return (
<Container>
<Title>LOBBY</Title>
<FlatList
data={players}
keyExtractor={item => item.id}
refreshControl={
<RefreshControl refreshing={loading} onRefresh={fetchPlayers} />
}
ListEmptyComponent={() => <EmptyList />}
renderItem={({ item }) => <GameInfo player={item} />}
contentContainerStyle={{
paddingHorizontal: 16,
}}
/>
<Footer showModal={() => setModalVisible(true)} />
<Modal
visible={modalVisible}
animationType="slide"
onRequestClose={() => setModalVisible(false)}
transparent
>
<ModalContent closeModal={() => setModalVisible(false)} />
</Modal>
</Container>
);
};
export default Lobby;
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/infra/repositories/UsersRepository.ts | import IUsersRepository, {
IUpdateParams,
} from 'modules/chooseGame/domain/repositories/IUsersRepository';
import IUser from 'shared/domain/entities/IUser';
import makeHttpProvider from 'shared/infra/providers/factories/makeHttpProvider';
const FILETYPE_REGEX = /\.(\w+)$/;
export default class UsersRepository implements IUsersRepository {
private httpProvider = makeHttpProvider();
public async findById(id: string): Promise<IUser> {
return this.httpProvider.get(`users/${id}`);
}
public async update({
firstname,
lastname,
image,
}: IUpdateParams): Promise<void> {
await this.httpProvider.put('users', { firstname, lastname });
if (!image) return;
const imageData = this.getImageFormData(image);
await this.httpProvider.patch('users/avatar', imageData);
}
private getImageFormData(uri: string): FormData {
const pathAsArray = uri.split('/');
const filename = pathAsArray.pop() || '';
// Infer the type of the image
const match = FILETYPE_REGEX.exec(filename);
const type = match ? `image/${match[1]}` : 'image';
const imageData = { uri, name: filename, type } as unknown;
const formData = new FormData();
formData.append('avatar', imageData as Blob);
return formData;
}
}
|
raulrozza/Gametask_Mobile | src/shared/infra/routes/game.tsx | import React from 'react';
// Navigation
import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';
import { NavigationContainer } from '@react-navigation/native';
// Pages
import SelectedGameGameRoutes from 'modules/selectedGame/infra/routes/game';
import { useThemeContext } from 'shared/view/contexts';
const Tab = createBottomTabNavigator();
export type IGameRouteScreen = typeof Tab.Screen;
const GameRoutes: React.FC = () => {
const { theme } = useThemeContext();
return (
<NavigationContainer>
<Tab.Navigator
tabBarOptions={{
style: {
backgroundColor: theme.palette.gray['0'],
borderTopColor: theme.palette.secondary.dark,
},
activeTintColor: theme.palette.secondary.dark,
inactiveTintColor: theme.palette.primary.contrast,
}}
>
{SelectedGameGameRoutes(Tab.Screen)}
</Tab.Navigator>
</NavigationContainer>
);
};
export default GameRoutes;
|
raulrozza/Gametask_Mobile | src/shared/infra/providers/JwtDecodeJwtProvider.ts | import decode from 'jwt-decode';
import { IJwtProvider } from 'shared/domain/providers/IJwtProvider';
export default class JsonwebtokenJwtProvider implements IJwtProvider {
public async decode<T = unknown>(token: string): Promise<T | null> {
try {
const decoded = decode(token);
if (!decoded) return null;
return decoded as T;
} catch (error) {
return null;
}
}
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/PlayerProfile/components/ProgressBar/styles.ts | <reponame>raulrozza/Gametask_Mobile<gh_stars>0
import styled, { css } from 'styled-components/native';
export const BarContainer = styled.View`
height: 48px;
width: 100%;
border-width: 3px;
border-radius: 15px;
overflow: hidden;
${({ theme }) => css`
background-color: ${theme.palette.primary.main};
border-color: ${theme.palette.primary.dark};
`}
`;
interface ProgressProps {
width: number;
}
export const Progress = styled.View<ProgressProps>`
width: 100%;
height: 100%;
${({ theme, width }) => css`
background-color: ${theme.palette.secondary.main};
width: ${width}%;
`}
`;
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/view/pages/Profile/components/index.ts | <reponame>raulrozza/Gametask_Mobile<filename>src/modules/chooseGame/view/pages/Profile/components/index.ts
export { default as ImageInput } from './ImageInput';
|
raulrozza/Gametask_Mobile | src/modules/authentication/view/validation/Signup.ts | import * as Yup from 'yup';
interface PasswordValues {
password: string;
confirmPassword: string;
}
interface PasswordsMatchErrors {
confirmPassword?: string;
}
const passwordsDontMatchError = (
password: string,
confirmPassword: string,
): string | void => {
if (password !== confirmPassword) return 'As senhas não são iguais';
};
export const passwordsMatchValidation = (
values: PasswordValues,
): PasswordsMatchErrors => {
const matchError = passwordsDontMatchError(
values.password,
values.confirmPassword,
);
if (matchError)
return {
confirmPassword: matchError,
};
return {};
};
const SignupSchema = Yup.object().shape({
firstname: Yup.string().required('Digite seu nome'),
lastname: Yup.string(),
email: Yup.string().email('E-mail inválido').required('Digite um e-mail'),
password: Yup.string().required('Digite uma senha'),
confirmPassword: Yup.string().required('Repita sua senha'),
});
export default SignupSchema;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/PlayerProfile/styles.ts | <filename>src/modules/selectedGame/view/pages/PlayerProfile/styles.ts
import styled from 'styled-components/native';
export const Container = styled.ScrollView.attrs(() => ({
contentContainerStyle: {
alignItems: 'center',
justifyContent: 'space-between',
},
}))`
background-color: ${({ theme }) => theme.palette.primary.main};
min-height: 100%;
`;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/RequestAchievementUnlock/index.tsx | import React, { useCallback } from 'react';
import { useRoute, useNavigation, RouteProp } from '@react-navigation/native';
import { Formik } from 'formik';
import IAchievement from 'modules/selectedGame/domain/entities/IAchievement';
import useRequestAchievementUnlockController from 'modules/selectedGame/infra/controllers/useRequestAchievementUnlockController';
import RequestAchievementUnlockSchema from 'modules/selectedGame/view/validation/RequestAchievementUnlockSchema';
import { Input } from 'shared/view/components';
import { useSessionContext } from 'shared/view/contexts';
import { useToastContext } from 'shared/view/contexts';
import { Container, Title, Form, Footer } from './styles';
const initialValues = {
information: '',
};
type RequestAchievementUnlockParams = RouteProp<
{
requestAchievementUnlock: {
achievement: IAchievement;
};
},
'requestAchievementUnlock'
>;
const RequestAchievementUnlock: React.FC = () => {
const {
params: { achievement },
} = useRoute<RequestAchievementUnlockParams>();
const { goBack } = useNavigation();
const toast = useToastContext();
const session = useSessionContext();
const {
loading,
requestAchievement,
} = useRequestAchievementUnlockController();
const onSubmit = useCallback(
async values => {
const result = await requestAchievement({
id: achievement.id,
information: values.information,
playerId: session.playerId,
});
if (result !== null) {
toast.showSuccess('Conquista requisitada!');
return goBack();
}
},
[goBack, toast, achievement.id, session.playerId, requestAchievement],
);
return (
<Container>
<Title>Requisitar Conquista</Title>
<Title>{achievement.name}</Title>
<Formik
initialValues={initialValues}
validationSchema={RequestAchievementUnlockSchema}
onSubmit={onSubmit}
>
<Form>
<Input
name="information"
multiline={true}
placeholder="Como desbloqueou a conquista?"
fullWidth
/>
<Footer.Container>
<Footer.Back outline onPress={goBack}>
Voltar
</Footer.Back>
<Footer.Button loading={loading}>Confirmar</Footer.Button>
</Footer.Container>
</Form>
</Formik>
</Container>
);
};
export default RequestAchievementUnlock;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/Activities/index.tsx | import React from 'react';
import { ActivityCard, EmptyList } from './components';
import { RefreshControl } from 'shared/view/components';
import { FlatList } from 'react-native';
import { SafeAreaProvider } from 'react-native-safe-area-context';
import useGetActivitiesController from 'modules/selectedGame/infra/controllers/useGetActivitiesController';
import { Container, PageTitle, Description, ActivityContainer } from './styles';
import IActivity from 'modules/selectedGame/domain/entities/IActivity';
const Activities: React.FC = () => {
const { loading, activities, getActivities } = useGetActivitiesController();
return (
<SafeAreaProvider>
<Container>
<PageTitle variant="title">Registrar Atividades</PageTitle>
<Description>
Completou alguma atividade? Informe aos moderadores para ganhar XP!
</Description>
<ActivityContainer.View>
<ActivityContainer.Title>Atividades</ActivityContainer.Title>
<FlatList
refreshControl={
<RefreshControl refreshing={loading} onRefresh={getActivities} />
}
keyExtractor={activity => activity.id}
data={activities}
ListEmptyComponent={() => <EmptyList />}
renderItem={({ item }) => <ActivityCard activity={item} />}
/>
</ActivityContainer.View>
</Container>
</SafeAreaProvider>
);
};
export default Activities;
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/view/pages/Profile/styles.ts | <gh_stars>0
import styled from 'styled-components/native';
export const Form = styled.View`
flex: 1;
justify-content: center;
align-items: center;
padding: ${({ theme }) => theme.layout.spacing(4)};
`;
export const InputGroup = styled.View`
width: 80%;
margin-bottom: ${({ theme }) => theme.layout.spacing(2)};
`;
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/infra/repositories/GamesRepository.ts | <gh_stars>0
import IGamesRepository from 'modules/chooseGame/domain/repositories/IGamesRepository';
import IGame from 'shared/domain/entities/IGame';
import makeHttpProvider from 'shared/infra/providers/factories/makeHttpProvider';
export default class GamesRepository implements IGamesRepository {
private httpProvider = makeHttpProvider();
public async findById(id: string): Promise<IGame> {
const response = await this.httpProvider.get<IGame>('games/details', {
headers: {
'x-game-id': id,
},
});
return response;
}
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/pages/Feed/components/LevelUpFeed/index.tsx | import React from 'react';
import IFeedPost from 'modules/selectedGame/domain/entities/IFeedPost';
import FeedText from '../FeedText';
import RankTag from '../RankTag';
interface LevelUpFeedProps {
post: IFeedPost;
}
const LevelUpFeed: React.FC<LevelUpFeedProps> = ({ post }) => (
<FeedText.Text>
<RankTag rank={post.player.rank} />{' '}
<FeedText.Name>
{post.player.user.firstname}
{post.player.user.lastname && ` ${post.player.user.lastname}`}
{post.player.currentTitle && `, ${post.player.currentTitle?.name}`}
</FeedText.Name>{' '}
atingiu o{' '}
{post.level.title ? (
<>
nível <FeedText.Activity>{post.level.title}</FeedText.Activity>!
</>
) : (
<>
<FeedText.Activity>{post.level.level}º nível</FeedText.Activity>!
</>
)}
</FeedText.Text>
);
export default LevelUpFeed;
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/view/pages/Profile/index.tsx | import React, { useCallback, useMemo } from 'react';
import { useNavigation } from '@react-navigation/native';
import { Formik } from 'formik';
import useGetUserController from 'modules/chooseGame/infra/controllers/useGetUserController';
import useUpdateUserController from 'modules/chooseGame/infra/controllers/useUpdateUserController';
import UserSchema from 'modules/chooseGame/view/validation/UserSchema';
import { Input, SubmitButton } from 'shared/view/components';
import { useToastContext, useSessionContext } from 'shared/view/contexts';
import { ImageInput } from './components';
import { Form, InputGroup } from './styles';
const Profile: React.FC = () => {
const { userData } = useSessionContext();
const { goBack } = useNavigation();
const toast = useToastContext();
const { loading, updateUser } = useUpdateUserController();
const { loading: loadingUser, user } = useGetUserController({
userId: userData.id,
});
const onSubmit = useCallback(
async values => {
const success = await updateUser(values);
if (success) {
toast.showSuccess('Dados atualizados!');
goBack();
}
},
[goBack, toast, updateUser],
);
const initialValues = useMemo(
() => ({
firstname: user.firstname,
lastname: user.lastname,
image: user.profile_url,
}),
[user],
);
if (loadingUser) return null;
return (
<Formik
initialValues={initialValues}
validationSchema={UserSchema}
onSubmit={onSubmit}
enableReinitialize
>
<Form>
<ImageInput name="image" />
<Input
name="firstname"
textContentType="name"
placeholder="Nome"
autoCapitalize="words"
/>
<Input
name="lastname"
textContentType="familyName"
placeholder="Sobrenome"
autoCapitalize="words"
/>
<InputGroup>
<SubmitButton loading={loading}>Salvar Alterações</SubmitButton>
</InputGroup>
</Form>
</Formik>
);
};
export default Profile;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/domain/repositories/IFeedPostsRepository.ts | <filename>src/modules/selectedGame/domain/repositories/IFeedPostsRepository.ts
import IFeedPost from 'modules/selectedGame/domain/entities/IFeedPost';
export default interface IFeedPostsRepository {
findAll(): Promise<IFeedPost[]>;
}
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/domain/providers/ICryptoProvider.ts | <filename>src/modules/chooseGame/domain/providers/ICryptoProvider.ts
export default interface ICryptoProvider {
decrypt<T = unknown>(encrypted: string): T | undefined;
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/domain/repositories/IPlayersRepository.ts | <reponame>raulrozza/Gametask_Mobile<gh_stars>0
import IPlayer from 'shared/domain/entities/IPlayer';
export default interface IPlayersRepository {
updateCurrentTitle(id: string, titleId?: string): Promise<void>;
findById(id: string): Promise<IPlayer>;
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/view/validation/RequestActivitySchema.ts | <gh_stars>0
import * as Yup from 'yup';
const RequestActivitySchema = Yup.object().shape({
date: Yup.date().required('Informe a data'),
information: Yup.string().required('Conte como concluiu a atividade'),
});
export default RequestActivitySchema;
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/domain/repositories/IActivitiesRepository.ts | import IActivity from 'modules/selectedGame/domain/entities/IActivity';
export default interface IActivitiesRepository {
findAll(): Promise<IActivity[]>;
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/infra/controllers/useUpdateTitleController.ts | <gh_stars>0
import { useCallback, useMemo, useState } from 'react';
import IUpdateTitleDTO from 'modules/selectedGame/domain/dtos/IUpdateTitleDTO';
import makeUpdatePlayerTitleUseCase from 'modules/selectedGame/services/factories/makeUpdatePlayerTitleUseCase';
import { useSessionContext, useToastContext } from 'shared/view/contexts';
interface UseUpdateTitleController {
loading: boolean;
updateTitle(params: IUpdateTitleDTO): Promise<void>;
}
export default function useUpdateTitleController(): UseUpdateTitleController {
const [loading, setLoading] = useState(true);
const updateTitleService = useMemo(() => makeUpdatePlayerTitleUseCase(), []);
const session = useSessionContext();
const toast = useToastContext();
const updateTitle = useCallback<UseUpdateTitleController['updateTitle']>(
async params => {
setLoading(true);
const response = await updateTitleService.execute(params);
setLoading(false);
if (response.shouldLogout) return session.logout();
if (response.error) return toast.showError(response.error);
},
[updateTitleService, session, toast],
);
return {
loading,
updateTitle,
};
}
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/view/pages/Profile/components/ImageInput/index.tsx | <filename>src/modules/chooseGame/view/pages/Profile/components/ImageInput/index.tsx
import React, { useEffect } from 'react';
import * as ImagePicker from 'expo-image-picker';
import { useField } from 'formik';
import { TouchableOpacity } from 'react-native-gesture-handler';
import { useToastContext } from 'shared/view/contexts';
// Libs
import { Image } from './styles';
interface ImageInputProps {
name: string;
}
const ImageInput: React.FC<ImageInputProps> = ({ name }) => {
const toast = useToastContext();
const [{ value }, , { setValue }] = useField(name);
useEffect(() => {
(async () => {
const { status } = await ImagePicker.requestCameraPermissionsAsync();
if (status !== 'granted')
toast.showError('É necessária permissão para acessar a câmera.');
})();
}, [toast]);
const pickImage = async () => {
const result = await ImagePicker.launchImageLibraryAsync({
mediaTypes: ImagePicker.MediaTypeOptions.Images,
allowsEditing: true,
aspect: [4, 4],
quality: 1,
});
if (!result.cancelled) {
setValue(result.uri);
}
};
return (
<TouchableOpacity onPress={pickImage}>
<Image
source={
value
? {
uri: value,
}
: require('assets/img/users/placeholder.png')
}
/>
</TouchableOpacity>
);
};
export default ImageInput;
|
raulrozza/Gametask_Mobile | src/shared/domain/providers/IToastContext.ts | export default interface IToastContext {
showInfo(message: string): void;
showSuccess(message: string): void;
showError(message: string): void;
}
|
raulrozza/Gametask_Mobile | src/modules/chooseGame/infra/controllers/useCreatePlayerController.ts | import { useCallback, useMemo, useState } from 'react';
import makeCreatePlayerService from 'modules/chooseGame/services/factories/makeCreatePlayerService';
import { useSessionContext, useToastContext } from 'shared/view/contexts';
interface UseCreatePlayerController {
loading: boolean;
createPlayer(gameId: string): Promise<boolean>;
}
export default function useCreatePlayerController(): UseCreatePlayerController {
const [loading, setLoading] = useState(false);
const createPlayerService = useMemo(() => makeCreatePlayerService(), []);
const session = useSessionContext();
const toast = useToastContext();
const createPlayer = useCallback(
async (gameId: string) => {
setLoading(true);
const response = await createPlayerService.execute(gameId);
setLoading(false);
if (response.shouldLogout) {
session.logout();
return false;
}
if (response.error) {
toast.showError(response.error);
return false;
}
return true;
},
[createPlayerService, session, toast],
);
return {
loading,
createPlayer,
};
}
|
raulrozza/Gametask_Mobile | src/modules/selectedGame/infra/repositories/factories/makeLeaderboardsRepository.ts | <filename>src/modules/selectedGame/infra/repositories/factories/makeLeaderboardsRepository.ts<gh_stars>0
import ILeaderboardsRepository from 'modules/selectedGame/domain/repositories/ILeaderboardsRepository';
import LeaderboardsRepository from 'modules/selectedGame/infra/repositories/LeaderboardsRepository';
export default function makeLeaderboardsRepository(): ILeaderboardsRepository {
return new LeaderboardsRepository();
}
|
Subsets and Splits