I wonder why there are different results from errors when I use express, axios, and cors - node.js

When i'm crawling to my college site of one part, there is error.
Failed to load resource: net::ERR_CONNECTION_REFUSED (localhost:3000/:1)
createError.js:16 Uncaught (in promise) Error: Network Error
at createError (createError.js:16)
at XMLHttpRequest.handleError (xhr.js:99)
I've tried other things but I'm not sure why it is getting shows 'Load...' and in the console there is error.
The site is working but crawling is not working properly and showing 'Load...'
this is kangnam.js :
const axios = require('axios');
const cheerio = require('cheerio');
const log = console.log;
const express = require("express");
const cors = require("cors");
const PORT = 4000;
const app = express();
app.use(cors());
const getHTML = async () => {
try {
return await axios.get('https://web.kangnam.ac.kr', {
headers: {
Accept: 'text/html'
}
});
} catch (error) {
console.log(error);
}
};
app.get("/", (req, res) => {
getHTML()
.then(html => {
const $ = cheerio.load(html.data);
const $allNotices = $("ul.tab_listl div.list_txt");
let resultArr = [];
$allNotices.each(function(idx, element) {
let itemObj = {
title : $(this).children('a').attr('title'),
url : $(this).children('a').attr('href'),
};
resultArr.push(itemObj);
});
resultArr.forEach((element) => {
console.log(`현재 ${element._title}의 현황 : ${element._url}`);
});
return resultArr;
// const data = ulList.filter(n => n.title);
// return data;
}). then((data) => res.send(data));
});
app.listen(PORT, () =>
console.log(`Example app listening at http://localhost:${PORT}`)
);
this is NoticesList.js :
import React, {useEffect, useState} from 'react';
import styled from 'styled-components';
import NoticesItem from './NoticesItem';
import axios from "axios";
const NoticesListBlock = styled.div`
box-sizing: border-box;
padding-bottom: 3rem;
width: 768px;
margin: 0 auto;
margin-top: 2rem;
`;
const sampleArticle = {
title: 'title',
url: 'https://google.com',
};
const NoticesList = () => {
const [data, setData] = useState(null);
useEffect(() => {
const getData = async() => {
const datas = await axios.get("http://localhost:3000/");
setData(datas.data);
};
getData();
}, []);
useEffect(() => {
console.log(data);
}, [data]);
if(data === null){
return <div>Load....</div>;
}else{
console.log(data);
return (
<div>
{data.map((ele) => (
<>
<div>
{ele.title};
</div>
<br/>
</>
))}
</div>
);
};
};
export default NoticesList;
this is NoticesItem.js :
import React from 'react';
import styled from 'styled-components';
const NoticesItemBlock = styled.div`
display: flex;
.contents {
h6 {
margin: 15px;
a {
color: black;
}
}
}
& + & {
margin-top: 1.5rem;
}
`;
const NoticesItem = ({ article }) => {
const { title, url } = article;
return (
<NoticesItemBlock>
<div className="contents">
<h6>
<a href={url} target="_blank" rel="noopener noreferrer">
{title}
</a>
</h6>
</div>
</NoticesItemBlock>
);
};
export default NoticesItem;

try deploying an API on goormide, just change the last part of kangnam.js for:
app.listen(3000, function() {
console.log('Server listening on port 3000');
});
this will give a link like: https://server-clgoz.run-eu-central1.goorm.io/
wich you will use instead of: http://localhost:4000/
on NoticesList.js
Also in this file you can set a variable like:
const site="https://web.kangnam.ac.kr/";
and then in the map function:
<a href={site+decodeURIComponent(ele.url.slice(17))}>{ele.title}</a>
this will give the links to the site.
Good luck :) !!!

Related

Can't resolve 'react-transition-group/Transition' in 'C:\...;

I have an app which displays blogposts.
The app works perfectly without styles.
However, when I import a component from EITHER React Bootstrap OR material-ui. I get the following error message:
Can't resolve 'react-transition-group/Transition' in 'C:\Users\xxxxx\Documents\Web Development\bloglist-frontend\node_modules\react-bootstrap\esm'
How do you work around this message?
The App:
import { useState, useEffect } from "react";
import Blog from "./components/Blog";
import blogService from "./services/blogs";
import loginService from "./services/login";
import Notification from "./components/Notification";
import ErrorNotification from "./components/ErrorNotification";
import BlogForm from "./components/BlogForm";
import Togglable from "./components/Togglable";
import { useDispatch, useSelector } from 'react-redux'
import { setBlogs } from './reducers/blogReducer'
import User from './components/User'
import SingleBlog from './components/SingleBlog'
import styled from 'styled-components'
import LoginForm from './components/LoginForm'
import Blogs from './components/Blogs'
import Logout from './components/Logout'
import { Table } from 'react-bootstrap'
import {
BrowserRouter as Router,
Routes, Route, Link
} from "react-router-dom"
const Page = styled.div`
padding: 1em;
background: papayawhip;
`
const Navigation = styled.div`
background: BurlyWood;
padding: 1em;
`
const Footer = styled.div`
background: Chocolate;
padding: 1em;
margin-top: 1em;
`
const App = () => {
/* const [blogs, setBlogs] = useState([]); */
const [username, setUsername] = useState("");
const [password, setPassword] = useState("");
const [user, setUser] = useState(null);
const [errorMessage, setErrorMessage] = useState(null);
const [newAuthor, setNewAuthor] = useState("");
const [newTitle, setNewTitle] = useState("");
const [newUrl, setNewUrl] = useState("");
const [failureMessage, setFailureMessage] = useState(null);
const dispatch = useDispatch()
useEffect(() => {
blogService
.getAll().then(blogs => dispatch(setBlogs(blogs)))
}, [dispatch])
const blogs = useSelector(state => state)
/*
useEffect(() => {
blogService.getAll().then((blogs) => setBlogs(blogs));
}, []); */
useEffect(() => {
const loggedUserJSON = window.localStorage.getItem("loggedBlogappUser");
if (loggedUserJSON) {
const user = JSON.parse(loggedUserJSON);
setUser(user);
blogService.setToken(user.token);
}
}, []);
const handleAuthorChange = (event) => {
setNewAuthor(event.target.value);
};
const handleTitleChange = (event) => {
setNewTitle(event.target.value);
};
const handleUrlChange = (event) => {
setNewUrl(event.target.value);
};
const handleLogin = async (event) => {
event.preventDefault();
try {
const user = await loginService.login({
username,
password,
});
window.localStorage.setItem("loggedBlogappUser", JSON.stringify(user));
blogService.setToken(user.token);
setUser(user);
setUsername("");
setPassword("");
setErrorMessage(`${user.name} is now logged in!`);
setTimeout(() => {
setErrorMessage(null);
}, 5000);
} catch (exception) {
setFailureMessage("Wrong username or password");
setTimeout(() => {
setFailureMessage(null);
}, 5000);
setErrorMessage("Wrong credentials");
setTimeout(() => {
setErrorMessage(null);
}, 5000);
}
};
const handleLogout = () => {
window.localStorage.removeItem("loggedBlogappUser");
};
const padding = {
padding: 5
}
/* const createBlog = async () => {
try {
const blogObject = {
author: newAuthor,
title: newTitle,
url: newUrl,
likes: 0,
};
await blogService.create(blogObject);
setBlogs(blogs.concat(blogObject));
setNewTitle("");
setNewAuthor("");
setNewUrl("");
setErrorMessage(`${blogObject.title} has been added!`);
setTimeout(() => {
setErrorMessage(null);
}, 5000);
} catch (exception) {
setErrorMessage(`blog couldn't be added`);
}
};
*/
/* const handleLike = (id) => {
const blog = blogs.find((b) => b.id === id);
const changedBlog = { ...blog, likes: blog.likes + 1 };
blogService
.update(id, changedBlog)
.then((returnedBlog) => {
setBlogs(blogs.map((blog) => (blog.id !== id ? blog : returnedBlog)));
})
.catch((error) => {
alert(`the blog '${blog.content} was already deleted from the server`);
setBlogs(blogs.filter((b) => b.id !== id));
});
}; */
/* const handleDelete = (id) => {
const blog = blogs.find((b) => b.id === id);
if (window.confirm(`are you sure you want to remove ${blog.title}`)) {
blogService
.remove(id)
.then(setBlogs(blogs.filter((b) => b.id !== id)))
.catch((error) => {
alert(`${error}`);
});
} else {
alert("deletion cancelled");
}
};
*/
/* const arrayforSort = [...blogs] */
if (!blogs) {
return null
}
if (blogs.length > 1)
{
return (
<Router>
<Page>
<Navigation>
<div>
<Link style={padding} to="/">home</Link>
<Link style={padding} to="/blogform">blogform</Link>
<Link style={padding} to="/users">Users</Link>
<Link style={padding} to="/login">Login</Link>
</div>
</Navigation>
<Routes>
<Route path="/blogform" element={<BlogForm newAuthor={newAuthor}
newTitle={newTitle}
newUrl={newUrl}
handleAuthorChange={handleAuthorChange}
handleUrlChange={handleUrlChange}
handleTitleChange={handleTitleChange}
setErrorMessage={setErrorMessage}
blogs={blogs}/>} />
<Route path="/login" element={user === null ? (
<LoginForm handleLogin={handleLogin} setUsername={setUsername} setPassword={setPassword} username={username} password={password} />
) : (
<div>
<p>{user.name} logged-in</p>
<Logout handleLogout={handleLogout} />
</div>
)} />
<Route path="/" element={<Blogs blogs={blogs} />} />
<Route path="/users" element={<User/>} />
</Routes>
<div>
<Notification message={errorMessage} />
<ErrorNotification message={failureMessage} />
<Togglable buttonLabel="new blog">
<BlogForm
newAuthor={newAuthor}
newTitle={newTitle}
newUrl={newUrl}
handleAuthorChange={handleAuthorChange}
handleUrlChange={handleUrlChange}
handleTitleChange={handleTitleChange}
setErrorMessage={setErrorMessage}
blogs={blogs}
/>
</Togglable>
<div>
</div>
</div>
</Page>
</Router>
);
} else {
return (
<SingleBlog blogs={blogs} setBlogs={setBlogs}/>
)
}
};
export default App;

Uncaught Error: The error you provided does not contain a stack trace. | React JS | NodeJS

I am trying to make a group video call app with the help of a youtube tutorial. I am using react and socket io,
But somehow its giving me the above error. Can't understand what exactly I am doing wrong.
Kindly correct me.
Attaching the code for reference:
Create room page- The homepage
import React from "react";
import { v1 as uuid } from "uuid";
import { useNavigate } from "react-router-dom";
const CreateRoom = (props) => {
const navigate = useNavigate();
function create() {
const id = uuid();
//props.history.push(`/room/${id}`);
navigate(`/room/${id}`);
}
return (
<button onClick={create}>Create room</button>
);
};
export default CreateRoom;
Room.js - This is the landing page once call gets started.
import React, { useEffect, useRef, useState } from "react";
import io from "socket.io-client";
import Peer from "simple-peer";
import styled from "styled-components";
import { useParams } from "react-router-dom";
const Container = styled.div`
padding: 20px;
display: flex;
height: 100vh;
width: 90%;
margin: auto;
flex-wrap: wrap;
`;
const StyledVideo = styled.video`
height: 40%;
width: 50%;
`;
const Video = (props) => {
const ref = useRef();
useEffect(() => {
props.peer.on("stream", (stream) => {
ref.current.srcObject = stream;
});
});
return <StyledVideo playsInline autoPlay ref={ref} />;
};
const videoConstraints = {
height: window.innerHeight / 2,
width: window.innerWidth / 2,
};
const Room = (props) => {
const [peers, setPeers] = useState([]);
const socketRef = useRef();
const userVideo = useRef();
const peersRef = useRef([]);
let {roomID} = useParams();
console.log(roomID);
useEffect(() => {
socketRef.current = io.connect("http://localhost:8000");
navigator.mediaDevices
.getUserMedia({ video: videoConstraints, audio: true })
.then((stream) => {
userVideo.current.srcObject = stream;
socketRef.current.emit("join room", roomID);
socketRef.current.on("all users", (users) => {
const peers = [];
users.forEach((userID) => {
const peer = createPeer(userID, socketRef.current.id, stream);
peersRef.current.push({
peerID: userID,
peer,
});
peers.push(peer);
});
setPeers(peers);
});
socketRef.current.on("user joined", (payload) => {
const peer = addPeer(payload.signal, payload.callerID, stream);
peersRef.current.push({
peerID: payload.callerID,
peer,
});
setPeers((users) => [...users, peer]);
});
socketRef.current.on("receiving returned signal", (payload) => {
const item = peersRef.current.find((p) => p.peerID === payload.id);
item.peer.signal(payload.signal);
});
});
});
function createPeer(userToSignal, callerID, stream) {
const peer = new Peer({
initiator: true,
trickle: false,
stream,
});
peer.on("signal", (signal) => {
socketRef.current.emit("sending signal", {
userToSignal,
callerID,
signal,
});
});
return peer;
}
function addPeer(incomingSignal, callerID, stream) {
const peer = new Peer({
initiator: false,
trickle: false,
stream,
});
peer.on("signal", (signal) => {
socketRef.current.emit("returning signal", { signal, callerID });
});
peer.signal(incomingSignal);
return peer;
}
return (
<Container>
<StyledVideo muted ref={userVideo} autoPlay playsInline />
{peers.map((peer, index) => {
return <Video key={index} peer={peer} />;
})}
</Container>
);
};
export default Room;
Now for server end, this is my server code:
require('dotenv').config();
const express = require("express");
const http = require("http");
const app = express();
const cors = require("cors");
const server = http.createServer(app);
const socket = require("socket.io");
const io = socket(server);
const users = {};
const socketToRoom = {};
app.use(cors);
io.on('connection', socket => {
socket.on("join room", roomID => {
if (users[roomID]) {
const length = users[roomID].length;
if (length === 4) {
socket.emit("room full");
return;
}
users[roomID].push(socket.id);
} else {
users[roomID] = [socket.id];
}
socketToRoom[socket.id] = roomID;
const usersInThisRoom = users[roomID].filter(id => id !== socket.id);
socket.emit("all users", usersInThisRoom);
});
socket.on("sending signal", payload => {
io.to(payload.userToSignal).emit('user joined', { signal: payload.signal, callerID: payload.callerID });
});
socket.on("returning signal", payload => {
io.to(payload.callerID).emit('receiving returned signal', { signal: payload.signal, id: socket.id });
});
socket.on('disconnect', () => {
const roomID = socketToRoom[socket.id];
let room = users[roomID];
if (room) {
room = room.filter(id => id !== socket.id);
users[roomID] = room;
}
});
});
server.listen(process.env.PORT || 8000, () => console.log('server is running on port 8000'));
This is the link for youtube tutorial:
https://www.youtube.com/watch?v=R1sfHPwEH7A&t=154s

How to receive Cloudinary image URL immediately upon upload (React JS and Node Js)?

I can successfully upload images to Cloudinary. But my question is how can I get the Cloudinary url of the successfully uploaded image sent back to me immediately upon upload?
I know it's sent back as part of const uploadedResponse = await cloudinary.uploader.upload(fileStr, {upload_preset: 'dev_setups'}), but this is on the backend (see code #2 below), I would like to receive the URL on the frontend (see code #1 below) so I can set it to React state. What is the best approach to accomplishing this?
Please let me know if you need more details.
Code #1: Below is my code to upload a picture to Cloudinary (Cloudinary specific code is commented below for reference as /* Cloudinary upload */)
import React, { useState } from 'react'
import { Card, Button, CardContent } from '#material-ui/core';
import { post, makePostAction } from '../actions';
import { useSelector, useDispatch } from 'react-redux';
export default function MakePost() {
const [title, setTitle] = useState("")
const dispatch = useDispatch();
const usernameHandle = useSelector(state => state.username)
const [fileInputState, setFileInputState] = useState('') /* new */
const [previewSource, setPreviewSource] = useState('') /* new */
const [selectedFile, setSelectedFile] = useState('') /* new */
const onInputChange = (event) => {
setTitle(event.target.value);
}
const handleSubmit = (evt) => {
evt.preventDefault();
if (!title) return
dispatch(makePostAction({
title,
comment: false,
comments_text: "",
handle: usernameHandle,
post_date: new Date().getTime()
}))
setTitle("")
}
/* Cloudinary upload */
const handleFileInputChange = (e) => {
const file = e.target.files[0]
previewFile(file)
}
const previewFile = (file) => {
const reader = new FileReader();
reader.readAsDataURL(file);
reader.onloadend = () => {
setPreviewSource(reader.result)
}
}
const handleSubmitFile = (e) => {
e.preventDefault();
if(!previewSource) return;
uploadImage(previewSource)
}
const uploadImage = async (base64EncodedImage) => {
console.log(base64EncodedImage)
try {
await fetch('/api/upload', {
method: 'POST',
body: JSON.stringify({data: base64EncodedImage}),
headers: {'Content-type': 'application/json'}
})
} catch (error) {
console.error(error)
}
}
/* Cloudinary upload */
return (
<div>
<Card>
<CardContent>
<form onSubmit={handleSubmit}>
<input type="text" value={title} onChange={onInputChange} />
</form>
{/* new */}
<form onSubmit={handleSubmitFile} className="form">
<input type="file" name="image" onChange={handleFileInputChange} value={fileInputState} className="form-input" />
<button className="btn" type="submit">Submit</button>
</form>
{/* new */}
{previewSource && (
<img
src={previewSource}
alt="chosen"
style={{height: '300px'}}
/>
)}
</CardContent>
</Card>
</div>
)
}
Code #2: Here is my server.js
const express = require('express');
const app = express();
const {cloudinary} = require('./utils/cloudinary');
app.use(express.json({limit: '50mb'}));
app.use(express.urlencoded({limit: '50mb', extended: true}))
app.get('/api/images', async (req, res) => {
const {resources} = await cloudinary.search.expression('folder:dev_setups')
.sort_by('public_id', 'desc')
.max_results(1)
.execute()
const publicIds = resources.map(file => file.secure_url)
res.send(publicIds)
})
app.post('/api/upload', async (req, res) => {
try {
const fileStr = req.body.data;
const uploadedResponse = await cloudinary.uploader.upload(fileStr, {upload_preset: 'dev_setups'})
res.json({msg: "Success"})
} catch (error){
console.error(error)
res.status(500).json({err: 'Something went wrong'})
}
})
const port = process.env.PORT || 3001
app.listen(port, () => {
console.log(`listening on port ${port}`)
});
The Cloudinary upload response object includes a secure_url attribute which you can send back to the front end. Looking at code #2, it seems that you're currently sending a "Success" msg (res.json({msg: "Success"})). Sounds like you want to change that line to -
res.json({url: uploadedResponse.secure_url})
In your front end (code #1), I'd consider switching from async/await to .then mechanism, as you don't want to the entire app to wait for the response -
const uploadImage = (base64EncodedImage) => {
console.log(base64EncodedImage);
fetch('/api/upload', {
method: 'POST',
body: JSON.stringify({data: base64EncodedImage}),
headers: {'Content-type': 'application/json'}
})
.then(doWhateverYouWant)
.catch((error) => console.error(error))
}
const doWhateverYouWant = async (res) => {
// you can use res.url
}

POST http://localhost:3000/socket.io/?EIO=3&transport=polling&t=NGO9TCV NOT FOUND

I am trying to make a React web chat platform using webRTC, socket.io-client, and simple-peer. I followed a tutorial and used their code but I keep getting this error.
The error happens every second or so and I'm not sure why.
Here is my code for the component (Room.js) that I am importing in my App.js:
import React, { useEffect, useState, useRef } from 'react';
import '../App.css';
import io from "socket.io-client";
import Peer from "simple-peer";
import styled from "styled-components";
const Container = styled.div`
height: 100vh;
width: 100%;
display: flex;
flex-direction: column;
`;
const Row = styled.div`
display: flex;
width: 100%;
`;
const Video = styled.video`
border: 1px solid blue;
width: 50%;
height: 50%;
`;
function Room() {
const [yourID, setYourID] = useState("");
const [users, setUsers] = useState({});
const [stream, setStream] = useState();
const [receivingCall, setReceivingCall] = useState(false);
const [caller, setCaller] = useState("");
const [callerSignal, setCallerSignal] = useState();
const [callAccepted, setCallAccepted] = useState(false);
const userVideo = useRef();
const partnerVideo = useRef();
const socket = useRef();
useEffect(() => {
socket.current = io.connect("/");
navigator.mediaDevices.getUserMedia({ video: true, audio: true }).then(stream => {
setStream(stream);
if (userVideo.current) {
userVideo.current.srcObject = stream;
}
})
socket.current.on("yourID", (id) => {
setYourID(id);
})
socket.current.on("allUsers", (users) => {
setUsers(users);
})
socket.current.on("hey", (data) => {
setReceivingCall(true);
setCaller(data.from);
setCallerSignal(data.signal);
})
}, []);
function callPeer(id) {
const peer = new Peer({
initiator: true,
trickle: false,
config: {
iceServers: [
{
urls: "stun:numb.viagenie.ca",
username: "sultan1640#gmail.com",
credential: "98376683"
},
{
urls: "turn:numb.viagenie.ca",
username: "sultan1640#gmail.com",
credential: "98376683"
}
]
},
stream: stream,
});
peer.on("signal", data => {
socket.current.emit("callUser", { userToCall: id, signalData: data, from: yourID })
})
peer.on("stream", stream => {
if (partnerVideo.current) {
partnerVideo.current.srcObject = stream;
}
});
socket.current.on("callAccepted", signal => {
setCallAccepted(true);
peer.signal(signal);
})
}
function acceptCall() {
setCallAccepted(true);
const peer = new Peer({
initiator: false,
trickle: false,
stream: stream,
});
peer.on("signal", data => {
socket.current.emit("acceptCall", { signal: data, to: caller })
})
peer.on("stream", stream => {
partnerVideo.current.srcObject = stream;
});
peer.signal(callerSignal);
}
let UserVideo;
if (stream) {
UserVideo = (
<Video playsInline muted ref={userVideo} autoPlay />
);
}
let PartnerVideo;
if (callAccepted) {
PartnerVideo = (
<Video playsInline ref={partnerVideo} autoPlay />
);
}
let incomingCall;
if (receivingCall) {
incomingCall = (
<div>
<h1>{caller} is calling you</h1>
<button onClick={acceptCall}>Accept</button>
</div>
)
}
return (
<Container>
<Row>
{UserVideo}
{PartnerVideo}
</Row>
<Row>
{Object.keys(users).map(key => {
if (key === yourID) {
return null;
}
return (
<button onClick={() => callPeer(key)}>Call {key}</button>
);
})}
</Row>
<Row>
{incomingCall}
</Row>
</Container>
);
}
export default Room;
Here is my App.js file:
import React from 'react';
import { BrowserRouter as Router, Route, Switch } from 'react-router-dom'
import './App.css';
import { ApolloProvider } from '#apollo/react-hooks';
import ApolloClient from 'apollo-boost';
import coverImg from './assets/videochat.jpg';
//components
import Room from './pages/Room';
import Cover from './components/Cover'
const client = new ApolloClient({
request: operation => {
const token = localStorage.getItem('User_token');
operation.setContext({
headers: {
authorization: token ? `Bearer ${token}` : ''
}
});
},
uri: '/graphql'
});
function App() {
return (
<ApolloProvider client={client}>
<Router>
<>
<Navbar />
<Switch>
<Route exact path="/" component={Cover}/>
<Route path='/create-room' component={Room} />
</Switch>
</>
</Router>
</ApolloProvider>
);
}
export default App;
And then here is my server.js file:
// const express = require('express')
// const app = express()
// const server = require('http').Server(app)
// const io = require('socket.io')(server)
// const { v4: uuidV4 } = require('uuid')
// app.set('view engine', 'ejs')
// app.use(express.static('public'))
// app.get('/create-room', (req, res) => {
// console.log("does this work")
// res.redirect(`/${uuidV4()}`)
// })
// app.get('/:room', (req, res) => {
// res.render('../client/src/pages/room', { roomId: req.params.room })
// })
// io.on('connection', socket => {
// socket.on('join-room', (roomId, userId) => {
// if (!person[socket.id]) {
// person[socket.id] = socket.id;
// }
// socket.emit("yourID", socket.id);
// io.sockets.emit("allUsers", person);
// socket.on("disconnect", () => {
// delete person[socket.id];
// });
// socket.on("callUser", (data) => {
// io.to(data.userToCall).emit("hey", {
// signal: data.signalData,
// from: data.from,
// });
// });
// socket.on("acceptCall", (data) => {
// io.to(data.to).emit("callAccepted", data.signal);
// });
// socket.join(roomId)
// socket.to(roomId).broadcast.emit('user-connected', userId)
// socket.on('disconnect', () => {
// socket.to(roomId).broadcast.emit('user-disconnected', userId)
// })
// })
// })
// server.listen(3000)
const express = require("express");
const http = require("http");
const app = express();
const server = http.createServer(app);
const socket = require("socket.io");
const io = socket(server);
const users = {};
io.on('connection', socket => {
if (!users[socket.id]) {
users[socket.id] = socket.id;
}
socket.emit("yourID", socket.id);
io.sockets.emit("allUsers", users);
socket.on('disconnect', () => {
delete users[socket.id];
})
socket.on("callUser", (data) => {
io.to(data.userToCall).emit('hey', {signal: data.signalData, from: data.from});
})
socket.on("acceptCall", (data) => {
io.to(data.to).emit('callAccepted', data.signal);
})
});
// For some reason the console.log is not printed either
server.listen(3000, () => console.log('server is running on port 3000'));
This is my project file structure:
project name
.env
package.json
package-lock.json
.gitignore
server
server.js
client
public
react-images
src
pages
Room.js
App.js
index.js
App.css
App.test.js
serviceWorker.js
setupTests.js
.gitIgnore
package.json
package-lock.js
README.md
I was able to figure out my error and thought to post it here for any future people.
In my server.js file I needed it to run on a different port so that my actual client side code use the server on a different port. To do this you just have to change this:
server.listen(3000, () => console.log('server is running on port 3000'));
to this:
server.listen(8000, () => console.log('server is running on port 8000'));
Changing that line means that your server will run on http://localhost:8000. Another one of my errors was that my client side code was not linked to the server, which means that all of the code I wrote in server.js was irrelevant to the client side code.
To change this you have to add a line to the package.json file in the client folder. Instead of having this:
{
"name": "client",
"version": "0.1.0",
"private": true,
"dependencies": {
"#apollo/react-hooks": "^4.0.0",
change it to this:
{
"name": "client",
"version": "0.1.0",
"private": true,
"proxy": "http://localhost:8000",
"dependencies": {
"#apollo/react-hooks": "^4.0.0",
Now your code should work! Good Luck!!!

Login Form Not POSTing Correctly

I'm developing a login form with react-native. My back-end definitely works, but I have included it below for reference (I've tested this by using a curl command). Anyway, I'm trying to figure out why this react-native login form doesn't POST on form submission. Whenever I attempt to debug by simply adding an alert("test") it seems to call _handleSubmit() whenever there is a detected change in either of the FormInputs. Below is the react-native code:
import React from 'react';
import { FormInput } from 'react-native-elements';
import {Animated, View, TouchableOpacity} from 'react-native';
import cssta from "cssta/native";
import Config from 'react-native-config';
const LoginButtonContainer = cssta(Animated.View)`
--primary: white;
--foreground: var(--primary);
--background: #1b2535;
padding: 10px;
background-color: var(--background);
`;
const LoginButtonText = cssta(Animated.Text)`
color: var(--foreground);
text-align: center;
`;
const RegisterButtonContainer = cssta(Animated.View)`
--primary: #1b2535;
--foreground: var(--primary);
--background: white;
padding: 10px;
border: 1px solid var(--primary);
background-color: var(--background);
`;
const RegisterButtonText = cssta(Animated.Text)`
color: var(--foreground);
text-align: center;
`;
export default class Login extends React.Component {
constructor() {
super();
this.state = {
username: '',
password: ''
};
}
_handleSubmit() {
let username = this.state.username;
let password = this.state.password;
fetch('http://localhost:4200/login', {
method: 'POST',
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json'
},
body: JSON.stringify({username: username, password: password})
}).then((response) => JSON.stringify(response.json()))
.then((responseData) => { console.log("response: " + responseData); })
.catch((err) => { console.log(err); });
}
_onRegisterClick() {
}
render() {
return(
<View style={{justifyContent: 'space-between'}}>
<FormInput
placeholder='Username'
onChangeText={(username) => this.setState({username})}
value={this.state.username}
/>
<FormInput
placeholder='Password'
onChangeText={(password) => this.setState({password})}
value={this.state.password}
/>
<TouchableOpacity onPress={this._handleSubmit()}>
<LoginButtonContainer>
<LoginButtonText>Login</LoginButtonText>
</LoginButtonContainer>
</TouchableOpacity>
<TouchableOpacity onPress={this._onRegisterClick()}>
<RegisterButtonContainer>
<RegisterButtonText>Register</RegisterButtonText>
</RegisterButtonContainer>
</TouchableOpacity>
</View>
)
}
};
The next bit of code is a snippet of my back-end code
import models from './models';
import mongoose from 'mongoose';
const express = require('express');
import bodyParser from 'body-parser';
const app = express();
app.use('/', express.Router());
app.use(bodyParser.urlencoded({
extended: true
}));
app.use(bodyParser.json());
app.set('view engine', 'ejs');
const PORT = 4200;
app.post('/login', (req, res) => {
console.log(req.body.username);
});
app.listen(PORT, () => {
console.log(`Server is running at PORT ${PORT}`);
});
On Press Function accepts a function as an arguments. But in your code rahter then passing a function you are invoking the funtion.
<TouchableOpacity onPress={this._handleSubmit()}>
Change To
<TouchableOpacity onPress={()=> this._handleSubmit()}>
Try This code
let _username = this.state.username;
let _password = this.state.password;
let params = {
username: _username,
password: _password
};
var formBody = [];
for (var property in params) {
var encodedKey = encodeURIComponent(property);
var encodedValue = encodeURIComponent(params[property]);
formBody.push(encodedKey + "=" + encodedValue);
}
formBody = formBody.join("&");
let fetchData = {
method: "POST",
headers: {
"Content-Type": "application/x-www-form-urlencoded;charset=UTF-8"
},
body: formBody
};
fetch("http://localhost:4200/login", fetchData)
.then(response => JSON.stringify(response.json()))
.then(responseData => {
console.log("response: " + responseData);
})
.catch(err => {
console.log(err);
});

Resources