repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
Mrtinic489/elevator-front | src/client/models/buildConfigs/createBuildConfigRequest.ts | <reponame>Mrtinic489/elevator-front
export class CreateBuildConfigRequest {
name: string;
projectId: string;
constructor(name: string, projectId: string) {
this.name = name;
this.projectId = projectId;
}
}
|
Mrtinic489/elevator-front | src/client/models/users/user.ts | export interface User {
id: string;
name: string;
email: string;
isRegistered: boolean;
projectAccesses: ProjectAccesses;
}
export interface ProjectAccesses {
admin: Array<string>;
user: Array<string>;
}
|
Mrtinic489/elevator-front | src/components/ProjectsPage/ProjectsPage.tsx | import React from "react";
import {RouteComponentProps} from "react-router-dom";
import {ApiClient, Project, User} from "../../client";
import {Profile} from "../../models/Profile/Profile";
import NoProjectsPage from "./NoProjectsPage"
import styles from "./ProjectsPage.module.css";
import {ProjectCard} from "../ProjectCard/ProjectCard";
interface ProjectsPageProps extends RouteComponentProps {
apiClient: ApiClient;
user?: User;
}
interface ProjectsPageState {
projects?: Project[];
}
export class ProjectsPage extends React.Component<ProjectsPageProps, ProjectsPageState> {
constructor(props: ProjectsPageProps) {
super(props);
this.state = { projects: undefined };
}
async componentDidMount() {
if (!this.props.user)
return;
const projects = await this.props.apiClient.projects.getAllProjects();
this.setState({projects: projects});
}
renderProject(project: Project) {
return <ProjectCard key={project.id} id={project.id} name={project.name}/>;
}
render() {
if (!this.state.projects)
return (
<div className={styles.mainContainer}>
<div>
"Loading..."
</div>
</div>
);
if (this.state.projects.length === 0) {
return <NoProjectsPage/>
}
return (
<div className={styles.mainContainer}>
{ this.state.projects.map(this.renderProject) }
</div>
);
}
}
|
Mrtinic489/elevator-front | src/components/AuthenticationPage/AuthenticationPage.tsx | import React from "react";
import {RouteComponentProps} from "react-router-dom";
import styles from './AuthenticationPage.module.css'
import {Profile} from "../../models/Profile/Profile";
import {User} from "../../client";
interface AuthenticationPageProps extends RouteComponentProps {
user?: User
}
export class AuthenticationPage extends React.PureComponent<AuthenticationPageProps> {
render() {
if (this.props.user)
this.props.history.push('/');
return (
<div className={styles.mainContainer}>
<div className={styles.rowContainer}>
<div className={styles.authorizationContainer}>
<div className={styles.elevatorTitle}>
ELEVATOR CI
</div>
<div className={styles.delimiter}/>
<a href={"/sign-in/google"} className={styles.googleAuthorizationLink}>
<div>
Вход через Google
</div>
</a>
<a href={"/sign-in/google"} className={styles.googleAuthorizationLink}>
<div>
Еще раз через Google
</div>
</a>
</div>
</div>
</div>
);
}
}
|
Mrtinic489/elevator-front | src/client/models/projects/createProjectRequest.ts | <reponame>Mrtinic489/elevator-front<filename>src/client/models/projects/createProjectRequest.ts
export class CreateProjectRequest {
name: string;
gitUrl: string;
gitToken: string;
constructor(name: string, gitUrl: string, gitToken: string) {
this.name = name;
this.gitUrl = gitUrl;
this.gitToken = gitToken;
}
}
export class UpdateProjectRequest extends CreateProjectRequest {
}
|
Mrtinic489/elevator-front | src/components/BuildConfigPage/index.ts | import {withRouter} from "react-router-dom";
import {BuildConfigPage} from "./BuildConfigPage";
export default withRouter(BuildConfigPage);
|
Mrtinic489/elevator-front | src/components/Common/Input.tsx | import React, {PureComponent} from "react";
import styles from "./Input.module.css";
interface InputProps {
handleChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
title: string;
initialValue?: string;
disabled?: boolean;
}
export class SmallInput extends PureComponent<InputProps> {
render() {
return <div style={{}} className={styles.input}>
<div className={styles.inputTitleSmall}>{this.props.title}</div>
<input disabled={this.props.disabled} className={styles.inputValueSmall} type='text' defaultValue={this.props.initialValue ? this.props.initialValue : ''} onChange={this.props.handleChange}/>
</div>
}
}
export class MediumInput extends PureComponent<InputProps> {
render() {
return <div className={styles.input}>
<div className={styles.inputTitleMedium}>{this.props.title}</div>
<input className={styles.inputValueMedium} type='text' onChange={this.props.handleChange}/>
</div>
}
}
interface InputWithAutocompleteProps {
options: Array<string>;
handleChange: (event: React.ChangeEvent<HTMLSelectElement>) => void;
title: string;
initialValue?: string;
disabled?: boolean;
}
export class SmallCombobox extends PureComponent<InputWithAutocompleteProps> {
render() {
return <div className={styles.input}>
<div className={styles.inputTitleSmall}>{this.props.title}</div>
<select disabled={this.props.disabled} className={styles.comboboxValueSmall} onChange={this.props.handleChange}>
{this.props.options.map(x => {
if (this.props.initialValue && this.props.initialValue === x)
return <option selected={true}>{x}</option>
return <option>{x}</option>
})}
</select>
</div>
}
}
|
Mrtinic489/elevator-front | src/client/models/buildConfigs/index.ts | <filename>src/client/models/buildConfigs/index.ts
export * from './buildConfig'
export * from './createBuildConfigRequest'
|
Mrtinic489/elevator-front | src/components/ProfileInformation/AuthenticatedProfileInformation/AuthenticatedProfileInformation.tsx | import React from "react";
import Dropdown from 'react-bootstrap/Dropdown';
import styles from "./AuthenticatedProfileInformation.module.css"
import {User} from "../../../client/models/users";
interface AuthenticatedProfileInformationProps {
user: User
}
export class AuthenticatedProfileInformation extends React.PureComponent<AuthenticatedProfileInformationProps> {
render() {
return (
<Dropdown className={styles.dropdown}>
<Dropdown.Toggle className={styles.dropdownButton}>
{this.props.user.name} ˅
</Dropdown.Toggle>
<Dropdown.Menu className={styles.dropdownMenu} align="right">
<Dropdown.Item href="/create-project" className={styles.dropdownItem}>Add project</Dropdown.Item>
<Dropdown.Item href="#/action-1" className={styles.dropdownItem}>Log out</Dropdown.Item>
</Dropdown.Menu>
</Dropdown>);
}
}
|
Mrtinic489/elevator-front | src/components/Common/Button.tsx | <reponame>Mrtinic489/elevator-front
import React, {Component, PureComponent} from "react";
import styles from "./Button.module.css";
interface ButtonProps {
onClick: () => void;
text: string;
isActive: () => boolean;
}
export class SmallConfirmButton extends Component<ButtonProps> {
render() {
return <div className={this.props.isActive() ? styles.smallConfirmButton : styles.smallConfirmButtonDisabled} onClick={this.props.isActive() ? this.props.onClick : undefined}>{this.props.text}</div>
}
}
export class MediumConfirmButton extends PureComponent<ButtonProps> {
render() {
return <div className={styles.smallConfirmButton} onClick={this.props.onClick}>{this.props.text}</div>
}
}
|
Mrtinic489/elevator-front | src/client/models/buildSteps/createBuildStepRequest.ts | export class CreateBuildStepRequest {
name: string;
buildConfigId: string;
buildStepScript: BuildStepScript;
constructor(name: string, buildConfigId: string, buildStepScript: BuildStepScript) {
this.name = name;
this.buildConfigId = buildConfigId;
this.buildStepScript = buildStepScript;
}
}
export class BuildStepScript {
command: string;
arguments: string;
constructor(command: string, args: string) {
this.command = command;
this.arguments = args;
}
}
export class UpdateBuildStepRequest extends CreateBuildStepRequest { }
|
Mrtinic489/elevator-front | src/client/models/operationResult.ts | export interface OperationResult<T> {
value?: T;
isSuccessful: boolean;
httpStatusCode: number;
error: string;
}
export interface VoidOperationResult {
isSuccessful: boolean;
httpStatusCode: number;
error: string;
}
|
Mrtinic489/elevator-front | src/client/providers/baseProvider.ts | <filename>src/client/providers/baseProvider.ts
import {UserService} from "../../services";
import {OperationResult, VoidOperationResult} from "../models";
export class BaseProvider {
userService: UserService;
apiUrl: string;
constructor(userService: UserService, apiUrl: string) {
this.userService = userService;
this.apiUrl = apiUrl;
}
protected async get<T>(url: string): Promise<T> {
const options: RequestInit = {
method: "GET",
headers: {
'Accept': "application/json",
'Authorization': "Bearer " + await this.userService.getToken()
}
};
return await BaseProvider.send<T>(url, options)
}
protected async put<T>(url: string, bodyContent?: string): Promise<T> {
const options: RequestInit = {
method: "PUT",
headers: {
'Accept': "application/json",
'Authorization': "Bearer " + await this.userService.getToken()
}
};
if (bodyContent) {
options.body = bodyContent;
options.headers = {
'Accept': "application/json",
'Authorization': "Bearer " + await this.userService.getToken(),
'Content-Type': "application/json"
}
}
return await BaseProvider.send<T>(url, options)
}
protected async post<T>(url: string, bodyContent?: string): Promise<T> {
const options: RequestInit = {
method: "POST",
headers: {
'Accept': "application/json",
'Authorization': "Bearer " + await this.userService.getToken()
}
};
if (bodyContent) {
options.body = bodyContent;
options.headers = {
'Accept': "application/json",
'Authorization': "Bearer " + await this.userService.getToken(),
'Content-Type': "application/json"
}
}
return await BaseProvider.send<T>(url, options)
}
protected async postWithVoidResult<T>(url: string, bodyContent?: string): Promise<T> {
const options: RequestInit = {
method: "POST",
headers: {
'Accept': "application/json",
'Authorization': "Bearer " + await this.userService.getToken()
}
};
if (bodyContent) {
options.body = bodyContent;
options.headers = {
'Accept': "application/json",
'Authorization': "Bearer " + await this.userService.getToken(),
'Content-Type': "application/json"
}
}
return await BaseProvider.send<T>(url, options)
}
private static async send<T>(url: string, options: RequestInit) {
let operationResult: OperationResult<T>;
const response = await fetch(url, options);
if (response.status >= 200 && response.status < 300) {
operationResult = await response.json();
} else {
throw response;
}
if (operationResult.isSuccessful)
return operationResult.value!;
console.log(operationResult);
throw Error(operationResult.error);
}
}
|
Mrtinic489/elevator-front | src/components/EditProjectModal/EditProjectModal.tsx | import {RouteComponentProps} from "react-router-dom";
import {ApiClient, UpdateProjectRequest} from "../../client";
import React from "react";
import {Modal} from '@material-ui/core'
import styles from './EditProjectModal.module.css'
interface UpdateProjectModalParams {
id: string;
}
interface UpdateProjectModalProps extends RouteComponentProps<UpdateProjectModalParams> {
client: ApiClient;
}
interface UpdateProjectModalState {
name: string;
gitUrl: string;
gitToken: string;
loading: boolean;
}
export class EditProjectModal extends React.PureComponent<UpdateProjectModalProps, UpdateProjectModalState> {
constructor(props: UpdateProjectModalProps) {
super(props);
this.state = {name: '', gitUrl: '', gitToken: '', loading: false};
}
handleNameChange = (event: React.ChangeEvent<HTMLInputElement>) => {
this.setState({name: event.target.value});
};
handleGitUrlChange = (event: React.ChangeEvent<HTMLInputElement>) => {
this.setState({gitUrl: event.target.value});
};
handleGitTokenChange = (event: React.ChangeEvent<HTMLInputElement>) => {
this.setState({gitToken: event.target.value});
};
render() {
return (<Modal className={styles.modal} open={true} aria-labelledby="simple-modal-title" aria-describedby="simple-modal-description">
<div className={styles.modalContent}>
<div className={styles.title}>
Edit project
</div>
<div className={styles.inputs}>
<div className={styles.input}>
<div className={styles.inputTitle}>
<p>Name</p>
</div>
<input className={styles.inputValue} onChange={this.handleNameChange} type="text"/>
</div><div className={styles.input}>
<div className={styles.inputTitle}>
<p>Git url</p>
</div>
<input className={styles.inputValue} onChange={this.handleGitUrlChange} type="text"/>
</div><div className={styles.input}>
<div className={styles.inputTitle}>
<p>Git token</p>
</div>
<input className={styles.inputValue} onChange={this.handleGitTokenChange} type="text"/>
</div>
</div>
<div className={styles.buttons}>
<button className={styles.saveButton} disabled={this.state.loading} onClick={this.updateProject}>Save</button>
<button className={styles.cancelButton} disabled={this.state.loading} onClick={this.cancel}>Cancel</button>
</div>
</div>
</Modal>)
}
updateProject = () => {
const updateProjectRequest = new UpdateProjectRequest(this.state.name, this.state.gitUrl, this.state.gitToken);
this.setState({loading: true});
this.props.client.projects.updateProject(this.props.match.params.id, updateProjectRequest).then(project => {
this.setState({loading: false});
this.props.history.push('/projects/' + project.id);
}
).catch((error) => {
this.setState({loading: false});
console.log(error);
this.props.history.push('/');
})
};
cancel = () => {
this.props.history.push('/projects/' + this.props.match.params.id);
}
}
|
Mrtinic489/elevator-front | src/components/ProjectPage/ProjectPage.tsx | <reponame>Mrtinic489/elevator-front
import React, {PureComponent} from "react";
import {RouteComponentProps} from "react-router-dom";
import {GrantAccessRequest, Project} from "../../client/models/projects";
import {BuildConfig, CreateBuildConfigRequest} from "../../client/models/buildConfigs";
import {ApiClient, User} from "../../client";
import styles from './ProjectPage.module.css';
import {BuildConfigComponent} from "../BuildConfigComponent/BuildConfigComponent";
import {SmallConfirmButton, SmallInput, SmallCombobox} from "../Common";
interface ProjectPageParams {
id: string;
}
interface ProjectPageProps extends RouteComponentProps<ProjectPageParams>{
user: User;
apiClient: ApiClient
}
interface ProjectPageState {
project?: Project
buildConfigs?: BuildConfig[]
modals: Modals;
userIds: Array<string>;
}
interface Modals {
addBuildConfig: boolean;
accessControl: boolean;
generalSettings: boolean;
}
export class ProjectPage extends React.PureComponent<ProjectPageProps, ProjectPageState> {
constructor(props: ProjectPageProps) {
super(props);
this.state = {project: undefined, buildConfigs: undefined, modals: {addBuildConfig: false, accessControl: false, generalSettings: false}, userIds: []};
}
async componentDidMount() {
await this.setProject();
await this.setBuildConfigs();
await this.setUserIds();
}
async setProject() {
this.setState({project: await this.props.apiClient.projects.getProject(this.props.match.params.id)})
}
async setBuildConfigs() {
this.setState({buildConfigs: await this.props.apiClient.buildConfigs.getAllBuildConfigs(this.props.match.params.id)})
}
async setUserIds() {
this.setState({userIds: await this.props.apiClient.users.getAllIds()});
}
render() {
const projectName = this.state.project ? this.state.project.name : 'Loading...';
const hasUserAdminAccess = this.state.project && this.props.user.projectAccesses.admin.includes(this.state.project.id);
return <div className={styles.mainContainer}>
<div className={styles.infoContainer}>
<div className={styles.leftContainer}>
<div className={styles.nameContainer}>{projectName}</div>
{this.state.buildConfigs ? <div className={styles.buildConfigsContainer}>{this.renderBuildConfigs()}</div> : <div className={styles.buildConfigsContainer}>Loading...</div>}
</div>
<div className={styles.adminPanelContainer}>{hasUserAdminAccess ? this.renderAdminPanel() : <div></div>}</div>
</div>
</div>
}
renderAdminPanel() {
if (!this.state.project)
return;
return <div>
<div className={styles.adminPanelTitle}>Project settings</div>
<div className={styles.adminLinkContainer} onClick={this.showGeneralSettingsModal}>
<div className={styles.adminLink}>General settings</div>
<div className={styles.downArrow}>˅</div>
</div>
<div style={{display: this.state.modals.generalSettings ? 'block' : 'none'}}>
<div className={styles.adminPanelTitle}>Will be available in future!</div>
</div>
<div className={styles.adminLinkContainer} onClick={this.showAddBuildConfigModal}>
<div className={styles.adminLink}>Add build config</div>
<div className={styles.downArrow}>˅</div>
</div>
<div style={{display: this.state.modals.addBuildConfig ? 'block' : 'none'}}>
<AddBuildConfigModal projectId={this.props.match.params.id} createBuildConfig={this.createBuildConfig}/>
</div>
<div className={styles.adminLinkContainer} onClick={this.showAccessControlModal}>
<div className={styles.adminLink}>Access control</div>
<div className={styles.downArrow}>˅</div>
</div>
<div style={{display: this.state.modals.accessControl ? 'block' : 'none'}}>
<AccessControlModal projectId={this.props.match.params.id} userIds={['', ...this.state.userIds]} roles={['', 'user', 'admin']} grantAccess={this.grantAccess} />
</div>
</div>
}
showAddBuildConfigModal = () => {
const isOpenedNow = this.state.modals.addBuildConfig;
this.setState({modals: {...this.state.modals, addBuildConfig: !isOpenedNow}})
};
showAccessControlModal = () => {
const isOpenedNow = this.state.modals.accessControl;
this.setState({modals: {...this.state.modals, accessControl: !isOpenedNow}});
};
showGeneralSettingsModal = () => {
const isOpenedNow = this.state.modals.generalSettings;
this.setState({modals: {...this.state.modals, generalSettings: !isOpenedNow}});
};
renderBuildConfigs() {
if (!this.state.buildConfigs || !this.state.project)
return;
if (this.state.buildConfigs.length === 0)
return <div>
<div>There are no any build configs</div>
</div>;
const project = this.state.project;
return this.state.buildConfigs.map(bc => {
return <BuildConfigComponent project={project} buildConfig={bc}/>
})
}
createBuildConfig = async (createBuildConfigRequest: CreateBuildConfigRequest) => {
await this.props.apiClient.buildConfigs.createBuildConfig(createBuildConfigRequest);
await this.setProject();
await this.setBuildConfigs();
};
grantAccess = async (grantAccessRequest: GrantAccessRequest) => {
await this.props.apiClient.projects.grantAccess(grantAccessRequest);
await this.setProject();
console.log(this.state.project);
};
}
interface AddBuildConfigModalProps {
projectId: string;
createBuildConfig: (createBuildConfigRequest: CreateBuildConfigRequest) => void;
}
interface AddBuildConfigModalState {
name: string;
}
class AddBuildConfigModal extends PureComponent<AddBuildConfigModalProps, AddBuildConfigModalState> {
constructor(props: AddBuildConfigModalProps) {
super(props);
this.state = {name: ''}
}
handleNameChanged = (event: React.ChangeEvent<HTMLInputElement>) => {
this.setState({name: event.target.value});
};
confirm = () => {
const createBuildConfigRequest = new CreateBuildConfigRequest(this.state.name, this.props.projectId);
this.props.createBuildConfig(createBuildConfigRequest);
};
render() {
return <div className={styles.modalContainer}>
<SmallInput handleChange={this.handleNameChanged} title='Name'/>
<SmallConfirmButton isActive={() => this.state.name !== ''} onClick={this.confirm} text='Add'/>
</div>;
}
}
interface AccessControlModalProps {
projectId: string;
userIds: Array<string>;
roles: Array<string>;
grantAccess: (grantAccessRequest: GrantAccessRequest) => void;
}
interface AccessControlModalState {
id: string;
role: string;
}
class AccessControlModal extends PureComponent<AccessControlModalProps, AccessControlModalState> {
constructor(props: AccessControlModalProps) {
super(props);
this.state = {id: '', role: ''}
}
handleIdChanged = (event: React.ChangeEvent<HTMLSelectElement>) => {
this.setState({id: event.target.value});
};
handleRoleChanged = (event: React.ChangeEvent<HTMLSelectElement>) => {
this.setState({role: event.target.value});
};
render() {
return <div className={styles.modalContainer}>
<SmallCombobox options={this.props.userIds} handleChange={this.handleIdChanged} title='User'/>
<SmallCombobox options={this.props.roles} handleChange={this.handleRoleChanged} title='Role'/>
<SmallConfirmButton isActive={() => this.state.id !== '' && this.state.role !== ''} onClick={this.confirm} text='Grant'/>
</div>;
}
confirm = () => {
const grantAccessRequest = new GrantAccessRequest(this.props.projectId, this.state.id, this.state.role);
if (grantAccessRequest.accessType === '' || grantAccessRequest.userId === '')
console.log('You should choose access type and user');
this.props.grantAccess(grantAccessRequest);
}
}
|
Mrtinic489/elevator-front | src/components/ProfileInformation/AuthenticatedProfileInformation/index.ts | import { AuthenticatedProfileInformation } from "./AuthenticatedProfileInformation";
export default AuthenticatedProfileInformation;
|
Mrtinic489/elevator-front | src/client/index.ts | <filename>src/client/index.ts
import {
ProjectsProvider, UsersProvider
} from "./providers";
import { UserService } from '../services'
import {BuildConfigsProvider} from "./providers/buildConfigsProvider";
import {BuildStepsProvider} from "./providers/buildStepsProvider";
import {BuildProvider} from "./providers/buildProvider";
export * from './models';
export * from './providers';
export class ApiClient {
projects: ProjectsProvider;
users: UsersProvider;
buildConfigs: BuildConfigsProvider;
buildSteps: BuildStepsProvider;
builds: BuildProvider;
constructor(userService: UserService, apiUrl: string) {
this.projects = new ProjectsProvider(userService, apiUrl);
this.users = new UsersProvider(userService, apiUrl);
this.buildConfigs = new BuildConfigsProvider(userService, apiUrl);
this.buildSteps = new BuildStepsProvider(userService, apiUrl);
this.builds = new BuildProvider(userService, apiUrl);
}
}
|
Mrtinic489/elevator-front | src/components/BuildConfigComponent/BuildConfigComponent.tsx | <reponame>Mrtinic489/elevator-front<filename>src/components/BuildConfigComponent/BuildConfigComponent.tsx
import {BuildConfig} from "../../client/models/buildConfigs";
import React, {PureComponent} from "react";
import styles from './BuildConfigComponent.module.css'
import {Project} from "../../client/models/projects";
interface BuildConfigProps {
project: Project;
buildConfig: BuildConfig;
}
export class BuildConfigComponent extends PureComponent<BuildConfigProps> {
render() {
return (<div className={styles.buildConfigContainer}>
<a className={styles.buildConfigName} href={this.props.project.id + '/buildConfigs/' + this.props.buildConfig.id}>{this.props.buildConfig.name}</a>
</div>);
}
}
|
Mrtinic489/elevator-front | src/client/providers/usersProvider.ts | import {User} from '../models'
import {BaseProvider} from "./baseProvider";
export class UsersProvider extends BaseProvider{
public getCurrentUser(): Promise<User> {
const url = this.apiUrl + '/users/me';
return this.get<User>(url);
}
public register(): Promise<User> {
const url = this.apiUrl + '/users/me/register';
return this.post<User>(url);
}
public getAllIds(): Promise<Array<string>> {
const url = this.apiUrl + '/users';
return this.get<Array<string>>(url);
}
}
|
Mrtinic489/elevator-front | src/components/ProfileInformation/ProfileInformation.tsx | <gh_stars>1-10
import React from "react";
import {AuthenticatedProfileInformation} from "./AuthenticatedProfileInformation/AuthenticatedProfileInformation";
import {User} from "../../client/models/users";
interface ProfileInformationProps {
user?: User
}
export class ProfileInformation extends React.PureComponent<ProfileInformationProps> {
render() {
return (
this.props.user ?
<AuthenticatedProfileInformation user={this.props.user}/> :
null
)
}
}
|
Mrtinic489/elevator-front | src/client/models/projects/index.ts | export * from './createProjectRequest';
export * from "./createProjectResponse";
export * from "./project";
export * from "./grantAccessRequest"
|
Mrtinic489/elevator-front | src/client/models/build/build.ts | <reponame>Mrtinic489/elevator-front
export interface Build {
id: string;
buildConfigId: string;
logs?: Array<string>;
finishTime?: string;
buildStatus: number;
startedByUserId: string;
}
|
Mrtinic489/elevator-front | src/components/ProjectCard/index.ts | import {ProjectCard} from "./ProjectCard";
export default ProjectCard;
|
Mrtinic489/elevator-front | src/components/EditProjectModal/index.ts | <gh_stars>1-10
import { EditProjectModal } from "./EditProjectModal";
import {withRouter} from "react-router-dom";
export default withRouter(EditProjectModal);
|
Mrtinic489/elevator-front | src/client/models/buildSteps/index.ts | export * from './buildStep'
export * from './createBuildStepRequest'
|
Mrtinic489/elevator-front | src/components/ProjectsPage/index.ts | import { ProjectsPage } from "./ProjectsPage";
import {withRouter} from "react-router-dom";
export default withRouter(ProjectsPage);
|
Mrtinic489/elevator-front | src/components/CreateProjectModal/index.ts | import { CreateProjectModal } from "./CreateProjectModal";
import {withRouter} from "react-router-dom";
export default withRouter(CreateProjectModal);
|
Mrtinic489/elevator-front | src/services/userService.ts | import {makeUserManager} from "react-oidc";
import {UserManager} from "oidc-client";
import { User } from "../client";
export class UserService {
userManager: UserManager;
private user?: User;
private token?: string;
constructor() {
this.userManager = makeUserManager({
clockSkew: 300,
authority: 'https://accounts.google.com',
scope: 'openid profile email',
loadUserInfo: true,
monitorSession: true, // NOTE: for logout sync to work across tabs
filterProtocolClaims: true,
automaticSilentRenew: true,
client_id: '498787926402-3g4k9qteipbiahitls1r709is6fule9a.apps.googleusercontent.com',
response_type: 'token id_token',
redirect_uri: 'http://localhost:3000/sign-in/callback/google', //временно так
post_logout_redirect_uri: 'http://localhost:3000',
});
}
private async setToken() {
const user = await this.userManager.getUser();
this.token = user?.id_token;
}
async getToken(): Promise<string> {
await this.setToken();
if (!this.token)
throw Error('User is not authorized');
return this.token;
}
async isUserAuthorized(): Promise<boolean> {
await this.setToken();
return !!this.token;
}
}
|
Mrtinic489/elevator-front | src/components/BuildConfigPage/BuildConfigPage.tsx | <reponame>Mrtinic489/elevator-front
import {RouteComponentProps} from "react-router-dom";
import {User} from "../../client/models/users";
import {
ApiClient, Build,
BuildConfig,
BuildStep, BuildStepScript,
CreateBuildConfigRequest,
CreateBuildStepRequest,
Project, UpdateBuildStepRequest
} from "../../client";
import React, {Component, PureComponent} from "react";
import styles from './BuildConfigPage.module.css'
import {SmallCombobox, SmallConfirmButton, SmallInput} from "../Common";
import {createDeflateRaw} from "zlib";
interface BuildConfigPageParams {
projectId: string;
buildConfigId: string;
}
interface BuildConfigPageProps extends RouteComponentProps<BuildConfigPageParams>{
user: User;
apiClient: ApiClient
}
interface BuildConfigPageState {
project?: Project;
buildSteps?: BuildStep[];
buildConfig?: BuildConfig;
currentBuild?: Build;
isCreateBuildStepModalOpened: boolean;
}
export class BuildConfigPage extends PureComponent<BuildConfigPageProps, BuildConfigPageState> {
constructor(props: BuildConfigPageProps) {
super(props);
this.state = {isCreateBuildStepModalOpened: false, project: undefined, buildSteps: undefined, buildConfig: undefined, currentBuild: undefined}
}
async componentDidMount() {
await this.setProject();
await this.setBuildSteps();
await this.setBuildConfig();
}
async setProject() {
this.setState({project: await this.props.apiClient.projects.getProject(this.props.match.params.projectId)})
}
async setBuildSteps() {
this.setState({buildSteps: await this.props.apiClient.buildSteps.getAllBuildSteps(this.props.match.params.projectId, this.props.match.params.buildConfigId)})
}
async setBuildConfig() {
this.setState({buildConfig: await this.props.apiClient.buildConfigs.getById(this.props.match.params.projectId, this.props.match.params.buildConfigId)})
}
render() {
if (!this.state.project || !this.state.buildSteps || !this.state.buildConfig)
return (
<div className={styles.mainContainer}>
<div className={styles.infoContainer}>
<div className={styles.leftContainer}>
<div className={styles.nameContainer}>
Loading...
</div>
</div>
</div>
</div>
);
const hasUserAdminAccess = this.state.project && this.props.user.projectAccesses.admin.includes(this.state.project.id);
return (
<div className={styles.mainContainer}>
<div className={styles.infoContainer}>
<div className={styles.leftContainer}>
<div className={styles.nameContainer}>
<a href={'/projects/' + this.state.project.id} className={styles.backToProjectLink}>{this.state.project.name}</a>
<div>- {this.state.buildConfig.name}</div>
<div onClick={this.runBuildConfig} className={styles.runButton}>Run</div>
</div>
<div className={styles.buildStepsContainer}>
{this.renderBuildSteps()}
</div>
{this.state.currentBuild ? <BuildComponent projectId={this.state.project.id} buildConfigId={this.state.buildConfig.id} apiClient={this.props.apiClient} build={this.state.currentBuild}/> : <div/>}
</div>
<div className={styles.adminPanelContainer}>{hasUserAdminAccess ? this.renderAdminPanel() : <div/>}</div>
</div>
</div>);
}
runBuildConfig = async () => {
if (!this.state.buildConfig)
return;
const build = await this.props.apiClient.buildConfigs.runBuildConfig(this.props.match.params.projectId, this.state.buildConfig);
this.setState({currentBuild: build});
};
renderBuildSteps() {
if (!this.state.buildSteps || !this.state.project)
return;
const hasUserAdminAccess = this.props.user.projectAccesses.admin.includes(this.state.project.id);
return this.state.buildSteps.map(x => {
return <BuildStepComponent onUpdate={async () => {await this.setBuildSteps()}} apiClient={this.props.apiClient} projectId={this.state.project!.id} buildConfigId={this.props.match.params.buildConfigId} updateBuildStep={this.updateBuildStep} buildStep={x} hasUserAdminAccess={hasUserAdminAccess} />
} )
}
createBuildStep = async (request: CreateBuildStepRequest) => {
await this.props.apiClient.buildSteps.createBuildStep(this.props.match.params.projectId, request);
await this.setBuildSteps();
};
updateBuildStep = async (buildStepId: string, request: UpdateBuildStepRequest) => {
await this.props.apiClient.buildSteps.updateBuildStep(this.props.match.params.projectId, buildStepId, request);
await this.setBuildSteps();
};
renderAdminPanel() {
return <div>
<div className={styles.adminPanelTitle}>Build config settings</div>
<div className={styles.adminLinkContainer} onClick={this.changeModalOpenedState}>
<div className={styles.adminLink}>Add build step</div>
<div className={styles.downArrow}>˅</div>
</div>
<div style={{display: this.state.isCreateBuildStepModalOpened ? 'block' : 'none'}}>
<AddBuildStepModal projectId={this.props.match.params.projectId} buildConfigId={this.props.match.params.buildConfigId} createBuildStep={this.createBuildStep}/>
</div>
</div>
}
changeModalOpenedState = () => {
this.setState({isCreateBuildStepModalOpened: !this.state.isCreateBuildStepModalOpened});
};
}
interface AddBuildStepModalProps {
projectId: string;
buildConfigId: string;
createBuildStep: (createBuildStepRequest: CreateBuildStepRequest) => void;
}
interface AddBuildStepModalState {
name: string;
scriptCommand: string;
scriptArguments: string;
}
class AddBuildStepModal extends PureComponent<AddBuildStepModalProps, AddBuildStepModalState> {
constructor(props: AddBuildStepModalProps) {
super(props);
this.state = {name: '', scriptArguments: '', scriptCommand: ''}
}
handleNameChanged = (event: React.ChangeEvent<HTMLInputElement>) => {
this.setState({name: event.target.value});
};
handleCommandChanged = (event: React.ChangeEvent<HTMLSelectElement>) => {
this.setState({scriptCommand: event.target.value});
};
handleArgumentsChanged = (event: React.ChangeEvent<HTMLInputElement>) => {
this.setState({scriptArguments: event.target.value});
};
confirm = () => {
const createBuildStepRequest = new CreateBuildStepRequest(this.state.name, this.props.buildConfigId, new BuildStepScript(this.state.scriptCommand, this.state.scriptArguments));
this.props.createBuildStep(createBuildStepRequest);
};
render() {
return <div className={styles.modalContainer}>
<SmallInput handleChange={this.handleNameChanged} title='Name'/>
<SmallCombobox options={['', 'dotnet', 'npm']} handleChange={this.handleCommandChanged} title='Command'/>
<SmallInput handleChange={this.handleArgumentsChanged} title='Arguments'/>
<SmallConfirmButton isActive={this.isStateCorrect} onClick={this.confirm} text='Add'/>
</div>;
}
isStateCorrect = () => {
return this.state.name !== '' && this.state.scriptCommand !== '';
}
}
interface BuildStepComponentProps {
buildConfigId: string;
hasUserAdminAccess: boolean;
buildStep: BuildStep;
updateBuildStep: (buildStepId: string, request: UpdateBuildStepRequest) => void;
projectId: string;
apiClient: ApiClient;
onUpdate: () => {};
}
interface BuildStepComponentState {
name: string;
scriptCommand: string;
scriptArguments: string;
isModalOpened: boolean;
loading: boolean;
}
class BuildStepComponent extends Component<BuildStepComponentProps, BuildStepComponentState> {
constructor(props: BuildStepComponentProps) {
super(props);
this.state = {
isModalOpened: false,
name: this.props.buildStep.name,
scriptCommand: this.props.buildStep.buildStepScript.command,
scriptArguments: this.props.buildStep.buildStepScript.arguments,
loading: false
};
}
handleChangeName = (event: React.ChangeEvent<HTMLInputElement>) => {
this.setState({name: event.target.value})
};
handleChangeCommand = (event: React.ChangeEvent<HTMLSelectElement>) => {
this.setState({scriptCommand: event.target.value})
};
handleChangeArguments = (event: React.ChangeEvent<HTMLInputElement>) => {
this.setState({scriptArguments: event.target.value})
};
render() {
return <div className={styles.buildStepContainer}>
<div className={styles.buildStepName} onClick={this.changeModalState}>{this.props.buildStep.name}</div>
<div className={styles.modalContainer} style={{display: this.state.isModalOpened ? 'block' : 'none'}}>
<SmallInput handleChange={this.handleChangeName} title='Name' initialValue={this.state.name} disabled={!this.props.hasUserAdminAccess}/>
<SmallCombobox options={['', 'dotnet', 'npm']} handleChange={this.handleChangeCommand} title='Command' initialValue={this.state.scriptCommand} disabled={!this.props.hasUserAdminAccess}/>
<SmallInput handleChange={this.handleChangeArguments} title='Arguments' initialValue={this.state.scriptArguments} disabled={!this.props.hasUserAdminAccess}/>
<SmallConfirmButton onClick={this.confirm} text={!this.state.loading ? "Save" : "Saving"} isActive={() => this.props.hasUserAdminAccess && !this.state.loading && this.isStateCorrect()}/>
</div>
</div>
}
isStateCorrect = () => {
return this.state.name !== '' && this.state.scriptCommand !== '';
};
changeModalState = () => {
this.setState({isModalOpened: !this.state.isModalOpened});
};
confirm = async () => {
this.setState({loading: true});
try {
const updateBuildStepRequest = new UpdateBuildStepRequest(this.state.name, this.props.buildConfigId, new BuildStepScript(this.state.scriptCommand, this.state.scriptArguments));
await this.props.apiClient.buildSteps.updateBuildStep(this.props.projectId, this.props.buildStep.id, updateBuildStepRequest);
} finally {
this.setState({loading: false, isModalOpened: false});
this.props.onUpdate();
}
};
}
interface BuildComponentProps {
build: Build;
apiClient: ApiClient;
projectId: string;
buildConfigId: string;
}
interface BuildComponentState {
build: Build;
}
class BuildComponent extends PureComponent<BuildComponentProps, BuildComponentState> {
constructor(props: BuildComponentProps) {
super(props);
this.state = {build: props.build};
}
render() {
return <div className={styles.buildInfoContainer}>
<div className={styles.refreshButton} onClick={this.updateBuild}>Refresh</div>
<div>Started by:{this.state.build.startedByUserId}</div>
<div>Status: {this.mapBuildStatus(this.state.build.buildStatus)}</div>
<div>Logs:</div>
<div className={styles.logsContainer}>
{this.state.build.logs ? this.renderLogs(this.state.build.logs) : <p/>}
</div>
</div>
}
renderLogs(logs: Array<string>) {
return logs.map(log => <p>{log}</p>);
}
mapBuildStatus = (status: number) => {
if (status === 0)
return 'Waiting to get place in queue';
else if (status === 1)
return 'Waiting to start';
else if (status === 2)
return 'In progress';
else if (status === 3)
return 'Success';
else if (status === 4)
return 'Failed';
else
return 'Unknown status';
}
updateBuild = async () => {
const build = await this.props.apiClient.builds.getById(this.props.projectId, this.props.buildConfigId, this.state.build.id);
this.setState({build: build});
}
}
|
Mrtinic489/elevator-front | src/client/providers/projectsProvider.ts | import {Project, CreateProjectRequest, UpdateProjectRequest, GrantAccessRequest} from "../models";
import {BaseProvider} from "./baseProvider";
export class ProjectsProvider extends BaseProvider {
public getAllProjects(): Promise<Project[]> {
const url = this.apiUrl + '/projects';
return this.get<Project[]>(url);
}
public createProject(createProjectRequest: CreateProjectRequest): Promise<Project> {
const url = this.apiUrl + '/projects';
return this.post<Project>(url, JSON.stringify(createProjectRequest));
}
public getProject(id: string): Promise<Project> {
const url = this.apiUrl + '/projects/' + id;
return this.get<Project>(url);
}
public updateProject(id: string, updateProjectRequest: UpdateProjectRequest): Promise<Project> {
const url = this.apiUrl + '/projects/' + id;
return this.put<Project>(url, JSON.stringify(updateProjectRequest));
}
public async grantAccess(grantAccessRequest: GrantAccessRequest) {
const url = this.apiUrl + '/projects/' + grantAccessRequest.projectId + '/grantAccess';
await this.post<any>(url, JSON.stringify(grantAccessRequest));
}
}
|
Mrtinic489/elevator-front | src/components/ProjectsPage/NoProjectsPage/index.ts | import {NoProjectsPage} from "./NoProjectsPage";
export default NoProjectsPage;
|
Mrtinic489/elevator-front | src/components/ProjectsPage/NoProjectsPage/NoProjectsPage.tsx | import React from "react";
import styles from "./NoProjectsPage.module.css"
export class NoProjectsPage extends React.Component {
render() {
return (
<div className={styles.mainContainer}>
<div className={styles.rowContainer}>
<div className={styles.title}>
No projects are available, you can create your own or ask for permission to existed projects.
</div>
</div>
</div>
)
}
}
|
Mrtinic489/elevator-front | src/components/BuildConfigComponent/index.ts | import {BuildConfigComponent} from "./BuildConfigComponent";
export default BuildConfigComponent;
|
Mrtinic489/elevator-front | src/components/App/App.tsx | <reponame>Mrtinic489/elevator-front
import React from 'react';
import { Switch, Route, RouteComponentProps } from "react-router-dom";
import './App.css';
import AuthenticationPage from "../AuthenticationPage";
import ProjectsPage from "../ProjectsPage";
import TopBar from "../TopBar"
import AuthPage from "../AuthPage";
import ProjectPage from "../ProjectPage"
import {Callback} from "react-oidc";
import {UserService} from "../../services";
import {ApiClient, User} from "../../client";
import CreateProjectModal from "../CreateProjectModal";
import BuildConfigPage from "../BuildConfigPage";
interface AppProps extends RouteComponentProps { }
interface AppState {
user?: User
}
export class App extends React.Component<AppProps, AppState> {
userService: UserService;
apiClient: ApiClient;
constructor(props: AppProps) {
super(props);
this.userService = new UserService();
this.apiClient = new ApiClient(this.userService, 'https://localhost:10101');
this.state = {user: undefined};
}
async componentDidMount() {
await this.trySetUser();
}
private async trySetUser() {
if (!await this.userService.isUserAuthorized())
return;
let user = await this.apiClient.users.getCurrentUser();
if (!user.isRegistered)
{
await this.register();
user = await this.apiClient.users.getCurrentUser();
}
this.setState({user: user})
}
private async singIn() {
await this.trySetUser();
}
private async register() {
await this.apiClient.users.register();
}
render() {
return (
<div className="App">
<div className="header">
<TopBar user={this.state.user} goHome={() => {this.props.history.push('/')}}/>
</div>
<Switch>
<Route exact path="/sign-in" render={(_ => <AuthenticationPage user={this.state.user}/>)}/>
<Route exact path="/sign-in/google" render={_ => <AuthPage userManager={this.userService.userManager}/> }/>
<Route
path="/sign-in/callback/google"
render={(routeProps) => {
return <Callback
onSuccess={async (_) => {
await this.singIn();
routeProps.history.push('/');
}}
onError={(error) => {
console.log('openid error', error);
}}
userManager={this.userService.userManager}
/>;}}/>
<Route exact path="/create-project" render={(_ => <CreateProjectModal client={this.apiClient}/>) }/>
<Route exact path={"/projects/:id"} render={(_ => this.state.user ? <ProjectPage user={this.state.user} apiClient={this.apiClient}/> : <AuthenticationPage user={this.state.user}/>)}/>
<Route exact path={"/projects/:projectId/buildConfigs/:buildConfigId"} render={(_ => this.state.user ? <BuildConfigPage user={this.state.user} apiClient={this.apiClient}/> : <AuthenticationPage user={this.state.user}/>)}/>
<Route exact path="/" render={(_ => this.state.user ? <ProjectsPage apiClient={this.apiClient} user={this.state.user}/> : <AuthenticationPage user={this.state.user}/>)}/>
</Switch>
</div>
);
}
}
|
Mrtinic489/elevator-front | src/components/App/index.ts | import { App } from "./App";
import {withRouter} from "react-router-dom";
export default withRouter(App);
|
Mrtinic489/elevator-front | src/components/AuthPage/index.ts | import {AuthPage} from "./AuthPage"
import {withRouter} from "react-router-dom";
export default withRouter(AuthPage)
|
Mrtinic489/elevator-front | src/components/ProjectCard/ProjectCard.tsx | import React from "react";
import styles from './ProjectCard.module.css'
interface ProjectCardProps {
id: string;
name: string;
}
export class ProjectCard extends React.PureComponent<ProjectCardProps> {
render() {
return (<div className={styles.projectContainer}>
<a className={styles.projectName} href={"projects/" + this.props.id}>{this.props.name}</a>
</div>);
}
}
|
Mrtinic489/elevator-front | src/components/NoAuthenticatedUserPage/NoAuthenticatedUserPage.tsx | import React from "react";
import {RouteComponentProps} from "react-router-dom";
interface NoAuthenticatedUserPageProps extends RouteComponentProps {
}
export class NoAuthenticatedUserPage extends React.PureComponent<NoAuthenticatedUserPageProps> {
render() {
return (
<div>Я не знаю кто ты уйди нахер</div>
);
}
}
|
Mrtinic489/elevator-front | src/components/AuthPage/AuthPage.tsx | import React from "react";
import {Profile} from "../../models/Profile/Profile";
import {UserManager} from "oidc-client"
import {RouteComponentProps} from "react-router-dom";
interface GoogleAuthPageProps extends RouteComponentProps {
profile?: Profile;
userManager: UserManager;
}
interface GoogleAuthPageState {
profile?: Profile;
}
export class AuthPage extends React.PureComponent<GoogleAuthPageProps, GoogleAuthPageState> {
constructor(props: GoogleAuthPageProps) {
super(props);
this.setState({profile: undefined})
}
async componentDidMount() {
const user = await this.props.userManager.getUser();
console.log(user);
if (!user) {
await this.props.userManager.signinRedirect()
} else {
this.props.history.push('/');
}
}
render() {
return "Авторизуемся.."
}
}
|
joshuaslate/type-cacheable | packages/redis-adapter/test/RedisAdapter.test.ts | import * as Redis from 'redis';
import { Cacheable, CacheClear } from '@type-cacheable/core';
import { RedisAdapter, useAdapter } from '../lib';
let client: Redis.RedisClient;
let redisAdapter: RedisAdapter;
const keyName = 'aSimpleKeyForRedis';
const simpleKeyKeys = 'anotherSimpleKeyForRedis';
const compoundKey = 'aCompound:keyForRedis';
const compoundKeyKeys = 'aCompound:keysForRedis';
const simpleValue = 'aSimpleValueForRedis';
const objectValue = { myKeyOne: 'myValOneForRedis' };
const arrayValue = ['element1', 2, { complex: 'elementForRedis' }];
describe('RedisAdapter Tests', () => {
beforeAll(async () => {
client = Redis.createClient();
// Wait until the connection is ready before passing the client to the adapter.
await new Promise((resolve) => {
client.on('ready', () => {
resolve(null);
});
});
redisAdapter = useAdapter(client);
});
describe('Setter tests', () => {
it('should set a string value on a standard key', (done) => {
redisAdapter.set(keyName, simpleValue).then(() => {
client.get(keyName, (err, result) => {
expect(result).toBe(JSON.stringify(simpleValue));
done();
});
});
});
it('should set an object value on a standard key', (done) => {
const keyName = 'aSimpleKey';
redisAdapter.set(keyName, objectValue).then(() => {
client.get(keyName, (err, result) => {
expect(result).toBe(JSON.stringify(objectValue));
done();
});
});
});
it('should set an array value on a standard key', (done) => {
redisAdapter.set(keyName, arrayValue).then(() => {
client.get(keyName, (err, result) => {
expect(result).toBe(JSON.stringify(arrayValue));
done();
});
});
});
it('should set an object value on a compound (x:y) key', (done) => {
redisAdapter.set(compoundKey, objectValue).then(() => {
client.hgetall(compoundKey, (err, result) => {
expect(result).toEqual(
Object.keys(objectValue).reduce((accum, curr) => {
accum[curr] = JSON.stringify((objectValue as any)[curr]);
return accum;
}, {} as any),
);
done();
});
});
});
it('should set an array value on a compound (x:y) key', (done) => {
redisAdapter.set(compoundKey, arrayValue).then(() => {
client.hgetall(compoundKey, (err, result) => {
expect(result).toEqual({ ...result });
done();
});
});
});
it('should set an expiresAt value on a compound (x:y) key when TTL is passed in', (done) => {
jest.spyOn(client, 'expire');
redisAdapter.set(compoundKey, objectValue, 50000).then(() => {
expect(client.expire).toHaveBeenCalled();
done();
});
});
});
describe('Getter tests', () => {
it('should get a string set on a simple key', (done) => {
client.set(keyName, simpleValue, async (err, setResult) => {
const result = await redisAdapter.get(keyName);
expect(result).toBe(simpleValue);
done();
});
});
it('should get an object set on a simple key', (done) => {
client.set(keyName, JSON.stringify(objectValue), async (err, setResult) => {
const result = await redisAdapter.get(keyName);
expect(result).toEqual(objectValue);
done();
});
});
it('should get an array set on a simple key', (done) => {
client.set(keyName, JSON.stringify(arrayValue), async (err, setResult) => {
const result = await redisAdapter.get(keyName);
expect(result).toEqual(arrayValue);
done();
});
});
it('should get an object set on a compound (x:y) key', (done) => {
const args = RedisAdapter.buildSetArgumentsFromObject(objectValue);
client.hmset(compoundKey, args, async (err, setResult) => {
const result = await redisAdapter.get(compoundKey);
expect(result).toEqual(objectValue);
done();
});
});
it('should get an array set on a compound (x:y) key', (done) => {
const args = RedisAdapter.buildSetArgumentsFromObject({ ...arrayValue });
client.hmset(compoundKey, args, async () => {
const result = await redisAdapter.get(compoundKey);
expect(result).toEqual(arrayValue);
done();
});
});
});
describe('Keys tests', () => {
it('should get keys by pattern on a compound (x:y) key', (done) => {
client.set(compoundKeyKeys, simpleValue, async () => {
const result = await redisAdapter.keys(`*${compoundKeyKeys}*`);
expect(result).toHaveLength(1);
expect(result).toContain(compoundKeyKeys);
done();
});
});
it('should not find keys for a non-existent simple key', (done) => {
client.set(simpleKeyKeys, simpleValue, async () => {
const result = await redisAdapter.keys(`*${simpleValue}*`);
expect(result).toHaveLength(0);
expect(result).toBeInstanceOf(Array);
done();
});
});
it('should return multiple pages worth of keys when more than the max page size exist', (done) => {
const vals = new Array(5000)
.fill(undefined)
.reduce((accum, _, i) => [...accum, `key-${i}`, `val-${i}`], []);
client.mset(...vals, async () => {
const result = await redisAdapter.keys('*key-*');
expect(result).toHaveLength(5000);
done();
});
});
});
describe('Delete tests', () => {
it('should delete a set value', (done) => {
client.set(simpleKeyKeys, simpleValue, async () => {
await redisAdapter.del(keyName);
expect(await redisAdapter.get(keyName)).toBeFalsy();
done();
});
});
});
describe('Delete full hash', () => {
it('should delete a full hash', (done) => {
const hashKey = compoundKey.split(':')[0];
const args = RedisAdapter.buildSetArgumentsFromObject({ ...objectValue });
client.hmset(compoundKey, args, async () => {
const keys = await redisAdapter.keys(`*${hashKey}:*`);
expect(keys).toHaveLength(1);
await redisAdapter.delHash(hashKey);
const keysPostDelete = await redisAdapter.keys(`*${hashKey}:*`);
expect(keysPostDelete).toHaveLength(0);
done();
});
});
});
describe('integration', () => {
describe('@Cacheable decorator', () => {
const getTestInstance = () => {
const mockGetIdImplementation = jest.fn();
const mockGetIntIdImplementation = jest.fn();
const mockGetBooleanValueImplementation = jest.fn();
const mockGetArrayValueImplementation = jest.fn();
const mockGetObjectValueImplementation = jest.fn();
class TestClass {
@Cacheable({
client: redisAdapter,
hashKey: 'user',
cacheKey: (x) => x[0],
})
async getId(id: string): Promise<string> {
mockGetIdImplementation();
return id;
}
@Cacheable({
client: redisAdapter,
hashKey: 'userInt',
cacheKey: (x) => x[0],
})
async getIntId(id: number): Promise<number> {
mockGetIntIdImplementation();
return id;
}
@Cacheable({
client: redisAdapter,
hashKey: 'boolVal',
cacheKey: (x) => x[0],
})
async getBoolValue(value: boolean): Promise<boolean> {
mockGetBooleanValueImplementation();
return value;
}
@Cacheable({
client: redisAdapter,
hashKey: 'arrVal',
cacheKey: (x) => x[0],
})
async getArrayValue(value: string): Promise<any[]> {
mockGetArrayValueImplementation();
return ['true', true, 'false', false, 1, '1'];
}
@Cacheable({
client: redisAdapter,
hashKey: 'objVal',
cacheKey: (x) => x[0],
})
async getObjectValue(value: string): Promise<any> {
mockGetObjectValueImplementation();
return { hello: 'world', 1: 2, '2': 1, true: false, false: 'true' };
}
}
const testClass = new TestClass();
return {
testClass,
mockGetIdImplementation,
mockGetIntIdImplementation,
mockGetBooleanValueImplementation,
mockGetArrayValueImplementation,
mockGetObjectValueImplementation,
};
};
it('should properly set, and get, cached string values', async () => {
const { testClass, mockGetIdImplementation } = getTestInstance();
const getIdResult1 = await testClass.getId('1');
expect(getIdResult1).toBe('1');
expect(mockGetIdImplementation).toHaveBeenCalled();
mockGetIdImplementation.mockClear();
const getIdResult2 = await testClass.getId('1');
expect(getIdResult2).toBe('1');
expect(mockGetIdImplementation).not.toHaveBeenCalled();
});
it('should properly set, and get, cached number values', async () => {
const { testClass, mockGetIntIdImplementation } = getTestInstance();
const getIntIdResult1 = await testClass.getIntId(1);
expect(getIntIdResult1).toBe(1);
expect(mockGetIntIdImplementation).toHaveBeenCalled();
mockGetIntIdImplementation.mockClear();
const getIntIdResult2 = await testClass.getIntId(1);
expect(getIntIdResult2).toBe(1);
expect(mockGetIntIdImplementation).not.toHaveBeenCalled();
});
it('should properly set, and get, cached boolean values', async () => {
const { testClass, mockGetBooleanValueImplementation } = getTestInstance();
const getBooleanValueResult1 = await testClass.getBoolValue(true);
expect(getBooleanValueResult1).toBe(true);
expect(mockGetBooleanValueImplementation).toHaveBeenCalled();
mockGetBooleanValueImplementation.mockClear();
const getBooleanValueResult2 = await testClass.getBoolValue(true);
expect(getBooleanValueResult2).toBe(true);
expect(mockGetBooleanValueImplementation).not.toHaveBeenCalled();
});
it('should properly set, and get, cached array values', async () => {
const { testClass, mockGetArrayValueImplementation } = getTestInstance();
const getArrayValueResult1 = await testClass.getArrayValue('test');
expect(mockGetArrayValueImplementation).toHaveBeenCalled();
expect(getArrayValueResult1).toEqual(['true', true, 'false', false, 1, '1']);
mockGetArrayValueImplementation.mockClear();
const getArrayValueResult2 = await testClass.getArrayValue('test');
expect(getArrayValueResult2).toEqual(getArrayValueResult1);
expect(mockGetArrayValueImplementation).not.toHaveBeenCalled();
});
it('should properly set, and get, cached object values', async () => {
const { testClass, mockGetObjectValueImplementation } = getTestInstance();
const getObjectValueResult1 = await testClass.getObjectValue('test');
expect(mockGetObjectValueImplementation).toHaveBeenCalled();
expect(getObjectValueResult1).toEqual({
hello: 'world',
1: 2,
'2': 1,
true: false,
false: 'true',
});
mockGetObjectValueImplementation.mockClear();
const getObjectValueResult2 = await testClass.getObjectValue('test');
expect(getObjectValueResult2).toEqual(getObjectValueResult1);
expect(mockGetObjectValueImplementation).not.toHaveBeenCalled();
});
});
describe('@CacheClear Decorator', () => {
const getTestInstance = () => {
class TestClass {
@Cacheable({
client: redisAdapter,
cacheKey: 'users',
})
async getUsers(): Promise<{ id: string; name: string }[]> {
return [{ id: '123', name: 'Kodiak' }];
}
@Cacheable({
client: redisAdapter,
cacheKey: 'todos',
})
async getTodos(): Promise<{ id: string; done: boolean }[]> {
return [{ id: '456', done: false }];
}
@CacheClear({
client: redisAdapter,
cacheKey: ['users', 'todos'],
})
async clearAll(): Promise<void> {
return;
}
}
const testInstance = new TestClass();
return {
testInstance,
};
};
it('should clear multiple cacheKeys when an array is passed', async () => {
const { testInstance } = getTestInstance();
await testInstance.getUsers();
await testInstance.getTodos();
const userCacheResult = await redisAdapter.get('users');
expect(userCacheResult).toEqual([{ id: '123', name: 'Kodiak' }]);
const todoCacheResult = await redisAdapter.get('todos');
expect(todoCacheResult).toEqual([{ id: '456', done: false }]);
await testInstance.clearAll();
const userCacheResultPostClear = await redisAdapter.get('users');
expect(userCacheResultPostClear).toEqual(null);
const todoCacheResultPostClear = await redisAdapter.get('todos');
expect(todoCacheResultPostClear).toEqual(null);
});
});
});
afterEach((done) => {
client.flushall(done);
});
afterAll(() => {
client.end(true);
});
});
|
asmadsen/vuex-subscriptions | test/specs/index.spec.ts | import Vue from "vue"
import Vuex from "vuex"
import addSubscriptions from "./../../src"
import {expect} from "chai";
Vue.config.productionTip = false
Vue.config.devtools = false
describe("Subscription", () => {
it("subscribed method gets run", () => {
Vue.use(Vuex);
const store = new Vuex.Store({
plugins: [
addSubscriptions({
subscriptions: {
changeProperty: ({state, commit}) => {
commit("setDone", true);
}
}
})
],
state: {
property: "value",
done: false
},
mutations: {
changeProperty(state, payload) {
state.property = payload;
},
setDone(state, payload) {
state.property = "changed again";
state.done = payload;
}
}
})
store.commit("changeProperty", "changed");
expect(store.state.property).to.equal("changed again")
})
it('multiple subscription for one mutation', () => {
Vue.use(Vuex);
const store = new Vuex.Store({
plugins: [
addSubscriptions({
subscriptions: {
changeProperty: [
({commit}) => {
commit('updateFirst', true)
},
({commit}) => {
commit('updateSecond', true)
}
]
}
})
],
state: {
property: "value",
first: false,
second: false
},
mutations: {
changeProperty(state, payload) {
state.property = payload
},
updateFirst(state, payload) {
state.first = payload
},
updateSecond(state, payload) {
state.second = payload
}
}
})
store.commit("changeProperty", "first change")
expect(store.state.first).to.equal(true)
expect(store.state.second).to.equal(true)
})
it('multiple subscription inside modules', () => {
Vue.use(Vuex);
const modules = {
user: {
namespaced: true,
subscriptions: {
changeProperty({commit}) {
commit('user/changeFirst', true)
}
},
state: {
property: "value",
first: false
},
mutations: {
changeProperty(state, payload) {
state.property = payload
},
changeFirst(state, payload) {
state.first = payload
}
}
}
}
const store = new Vuex.Store({
plugins: [
addSubscriptions({
modules
})
],
state: <any>{},
modules
})
store.commit("user/changeProperty", "first change")
expect(store.state.user.first).to.equal(true)
})
}) |
asmadsen/vuex-subscriptions | src/index.ts | import {ModuleTree, Store} from "vuex";
import {Vue} from 'vue/types/vue'
declare module 'vuex/types/index' {
interface Module<S, R> {
subscriptions? : subscriptions
}
}
export interface subscription {
(store: Store<any>): any
}
export interface subscriptions {
[propName: string]: subscription | subscription[]
}
export default function addSubscriptions({
modules = <ModuleTree<any>>{},
subscriptions = <subscriptions>{},
subscriber = store => handler => store.subscribe(handler)
}) {
let _subscriptions: {
[propName: string]: Array<(store: Store<any>) => any>
} = {};
const pushSubscriptions = (store: Store<any> , subscriptions: Array<subscription>) => {
subscriptions.forEach(subscription => subscription(store))
};
if (modules) {
subscriptions = Object.entries(modules).reduce((prev, [key, _module]) => {
if (_module.hasOwnProperty('subscriptions')) {
prev = Object.entries(_module.subscriptions).reduce((result, [sub, value]) => {
sub = _module.namespaced ? key + '/' + sub : sub
result[sub] = value
return result
}, prev)
}
return prev
}, subscriptions)
}
_subscriptions = Object.entries(subscriptions).reduce((prev, [key, value]) => {
if (!Array.isArray(value)) {
value = [value]
}
if (!prev.hasOwnProperty(key)) {
prev[key] = []
}
prev[key] = prev[key].concat(value)
return prev
}, _subscriptions)
return store => {
subscriber(store)((mutation) => {
if (_subscriptions.hasOwnProperty(mutation.type)) {
pushSubscriptions(store, _subscriptions[mutation.type]);
}
});
}
} |
asmadsen/vuex-subscriptions | test/index.ts | const testsContext = require.context("./specs", true, /\.tsx?$/)
testsContext.keys().forEach(testsContext); |
Diounata/calculator.io | src/Components/Key/index.tsx | import styles from './styles.module.scss';
import { useMath } from 'Contexts/MathContext';
type MathOperatorsProps = '+' | '-' | '×' | '÷' | null;
interface KeyProps {
children: string;
number?: number;
operator?: MathOperatorsProps;
actionType?: 'number' | 'delete' | 'reset' | 'operator' | 'result' | 'period';
}
export default function Key({ children, actionType = 'number', number = 0, operator = null }: KeyProps) {
const {
addNumber,
updateCurrentMathOperator,
toggleIsCurrentNumberDecimal,
deleteNumber,
resetOperation,
getFinalResult,
} = useMath();
function buttonAction() {
switch (actionType) {
case 'number':
addNumber(number);
break;
case 'period':
toggleIsCurrentNumberDecimal(true);
break;
case 'operator':
updateCurrentMathOperator(operator);
break;
case 'result':
getFinalResult();
break;
case 'delete':
deleteNumber();
break;
case 'reset':
resetOperation();
break;
default:
return;
}
}
return (
<div className={styles.keyContainer} onClick={buttonAction}>
{children}
</div>
);
}
|
Diounata/calculator.io | src/Components/Keypad/index.tsx | import styles from './styles.module.scss';
import Key from 'Components/Key';
export default function Keypad() {
return (
<div className={styles.keypadContainer}>
<Key number={7}>7</Key>
<Key number={8}>8</Key>
<Key number={9}>9</Key>
<Key actionType="delete">DEL</Key>
<Key number={4}>4</Key>
<Key number={5}>5</Key>
<Key number={6}>6</Key>
<Key actionType="operator" operator='+'>+</Key>
<Key number={1}>1</Key>
<Key number={2}>2</Key>
<Key number={3}>3</Key>
<Key actionType="operator" operator='-'>-</Key>
<Key actionType="period">.</Key>
<Key number={0}>0</Key>
<Key actionType="operator" operator='÷'>/</Key>
<Key actionType="operator" operator='×'>x</Key>
<Key actionType="reset">RESET</Key>
<Key actionType="result">=</Key>
</div>
);
}
|
Diounata/calculator.io | src/Contexts/MathContext.tsx | <filename>src/Contexts/MathContext.tsx
import { createContext, ReactNode, useContext, useEffect, useState } from 'react';
export const MathContext = createContext({} as ContextProps);
interface ChildrenProps {
children: ReactNode;
}
type MathOperatorsSignProps = '+' | '-' | '×' | '÷' | null;
type MathOperatorsNameProps = 'sum' | 'subtract' | 'multiply' | 'divide' | 'error';
interface ContextProps {
previousNumber: number | null;
currentNumber: number;
currentDecimalNumber: string;
currentMathOperator: MathOperatorsSignProps;
lastUsedMathOperator: MathOperatorsSignProps;
isCurrentNumberNegative: boolean;
isCurrentNumberDecimal: boolean;
hasBugResult: boolean;
formatNumber(number: number): string;
addNumber(number: number): void;
getFinalResult(): void;
deleteNumber(): void;
resetOperation(): void;
updateCurrentMathOperator(value: MathOperatorsSignProps): void;
toggleIsCurrentNumberDecimal(value: boolean): void;
}
export function MathProvider({ children }: ChildrenProps) {
const [previousNumber, setPreviousNumber] = useState<number | null>(null);
const [currentNumber, setCurrentNumber] = useState<number>(0);
const [currentDecimalNumber, setCurrentDecimalNumber] = useState<string>('');
const [currentMathOperator, setCurrentMathOperator] = useState<MathOperatorsSignProps>(null);
const [lastUsedMathOperator, setLastUsedMathOperator] = useState<MathOperatorsSignProps>(null);
const [isCurrentNumberNegative, setIsCurrentNumberNegative] = useState(false);
const [isCurrentNumberDecimal, setIsCurrentNumberDecimal] = useState(false);
const [isCountFinished, setIsCountFinished] = useState(false);
const [hasBugResult, setHasBugResult] = useState(false);
function formatNumber(number: number): string {
const numberString = new Intl.NumberFormat().format(number);
return numberString;
}
function addNumber(number: number): void {
if (isCountFinished) setIsCountFinished(false);
if (hasBugResult) setHasBugResult(false);
if (isCurrentNumberDecimal) {
if (!currentDecimalNumber) setCurrentDecimalNumber(String(number));
else {
const newCurrentDecimalNumber = currentDecimalNumber + String(number);
setCurrentDecimalNumber(newCurrentDecimalNumber);
}
} else {
const newCurrentNumber = Number(String(currentNumber) + number);
setCurrentNumber(newCurrentNumber);
}
}
function deleteNumber(): void {
if (hasBugResult) setHasBugResult(false);
if (isCurrentNumberDecimal) {
if (!currentDecimalNumber) resetCurrentDecimalNumber();
else {
let decimalNumberArray = Array.from(currentDecimalNumber);
decimalNumberArray.pop();
const newDecimalNumber = decimalNumberArray.join('');
setCurrentDecimalNumber(String(newDecimalNumber));
}
} else {
const newNumber = Math.floor(currentNumber / 10);
setCurrentNumber(newNumber);
}
}
function getFinalResult(): void {
if (lastUsedMathOperator === '÷' && (currentNumber === 0 || currentNumber === null)) setHasBugResult(true);
else {
const finalResult = calcPreviousNumberByCurrentNumber();
const finalResultString = finalResult % 1 === 0 ? finalResult.toFixed(1) : String(finalResult);
const [intNumber, floatNumber] = finalResultString.split('.');
setIsCurrentNumberDecimal(floatNumber !== '0');
setCurrentNumber(Number(intNumber));
setCurrentDecimalNumber(floatNumber === '0' ? '' : floatNumber);
}
setIsCountFinished(true);
setIsCurrentNumberNegative(false);
setPreviousNumber(null);
setCurrentMathOperator(null);
}
function resetOperation(): void {
if (hasBugResult) setHasBugResult(false);
setCurrentMathOperator(null);
setPreviousNumber(null);
setCurrentNumber(0);
setIsCurrentNumberNegative(false);
resetCurrentDecimalNumber();
}
function resetCurrentDecimalNumber(): void {
setCurrentDecimalNumber('');
setIsCurrentNumberDecimal(false);
}
function updateCurrentMathOperator(value: MathOperatorsSignProps): void {
if (isCountFinished) setIsCountFinished(false);
if (currentNumber === 0 && value === '-' && !isCurrentNumberDecimal) {
setIsCurrentNumberNegative(prev => !prev);
} else setCurrentMathOperator(value);
}
function toggleIsCurrentNumberDecimal(value: boolean): void {
setIsCurrentNumberDecimal(value);
}
function getCurrentNumberWithItsOperator(): number {
let convertedCurrentDecimalNumber = 0;
if (currentDecimalNumber !== '') {
const decimalNumberLength = Number(currentDecimalNumber.length);
convertedCurrentDecimalNumber = Number(currentDecimalNumber) / 10 ** decimalNumberLength;
}
const newCurrentNumber = currentNumber + convertedCurrentDecimalNumber;
const number = isCurrentNumberNegative ? newCurrentNumber * -1 : newCurrentNumber;
return number;
}
function getMathOperatorName(): MathOperatorsNameProps {
switch (lastUsedMathOperator) {
case '+':
return 'sum';
case '-':
return 'subtract';
case '×':
return 'multiply';
case '÷':
return 'divide';
default:
return 'error';
}
}
function calcPreviousNumberByCurrentNumber(): number {
const latestNumber = getCurrentNumberWithItsOperator();
if (previousNumber === null) return latestNumber;
else {
const mathOperator = getMathOperatorName();
const operation = {
sum: previousNumber + latestNumber,
subtract: previousNumber - latestNumber,
multiply: previousNumber * latestNumber,
divide: previousNumber / latestNumber,
error: -1,
};
return operation[mathOperator];
}
}
useEffect(() => {
if (currentMathOperator === null || (currentNumber === 0 && !isCurrentNumberDecimal) || isCountFinished)
return;
const newPreviousNumber = calcPreviousNumberByCurrentNumber();
setPreviousNumber(newPreviousNumber);
setIsCurrentNumberNegative(false);
setLastUsedMathOperator(currentMathOperator);
setCurrentNumber(0);
setCurrentMathOperator(null);
resetCurrentDecimalNumber();
}, [currentMathOperator]);
return (
<MathContext.Provider
value={{
previousNumber,
currentNumber,
currentDecimalNumber,
currentMathOperator,
lastUsedMathOperator,
isCurrentNumberNegative,
isCurrentNumberDecimal,
hasBugResult,
formatNumber,
addNumber,
getFinalResult,
deleteNumber,
resetOperation,
updateCurrentMathOperator,
toggleIsCurrentNumberDecimal,
}}
>
{children}
</MathContext.Provider>
);
}
export function useMath() {
return useContext(MathContext);
}
|
Diounata/calculator.io | src/pages/404.tsx | import { useEffect } from 'react';
import { useRouter } from 'next/dist/client/router';
import styles from '@styles/index.module.scss';
export default function NotFound() {
const router = useRouter();
useEffect(() => {
router.push('/');
}, []);
return <div className={styles.container}></div>;
}
|
Diounata/calculator.io | src/Components/Result/index.tsx | <reponame>Diounata/calculator.io
import styles from './styles.module.scss';
import { useMath } from 'Contexts/MathContext';
export default function Result() {
const {
previousNumber,
currentNumber,
currentDecimalNumber,
lastUsedMathOperator,
isCurrentNumberNegative,
isCurrentNumberDecimal,
hasBugResult,
formatNumber,
} = useMath();
function getDecimalNumber() {
if (isCurrentNumberDecimal) {
if (!currentDecimalNumber) return;
return currentDecimalNumber;
}
}
return (
<div className={styles.resultContainer}>
<div>
{previousNumber !== null && formatNumber(previousNumber)}
<span>{previousNumber !== null && lastUsedMathOperator}</span>
</div>
<div>
{isCurrentNumberNegative && '-'}
{hasBugResult ? <span>Can't divide by 0</span> : formatNumber(currentNumber)}
{isCurrentNumberDecimal && '.'}
{getDecimalNumber()}
</div>
</div>
);
}
|
Diounata/calculator.io | src/Contexts/ThemeContext.tsx | <gh_stars>1-10
import { createContext, ReactNode, useContext, useState } from 'react';
export const ThemeContext = createContext({} as ContextProps);
interface ChildrenProps {
children: ReactNode;
}
type ThemeProps = 'dark' | 'light' | 'alt';
interface ContextProps {
currentTheme: ThemeProps;
updateTheme(value: ThemeProps): void;
}
export function ThemeProvider({ children }: ChildrenProps) {
const [currentTheme, setCurrentTheme] = useState<ThemeProps>('dark');
function updateTheme(value: ThemeProps): void {
setCurrentTheme(value);
}
return <ThemeContext.Provider value={{ currentTheme, updateTheme }}>{children}</ThemeContext.Provider>;
}
export function useTheme() {
return useContext(ThemeContext);
}
|
Diounata/calculator.io | src/Components/App.tsx | <reponame>Diounata/calculator.io
import styles from '@styles/index.module.scss';
import Title from 'utils/Title';
import Header from 'Components/Header';
import Result from 'Components/Result';
import Keypad from 'Components/Keypad';
import { useTheme } from 'Contexts/ThemeContext';
export default function App() {
const { currentTheme } = useTheme();
return (
<div className={`${currentTheme} ${styles.container}`}>
<Title />
<Header />
<Result />
<Keypad />
</div>
);
}
|
Diounata/calculator.io | src/pages/index.tsx | import App from 'Components/App';
import { ThemeProvider } from 'Contexts/ThemeContext';
import { MathProvider } from 'Contexts/MathContext';
export default function Home() {
return (
<MathProvider>
<ThemeProvider>
<App />
</ThemeProvider>
</MathProvider>
);
}
|
Diounata/calculator.io | src/utils/Title.tsx | import Head from 'next/head';
export default function Title() {
return (
<Head>
<title>Calculator.io</title>
</Head>
);
}
|
Diounata/calculator.io | src/Components/Header/index.tsx | import styles from './styles.module.scss';
import { useTheme } from 'Contexts/ThemeContext';
type ThemeProps = 'dark' | 'light' | 'alt';
export default function Header() {
const { currentTheme, updateTheme } = useTheme();
const themes: ThemeProps[] = ['dark', 'light', 'alt'];
return (
<header className={styles.headerContainer}>
<h3>calc</h3>
<div className={styles.themeContainer}>
<h3>THEME</h3>
<div>
{themes.map((theme, key) => (
<div
className={currentTheme === theme ? styles.selected : undefined}
onClick={() => updateTheme(theme)}
key={key}
></div>
))}
</div>
</div>
</header>
);
}
|
shinneider/RE5-Save-Editor | src/main/re5/constants.ts | // /////
// // All of this list are inverted because readUInt32LE get inverted bytes position
// ////
export const allGameGuns = [
'RPG',
'S&W 500', 'L. Hawk', 'S&W M29',
'H&K PSG-1', 'Dragunov SVD', 'S75',
'SIG 556', 'H&K MP5', 'AK-74', 'VZ61',
'Hydra', 'Jail Breaker', 'M3', 'Ithaca M3',
'M93R', 'SIG P226', 'H&K P8', 'M92F'
]
export const allGameFiles = [
'<NAME>',
'<NAME>',
'<NAME>',
'Tricell',
'U-8',
'<NAME>',
'<NAME>',
'<NAME>',
'<NAME>',
'Manjini',
'BSAA',
'History of Resident Evil'
]
export const allGameFigures = [
'Jill (rare)', 'Sheva (rare)', 'Chris (rare)', 'Irving (transformed)', 'Ndesu',
'Popokarimu', 'U-8', 'Uroboros Aheri', 'Crocodile', 'Adjule', 'Bui Kichwa', 'Kipepeo', 'Licker 8',
'Uroboros', 'Motorcycle Majini', 'Gatling gun Majini', 'Chainsaw Majini', 'Executioner Majini',
'Big man Majini', 'Reaper', 'Majini (Duvalia)', 'Majini (Base B)', 'Majini (Base A)',
'Giant Majini', 'Majini (Wetlands C)', 'Majini (Wetlands B)', 'Majini (Wetlands A)',
'Majini (Agitator)', 'Majini (Cephalo)', 'Majini (Town D)', 'Majini (Town C)',
'Majini (Town B)', 'Majini (Town A)', 'Reynard', 'Kirk', 'Dave', 'DeChant', 'Spencer',
'Irving', 'Excella', 'Wesker', 'Jill (Brainwashed)', 'Josh', 'Sheva (BSAA)', 'Chris (BSSA)',
]
|
shinneider/RE5-Save-Editor | src/renderer/components/forms/SaveHeader.tsx | import { Grid } from '@mui/material';
import GenericField from '../fields/GenericField'
export default function SaveHeader() {
return (
<Grid container spacing={4}>
<Grid item xs={12} sm={6} lg={4}>
<GenericField title="Steam ID" ipcName="steam_id" type="text" ipcSet/>
</Grid>
<Grid item xs={12} sm={6} lg={4}>
<GenericField title="Save Date" ipcName="save_date" type="datetime-local" ipcSet/>
</Grid>
<Grid item xs={6} lg={2}>
<GenericField title="Save Checksum" ipcName="save_checksum" type="text" />
</Grid>
<Grid item xs={6} lg={2}>
<GenericField title="Real Checksum" ipcName="file_checksum" type="number" updateInterval={750}/>
</Grid>
</Grid>
);
}
|
shinneider/RE5-Save-Editor | src/renderer/screens/base/BaseScreen.tsx | import { Divider, Grid, Typography } from '@mui/material';
import { BaseScreenProps, BaseScreenTitleProps } from './props';
import './BaseScreen.css';
export const BaseScreen = (props: BaseScreenProps) => {
const { children } = props;
return (
<Grid
container
spacing={0}
direction="column"
alignItems="center"
justifyContent="center"
style={{ minHeight: '100vh' }}
>
<Grid item className="content-container">
{children}
</Grid>
</Grid>
);
};
export const BaseScreenWithTitle = (props: BaseScreenTitleProps) => {
const { children, title } = props;
return (
<BaseScreen>
<Grid container spacing={2}>
<Grid item xs={12}>
<Typography variant="h4" component="div" align="center" gutterBottom>
{title}
</Typography>
<Divider />
</Grid>
<Grid item xs={12}>
{children}
</Grid>
</Grid>
</BaseScreen>
);
};
|
shinneider/RE5-Save-Editor | src/renderer/components/fields/GenericSelect.tsx | import { useEffect, useState } from "react";
import { GenericSelectProps } from './props'
import { Checkbox, FormControl, InputLabel, ListItemText, MenuItem, OutlinedInput, Select } from '@mui/material';
const MenuProps = {
PaperProps: {
style: {
width: 250,
},
},
};
export default function GenericSelect(props: GenericSelectProps) {
const ipc = window.electron.ipcRenderer
const [retryValue, setRetryValue] = useState([]);
const [choicesValue, setChoicesValue] = useState([]);
const setValue = (event: any) => {
const selects = typeof event.target.value === 'string' ? event.target.value.split(',') : event.target.value
setRetryValue(selects);
ipc.send(`set-${props.ipcName}`, selects)
};
const fetchData = async () => {
setRetryValue(await ipc.invoke(`get-${props.ipcName}`))
setChoicesValue(await ipc.invoke(`get-${props.ipcName}_choices`))
}
useEffect(() => {
fetchData()
}, []);
return (
<FormControl size="small" fullWidth>
<InputLabel id="demo-multiple-checkbox-label">{props.title}</InputLabel>
<Select
multiple
autoWidth
value={retryValue}
onChange={setValue}
input={<OutlinedInput label="Tag" />}
renderValue={(selected) => selected.join(', ')}
MenuProps={MenuProps}
>
{choicesValue.map((name) => (
<MenuItem key={name} value={name}>
<Checkbox checked={retryValue.indexOf(name) > -1} />
<ListItemText primary={name} />
</MenuItem>
))}
</Select>
</FormControl>
);
}
|
shinneider/RE5-Save-Editor | src/main/re5/hack.ts | import * as fs from 'fs';
import { Buffer } from 'buffer';
import { allGameGuns, allGameFiles, allGameFigures } from './constants';
export class RE5SaveBase {
static magic: Buffer = Buffer.from([0x00, 0x21, 0x11, 0x08, 0xc0, 0x4b, 0x00, 0x00]);
static xor = (data: Buffer, key: Buffer) => data.map((e, index) => e ^ key[index]);
static readFile = (dir: fs.PathOrFileDescriptor) => fs.readFileSync(dir);
static writeFile = (dir: fs.PathOrFileDescriptor, buffer: Buffer) =>
fs.writeFileSync(dir, buffer, 'binary');
static decodeSaveData(buffer: Buffer) {
let outputFile = Buffer.from([]);
let key = this.magic;
for (let i = 0; i < buffer.length / 8; i += 1) {
const encodedData = buffer.subarray(i * 8, (i + 1) * 8);
const decodedData = this.xor(encodedData, key);
outputFile = Buffer.concat([outputFile, decodedData]);
key = encodedData;
}
return outputFile;
}
static encodeSaveData(buffer: Buffer) {
let outputFile = Buffer.from([]);
let key = this.magic;
for (let i = 0; i < buffer.length / 8; i += 1) {
const decodedData = buffer.subarray(i * 8, (i + 1) * 8);
const encodedData = this.xor(decodedData, key);
outputFile = Buffer.concat([outputFile, encodedData]);
key = encodedData;
}
return outputFile;
}
static checkSum = (fin: Buffer, seekpos: number, iters: number, ret: number) => {
for (let i = 0; i < iters; i += 1) {
const b = fin.readUIntLE(seekpos + i * 4, 4);
ret = (ret + b) % 2 ** 32;
}
return ret;
};
static calculateChecksum(buffer: Buffer) {
const firstCheckSum = this.checkSum(buffer, 0x10, 0xee7, 0);
return this.checkSum(buffer, 0x3bb0, 0x5c0, firstCheckSum);
}
}
export class Re5SteamSaveEditor {
savePath: fs.PathOrFileDescriptor = ""
saveBuffer: Buffer = Buffer.from([])
open = (dir: fs.PathOrFileDescriptor) => {
this.savePath = dir
this.saveBuffer = RE5SaveBase.decodeSaveData(RE5SaveBase.readFile(dir))
}
save(dir: fs.PathOrFileDescriptor) {
this.setSaveFileChecksum(RE5SaveBase.calculateChecksum(this.saveBuffer))
const encodedData = RE5SaveBase.encodeSaveData(this.saveBuffer)
RE5SaveBase.writeFile(dir, encodedData)
}
getUInt64 = (offset: number) => this.saveBuffer.readBigUInt64LE(offset)
setUInt64 = (offset: number, value: bigint) => this.saveBuffer.writeBigInt64LE(value, offset)
getUInt32 = (offset: number) => this.saveBuffer.readUInt32LE(offset)
setUInt32 = (offset: number, value: number) => this.saveBuffer.writeUInt32LE(value, offset)
getSteamId = () => this.saveBuffer.readBigInt64LE(0x0)
setSteamId = (steamId: bigint) => this.saveBuffer.writeBigInt64LE(steamId, 0x0)
getSaveFileChecksum = () => this.getUInt32(0x8)
setSaveFileChecksum = (checksum: number) => this.setUInt32(0x8, checksum)
getRealChecksum = () => RE5SaveBase.calculateChecksum(this.saveBuffer)
getSaveDate() {
const date = `${this.getUInt32(0x10)}-${this.getUInt32(0x14)}-${this.getUInt32(0x18)}`
const hours = `${this.getUInt32(0x1c)}:${this.getUInt32(0x20)}:${this.getUInt32(0x24)}`
return new Date(`${date}T${hours}`)
}
setSaveDate(date: Date) {
this.setUInt32(0x10, date.getFullYear()) && this.setUInt32(0x14, date.getMonth()) && this.setUInt32(0x18, date.getDate())
this.setUInt32(0x1c, date.getHours()) && this.setUInt32(0x20, date.getMinutes()) && this.setUInt32(0x24, date.getSeconds())
}
getMoney = () => this.getUInt32(0x194)
setMoney = (money: number) => this.setUInt32(0x194, money)
getPoints = () => this.getUInt32(0x198)
setPoints = (money: number) => this.setUInt32(0x198, money)
getChoicesHelper = (choices: Array<string>, value: number | bigint) => {
const binary = value.toString(2);
return choices.filter((_, index) => binary[index] == '1')
}
setChoicesHelper = (choices: Array<string>, value: Array<string>) => {
const reducFunc = (prev: string, curr: string) => {
const indexPos = choices.indexOf(curr)
return indexPos !== -1 ? prev.substring(0, indexPos) + '1' + prev.substring(indexPos + 1) : prev
};
return value.reduce(reducFunc, '0'.padStart(choices.length, '0'))
};
getChrisCostumesChoices = () => ['warrior', 'stars', 'safari', 'bsaa']
getChrisCostumes = () => this.getChoicesHelper(this.getChrisCostumesChoices(), this.getUInt32(0x124))
setChrisCostumes = (value: Array<string>) => this.setUInt32(0x124, parseInt(this.setChoicesHelper(this.getChrisCostumesChoices(), value), 2))
getShevaCostumesChoices = () => ['business', 'tribal', 'clubbin', 'bsaa']
getShevaCostumes = () => this.getChoicesHelper(this.getShevaCostumesChoices(), this.getUInt32(0x128))
setShevaCostumes = (value: Array<string>) => this.setUInt32(0x128, parseInt(this.setChoicesHelper(this.getShevaCostumesChoices(), value), 2))
getScreenFiltersChoices = () => ['noise', 'retro', 'classic', 'default']
getScreenFilters = () => this.getChoicesHelper(this.getScreenFiltersChoices(), this.getUInt32(0x12c))
setScreenFilters = (value: Array<string>) => this.setUInt32(0x12c, parseInt(this.setChoicesHelper(this.getScreenFiltersChoices(), value), 2))
getInfAmmoWeaponsChoices = () => allGameGuns
getInfAmmoWeapons = () => this.getChoicesHelper(allGameGuns, this.getUInt32(0x130))
setInfAmmoWeapons = (value: Array<string>) => this.setUInt32(0x130, parseInt(this.setChoicesHelper(allGameGuns, value), 2))
getGameFilesChoices = () => allGameFiles
getGameFiles = () => this.getChoicesHelper(this.getGameFilesChoices(), this.getUInt32(0x134))
setGameFiles = (value: Array<string>) => this.setUInt32(0x134, parseInt(this.setChoicesHelper(allGameFiles, value), 2))
getGameFiguresChoices = () => allGameFigures
getGameFigures = () => this.getChoicesHelper(allGameFigures, this.getUInt64(0x138))
setGameFigures = (value: Array<string>) => this.setUInt64(0x138, BigInt('0b' + this.setChoicesHelper(allGameFigures, value)))
}
|
shinneider/RE5-Save-Editor | src/renderer/screens/GameStatus.tsx | <reponame>shinneider/RE5-Save-Editor<filename>src/renderer/screens/GameStatus.tsx
import { useNavigate } from 'react-router-dom';
import { Button } from '@mui/material';
import { BaseScreenWithTitle } from './base/BaseScreen';
export default function GameStatus(props: any) {
const navigate = useNavigate();
const testDialog = async () => {
const openedSave = await window.electron.ipcRenderer.invoke('open-save');
if (openedSave) navigate('/hack-form');
};
return (
<BaseScreenWithTitle title="Load save file">
<Button
variant="outlined"
color="error"
component="span"
size="large"
fullWidth
onClick={testDialog}
>
Select File
</Button>
</BaseScreenWithTitle>
);
}
|
shinneider/RE5-Save-Editor | src/renderer/components/fields/props.ts | export interface GenericFieldProps {
/**
* Children components.
*/
title: string
ipcName: string
ipcSet?: boolean
type?: React.HTMLInputTypeAttribute
updateInterval?: Number
}
export interface GenericSelectProps {
/**
* Children components.
*/
title: string
ipcName: string
// ipcGet: string
// ipcSet?: string
// type?: React.HTMLInputTypeAttribute
// updateInterval?: Number
}
|
shinneider/RE5-Save-Editor | src/renderer/components/fields/GenericField.tsx | <reponame>shinneider/RE5-Save-Editor<gh_stars>0
import { useEffect, useState } from "react";
import { TextField } from '@mui/material';
import { GenericFieldProps } from './props'
export default function GenericField(props: GenericFieldProps) {
const ipc = window.electron.ipcRenderer
const [retryValue, setRetryValue] = useState<string>("");
const setValue = (event: any) => {
if(props.ipcSet) ipc.send(`set-${props.ipcName}`, event.target.value)
setRetryValue(event.target.value);
}
const fetchData = async () => {
let res = await ipc.invoke(`get-${props.ipcName}`)
if(props.type === "datetime-local" && res instanceof Date) {
res = res.toISOString().replace('Z', '')
}
setRetryValue(res.toString());
};
useEffect(() => {
fetchData();
if(props.updateInterval) {
const interval = setInterval(() => fetchData(), 2000);
return () => clearInterval(interval);
}
}, []);
return (
<TextField
label={props.title}
variant="outlined"
type={props.type}
size="small"
fullWidth
value={retryValue}
onChange={setValue}
disabled={!props.ipcSet}
/>
);
}
|
shinneider/RE5-Save-Editor | src/renderer/screens/base/props.ts | export interface BaseScreenProps {
/**
* Children components.
*/
children?: React.ReactNode;
}
export interface BaseScreenTitleProps {
/**
* Children components.
*/
children?: React.ReactNode;
title: string;
}
|
shinneider/RE5-Save-Editor | src/main/re5/events.ts | import { ipcMain, dialog } from 'electron';
import { Re5SteamSaveEditor } from './hack';
const gameHack = new Re5SteamSaveEditor();
ipcMain.on('save', async (event, arg: string) => {
const { canceled, filePath } = await dialog.showSaveDialog({
title: 'Select path to store your RE5 Save',
defaultPath: 'C:\\Program Files (x86)\\Steam\\userdata\\53188471\\21690\\remote\\savedata.bin'
});
if(!canceled && filePath !== undefined) {
gameHack.save(filePath)
}
});
ipcMain.handle('open-save', async (event, arg: any) => {
try {
const { canceled, filePaths } = await dialog.showOpenDialog({
title: 'Select Your RE5 Save',
defaultPath: 'C:\\Program Files (x86)\\Steam\\userdata\\53188471\\21690\\remote\\savedata.bin',
filters: [
{ name: 'BIN', extensions: ['bin'] },
{ name: 'All Files', extensions: ['*'] },
],
properties: ['openFile', 'showHiddenFiles'],
});
if (!canceled) {
gameHack.open(filePaths[0]);
return true;
}
} catch (error) {}
return false;
});
// //////
// // Basic Data
// ////
ipcMain.handle('get-steam_id', async (event, arg) => gameHack.getSteamId());
ipcMain.on('set-steam_id', async (event, arg: string) => gameHack.setSteamId(BigInt(arg)));
ipcMain.handle('get-save_date', async (event, arg) => gameHack.getSaveDate());
ipcMain.on('set-save_date', async (event, arg: string) => gameHack.setSaveDate(new Date(arg)));
ipcMain.handle('get-save_checksum', async (event, arg) => gameHack.getSaveFileChecksum());
ipcMain.handle('get-file_checksum', async (event, arg) => gameHack.getRealChecksum());
// //////
// // Save Data
// ////
ipcMain.handle('get-money', (event, arg) => gameHack.getMoney());
ipcMain.on('set-money', (event, arg: number) => gameHack.setMoney(Number(arg)));
ipcMain.handle('get-points', (event, arg) => gameHack.getPoints());
ipcMain.on('set-points', (event, arg: number) => gameHack.setPoints(Number(arg)));
ipcMain.handle('get-chris_costumes_choices', (event, arg) => gameHack.getChrisCostumesChoices());
ipcMain.handle('get-chris_costumes', (event, arg) => gameHack.getChrisCostumes());
ipcMain.on('set-chris_costumes', (event, arg) => gameHack.setChrisCostumes(arg));
ipcMain.handle('get-sheva_costumes_choices', (event, arg) => gameHack.getShevaCostumesChoices());
ipcMain.handle('get-sheva_costumes', (event, arg) => gameHack.getShevaCostumes());
ipcMain.on('set-sheva_costumes', (event, arg) => gameHack.setShevaCostumes(arg));
ipcMain.handle('get-screen_filters_choices', (event, arg) => gameHack.getScreenFiltersChoices());
ipcMain.handle('get-screen_filters', (event, arg) => gameHack.getScreenFilters());
ipcMain.on('set-screen_filters', (event, arg) => gameHack.setScreenFilters(arg));
ipcMain.handle('get-inf_ammo_weapons_choices', (event, arg) => gameHack.getInfAmmoWeaponsChoices());
ipcMain.handle('get-inf_ammo_weapons', (event, arg) => gameHack.getInfAmmoWeapons());
ipcMain.on('set-inf_ammo_weapons', (event, arg) => gameHack.setInfAmmoWeapons(arg));
ipcMain.handle('get-game_files_choices', (event, arg) => gameHack.getGameFilesChoices());
ipcMain.handle('get-game_files', (event, arg) => gameHack.getGameFiles());
ipcMain.on('set-game_files', (event, arg) => gameHack.setGameFiles(arg));
ipcMain.handle('get-game_figures_choices', (event, arg) => gameHack.getGameFiguresChoices());
ipcMain.handle('get-game_figures', (event, arg) => gameHack.getGameFigures());
ipcMain.on('set-game_figures', (event, arg) => gameHack.setGameFigures(arg));
// ipcMain.on('set-inf_ammo', (event, arg: boolean) => gameHack.setInfAmmo(arg));
// ipcMain.on('game-running', async (event, arg) => {
// event.reply('game-running', gameHack.gameRunning());
// });
|
shinneider/RE5-Save-Editor | src/renderer/components/forms/SaveData.tsx | <reponame>shinneider/RE5-Save-Editor<filename>src/renderer/components/forms/SaveData.tsx
import { Grid } from '@mui/material';
import GenericField from '../fields/GenericField'
import GenericSelect from '../fields/GenericSelect'
export default function SaveHeader() {
return (
<Grid container spacing={4}>
<Grid item xs={12} md={4}>
<GenericSelect title="Chris Costumes" ipcName="chris_costumes"/>
</Grid>
<Grid item xs={12} md={4}>
<GenericSelect title="Sheva Costumes" ipcName="sheva_costumes"/>
</Grid>
<Grid item xs={12} md={4}>
<GenericSelect title="Scene Filters" ipcName="screen_filters"/>
</Grid>
<Grid item xs={12} md={6}>
<GenericSelect title="Infinite Ammo Weapons" ipcName="inf_ammo_weapons"/>
</Grid>
<Grid item xs={12} md={6}>
<GenericSelect title="Game Files" ipcName="game_files"/>
</Grid>
<Grid item xs={12} md={6}>
<GenericSelect title="Game Figures" ipcName="game_figures"/>
</Grid>
<Grid item xs={6} md={3}>
<GenericField title="Money" ipcName="money" type="number" ipcSet/>
</Grid>
<Grid item xs={6} md={3}>
<GenericField title="Points" ipcName="points" type="number" ipcSet/>
</Grid>
</Grid>
);
}
|
shinneider/RE5-Save-Editor | src/renderer/screens/HackScreen.tsx | import { Button, Divider, Grid } from '@mui/material';
import { BaseScreenWithTitle } from './base/BaseScreen';
import SaveHeader from '../components/forms/SaveHeader'
import SaveData from '../components/forms/SaveData'
export default function HackScreen() {
const saveFile = (event: any) => window.electron.ipcRenderer.send(`save`)
return (
<BaseScreenWithTitle title="Save Editor">
<Grid container spacing={4}>
<Grid item xs={12}>
<Divider>Save Info</Divider>
</Grid>
<Grid item xs={12}>
<SaveHeader />
</Grid>
<Grid item xs={12}>
<Divider>Save Edit</Divider>
</Grid>
<Grid item xs={12}>
<SaveData />
</Grid>
<Grid item xs={12} sm={12} md={4}>
{/* <VaultItemCpnt vault={1}/> */}
</Grid>
</Grid>
<Divider />
<Grid container spacing={4} justifyContent="flex-end" sx={{ pt: 2 }}>
<Grid item>
<Button
variant="outlined"
color="error"
component="span"
size="large"
onClick={saveFile}
>
Save File
</Button>
</Grid>
</Grid>
</BaseScreenWithTitle>
)
}
|
shinneider/RE5-Save-Editor | src/renderer/App.tsx | import { MemoryRouter as Router, Routes, Route } from 'react-router-dom';
import GameStatus from './screens/GameStatus';
import HackScreen from './screens/HackScreen';
export default function App() {
return (
<Router>
<Routes>
<Route path="/" element={<GameStatus />} />
<Route path="/hack-form" element={<HackScreen />} />
</Routes>
</Router>
);
}
|
TimP4w/ngx-drag-scroll | demo/app/app.module.ts | import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { HttpClientModule } from '@angular/common/http';
import {
MatCommonModule,
MatIconModule,
MatSlideToggleModule,
MatToolbarModule,
MatButtonModule
} from '@angular/material';
import { AppComponent } from './app.component';
import { HeaderComponent } from './header/header.component';
import { DragScrollModule } from '../../src/ngx-drag-scroll';
import { NotFoundComponent } from './not-found/not-found.component';
import { AppRoutingModule } from './app-routing.module';
import { HomeComponent } from './home/home.component';
import { FooterComponent } from './footer/footer.component';
import { GithubComponent } from './github/github.component';
import { FlexLayoutModule } from '@angular/flex-layout';
@NgModule({
declarations: [
AppComponent,
HeaderComponent,
NotFoundComponent,
FooterComponent,
GithubComponent,
HomeComponent
],
imports: [
AppRoutingModule,
DragScrollModule,
BrowserModule,
FormsModule,
HttpClientModule,
MatCommonModule,
MatIconModule,
MatSlideToggleModule,
MatToolbarModule,
MatButtonModule,
FlexLayoutModule
],
providers: [
],
bootstrap: [AppComponent]
})
export class AppModule { }
|
TimP4w/ngx-drag-scroll | demo/app/home/home.component.ts | import { Component, OnInit, ElementRef, Renderer2, ViewChild } from '@angular/core';
import { DomSanitizer } from '@angular/platform-browser';
import { MatIconRegistry } from '@angular/material';
import { DragScrollDirective } from '../../../src/ngx-drag-scroll';
@Component({
selector: 'app-home',
templateUrl: './home.component.html',
styleUrls: ['./home.component.css'],
viewProviders: [MatIconRegistry]
})
export class HomeComponent implements OnInit {
title = 'app works!';
hideScrollbar;
disabled;
xDisabled;
yDisabled;
imagelist = [
'luke.png',
'chubaka.png',
'boba.png',
'c3po.png' ,
'leia.png',
'obi.png',
'r2d2.png',
'storm.png',
'varder.png',
'yoda.png',
'yolo.png'
];
leftNavDisabled = false;
rightNavDisabled = false;
dragScrollDom: any;
dragScrollRef: ElementRef;
dragScroll: DragScrollDirective;
@ViewChild('nav', {read: DragScrollDirective}) ds: DragScrollDirective;
constructor(
matIconRegistry: MatIconRegistry,
sanitizer: DomSanitizer,
private element: ElementRef,
private renderer: Renderer2
) {
matIconRegistry
.addSvgIcon('github',
sanitizer.bypassSecurityTrustResourceUrl('/assets/img/github.svg'))
.registerFontClassAlias('fontawesome', 'fa');
}
ngOnInit() {
}
clickItem(item) {
console.log('itmen clicked');
}
remove() {
this.imagelist.pop();
}
toggleHideSB() {
this.hideScrollbar = !this.hideScrollbar;
}
toggleDisable() {
this.disabled = !this.disabled;
}
toggleXDisable() {
this.xDisabled = !this.xDisabled;
}
toggleYDisable() {
this.yDisabled = !this.yDisabled;
}
moveLeft() {
this.ds.moveLeft();
}
moveRight() {
this.ds.moveRight();
}
leftBoundStat(reachesLeftBound: boolean) {
this.leftNavDisabled = reachesLeftBound;
}
rightBoundStat(reachesRightBound: boolean) {
this.rightNavDisabled = reachesRightBound;
}
}
|
TimP4w/ngx-drag-scroll | index.ts | <filename>index.ts
export * from './src/ngx-drag-scroll';
|
TimP4w/ngx-drag-scroll | src/ngx-drag-scroll.spec.ts | import {
Component,
Output,
Renderer2,
ElementRef
} from '@angular/core';
import { DragScrollDirective } from './ngx-drag-scroll';
import {
By
} from '@angular/platform-browser';
import {
inject,
async,
TestBed
} from '@angular/core/testing';
@Component({
selector: 'app-test-component',
template: ''
})
class TestComponent {
}
describe('Directive: DragScrollDirective', () => {
const scrollbarWidth = '15px';
beforeEach(() => {
TestBed.configureTestingModule({
declarations: [TestComponent, DragScrollDirective]
});
});
it('should drag to scroll horizontally and vertically', async(() => {
TestBed.overrideComponent(TestComponent, {set: {
template: `<div style="width: 50px; height: 50px;" dragScroll>
<div style="width: 300px; height: 300px;"></div>
</div>`
}});
TestBed.compileComponents().then(() => {
const fixture = TestBed.createComponent(TestComponent);
fixture.detectChanges();
const compiled = fixture.debugElement.query(By.directive(DragScrollDirective));
compiled.triggerEventHandler('mousedown', new MouseEvent('mousedown'));
document.dispatchEvent(new MouseEvent('mousemove', {bubbles: true, clientX: -100}));
document.dispatchEvent(new MouseEvent('mouseup'));
expect(compiled.nativeElement.scrollLeft).toBe(100);
compiled.triggerEventHandler('mousedown', new MouseEvent('mousedown'));
document.dispatchEvent(new MouseEvent('mousemove', {bubbles: true, clientY: -123}));
document.dispatchEvent(new MouseEvent('mouseup'));
expect(compiled.nativeElement.scrollTop).toBe(123);
});
}));
it('should disable drag and scroll horizontally and vertically', async(() => {
TestBed.overrideComponent(TestComponent, {set: {
template: `<div style="width: 50px; height: 50px;" dragScroll drag-scroll-disabled="true">
<div style="width: 300px; height: 300px;"></div>
</div>`
}});
TestBed.compileComponents().then(() => {
const fixture = TestBed.createComponent(TestComponent);
fixture.detectChanges();
const compiled = fixture.debugElement.query(By.directive(DragScrollDirective));
compiled.triggerEventHandler('mousedown', new MouseEvent('mousedown'));
document.dispatchEvent(new MouseEvent('mousemove', {bubbles: true, clientX: -100}));
document.dispatchEvent(new MouseEvent('mouseup'));
expect(compiled.nativeElement.style['overflow-x']).toBe('hidden');
expect(compiled.nativeElement.scrollLeft).toBe(0);
compiled.triggerEventHandler('mousedown', new MouseEvent('mousedown'));
document.dispatchEvent(new MouseEvent('mousemove', {bubbles: true, clientY: -123}));
document.dispatchEvent(new MouseEvent('mouseup'));
expect(compiled.nativeElement.style['overflow-y']).toBe('hidden');
expect(compiled.nativeElement.scrollTop).toBe(0);
});
}));
it('should disable drag and scroll horizontally', async(() => {
TestBed.overrideComponent(TestComponent, {set: {
template: `<div style="width: 50px; height: 50px;" dragScroll drag-scroll-x-disabled="true">
<div style="width: 300px; height: 300px;"></div>
</div>`
}});
TestBed.compileComponents().then(() => {
const fixture = TestBed.createComponent(TestComponent);
fixture.detectChanges();
const compiled = fixture.debugElement.query(By.directive(DragScrollDirective));
compiled.triggerEventHandler('mousedown', new MouseEvent('mousedown'));
document.dispatchEvent(new MouseEvent('mousemove', {bubbles: true, clientX: -100}));
document.dispatchEvent(new MouseEvent('mouseup'));
expect(compiled.nativeElement.style['overflow-x']).toBe('hidden');
expect(compiled.nativeElement.scrollLeft).toBe(0);
compiled.triggerEventHandler('mousedown', new MouseEvent('mousedown'));
document.dispatchEvent(new MouseEvent('mousemove', {bubbles: true, clientY: -123}));
document.dispatchEvent(new MouseEvent('mouseup'));
expect(compiled.nativeElement.style['overflow-y']).toBe('auto');
expect(compiled.nativeElement.scrollTop).toBe(123);
});
}));
it('should disable drag and scroll horizontally', async(() => {
TestBed.overrideComponent(TestComponent, {set: {
template: `<div style="width: 50px; height: 50px;" dragScroll drag-scroll-y-disabled="true">
<div style="width: 300px; height: 300px;"></div>
</div>`
}});
TestBed.compileComponents().then(() => {
const fixture = TestBed.createComponent(TestComponent);
fixture.detectChanges();
const compiled = fixture.debugElement.query(By.directive(DragScrollDirective));
compiled.triggerEventHandler('mousedown', new MouseEvent('mousedown'));
document.dispatchEvent(new MouseEvent('mousemove', {bubbles: true, clientX: -100}));
document.dispatchEvent(new MouseEvent('mouseup'));
expect(compiled.nativeElement.style['overflow-x']).toBe('auto');
expect(compiled.nativeElement.scrollLeft).toBe(100);
compiled.triggerEventHandler('mousedown', new MouseEvent('mousedown'));
document.dispatchEvent(new MouseEvent('mousemove', {bubbles: true, clientY: -123}));
document.dispatchEvent(new MouseEvent('mouseup'));
expect(compiled.nativeElement.style['overflow-y']).toBe('hidden');
expect(compiled.nativeElement.scrollTop).toBe(0);
});
}));
it('should only hide horizontal scroll bar', async(() => {
TestBed.overrideComponent(TestComponent, {set: {
template: `<div style="width: 50px; height: 350px;" dragScroll scrollbar-hidden="true">
<div style="width: 300px; height: 300px;"></div>
</div>`
}});
TestBed.compileComponents().then(() => {
const fixture = TestBed.createComponent(TestComponent);
fixture.detectChanges();
const compiled = fixture.debugElement.query(By.directive(DragScrollDirective));
expect(compiled.nativeElement.style.width).toBe('100%');
expect(compiled.nativeElement.style.height).toBe(`calc(100% + ${scrollbarWidth})`);
});
}));
it('should only hide vertical scroll bar', async(() => {
TestBed.overrideComponent(TestComponent, {set: {
template: `<div style="width: 350px; height: 50px;" dragScroll scrollbar-hidden="true">
<div style="width: 300px; height: 300px;"></div>
</div>`
}});
TestBed.compileComponents().then(() => {
const fixture = TestBed.createComponent(TestComponent);
fixture.detectChanges();
const compiled = fixture.debugElement.query(By.directive(DragScrollDirective));
expect(compiled.nativeElement.style.width).toBe(`calc(100% + ${scrollbarWidth})`);
expect(compiled.nativeElement.style.height).toBe('100%');
});
}));
it('should hide all scroll bars', async(() => {
TestBed.overrideComponent(TestComponent, {set: {
template: `<div style="width: 50px; height: 50px;" dragScroll scrollbar-hidden="true">
<div style="width: 300px; height: 300px;"></div>
</div>`
}});
TestBed.compileComponents().then(() => {
const fixture = TestBed.createComponent(TestComponent);
fixture.detectChanges();
const compiled = fixture.debugElement.query(By.directive(DragScrollDirective));
expect(compiled.nativeElement.style.width).toBe(`calc(100% + ${scrollbarWidth})`);
expect(compiled.nativeElement.style.height).toBe(`calc(100% + ${scrollbarWidth})`);
});
}));
it('should not trying to hide the scrollbar when there are nothing to hide', async(() => {
TestBed.overrideComponent(TestComponent, {set: {
template: `<div style="width: 50px; height: 50px;" dragScroll>
<div style="width: 49px; height: 49px;"></div>
</div>`
}});
TestBed.compileComponents().then(() => {
const fixture = TestBed.createComponent(TestComponent);
fixture.detectChanges();
const compiled = fixture.debugElement.query(By.directive(DragScrollDirective));
expect(compiled.nativeElement.style.width).toBe('50px');
expect(compiled.nativeElement.style.height).toBe('50px');
});
}));
});
|
carlosrojaso/chapter | client/src/modules/dashboard/Events/components/EventCancelButton.tsx | import { Button, ButtonProps } from '@chakra-ui/react';
import { useConfirm } from 'chakra-confirm';
import React from 'react';
import { Event, useCancelEventMutation } from '../../../../generated/graphql';
import { EVENT, EVENTS } from '../graphql/queries';
interface EventCancelButtonProps extends ButtonProps {
isFullWidth?: boolean;
buttonText: string;
event: Pick<Event, 'id' | 'canceled'>;
}
const EventCancelButton: React.FC<EventCancelButtonProps> = (props) => {
const { isFullWidth, buttonText, event, ...rest } = props;
const [cancel] = useCancelEventMutation();
const confirmCancel = useConfirm({
title: 'Are you sure you want to cancel this',
body: 'Canceling this will send emails to everyone who RSVPd',
buttonColor: 'orange',
});
const data = {
variables: { id: event.id },
refetchQueries: [
{ query: EVENT, variables: { id: event.id } },
{ query: EVENTS },
],
};
const clickCancel = async () => {
const ok = await confirmCancel();
if (ok) {
await cancel(data);
}
};
return (
<Button
{...rest}
isFullWidth={isFullWidth}
colorScheme="orange"
onClick={clickCancel}
>
{buttonText}
</Button>
);
};
export default EventCancelButton;
|
carlosrojaso/chapter | server/reminders/reminders.ts | import { EventReminder, EventWithRelations, User } from '../src/graphql-types';
import { prisma } from '../src/prisma';
import MailerService from '../src/services/MailerService';
const processingLimitInMinutes = 10;
const dateFormatter = new Intl.DateTimeFormat('en-us', {
weekday: 'long',
year: 'numeric',
month: 'long',
day: 'numeric',
timeZone: 'GMT',
});
const timeFormatter = new Intl.DateTimeFormat('en-us', {
hour: 'numeric',
minute: 'numeric',
timeZone: 'GMT',
});
const getRemindersOlderThanDate = async (date: Date) =>
await prisma.event_reminders.findMany({
include: {
rsvp: true,
user: true,
event: {
include: {
chapter: true,
venue: true,
},
},
},
where: {
remind_at: {
lte: date,
},
notifying: false,
},
orderBy: {
remind_at: 'asc',
},
});
const getOldReminders = async (date: Date) =>
await prisma.event_reminders.findMany({
include: {
rsvp: true,
user: true,
event: {
include: {
chapter: true,
venue: true,
},
},
},
where: {
notifying: true,
updated_at: {
lte: date,
},
},
});
interface ReminderLock {
user_id: number;
event_id: number;
}
interface ReminderRetryLock extends ReminderLock {
updated_at: Date;
}
const lockForNotifying = async (reminder: ReminderLock) => {
const lock = await prisma.event_reminders.updateMany({
data: {
notifying: true,
},
where: {
user_id: reminder.user_id,
event_id: reminder.event_id,
notifying: false,
},
});
return { hasLock: lock.count !== 0 };
};
const lockForRetry = async (reminder: ReminderRetryLock) => {
const lock = await prisma.event_reminders.updateMany({
data: { updated_at: new Date() },
where: {
user_id: reminder.user_id,
event_id: reminder.event_id,
updated_at: reminder.updated_at,
},
});
return { hasLock: lock.count !== 0 };
};
type LockCheck = (
reminder: ReminderLock | ReminderRetryLock,
) => Promise<{ hasLock: boolean }>;
const processReminders = async (reminders: EventReminder[], lock: LockCheck) =>
await Promise.all(
reminders.map(async (reminder) => {
const { hasLock } = await lock(reminder);
if (!hasLock) {
return;
}
await sendEmailForReminder(reminder);
await deleteReminder(reminder);
}),
);
const reminderMessage = (
event: Omit<EventWithRelations, 'sponsors' | 'rsvps' | 'tags'>,
user: User,
date: string,
start_time: string,
end_time: string,
) => {
return `[${event.name}](Link to the event page, like https://{instance domain name}/chapters/${event.chapter.id}]) organized by ${event.chapter.name} is happening soon.</br>
</br>
Your RSVP Status: {rsvps.name} | [Need to change your RSVP?](link to the chapter page, like https://{instance domain name}/chapters/${event.chapter.id}/events/${event.id}, where there's an option to change the RSVP)</br>
</br>
When: ${date} from ${start_time} to ${end_time} (GMT)</br>
</br>
Where: ${event.venue?.name} | ${event.venue?.street_address} ${event.venue?.city}, ${event.venue?.region} ${event.venue?.postal_code}</br>
</br>
(post-MVP feature) Add to My Calendar: [Google](URL for Google) | [Outlook](URL for Outlook) | [Yahoo](URL for Yahoo) | [iCal](URL for iCal)</br>
</br>
This email was sent to ${user.email} by ${event.chapter.name} | ${event.chapter.city}, ${event.chapter.region} ${event.chapter.country}</br>
Copyright © {current year in YYYY format} {Organization}. All rights reserved.</br>
Unsubscribe Options
- [Attend this event, but only turn off future notifications for this event](Unsubscribe link, like https://{instance domain name}/rsvp/unsubscribe/{users.id}/{events.id}/{unsigned JWOT token} which will set the appropriate {event_users.subscribed} to false when clicked)
- Or, [stop receiving all notifications by unfollowing ${event.chapter.name}](Unsubscribe link, like https://{instance domain name}/chapter/unsubscribe/{users.id}/{chapter.id}/{unsigned JWOT token} which will set the appropriate {chapter_users.subscribed} to false when clicked)
[Privacy Policy](link to privacy page)`;
};
const getEmailData = (reminder: EventReminder) => {
const date = dateFormatter.format(reminder.event.start_at);
const start_time = timeFormatter.format(reminder.event.start_at);
const end_time = timeFormatter.format(reminder.event.ends_at);
console.log(`Event: ${reminder.event.name}`);
console.log(`${date} from ${start_time} to ${end_time} (GMT)`);
console.log(
`Remind at ${reminder.remind_at.toUTCString()} to ${reminder.user.email}`,
);
console.log();
const email = reminderMessage(
reminder.event,
reminder.user,
date,
start_time,
end_time,
);
const subject = `Upcoming Event Reminder for ${reminder.event.name}`;
return { email: email, subject: subject };
};
const sendEmailForReminder = async (reminder: EventReminder) => {
const { email, subject } = getEmailData(reminder);
await new MailerService([reminder.user.email], subject, email).sendEmail();
};
const deleteReminder = async (reminder: EventReminder) =>
await prisma.event_reminders.delete({
where: {
user_id_event_id: {
user_id: reminder.user.id,
event_id: reminder.event.id,
},
},
});
(async () => {
const date = new Date();
const reminders = await getRemindersOlderThanDate(date);
console.log(
`Reminders older than ${date.toUTCString()}: ${reminders.length}`,
);
console.log();
await processReminders(reminders, lockForNotifying);
const updateDate = new Date();
updateDate.setMinutes(updateDate.getMinutes() - processingLimitInMinutes);
const oldReminders = await getOldReminders(updateDate);
console.log(
`Old reminders updated before ${updateDate.toUTCString()}: ${
oldReminders.length
}`,
);
await processReminders(oldReminders, lockForRetry);
})();
|
carlosrojaso/chapter | client/src/modules/events/pages/eventsPage.tsx | <reponame>carlosrojaso/chapter<gh_stars>10-100
import { Heading, VStack, Stack } from '@chakra-ui/layout';
import { NextPage } from 'next';
import React from 'react';
import { EventCard } from 'components/EventCard';
import { useMinEventsQuery } from 'generated/graphql';
export const EventsPage: NextPage = () => {
const { loading, error, data } = useMinEventsQuery();
if (loading) {
return <h1>Loading...</h1>;
}
if (error || !data?.events) {
return (
<div>
<h1>error...</h1>
<h2>{error?.message}</h2>
</div>
);
}
return (
<VStack>
<Stack w={['90%', '90%', '60%']} maxW="600px" spacing={6} mt={10} mb={5}>
<Heading>Events: </Heading>
{data.events.map((event) => (
<EventCard key={event.id} event={event} />
))}
</Stack>
</VStack>
);
};
|
carlosrojaso/chapter | client/src/modules/dashboard/Sponsors/pages/NewSponsorPage.tsx | import { NextPage } from 'next';
import { useRouter } from 'next/router';
import React, { useState } from 'react';
import { Sponsors } from '../../Events/graphql/queries';
import { Layout } from '../../shared/components/Layout';
import SponsorForm, { SponsorFormData } from '../components/SponsorForm';
import { useCreateSponsorMutation } from 'generated/graphql';
const NewSponsorPage: NextPage = () => {
const [loading, setLoading] = useState(false);
const router = useRouter();
const [createSponsor] = useCreateSponsorMutation({
refetchQueries: [{ query: Sponsors }],
});
const onSubmit = async (data: SponsorFormData) => {
setLoading(true);
try {
createSponsor({
variables: {
data,
},
});
router.replace('/dashboard/sponsors');
} catch (err) {
console.error(err);
} finally {
setLoading(false);
}
};
return (
<Layout>
<SponsorForm
loading={loading}
onSubmit={onSubmit}
submitText="Add New Sponsor"
/>
</Layout>
);
};
export { NewSponsorPage };
|
carlosrojaso/chapter | server/src/graphql-types/InstanceRole.ts | import { ObjectType, Field } from 'type-graphql';
@ObjectType()
export class InstancePermission {
@Field(() => String)
name: string;
}
@ObjectType()
export class InstanceRolePermission {
@Field(() => InstancePermission)
instance_permission: InstancePermission;
}
@ObjectType()
export class InstanceRole {
@Field(() => String)
name: string;
@Field(() => [InstanceRolePermission])
instance_role_permissions: InstanceRolePermission[];
}
|
carlosrojaso/chapter | server/src/controllers/Auth/inputs.ts | <reponame>carlosrojaso/chapter
import { InputType, Field, ObjectType } from 'type-graphql';
import { User } from '../../graphql-types';
@InputType()
export class RegisterInput {
@Field(() => String)
first_name: string;
@Field(() => String)
last_name: string;
@Field(() => String)
email: string;
}
@InputType()
export class LoginInput {
@Field(() => String)
email: string;
}
@ObjectType()
export class LoginType {
@Field(() => String)
code: string;
}
@ObjectType()
export class AuthenticateType {
@Field(() => String)
token: string;
@Field(() => User)
user: User;
}
|
carlosrojaso/chapter | client/src/modules/dashboard/Sponsors/index.ts | export { SponsorsPage } from './pages/SponsorsPage';
export { NewSponsorPage } from './pages/NewSponsorPage';
export { EditSponsorPage } from './pages/EditSponsorPage';
|
carlosrojaso/chapter | server/prisma/generator/factories/user.factory.ts | import { faker } from '@faker-js/faker';
import { Prisma } from '@prisma/client';
import { prisma } from '../../../src/prisma';
const { name, internet } = faker;
const createUsers = async (
instanceRoles: Record<string, { name: string; id: number }>,
): Promise<[number, number[]]> => {
// TODO: add seeding admin
const userData: Prisma.usersCreateInput = {
email: '<EMAIL>',
first_name: name.firstName(),
last_name: name.lastName(),
instance_role: { connect: { id: instanceRoles.administrator.id } },
};
const user = await prisma.users.create({ data: userData });
const othersData: Prisma.usersCreateInput[] = Array.from(
new Array(10),
() => ({
email: internet.email(),
first_name: name.firstName(),
last_name: name.lastName(),
instance_role: { connect: { id: instanceRoles.member.id } },
}),
);
const otherIds = (
await Promise.all(
othersData.map((other) => prisma.users.create({ data: other })),
)
).map((other) => other.id);
return [user.id, otherIds];
};
export default createUsers;
|
carlosrojaso/chapter | server/src/prisma.ts | <filename>server/src/prisma.ts
import { PrismaClient } from '@prisma/client';
// importing config so the .env gets parsed
import './config';
export const prisma = new PrismaClient({ rejectOnNotFound: true });
|
carlosrojaso/chapter | server/src/graphql-types/BaseObject.ts | import { ObjectType, Field, Int } from 'type-graphql';
@ObjectType()
export class BaseObject {
// TODO: Should this be a GraphQLID? It's a number in the db.
@Field(() => Int)
id: number;
}
|
carlosrojaso/chapter | client/src/modules/events/graphql/mutations.ts | <gh_stars>0
import { gql } from '@apollo/client';
// TODO: mutations must return something, so it returns confirmed_at for now.
// Should it return something the client can use?
export const rsvpToEvent = gql`
mutation rsvpToEvent($eventId: Int!) {
rsvpEvent(eventId: $eventId) {
confirmed_at
}
}
`;
|
carlosrojaso/chapter | server/src/graphql-types/EventTag.ts | import { ObjectType, Field } from 'type-graphql';
import { Tag } from './Tag';
@ObjectType()
export class EventTag {
@Field(() => Tag)
tag: Tag;
}
|
carlosrojaso/chapter | server/src/graphql-types/UserEventRole.ts | <reponame>carlosrojaso/chapter<gh_stars>0
import { Field, Int, ObjectType } from 'type-graphql';
import { Event } from './Event';
import { User } from './User';
// TODO: Make this enum, similarly to UserChapterRole
type EventRoles = 'organizer' | 'attendee';
@ObjectType()
export class UserEventRole {
@Field(() => Int)
user_id: number;
@Field(() => Int)
event_id: number;
@Field(() => User)
user: User;
@Field(() => Event)
event: Event;
@Field(() => String)
role_name: EventRoles;
@Field(() => Boolean)
subscribed: boolean;
}
|
carlosrojaso/chapter | client/src/modules/home/graphql/queries.ts | <gh_stars>10-100
import { gql } from '@apollo/client';
export const HOME_PAGE_QUERY = gql`
query home($limit: Int, $offset: Int) {
paginatedEvents(limit: $limit, offset: $offset) {
id
name
description
invite_only
canceled
start_at
image_url
tags {
tag {
id
name
}
}
chapter {
id
name
category
}
}
chapters {
id
name
description
category
imageUrl
}
}
`;
|
carlosrojaso/chapter | client/src/pages/events/index.tsx | <gh_stars>10-100
import { EventsPage } from 'modules/events';
export default EventsPage;
|
carlosrojaso/chapter | client/src/pages/dashboard/sponsors/[id]/edit.tsx | <reponame>carlosrojaso/chapter<filename>client/src/pages/dashboard/sponsors/[id]/edit.tsx
import { EditSponsorPage } from '../../../../modules/dashboard/Sponsors/pages/EditSponsorPage';
export default EditSponsorPage;
|
carlosrojaso/chapter | client/src/modules/dashboard/Chapters/Users/pages/ChapterUsersPage.tsx | <gh_stars>0
import { VStack, Flex, Text, Heading } from '@chakra-ui/react';
import { DataTable } from 'chakra-data-table';
import { NextPage } from 'next';
import { useRouter } from 'next/router';
import React from 'react';
import { useChapterUsersQuery } from '../../../../../generated/graphql';
import { Layout } from '../../../shared/components/Layout';
import { getId } from 'helpers/getId';
export const ChapterUsersPage: NextPage = () => {
const router = useRouter();
const id = getId(router.query) || -1;
const { loading, error, data } = useChapterUsersQuery({
variables: { id },
});
return (
<Layout>
<VStack>
<Flex w="full" justify="space-between">
<Heading id="page-heading">Chapter Users</Heading>
</Flex>
{loading ? (
<Heading>Loading...</Heading>
) : error || !data?.chapter?.users ? (
<>
<Heading>Error</Heading>
<Text>
{error?.name}: {error?.message}
</Text>
</>
) : (
<DataTable
data={data.chapter.users}
tableProps={{ table: { 'aria-labelledby': 'page-heading' } }}
keys={['name', 'email'] as const}
mapper={{
name: ({ user }) => user.name,
email: ({ user }) => user.email,
}}
/>
)}
</VStack>
</Layout>
);
};
|
carlosrojaso/chapter | client/src/modules/dashboard/Sponsors/pages/EditSponsorPage.tsx | <gh_stars>0
import { NextPage } from 'next';
import { useRouter } from 'next/router';
import React, { useState } from 'react';
import { getId } from '../../../../helpers/getId';
import { Sponsors } from '../../Events/graphql/queries';
import { Layout } from '../../shared/components/Layout';
import SponsorForm, { SponsorFormData } from '../components/SponsorForm';
import { SPONSOR } from '../graphql/queries';
import { useSponsorQuery, useUpdateSponsorMutation } from 'generated/graphql';
const EditSponsorPage: NextPage = () => {
const [loading, setLoading] = useState(false);
const router = useRouter();
const id = getId(router.query) || -1;
const {
loading: sponsorLoading,
error,
data,
} = useSponsorQuery({
variables: {
sponsorId: id,
},
});
const [updateSponsor] = useUpdateSponsorMutation({
refetchQueries: [
{ query: SPONSOR, variables: { id } },
{ query: Sponsors },
],
});
const onSubmit = async (data: SponsorFormData) => {
setLoading(true);
try {
updateSponsor({
variables: {
data,
updateSponsorId: id,
},
});
router.replace('/dashboard/sponsors');
} catch (err) {
console.error(err);
} finally {
setLoading(false);
}
};
if (sponsorLoading || error || !data?.sponsor) {
return (
<Layout>
<h1>{loading ? 'Loading...' : 'Error...'}</h1>
{error && <div>{error}</div>}
</Layout>
);
}
return (
<Layout>
<SponsorForm
loading={loading}
onSubmit={onSubmit}
data={data}
submitText="Save Sponsor Changes"
/>
</Layout>
);
};
export { EditSponsorPage };
|
carlosrojaso/chapter | client/src/modules/chapters/pages/chaptersPage.tsx | import { Heading, VStack, Stack } from '@chakra-ui/layout';
import { NextPage } from 'next';
import React from 'react';
import { ChapterCard } from 'components/ChapterCard';
import { useChaptersQuery } from 'generated/graphql';
export const ChaptersPage: NextPage = () => {
const { loading, error, data } = useChaptersQuery();
if (loading) {
return <h1>Loading...</h1>;
}
if (error || !data?.chapters) {
return (
<div>
<h1>error...</h1>
<h2>{error?.message}</h2>
</div>
);
}
return (
<VStack>
<Stack w={['90%', '90%', '60%']} maxW="600px" spacing={3} mt={10} mb={5}>
<Heading>Chapters: </Heading>
{data.chapters.map((chapter) => (
<Heading size="md" key={chapter.id}>
<ChapterCard key={chapter.id} chapter={chapter} />
</Heading>
))}
</Stack>
</VStack>
);
};
|
carlosrojaso/chapter | server/src/graphql-types/UserBan.ts | <reponame>carlosrojaso/chapter
import { ObjectType, Field } from 'type-graphql';
import { Chapter } from './Chapter';
import { User } from './User';
@ObjectType()
export class UserBan {
@Field(() => User)
user: User;
@Field(() => Chapter)
chapter: Chapter;
}
|
carlosrojaso/chapter | client/src/modules/dashboard/Events/components/Actions.tsx | import { useDisclosure } from '@chakra-ui/hooks';
import { Button, HStack } from '@chakra-ui/react';
import { useConfirmDelete } from 'chakra-confirm';
import { LinkButton } from 'chakra-next-link';
import React, { useMemo } from 'react';
import { EVENT, EVENTS } from '../graphql/queries';
import EventCancelButton from './EventCancelButton';
import SendEmailModal from './SendEmailModal';
import { Event, useDeleteEventMutation } from 'generated/graphql';
interface ActionsProps {
event: Pick<Event, 'id' | 'canceled'>;
onDelete?: () => any;
hideCancel?: boolean;
}
const Actions: React.FC<ActionsProps> = ({ event, onDelete, hideCancel }) => {
const { isOpen, onOpen, onClose } = useDisclosure();
const [remove] = useDeleteEventMutation();
const data = useMemo(
() => ({
variables: { id: event.id },
refetchQueries: [
{ query: EVENT, variables: { id: event.id } },
{ query: EVENTS },
],
}),
[event],
);
const confirmDelete = useConfirmDelete();
const clickDelete = async () => {
const ok = await confirmDelete();
if (ok) {
await remove(data);
await onDelete?.();
}
};
const clickEmailAttendees = () => {
onOpen();
};
return (
<HStack spacing="1">
<Button size="sm" colorScheme="red" onClick={clickDelete}>
Delete
</Button>
<LinkButton
size="sm"
colorScheme="green"
href={`/dashboard/events/${event.id}/edit`}
>
Edit
</LinkButton>
{!hideCancel && !event.canceled && (
<EventCancelButton size="sm" event={event} buttonText="Cancel" />
)}
<Button size="sm" colorScheme="blue" onClick={clickEmailAttendees}>
Email Attendees
</Button>
<SendEmailModal onClose={onClose} isOpen={isOpen} eventId={event.id} />
</HStack>
);
};
export default Actions;
|
carlosrojaso/chapter | client/src/pages/_app.tsx | <filename>client/src/pages/_app.tsx
import {
ApolloClient,
InMemoryCache,
ApolloProvider,
createHttpLink,
from,
ServerError,
} from '@apollo/client';
import { NetworkError } from '@apollo/client/errors';
import { setContext } from '@apollo/client/link/context';
import { onError } from '@apollo/client/link/error';
import { offsetLimitPagination } from '@apollo/client/utilities';
import { ChakraProvider } from '@chakra-ui/react';
import { ConfirmContextProvider } from 'chakra-confirm';
import { AppProps } from 'next/app';
import Head from 'next/head';
import React from 'react';
import PageLayout from '../components/PageLayout';
import { AuthContextProvider } from '../modules/auth/store';
const serverUri =
process.env.NEXT_PUBLIC_APOLLO_SERVER || 'http://localhost:5000';
const httpLink = createHttpLink({ uri: `${serverUri}/graphql` });
const authLink = setContext((_, { headers }) => {
const token = localStorage.getItem('token');
return {
headers: {
...headers,
authorization: token ? `Bearer ${token}` : '',
},
};
});
const errorLink = onError(({ networkError }) => {
if (isServerError(networkError)) {
if (networkError.statusCode === 401) {
localStorage.removeItem('token');
}
// TODO: do we want to implement some kind of refresh token instead of
// forcing the user to log in again?
if (networkError.result.message === 'Token expired') {
window.location.href = '/auth/login';
} else {
window.location.reload();
}
}
});
function isServerError(err?: NetworkError): err is ServerError {
return !(err == null) && 'result' in err && 'statusCode' in err;
}
const client = new ApolloClient({
link: from([errorLink, authLink, httpLink]),
cache: new InMemoryCache({
typePolicies: {
Query: {
fields: {
paginatedEvents: offsetLimitPagination(),
},
},
},
}),
});
const CustomApp: React.FC<AppProps> = ({ pageProps, Component }) => {
return (
<>
<Head>
<title>Chapter</title>
<meta charSet="utf-8" />
<meta
name="viewport"
content="minimum-scale=1, initial-scale=1, width=device-width, shrink-to-fit=no"
/>
</Head>
<ApolloProvider client={client}>
<ChakraProvider>
<AuthContextProvider>
<ConfirmContextProvider>
<PageLayout>
<Component {...pageProps} />
</PageLayout>
</ConfirmContextProvider>
</AuthContextProvider>
</ChakraProvider>
</ApolloProvider>
</>
);
};
export default CustomApp;
|
carlosrojaso/chapter | client/src/pages/dashboard/sponsors/index.tsx | import { SponsorsPage } from '../../../modules/dashboard/Sponsors/index';
export default SponsorsPage;
|
carlosrojaso/chapter | server/prisma/generator/factories/events.factory.ts | <gh_stars>0
import { faker } from '@faker-js/faker';
import { Prisma, events_venue_type_enum } from '@prisma/client';
import { addHours, add } from 'date-fns';
import { prisma } from '../../../src/prisma';
import { random, randomEnum, randomItem, randomItems } from '../lib/random';
const { company, internet, lorem, image } = faker;
const createEvents = async (
chapterIds: number[],
venueIds: number[],
sponsorIds: number[],
count: number,
): Promise<number[]> => {
const events: number[] = [];
for (let i = 0; i < count; i++) {
const date = new Date();
date.setMilliseconds(0);
date.setSeconds(0);
date.setMinutes(0);
const start_at = add(date, {
days: random(10),
hours: random(5),
minutes: random(4) * 15,
});
const eventData: Prisma.eventsCreateInput = {
name: company.companyName(),
chapter: { connect: { id: randomItem(chapterIds) } },
description: lorem.words(),
url: internet.url(),
streaming_url: internet.url(),
venue_type: randomEnum(events_venue_type_enum),
capacity: random(1000),
venue: { connect: { id: randomItem(venueIds) } },
canceled: Math.random() > 0.5,
start_at,
ends_at: addHours(start_at, random(5)),
image_url: image.imageUrl(640, 480, 'nature', true),
};
const event = await prisma.events.create({ data: eventData });
await Promise.all(
randomItems(sponsorIds, 2).map(async (sponsor) => {
const eventSponsorData: Prisma.event_sponsorsCreateInput = {
events: { connect: { id: event.id } },
sponsor: { connect: { id: sponsor } },
};
return prisma.event_sponsors.create({ data: eventSponsorData });
}),
);
const tagNames = Array.from(new Array(1 + random(3)), () => lorem.word());
await prisma.events.update({
where: { id: event.id },
data: {
tags: {
create: [...new Set(tagNames)].map((tagName) => ({
tag: {
connectOrCreate: {
create: { name: tagName },
where: { name: tagName },
},
},
})),
},
},
});
events.push(event.id);
}
return events;
};
export default createEvents;
|
carlosrojaso/chapter | server/tests/testUtils/createSchema.ts | <gh_stars>10-100
import { buildSchema } from 'type-graphql';
import { resolvers } from '../../src/controllers';
export const createSchema = () =>
buildSchema({
resolvers,
});
|
carlosrojaso/chapter | server/src/controllers/Chapter/resolver.ts | import { Prisma } from '@prisma/client';
import { Resolver, Query, Arg, Int, Mutation, Ctx } from 'type-graphql';
import { GQLCtx } from '../../common-types/gql';
import { Chapter, ChapterWithRelations } from '../../graphql-types';
import { prisma } from '../../prisma';
import { CreateChapterInputs, UpdateChapterInputs } from './inputs';
@Resolver()
export class ChapterResolver {
@Query(() => [Chapter])
async chapters(): Promise<Chapter[]> {
return await prisma.chapters.findMany();
}
@Query(() => ChapterWithRelations, { nullable: true })
async chapter(
@Arg('id', () => Int) id: number,
): Promise<ChapterWithRelations | null> {
return await prisma.chapters.findUnique({
where: { id },
include: {
events: { include: { tags: { include: { tag: true } } } },
users: { include: { user: true } },
},
});
}
@Mutation(() => Chapter)
async createChapter(
@Arg('data') data: CreateChapterInputs,
@Ctx() ctx: GQLCtx,
): Promise<Chapter> {
if (!ctx.user) {
throw Error('User must be logged in to create chapters');
}
const chapterData: Prisma.chaptersCreateInput = {
...data,
creator_id: ctx.user.id,
};
return prisma.chapters.create({ data: chapterData });
}
@Mutation(() => Chapter)
async updateChapter(
@Arg('id', () => Int) id: number,
@Arg('data') data: UpdateChapterInputs,
): Promise<Chapter> {
const chapterData: Prisma.chaptersUpdateInput = data;
return prisma.chapters.update({ where: { id }, data: chapterData });
}
@Mutation(() => Chapter)
async deleteChapter(@Arg('id', () => Int) id: number): Promise<Chapter> {
return await prisma.chapters.delete({ where: { id } });
}
}
|
carlosrojaso/chapter | server/src/controllers/Chapter/inputs.ts | import { InputType, Field } from 'type-graphql';
import { Chapter } from '../../graphql-types';
@InputType()
export class CreateChapterInputs implements Omit<Chapter, 'id' | 'creator_id'> {
@Field(() => String)
name: string;
@Field(() => String)
description: string;
@Field(() => String)
category: string;
@Field(() => String)
city: string;
@Field(() => String)
region: string;
@Field(() => String)
country: string;
@Field(() => String)
imageUrl: string;
}
@InputType()
export class UpdateChapterInputs implements Omit<Chapter, 'id' | 'creator_id'> {
@Field(() => String, { nullable: true })
name: string;
@Field(() => String, { nullable: true })
description: string;
@Field(() => String, { nullable: true })
category: string;
@Field(() => String, { nullable: true })
city: string;
@Field(() => String, { nullable: true })
region: string;
@Field(() => String, { nullable: true })
country: string;
@Field(() => String, { nullable: true })
imageUrl: string;
}
|
carlosrojaso/chapter | client/src/pages/dashboard/sponsors/new.tsx | <filename>client/src/pages/dashboard/sponsors/new.tsx
import { NewSponsorPage } from '../../../modules/dashboard/Sponsors/pages/NewSponsorPage';
export default NewSponsorPage;
|
carlosrojaso/chapter | server/src/graphql-types/Event.ts | import { events_venue_type_enum } from '@prisma/client';
import { ObjectType, Field, Int, registerEnumType } from 'type-graphql';
import { BaseObject } from './BaseObject';
import { Chapter, EventTag, EventSponsor, RsvpWithUser, Venue } from '.';
export { events_venue_type_enum };
registerEnumType(events_venue_type_enum, {
name: 'VenueType',
description: 'All possible venue types for an event',
});
@ObjectType()
export class Event extends BaseObject {
@Field(() => String)
name: string;
@Field(() => String)
description: string;
@Field(() => String, { nullable: true })
url?: string | null;
@Field(() => String, { nullable: true })
streaming_url?: string | null;
@Field(() => events_venue_type_enum)
venue_type: events_venue_type_enum;
@Field(() => Date)
start_at: Date;
@Field(() => Date)
ends_at: Date;
@Field(() => Boolean)
canceled: boolean;
@Field(() => Int)
capacity: number;
@Field(() => Boolean)
invite_only: boolean;
@Field(() => String)
image_url: string;
@Field(() => [EventTag])
tags: EventTag[];
}
@ObjectType()
export class EventWithChapter extends Event {
@Field(() => Chapter)
chapter: Chapter;
}
@ObjectType()
export class EventWithRelations extends Event {
@Field(() => Chapter)
chapter: Chapter;
@Field(() => [EventSponsor])
sponsors: EventSponsor[];
@Field(() => Venue, { nullable: true })
venue?: Venue | null;
@Field(() => [RsvpWithUser])
rsvps: RsvpWithUser[];
}
|
carlosrojaso/chapter | server/src/graphql-types/Sponsor.ts | import { ObjectType, Field } from 'type-graphql';
import { BaseObject } from './BaseObject';
@ObjectType()
export class Sponsor extends BaseObject {
@Field(() => String)
name: string;
@Field(() => String)
website: string;
@Field(() => String)
logo_path: string;
@Field(() => String)
type: string;
}
|