3 |
4 |
5 |
6 |
19 |
20 |
123 |
--------------------------------------------------------------------------------
/.github/workflows/server-deploy.yml:
--------------------------------------------------------------------------------
1 | name: Deploy
2 |
3 | on:
4 | push:
5 | branches:
6 | - master
7 | schedule:
8 | # Run every 4 hours
9 | - cron: "0 */4 * * *"
10 |
11 | jobs:
12 | worker:
13 | runs-on: ubuntu-latest
14 | steps:
15 | - uses: actions/checkout@v4
16 | - name: Publish
17 | uses: cloudflare/wrangler-action@v3
18 | with:
19 | apiToken: ${{ secrets.CF_API_TOKEN }}
20 | workingDirectory: "worker"
21 |
22 | web:
23 | runs-on: ubuntu-latest
24 | defaults:
25 | run:
26 | working-directory: ./vue
27 | steps:
28 | - name: checkout
29 | uses: actions/checkout@v3
30 | - name: install node
31 | uses: actions/setup-node@v3
32 | with:
33 | node-version: "16"
34 | - name: build
35 | run: npm install && npm run build
36 | - name: deploy
37 | uses: w9jds/firebase-action@master
38 | with:
39 | args: deploy --only hosting
40 | env:
41 | FIREBASE_TOKEN: ${{ secrets.FIREBASE_TOKEN }}
42 | PROJECT_PATH: ./vue
43 | server:
44 | permissions:
45 | contents: "read"
46 | id-token: "write"
47 | runs-on: ubuntu-latest
48 | defaults:
49 | run:
50 | working-directory: ./express
51 | steps:
52 | - name: checkout
53 | uses: actions/checkout@v3
54 |
55 | - name: build
56 | uses: actions/setup-node@v3
57 | with:
58 | node-version: "14"
59 |
60 | - name: install node deps
61 | run: npm install --only=production
62 |
63 | - name: env file
64 | run: |
65 | touch .env
66 | echo COOKIE_SECRET=${{ secrets.COOKIE_SECRET }} >> .env
67 | echo TWITTER_CONSUMER_KEY=${{ secrets.TWITTER_CONSUMER_KEY }} >> .env
68 | echo TWITTER_CONSUMER_SECRET=${{ secrets.TWITTER_CONSUMER_SECRET }} >> .env
69 |
70 | echo AUTO_TWT_CONSUMER_KEY=${{ secrets.AUTO_TWT_CONSUMER_KEY }} >> .env
71 | echo AUTO_TWT_CONSUMER_SECRET=${{ secrets.AUTO_TWT_CONSUMER_SECRET }} >> .env
72 | echo AUTO_TWT_ACCESS_TOKEN=${{ secrets.AUTO_TWT_ACCESS_TOKEN }} >> .env
73 | echo AUTO_TWT_ACCESS_SECRET=${{ secrets.AUTO_TWT_ACCESS_SECRET }} >> .env
74 |
75 | echo GH_CLIENT_ID=${{ secrets.GH_CLIENT_ID }} >> .env
76 | echo GH_CLIENT_SECRET=${{ secrets.GH_CLIENT_SECRET }} >> .env
77 | echo GOOG_CLIENT_ID=${{ secrets.GOOG_CLIENT_ID }} >> .env
78 | echo GOOG_CLIENT_SECRET=${{ secrets.GOOG_CLIENT_SECRET }} >> .env
79 | echo YOUTUBE_API_KEY=${{ secrets.YOUTUBE_API_KEY }} >> .env
80 | cat .env
81 |
82 | - name: gcp auth
83 | uses: "google-github-actions/auth@v2"
84 | with:
85 | credentials_json: "${{ secrets.GCP_CREDENTIALS }}"
86 |
87 | - name: gcloud cli install
88 | uses: "google-github-actions/setup-gcloud@v2"
89 |
90 | - name: prepare data dir
91 | run: mkdir ./data
92 |
93 | - name: build index
94 | run: npm run reindex
95 |
96 | - name: deploy
97 | run: "gcloud functions deploy api --trigger-http --runtime nodejs18 --memory=1024MB --timeout=1m --project=dev-tube --no-gen2"
98 |
--------------------------------------------------------------------------------
/express/src/routes/user.js:
--------------------------------------------------------------------------------
1 | const router = require("express").Router();
2 |
3 | const { authenticated } = require("../libs/Middlewares");
4 | const { datastoreForever } = require("../libs/Datastore")
5 |
6 | router.get("/bootstrap", async (req, res) => {
7 |
8 | if (!req.user) {
9 | res.json({})
10 | return;
11 | }
12 |
13 | const userKey = req.user.email
14 | try {
15 | const [user] = await datastoreForever().get(datastoreForever().key(['user', userKey]));
16 | res.json(user)
17 | } catch (err) {
18 | console.log(err);
19 | res.sendStatus(500)
20 | }
21 | })
22 |
23 | router.post("/weekly-subscription", authenticated, async (req, res) => {
24 | const userKey = req.user.email
25 | try {
26 | const key = datastoreForever().key(['user', userKey]);
27 | const tx = datastoreForever().transaction();
28 |
29 | const [user] = await tx.get(key);
30 | const data = user || {
31 | later: [],
32 | favorites: [],
33 | watched: [],
34 | }
35 |
36 | data.subscribedToWeekly = true;
37 |
38 | tx.upsert({ key, data });
39 | await tx.commit();
40 |
41 | res.json(data)
42 | } catch (e) {
43 | console.error(e);
44 | res.sendStatus(500);
45 | }
46 | })
47 |
48 | router.delete("/weekly-subscription", authenticated, async (req, res) => {
49 | const userKey = req.user.email
50 | try {
51 | const key = datastoreForever().key(['user', userKey]);
52 | const tx = datastoreForever().transaction();
53 | const [user] = await tx.get(key);
54 | user.subscribedToWeekly = false
55 | tx.upsert({ key, data: user });
56 | await tx.commit();
57 | res.json(user)
58 | } catch (e) {
59 | console.error(e);
60 | res.sendStatus(500);
61 | }
62 | })
63 |
64 | router.delete("/lists/:list/:videoId", authenticated, async (req, res) => {
65 | const userKey = req.user.email
66 | const { list, videoId } = req.params
67 | if (!list || !videoId || !userKey) {
68 | res.sendStatus(500)
69 | return;
70 | }
71 |
72 | const key = datastoreForever().key(['user', userKey])
73 |
74 | try {
75 | const tx = datastoreForever().transaction();
76 | const [data] = await tx.get(key);
77 |
78 |
79 | const index = data[list].indexOf(videoId);
80 | if (index != -1) {
81 | data[list].splice(index, 1);
82 | tx.upsert({ key, data });
83 | await tx.commit();
84 | }
85 |
86 | res.json(data[list])
87 | } catch {
88 | res.sendStatus(500);
89 | }
90 |
91 | })
92 |
93 | router.post("/lists/:list/:videoId", authenticated, async (req, res) => {
94 | const { list, videoId } = req.params
95 | if (!list || !videoId) {
96 | res.sendStatus(500)
97 | return;
98 | }
99 |
100 | const userKey = req.user.email
101 |
102 | try {
103 | const key = datastoreForever().key(['user', userKey]);
104 | const tx = datastoreForever().transaction();
105 |
106 | const [user] = await tx.get(key);
107 | const data = user || {
108 | later: [],
109 | favorites: [],
110 | watched: []
111 | }
112 |
113 | if (!data[list].includes(videoId)) {
114 | data[list].push(videoId);
115 | tx.upsert({ key, data });
116 | await tx.commit();
117 | }
118 |
119 | res.json(data[list])
120 | } catch (e) {
121 | console.error(e);
122 | res.sendStatus(500);
123 | }
124 | });
125 |
126 | module.exports = router;
127 |
--------------------------------------------------------------------------------
/express/src/libs/Datastore.js:
--------------------------------------------------------------------------------
1 | const jsonDiff = require("json-diff");
2 | const memoize = require("memoizee");
3 | const { readFileSync } = require("fs");
4 |
5 | const datastoreForever = memoize(() => {
6 | const { Datastore } = require("@google-cloud/datastore");
7 | const datastore = new Datastore();
8 | return datastore;
9 | })
10 |
11 | const processVideos = (mapper = (data) => data, done = () => { }) => {
12 | let changed = 0;
13 | let processed = 0;
14 | datastoreForever()
15 | .runQueryStream(datastoreForever().createQuery("videos").filter("status", "approved"))
16 | .on("error", console.error)
17 | .on("data", (data) => {
18 | const key = data[datastoreForever().KEY];
19 | const copy = { ...data };
20 | mapper(copy);
21 | const diff = jsonDiff.diffString(data, copy);
22 | if (diff) {
23 | datastoreForever().update({ key, data: copy });
24 | changed++;
25 | console.log(diff);
26 | }
27 | processed++
28 | })
29 | .on("end", () => {
30 | console.log(`Processing has completed. ${processed} entities processed. ${changed} updated.`)
31 | done()
32 | }
33 | );
34 | };
35 |
36 | const oneVideo = async (videoID) => {
37 | const key = datastoreForever().key(["videos", videoID])
38 | const [video] = await datastoreForever().get(key);
39 | return video;
40 | }
41 |
42 | const deleteVideo = async (videoID) => {
43 | const key = datastoreForever().key(["videos", videoID])
44 | return datastoreForever().delete(key);
45 | }
46 |
47 | const updateVideo = async (videoID, mutate) => {
48 | const key = datastoreForever().key(["videos", videoID])
49 | const [video] = await datastoreForever().get(key);
50 |
51 | const newVideo = { ...video }
52 | mutate(newVideo);
53 | const diff = jsonDiff.diffString(video, newVideo);
54 | console.log(diff)
55 | return datastoreForever().update({ key, data: newVideo })
56 | }
57 |
58 |
59 |
60 | const replaceVideo = async (newVideo) => {
61 | const key = datastoreForever().key(["videos", newVideo.objectID])
62 | const [video] = await datastoreForever().get(key);
63 | const diff = jsonDiff.diffString(video, newVideo);
64 | console.log(diff)
65 | return datastoreForever().update({ key, data: newVideo })
66 | }
67 |
68 | const createVideo = async (newVideo) => {
69 | const key = datastoreForever().key(["videos", newVideo.objectID])
70 | return datastoreForever().insert({ key, data: newVideo })
71 | }
72 |
73 | const searchApprovedVideos = () => {
74 | const q = datastoreForever().createQuery("videos").filter("status", "approved");
75 | return datastoreForever().runQuery(q);
76 | }
77 |
78 | const searchAllVideos = () => {
79 | const q = datastoreForever().createQuery("videos");
80 | return datastoreForever().runQuery(q).then(([videos]) => videos);
81 | }
82 |
83 | const readApprovedVideos = () => JSON.parse(readFileSync('./data/videos.json', { encoding: "utf8" }));
84 | const searchApprovedVideosForever = memoize(readApprovedVideos)
85 |
86 | module.exports.processVideos = processVideos;
87 | module.exports.oneVideo = oneVideo;
88 | module.exports.updateVideo = updateVideo;
89 | module.exports.createVideo = createVideo;
90 | module.exports.replaceVideo = replaceVideo;
91 | module.exports.deleteVideo = deleteVideo;
92 | module.exports.searchApprovedVideos = searchApprovedVideos;
93 | module.exports.searchAllVideos = searchAllVideos;
94 | module.exports.searchApprovedVideosForever = searchApprovedVideosForever;
95 | module.exports.datastoreForever = datastoreForever;
--------------------------------------------------------------------------------
/vue/src/main.js:
--------------------------------------------------------------------------------
1 | import Vue from "vue";
2 | import Vuex from "vuex";
3 |
4 | import VueHead from "vue-head";
5 | import VueRouter from "vue-router";
6 | import Notifications from "vue-notification";
7 | import VueObserveVisibility from "vue-observe-visibility";
8 |
9 | import { library } from "@fortawesome/fontawesome-svg-core";
10 | import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
11 |
12 | import {
13 | faTwitter,
14 | faGithub,
15 | faGoogle,
16 | faLinkedin
17 | } from "@fortawesome/free-brands-svg-icons";
18 | import {
19 | faTimes,
20 | faCheck,
21 | faEnvelope,
22 | faPlus,
23 | faCircle,
24 | faHashtag,
25 | faSquareRss
26 | } from "@fortawesome/free-solid-svg-icons";
27 | import { faStar as fasStar } from "@fortawesome/free-solid-svg-icons/faStar";
28 | import { faCheckCircle as fasCheckCircle } from "@fortawesome/free-solid-svg-icons/faCheckCircle";
29 | import { faClock as fasClock } from "@fortawesome/free-solid-svg-icons/faClock";
30 | import { faHeart as fasHeart } from "@fortawesome/free-solid-svg-icons/faHeart";
31 | import {
32 | faHeart,
33 | faEye,
34 | faEyeSlash,
35 | faStar,
36 | faCheckCircle,
37 | faClock,
38 | faEdit
39 | } from "@fortawesome/free-regular-svg-icons";
40 | library.add(
41 | faTimes,
42 | faCheck,
43 | faClock,
44 | faStar,
45 | faEnvelope,
46 | faPlus,
47 | faGithub,
48 | faCircle,
49 | faGoogle,
50 | faEdit,
51 | faEyeSlash,
52 | faHashtag,
53 | faHeart,
54 | faSquareRss,
55 | faTwitter,
56 | faLinkedin,
57 | faEye,
58 | faCheckCircle,
59 | fasHeart,
60 | fasCheckCircle,
61 | fasStar,
62 | fasClock,
63 | faClock
64 | );
65 |
66 | import VideoComment from "./VideoComment.vue";
67 | Vue.component("VideoComment", VideoComment);
68 | Vue.component("font-awesome-icon", FontAwesomeIcon);
69 |
70 | import App from "./App.vue";
71 | import Watch from "./Watch.vue";
72 | import Search from "./Search.vue";
73 | import { ago, published, year, durationFull } from "./helpers/filters";
74 |
75 | import auth from "./auth";
76 | import edit from "./edit";
77 | import user from "./user";
78 |
79 | Vue.use(VueHead, {
80 | separator: "",
81 | complement: ""
82 | });
83 | Vue.use(Vuex);
84 | Vue.use(Notifications);
85 | Vue.use(VueRouter);
86 | Vue.use(VueObserveVisibility);
87 |
88 | Vue.filter("durationFull", durationFull);
89 | Vue.filter("published", published);
90 | Vue.filter("year", year);
91 | Vue.filter("ago", ago);
92 | require("./styles/main.scss");
93 |
94 | const router = new VueRouter({
95 | mode: "history",
96 | linkExactActiveClass: "is-active",
97 | routes: [
98 | { name: "video", path: "/video/:id", component: Watch, props: true },
99 | {
100 | name: "search",
101 | path: "/:query?",
102 | component: Search
103 | }
104 | ],
105 | scrollBehavior() {
106 | return { x: 0, y: 0 };
107 | }
108 | });
109 |
110 | const store = new Vuex.Store({
111 | modules: {
112 | auth,
113 | edit,
114 | user
115 | },
116 | strict: true
117 | });
118 |
119 | import Plausible from 'plausible-tracker'
120 | const { enableAutoPageviews } = Plausible({
121 | domain: 'dev.tube',
122 | apiHost: 'https://a.devternity.com'
123 | })
124 | enableAutoPageviews()
125 |
126 | new Vue({
127 | el: "#app",
128 | store,
129 | router,
130 | render: h => h(App),
131 | async created() {
132 | store.dispatch("auth/bootstrap");
133 | store.dispatch("user/bootstrap");
134 | }
135 | });
136 |
--------------------------------------------------------------------------------
/express/src/routes/search.js:
--------------------------------------------------------------------------------
1 | const asyncHandler = require('express-async-handler')
2 | const { datastoreForever, searchApprovedVideosForever, searchAllVideos } = require("../libs/Datastore");
3 | const { authenticated } = require('../libs/Middlewares');
4 | const router = require("express").Router();
5 | const _ = require("lodash");
6 |
7 | const NOTHING_FOUND = `¯\\_(ツ)_/¯ No talks matching your criteria`
8 |
9 | router.post("/", asyncHandler(async (req, res) => {
10 | const { p, s } = req.body;
11 |
12 | const search = req.user?.admin ? searchAllVideos : searchApprovedVideosForever
13 | const foundItems = await search();
14 | const { videos, more } = await paginate(foundItems, p, s);
15 |
16 | res.json({
17 | videos,
18 | more
19 | })
20 | }));
21 |
22 | router.post("/@:speaker", asyncHandler(async (req, res) => {
23 | const { speaker } = req.params;
24 | const { p, s } = req.body;
25 |
26 | const foundItems = await searchApprovedVideosForever()
27 | const someItems = foundItems.filter(it => it.speakerTwitters.includes(speaker))
28 |
29 | const { videos, more } = await paginate(someItems, p, s);
30 |
31 | const speakerIndex = videos[0]?.speakerTwitters.indexOf(speaker)
32 | const whois = videos[0]?.speakerNames[speakerIndex];
33 | res.json({
34 | videos,
35 | more,
36 | speakerIndex,
37 | title: videos.length ? `The best tech talks by ${whois}` : NOTHING_FOUND
38 | })
39 | }));
40 |
41 | router.post("/~:topic(*)", asyncHandler(async (req, res) => {
42 | const { topic } = req.params;
43 | const { p, s } = req.body;
44 |
45 | const foundItems = await searchApprovedVideosForever()
46 | const someItems = foundItems.filter(it => it.topics.includes(topic))
47 |
48 | const { videos, more } = await paginate(someItems, p, s);
49 | res.json({
50 | videos,
51 | more,
52 | title: videos.length ? `The best ${topic} talks` : NOTHING_FOUND
53 | })
54 | }));
55 |
56 | router.post("/:list(later|watched|favorites)", authenticated, asyncHandler(async (req, res) => {
57 | const list = req.params.list;
58 | const tx = datastoreForever().transaction();
59 | const [lists] = await tx.get(datastoreForever().key(['user', req.user.email]));
60 | if (!lists || !lists[list] || !lists[list].length) {
61 | res.json({})
62 | return
63 | }
64 | const videoIds = lists[list];
65 |
66 | const keys = videoIds.map(id => datastoreForever().key(["videos", id]));
67 | const [matches] = await tx.get(keys);
68 | matches.sort(match => -videoIds.indexOf(match.objectID))
69 | const videos = matches;
70 |
71 | const titles = {
72 | later: `Tech talks to watch later (${matches.length})`,
73 | watched: `Tech talks I watched (${matches.length})`,
74 | favorites: `My favorite tech talks (${matches.length})`
75 | }
76 |
77 | res.json({
78 | videos,
79 | title: titles[list]
80 | })
81 | }));
82 |
83 | async function paginate(items, p, s) {
84 | const pg = Number(p) || 1;
85 | const pgSize = 30;
86 | const pgTotal = Math.ceil(items.length / pgSize);
87 | const offset = (pg - 1) * pgSize;
88 | const more = pgTotal === pg ? "" : pg + 1
89 |
90 | let sortedItems = items
91 | if (s === 'likes') {
92 | sortedItems = _.orderBy(items, ['likes'], ['desc'])
93 | }
94 | if (s === 'recent') {
95 | sortedItems = _.orderBy(items, ['submissionDate'], ['desc'])
96 | }
97 |
98 | const videos = _.drop(sortedItems, offset).slice(0, pgSize);
99 | return {
100 | videos,
101 | more
102 | }
103 | }
104 |
105 | module.exports = router;
106 |
--------------------------------------------------------------------------------
/vue/public/logo.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
46 |
--------------------------------------------------------------------------------
/vue/public/logo_dark.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
46 |
--------------------------------------------------------------------------------
/express/src/routes/auth.js:
--------------------------------------------------------------------------------
1 | const asyncHandler = require('express-async-handler')
2 | const router = require("express").Router();
3 | const passport = require("passport");
4 | const TwitterStrategy = require('passport-twitter');
5 | const GitHubStrategy = require('passport-github2');
6 | const GoogleStrategy = require('passport-google-oauth2');
7 | const { statsForever } = require('../libs/Stats');
8 |
9 | const { returnBack } = require("../libs/Middlewares")
10 |
11 | const successRedirect = process.env.DEVTUBE_HOST || 'https://dev.tube'
12 | const successReturnToOrRedirect = successRedirect
13 | const admins = ['eduards@sizovs.net', 'eduards@devternity.com', 'eduards.sizovs@gmail.com']
14 |
15 | function toUserProfile(request, access_token, refresh_token, profile, done) {
16 | const avatar = profile.photos[0].value
17 | const email = profile.emails[0].value
18 | if (!avatar || !email) {
19 | throw "Sorry, unable to retrieve user data from OAuth"
20 | }
21 |
22 | const admin = admins.includes(email);
23 |
24 | const user = request.user || {
25 | avatar,
26 | email,
27 | admin,
28 | username: profile.username || email.split("@")[0],
29 | provider: profile.provider
30 | };
31 |
32 | user[profile.provider] = { access_token, refresh_token }
33 |
34 | return done(null, user);
35 | }
36 |
37 | passport.use(new GitHubStrategy({
38 | clientID: process.env.GH_CLIENT_ID,
39 | clientSecret: process.env.GH_CLIENT_SECRET,
40 | callbackURL: "/api/auth/github/callback",
41 | passReqToCallback: true,
42 | scope: ['user:email'],
43 | proxy: true
44 | },
45 | toUserProfile
46 | ));
47 |
48 | passport.use(new TwitterStrategy({
49 | consumerKey: process.env.TWITTER_CONSUMER_KEY,
50 | consumerSecret: process.env.TWITTER_CONSUMER_SECRET,
51 | callbackURL: '/api/auth/twitter/callback',
52 | passReqToCallback: true,
53 | proxy: true,
54 | includeEmail: true
55 | },
56 | toUserProfile));
57 |
58 | passport.use(new GoogleStrategy({
59 | clientID: process.env.GOOG_CLIENT_ID,
60 | clientSecret: process.env.GOOG_CLIENT_SECRET,
61 | callbackURL: "/api/auth/google/callback",
62 | passReqToCallback: true,
63 | proxy: true
64 | },
65 | toUserProfile));
66 |
67 |
68 | passport.serializeUser((user, cb) => {
69 | cb(null, user);
70 | });
71 |
72 | passport.deserializeUser((obj, cb) => {
73 | cb(null, obj);
74 | });
75 |
76 | router.get('/loggedIn', asyncHandler(async (req, res) => {
77 | const loggedIn = !!req.user;
78 |
79 | const username = req.user?.username;
80 | const avatar = req.user?.avatar;
81 | const admin = !!req.user?.admin;
82 | const youtubeAccess = !!req.user?.google
83 |
84 | const calculateKarma = async () => {
85 | if (loggedIn) {
86 | const stats = await statsForever();
87 | return stats.karma[username] || 0
88 | } else {
89 | return 0;
90 | }
91 | }
92 |
93 | const karma = await calculateKarma();
94 |
95 | res.json({ loggedIn, admin, avatar, username, karma, youtubeAccess })
96 | }))
97 |
98 | router.get('/logout', (req, res) => {
99 | req.logout();
100 | req.session = null;
101 | res.redirect(req.query.returnTo);
102 | });
103 |
104 | const googleScopes = ['email', 'profile', 'https://www.googleapis.com/auth/youtube.force-ssl']
105 |
106 | router.get('/github', returnBack, passport.authenticate('github'));
107 | router.get('/twitter', returnBack, passport.authenticate('twitter'));
108 | router.get('/google', returnBack, passport.authenticate('google', {
109 | scope: googleScopes, accessType: 'offline', prompt: 'consent'
110 | }));
111 |
112 | router.get('/google/callback',
113 | passport.authenticate('google', { successReturnToOrRedirect, failureRedirect: '/' }));
114 |
115 | router.get('/twitter/callback',
116 | passport.authenticate('twitter', { successReturnToOrRedirect, failureRedirect: '/' }));
117 |
118 | router.get('/github/callback',
119 | passport.authenticate('github', { successReturnToOrRedirect, failureRedirect: '/' }));
120 |
121 | module.exports = router;
122 |
--------------------------------------------------------------------------------
/express/src/libs/Youtube.js:
--------------------------------------------------------------------------------
1 | const dayjs = require("dayjs");
2 | const memoize = require("memoizee");
3 |
4 | const googleForever = memoize(() => {
5 | const { google } = require('googleapis')
6 | return google;
7 | })
8 |
9 |
10 | function mapComment(it) {
11 | const { totalReplyCount, canReply } = it.snippet;
12 | const { authorDisplayName, authorProfileImageUrl, textOriginal, publishedAt, likeCount } = it.snippet.topLevelComment.snippet
13 | const comment = {
14 | id: it.id,
15 | authorDisplayName,
16 | authorProfileImageUrl,
17 | textOriginal,
18 | totalReplyCount,
19 | likeCount,
20 | publishedAt,
21 | canReply
22 | }
23 | return comment;
24 | }
25 |
26 | function mapCommentReply(c) {
27 | const { authorDisplayName, authorProfileImageUrl, textOriginal, publishedAt, likeCount } = c.snippet;
28 | const reply = {
29 | id: c.id,
30 | authorDisplayName,
31 | authorProfileImageUrl,
32 | textOriginal,
33 | publishedAt,
34 | likeCount,
35 | }
36 | return reply;
37 | }
38 |
39 | class Youtube {
40 | constructor(auth) {
41 | this.auth = auth;
42 | this.youtube = googleForever().youtube({
43 | version: 'v3',
44 | auth
45 | })
46 | }
47 |
48 | async fetchCommentCount(videoId) {
49 | const response = await this.youtube.videos.list({
50 | id: videoId,
51 | part: "statistics"
52 | })
53 |
54 | return response?.data?.items?.[0]?.statistics?.commentCount || 0
55 | }
56 |
57 | async fetchVideo(videoId) {
58 | const response = await this.youtube.videos.list({
59 | id: videoId,
60 | part: "snippet,statistics,contentDetails,status"
61 | })
62 |
63 | const [video] = response?.data?.items || []
64 | console.log(video)
65 | if (!video) {
66 | return { error: "Video doesn't exist." };
67 | }
68 |
69 | if (video.status.privacyStatus === 'private') {
70 | return { error: "Video is private." }
71 | }
72 |
73 | if (!video.status.embeddable) {
74 | return { error: "Video is not embeddable." }
75 | }
76 |
77 | const someLikes = Math.floor(Math.random() * (50 - 10 + 1)) + 10;
78 | return {
79 | video: {
80 | objectID: videoId,
81 | title: video.snippet.title,
82 | recordingDate: dayjs(video.snippet.publishedAt).toDate(),
83 | channelId: video.snippet.channelId,
84 | likes: parseInt(video.statistics.likeCount) || someLikes,
85 | channelTitle: video.snippet.channelTitle,
86 | duration: video.contentDetails.duration,
87 | submissionDate: new Date(),
88 | }
89 | }
90 | }
91 |
92 | async fetchReplies(commentId) {
93 | const response = await this.youtube.comments.list({
94 | parentId: commentId,
95 | maxResults: 50,
96 | part: "snippet"
97 | })
98 | return response?.data?.items?.map(mapCommentReply)
99 | }
100 |
101 | async replyToComment(parentId, text) {
102 | const response = await this.youtube.comments.insert({
103 | part: "snippet",
104 | requestBody: {
105 | snippet: {
106 | parentId,
107 | textOriginal: text
108 | }
109 | }
110 | })
111 | return mapCommentReply(response.data)
112 | }
113 |
114 | async addComment(videoId, text) {
115 | const response = await this.youtube.commentThreads.insert({
116 | part: "snippet",
117 | requestBody: {
118 | snippet: {
119 | videoId,
120 | topLevelComment: {
121 | snippet: {
122 | textOriginal: text
123 | }
124 | }
125 | }
126 | }
127 | })
128 | return mapComment(response.data)
129 | }
130 |
131 | async fetchComments(videoId, pageToken = undefined) {
132 | const response = await this.youtube.commentThreads.list({
133 | pageToken,
134 | videoId,
135 | maxResults: 50,
136 | order: "relevance",
137 | part: "snippet"
138 | })
139 |
140 | const nextPageToken = response?.data?.nextPageToken;
141 | const comments = response?.data?.items?.map(mapComment);
142 |
143 | return {
144 | nextPageToken,
145 | comments
146 | }
147 | }
148 | }
149 |
150 | module.exports.Youtube = Youtube
151 |
152 |
153 |
154 |
155 |
156 |
157 |
--------------------------------------------------------------------------------
/vue/src/Watch.vue:
--------------------------------------------------------------------------------
1 |
2 | .watch
3 | section.section(v-if="error")
4 | .container
5 | article.message.is-danger
6 | .message-header
7 | p Error
8 | .message-body {{ error }}
9 | section.section
10 | .container
11 | .columns
12 | .column
13 | .videoWrapper.shadow
14 | iframe(
15 | :src="`https://www.youtube-nocookie.com/embed/${id}`",
16 | title="Embedded video",
17 | frameborder="0",
18 | allow="autoplay; encrypted-media" allowfullscreen
19 | )
20 | .columns(v-if="video")
21 | .column
22 | span.has-text-grey.title.is-size-7
23 | span.mr-4 {{ video.duration | durationFull }}
24 | span.mr-3 {{ video.recordingDate | published }}
25 | WatchingNow(:video="video" v-if="video.objectID" :minimumWatching="1")
26 | span(v-if="video.series")
27 | br
28 | router-link.mr-4(v-for="(serie, index) in video.series" :key="serie" :to="{ name: 'video', params: { id: serie } }" v-bind:class="{ 'has-text-grey': serie === id }") Part {{ index + 1 }}
29 | br
30 | span.mr-4(v-for="(speakerTwitter, speakerIndex) in video.speakerTwitters")
31 | router-link(:to="'/@' + speakerTwitter") {{ video.speakerNames[speakerIndex] }}
32 | .column
33 | .is-pulled-right.has-text-right
34 | VideoActions(:video="video" v-if="video.objectID")
35 | br
36 | TwitterThanks(:video="video" v-if="video.objectID")
37 | .clearfix
38 | section.section(v-if="video")
39 | .container
40 | VideoComments(:video="video" :key="video.objectID")
41 |
42 |
61 |
151 |
--------------------------------------------------------------------------------
/vue/src/VideoActions.vue:
--------------------------------------------------------------------------------
1 |
2 | .videoActions(v-bind:class="{ 'dark': darkMode }")
3 | component(v-bind:is="component" v-bind="{ video }" v-on:close="component = ''")
4 | .buttons.are-small
5 | // Like
6 | button.button(@click="like()" v-bind:class="{ 'is-loading': wip === 'liking'}")
7 | span.icon
8 | font-awesome-icon.has-text-danger(:icon="['far', 'heart']")
9 | span {{video.likes}}
10 |
11 | // Watch later
12 | button.button(v-if="listedIn('later')" @click="removeFrom('later')" v-bind:class="{ 'is-loading': wip === 'later'}")
13 | span.icon
14 | font-awesome-icon.has-text-info(:icon="['fas', 'clock']" title="remove from watch later")
15 | span.is-hidden-mobile later
16 | button.button(v-else @click="addTo('later')" v-bind:class="{ 'is-loading': wip === 'later' }")
17 | span.icon
18 | font-awesome-icon(:icon="['far', 'clock']" title="watch later")
19 | span.is-hidden-mobile later
20 |
21 | // Watched
22 | button.button(v-if="listedIn('watched')" @click="removeFrom('watched')" v-bind:class="{ 'is-loading': wip === 'watched' }")
23 | span.icon
24 | font-awesome-icon.has-text-primary(:icon="['fas', 'check-circle']" title="remove from watched")
25 | span.is-hidden-mobile watched
26 | button.button(v-else @click="addTo('watched')" v-bind:class="{ 'is-loading': wip === 'watched' }")
27 | span.icon
28 | font-awesome-icon(:icon="['far', 'check-circle']" title="add to watched")
29 | span.is-hidden-mobile watched
30 |
31 | // Favorites
32 | button.button(v-if="listedIn('favorites')" @click="removeFrom('favorites')" v-bind:class="{ 'is-loading': wip === 'favorites' }")
33 | span.icon
34 | font-awesome-icon.has-text-warning(:icon="['fas', 'star']" title="remove from favorites")
35 | span.is-hidden-mobile favorites
36 | button.button(v-else @click="addTo('favorites')" v-bind:class="{ 'is-loading': wip === 'favorites' }")
37 | span.icon
38 | font-awesome-icon(:icon="['far', 'star']" title="add to favorites")
39 | span.is-hidden-mobile favorites
40 |
41 | // Edit
42 | button.button(v-if="isAdmin()" @click="editVideo()")
43 | span.icon
44 | font-awesome-icon(:icon="['far', 'edit']")
45 | span edit
46 |
47 | // Delete
48 | button.button(v-if="isAdmin()" @click="deleteVideo()" v-bind:class="{ 'is-loading': wip === 'deleting' }")
49 | span.icon
50 | font-awesome-icon(:icon="['fa', 'times']")
51 | span delete
52 |
53 | // Tweet
54 | button.button(v-if="isAdmin()" @click="tweetVideo()" v-bind:class="{ 'is-loading': wip === 'tweeting' }")
55 | span.icon
56 | font-awesome-icon(:icon="['fab', 'twitter']")
57 | span tweet
58 |
59 |
70 |
146 |
--------------------------------------------------------------------------------
/vue/src/Search.vue:
--------------------------------------------------------------------------------
1 |
2 | section.section.pt-0
3 | loading(:active.sync="isLoading")
4 | aside.container.pb-6
5 | .columns.is-mobile.is-multiline.is-vcentered
6 | .column.column.is-four-fifths.is-full-tablet
7 | h1.title.is-1.is-size-3-mobile(style="letter-spacing: -2px") {{title}}
8 | .column.is-full-mobile
9 | .is-pulled-right
10 | .select.is-small(@change='sortingChanged()')
11 | select(aria-label='Sorting' v-model="sorting")
12 | option(value='recent') Newest first
13 | option(value='likes') Most liked first
14 | .is-pulled-left
15 | .is-hidden-tablet.is-size-7
16 | a.has-text-grey-dark(@click='toggleCategories()' v-if='categoriesVisible' rel="noopener noreferrer nofollow")
17 | font-awesome-icon(:icon="['far', 'eye-slash']")
18 | | Hide categories
19 | .is-hidden-tablet.is-size-7
20 | a.has-text-grey-dark(@click='toggleCategories()' v-if='!categoriesVisible' rel="noopener noreferrer nofollow")
21 | font-awesome-icon(:icon="['far', 'eye']")
22 | | Show categories
23 | main.container.mt-6
24 | .columns
25 | .column.is-4
26 | Categories.mb-6(:class="{ 'is-hidden-mobile': !forceShowCategories }"
27 | v-observe-visibility="categoryVisibilityChanged")
28 | .column.is-8
29 | VideoCard.is-12(v-for="video in videos"
30 | :speakerIndex="speakerIndex"
31 | :video="video" :key="video.objectID"
32 | )
33 | button.button.is-small(v-if="more" @click="showMore()") More
34 | button.button.submit-video.is-info(@click="submitVideo()") Submit a talk
35 | component(v-bind:is="component" v-on:close="component = ''")
36 |
37 |
75 |
172 |
--------------------------------------------------------------------------------
/vue/public/privacy.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
8 |
9 |
10 |
11 |
7 |
12 |
13 |
8 | 
10 |
11 |
10 | 14 | The Principal Dev – Masterclass for Tech Leads 15 | • July 17-18 16 |
17 | Join → 18 |
12 |
106 |
107 |
108 |
109 |
--------------------------------------------------------------------------------
/express/src/libs/Cookies.js:
--------------------------------------------------------------------------------
1 | const crypto = require("crypto");
2 | const algorithm = 'aes-256-ctr';
3 | const iv = crypto.randomBytes(16);
4 |
5 | const { COOKIE_SECRET } = process.env;
6 |
7 | const encrypt = (text) => {
8 | const cipher = crypto.createCipheriv(algorithm, COOKIE_SECRET, iv);
9 | const encrypted = Buffer.concat([cipher.update(text), cipher.final()]);
10 |
11 | return iv.toString('hex') + "----" + encrypted.toString('hex')
12 | };
13 |
14 | const decrypt = (hash) => {
15 | const [iv, content] = hash.split("----");
16 | const decipher = crypto.createDecipheriv(algorithm, COOKIE_SECRET, Buffer.from(iv, 'hex'));
17 | const decrypted = Buffer.concat([decipher.update(Buffer.from(content, 'hex')), decipher.final()]);
18 | return decrypted.toString();
19 | };
20 |
21 | var Buffer = require('safe-buffer').Buffer
22 | var debug = require('debug')('cookie-session')
23 | var Cookies = require('cookies')
24 | var onHeaders = require('on-headers')
25 |
26 | module.exports = cookieSession
27 |
28 | /**
29 | * Create a new cookie session middleware.
30 | *
31 | * @param {object} [options]
32 | * @param {boolean} [options.httpOnly=true]
33 | * @param {array} [options.keys]
34 | * @param {string} [options.name=session] Name of the cookie to use
35 | * @param {boolean} [options.overwrite=true]
36 | * @param {string} [options.secret]
37 | * @param {boolean} [options.signed=true]
38 | * @return {function} middleware
39 | * @public
40 | */
41 |
42 | function cookieSession(options) {
43 | var opts = options || {}
44 |
45 | // cookie name
46 | var name = opts.name || 'session'
47 |
48 | // secrets
49 | var keys = opts.keys
50 | if (!keys && opts.secret) keys = [opts.secret]
51 |
52 | // defaults
53 | if (opts.overwrite == null) opts.overwrite = true
54 | if (opts.httpOnly == null) opts.httpOnly = true
55 | if (opts.signed == null) opts.signed = true
56 |
57 | if (!keys && opts.signed) throw new Error('.keys required.')
58 |
59 | debug('session options %j', opts)
60 |
61 | return function _cookieSession(req, res, next) {
62 | var cookies = new Cookies(req, res, {
63 | keys: keys
64 | })
65 | var sess
66 |
67 | // for overriding
68 | req.sessionOptions = Object.create(opts)
69 |
70 | // define req.session getter / setter
71 | Object.defineProperty(req, 'session', {
72 | configurable: true,
73 | enumerable: true,
74 | get: getSession,
75 | set: setSession
76 | })
77 |
78 | function getSession() {
79 | // already retrieved
80 | if (sess) {
81 | return sess
82 | }
83 |
84 | // unset
85 | if (sess === false) {
86 | return null
87 | }
88 |
89 | // get session
90 | if ((sess = tryGetSession(cookies, name, req.sessionOptions))) {
91 | return sess
92 | }
93 |
94 | // create session
95 | debug('new session')
96 | return (sess = Session.create())
97 | }
98 |
99 | function setSession(val) {
100 | if (val == null) {
101 | // unset session
102 | sess = false
103 | return val
104 | }
105 |
106 | if (typeof val === 'object') {
107 | // create a new session
108 | sess = Session.create(val)
109 | return sess
110 | }
111 |
112 | throw new Error('req.session can only be set as null or an object.')
113 | }
114 |
115 | onHeaders(res, function setHeaders() {
116 | if (sess === undefined) {
117 | // not accessed
118 | return
119 | }
120 |
121 | try {
122 | if (sess === false) {
123 | // remove
124 | debug('remove %s', name)
125 | cookies.set(name, '', req.sessionOptions)
126 | } else if ((!sess.isNew || sess.isPopulated) && sess.isChanged) {
127 | // save populated or non-new changed session
128 | debug('save %s', name)
129 | cookies.set(name, Session.serialize(sess), req.sessionOptions)
130 | }
131 | } catch (e) {
132 | debug('error saving session %s', e.message)
133 | }
134 | })
135 |
136 | next()
137 | }
138 | };
139 |
140 | /**
141 | * Session model.
142 | *
143 | * @param {Context} ctx
144 | * @param {Object} obj
145 | * @private
146 | */
147 |
148 | function Session(ctx, obj) {
149 | Object.defineProperty(this, '_ctx', {
150 | value: ctx
151 | })
152 |
153 | if (obj) {
154 | for (var key in obj) {
155 | this[key] = obj[key]
156 | }
157 | }
158 | }
159 |
160 | /**
161 | * Create new session.
162 | * @private
163 | */
164 |
165 | Session.create = function create(obj) {
166 | var ctx = new SessionContext()
167 | return new Session(ctx, obj)
168 | }
169 |
170 | /**
171 | * Create session from serialized form.
172 | * @private
173 | */
174 |
175 | Session.deserialize = function deserialize(str) {
176 | var ctx = new SessionContext()
177 | var obj = decode(str)
178 |
179 | ctx._new = false
180 | ctx._val = str
181 |
182 | return new Session(ctx, obj)
183 | }
184 |
185 | /**
186 | * Serialize a session to a string.
187 | * @private
188 | */
189 |
190 | Session.serialize = function serialize(sess) {
191 | return encode(sess)
192 | }
193 |
194 | /**
195 | * Return if the session is changed for this request.
196 | *
197 | * @return {Boolean}
198 | * @public
199 | */
200 |
201 | Object.defineProperty(Session.prototype, 'isChanged', {
202 | get: function getIsChanged() {
203 | return this._ctx._new || this._ctx._val !== Session.serialize(this)
204 | }
205 | })
206 |
207 | /**
208 | * Return if the session is new for this request.
209 | *
210 | * @return {Boolean}
211 | * @public
212 | */
213 |
214 | Object.defineProperty(Session.prototype, 'isNew', {
215 | get: function getIsNew() {
216 | return this._ctx._new
217 | }
218 | })
219 |
220 | /**
221 | * populated flag, which is just a boolean alias of .length.
222 | *
223 | * @return {Boolean}
224 | * @public
225 | */
226 |
227 | Object.defineProperty(Session.prototype, 'isPopulated', {
228 | get: function getIsPopulated() {
229 | return Object.keys(this).length > 0
230 | }
231 | })
232 |
233 | /**
234 | * Session context to store metadata.
235 | *
236 | * @private
237 | */
238 |
239 | function SessionContext() {
240 | this._new = true
241 | this._val = undefined
242 | }
243 |
244 | /**
245 | * Decode the base64 cookie value to an object.
246 | *
247 | * @param {String} string
248 | * @return {Object}
249 | * @private
250 | */
251 |
252 | function decode(string) {
253 | return JSON.parse(decrypt(string))
254 | }
255 |
256 | /**
257 | * Encode an object into a base64-encoded JSON string.
258 | *
259 | * @param {Object} body
260 | * @return {String}
261 | * @private
262 | */
263 |
264 | function encode(body) {
265 | return encrypt(JSON.stringify(body));
266 | // return Buffer.from(str).toString('base64')
267 | }
268 |
269 | /**
270 | * Try getting a session from a cookie.
271 | * @private
272 | */
273 |
274 | function tryGetSession(cookies, name, opts) {
275 | var str = cookies.get(name, opts)
276 |
277 | if (!str) {
278 | return undefined
279 | }
280 |
281 | debug('parse %s', str)
282 |
283 | try {
284 | return Session.deserialize(str)
285 | } catch (err) {
286 | return undefined
287 | }
288 | }
289 |
--------------------------------------------------------------------------------
/vue/src/SubmitVideo.vue:
--------------------------------------------------------------------------------
1 |
2 | .modal.is-active
3 | .modal-background
4 | .modal-content
5 | .columns.is-mobile
6 | .column.is-10.is-offset-1.window
7 | h1.title.has-text-weight-bold.is-4.has-text-centered Submit a talk to DevTube
8 | p.has-text-centered
9 | font-awesome-icon(:icon="['far', 'heart']").has-text-danger
10 | span You'll get karma points if the talk gets published (and for every like the talk gets).
11 | br
12 | .beforeFetching(v-if="!video.objectID")
13 | .columns
14 | .column
15 | .field
16 | label.label Video URL
17 | .control(v-bind:class="{ 'is-loading': isLoading }")
18 | input.input(type="text", v-model="url" @input="urlChanged()" :disabled="isLoading" placeholder="https://youtube.com/watch?v=AEtCEt44vlE?x")
19 | p.help(v-if="isLoading") Fetching video from YouTube...
20 | p.help.has-text-danger(v-if="error") {{error}}
21 | .whenFetchingDone(v-else)
22 | .columns
23 | .column
24 | .field
25 | .control
26 | input.input(type="text", v-model="video.title" placeholder="Title")
27 | p.help {{video.duration | durationFull}} • {{video.recordingDate | year}} • {{video.channelTitle}}
28 | .columns
29 | .column
30 | .field.is-grouped.is-grouped-multiline
31 | .control(v-for="(speakerName, index) in video.speakerNames")
32 | .tags.has-addons
33 | span.tag.is-medium {{speakerName}}
34 | a.tag.is-delete.is-medium(@click="removeSpeaker(index)")
35 | .columns
36 | .column
37 | .field
38 | .control
39 | input.input(type="text", v-model="newSpeakerName" placeholder="Elon Musk")
40 | p.help(v-if="suggestedSpeaker")
41 | a(@click="addSpeaker(suggestedSpeaker.name, suggestedSpeaker.twitter)")
42 | font-awesome-icon(:icon="['fa', 'plus']")
43 | | {{suggestedSpeaker.name}}
44 | .columns
45 | .column
46 | .field
47 | .control.has-icons-left
48 | input.input(type="text", v-model="newSpeakerTwitter" placeholder="elonmusk")
49 | .icon.is-small.is-left
50 | font-awesome-icon(:icon="['fab', 'twitter']")
51 | button.button.is-pulled-right.is-text(@click="addSpeaker(newSpeakerName, newSpeakerTwitter)") Add speaker
52 | .columns
53 | .column
54 | .field.is-grouped.is-grouped-multiline
55 | .control(v-for="(topic, index) in video.topics" :key="topic")
56 | .tags.has-addons
57 | span.tag.is-medium {{topic}}
58 | a.tag.is-delete.is-medium(@click="removeTopic(index)")
59 | .columns
60 | .column
61 | .field
62 | .control.has-icons-left
63 | input.input(type="text" placeholder="Future" v-model="newTopic" v-on:keyup.enter="addTopic(newTopic)")
64 | .icon.is-small.is-left
65 | font-awesome-icon(:icon="['fa', 'hashtag']")
66 | p.help(v-if="suggestedTopic")
67 | a(@click="addTopic(suggestedTopic)")
68 | font-awesome-icon(:icon="['fa', 'plus']")
69 | | {{suggestedTopic}}
70 | button.button.is-pulled-right.is-text(@click="addTopic(newTopic)") Add topic
71 | .columns
72 | .column
73 | .field
74 | .control
75 | .buttons.is-pulled-right
76 | button.button.is-success(@click="submitVideo()" v-bind:class="{'is-loading': isSaving}" :disabled="isSubmitButtonDisabled") Submit
77 | button.button(@click="close()") Cancel
78 | .modal-close.is-large(aria-label="close" @click="close()")
79 |
80 |
83 |
88 |
207 |
--------------------------------------------------------------------------------
/vue/public/404.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
147 |
272 |
273 |
304 |
305 |
306 |
307 |
308 |
324 |
325 |
326 |
436 |
437 |
438 |
441 |
442 |
443 |
444 |
445 |
--------------------------------------------------------------------------------
Privacy Policy
13 |Eduards Sizovs has built DevTube as an [open 14 | source](https://github.com/watch-devtube/web) app and its code is publicly available for the inspection. This 15 | SERVICE is provided at no cost and is intended for use as is.
16 |This page is used to inform website visitors regarding our policies with the collection, use, and disclosure of 17 | Personal Information if anyone decided to use our Service.
18 |If you choose to use our Service, then you agree to the collection and use of information in relation to this 19 | policy. 20 | The Personal Information that we collect is used for providing and improving the Service. We will not use or share 21 | your information with anyone except as described in this Privacy Policy.
22 |The terms used in this Privacy Policy have the same meanings as in our Terms and Conditions, which is accessible 23 | at 24 | DevTube unless otherwise defined in this Privacy Policy.
25 |Information Collection and Use
26 |For better experience, while using our Service, we may require you to provide us with certain personally 27 | identifiable 28 | information, including but not limited to email, first name, last name, contacts. The information that we request 29 | is 30 | will be retained by us and used as described in this privacy policy.
31 |Cookies
32 |Cookies are files with a small amount of data that are commonly used as anonymous unique identifiers. These are 33 | sent 34 | to your browser from the websites that you visit and are stored on your device's internal memory. This service 35 | uses cookies to improve your UX. This includes authentication, sorting preference, night mode, and resuming video 36 | from 37 | the last played position. The app may use third party code and libraries that use “cookies” to collect information 38 | and 39 | improve their services. You have the option control cookies in your browser. If you choose to refuse our cookies, 40 | you 41 | may not be able to use some portions of this Service.
42 |Service Providers
43 |We may employ third-party companies and individuals due to the following reasons:
44 |-
45 |
- To facilitate our Service; 46 |
- To provide the Service on our behalf; 47 |
- To perform Service-related services; or 48 |
- To assist us in analyzing how our Service is used. 49 |
We want to inform users of this Service that these third parties have access to your Personal Information. The 51 | reason 52 | is to perform the tasks assigned to them on our behalf. However, they are obligated not to disclose or use the 53 | information for any other purpose.
54 |Security
55 |We value your trust in providing us your Personal Information, thus we are striving to use commercially 56 | acceptable 57 | means of protecting it. But remember that no method of transmission over the internet, or method of electronic 58 | storage 59 | is 100% secure and reliable, and we cannot guarantee its absolute security.
60 |Links to Other Sites
61 |Service may contain links to other sites. If you click on a third-party link, you will be directed to that site. 62 | Note 63 | that these external sites are not operated by us. Therefore, we strongly advise you to review the Privacy Policy 64 | of 65 | these websites. We have no control over and assume no responsibility for the content, privacy policies, or 66 | practices 67 | of any third-party sites or services.
68 |Children’s Privacy
69 |These Services do not address anyone under the age of 13. We do not knowingly collect personally identifiable 70 | information from children under 13. In the case we discover that a child under 13 has provided us with personal 71 | information, we immediately delete this from our servers. If you are a parent or guardian and you are aware that 72 | your 73 | child has provided us with personal information, please contact us so that we will be able to do necessary 74 | actions. 75 |
76 |Changes to This Privacy Policy
77 |We may update our Privacy Policy from time to time. Thus, you are advised to review this page periodically for 78 | any 79 | changes. We will notify you of any changes by posting the new Privacy Policy on this page. These changes are 80 | effective 81 | immediately after they are posted on this page.
82 |YouTube/Google Privacy Policy
83 |A user may choose to grant DevTube access to their Google user data by authenticating via Google/Youtube via the 84 | standard OAuth Consent Screen.
85 |DevTube will then retrieve the username, email, avatar, OAuth Access Token, and OAuth Refresh Token and store 86 | them 87 | securely in the corresponding user browser's Cookies, encrypted with the AES-256 algorithm. The basic user data – 88 | username, email, and avatar – are used to identify the user. The sensitive data – OAuth token – is used to let the 89 | user comment on YouTube videos directly from the DevTube. Because OAuth tokens automatically expire in 7 days, we 90 | use 91 | OAuth Refresh Token to refresh the Access Token after its expiration. DevTube never shares Google user data 92 | with 93 | a 94 | 3rd party and the use of Google user data is strictly limited to what's 95 | described in this privacy policy.
96 | 97 |DevTube contains data extracted from YouTube API. Related privacy policies:
98 |-
99 |
- https://www.youtube.com/t/terms 100 |
- https://policies.google.com/privacy 101 |
Contact Us
103 |If you have any questions or suggestions about our Privacy Policy, do not hesitate to contact us at 104 | hello+policy@dev.tube
105 |