3 |
8 |
14 |
--------------------------------------------------------------------------------
/server/server.js:
--------------------------------------------------------------------------------
1 | var express = require('express');
2 | var mongoose = require('mongoose');
3 |
4 | var app = express();
5 |
6 | // ------ Connection to mongoose database -----
7 | var uristring =
8 | process.env.MONGOLAB_URI ||
9 | process.env.MONGOHQ_URL ||
10 | 'mongodb://localhost/hfPersonal';
11 |
12 | mongoose.connect(uristring, {}, function (err, res) {
13 | if (err) {
14 | console.log ('ERROR connecting to: ' + uristring + '. ' + err);
15 | } else {
16 | console.log ('Succeeded connected to: ' + uristring);
17 | }
18 | });
19 |
20 | require('./config/middleware.js')(app, express);
21 |
22 | // app.listen(3000, function(){
23 | // console.log("Listening on 3000");
24 | // });
25 |
26 | module.exports = app;
--------------------------------------------------------------------------------
/public/app/tabs/tabs.js:
--------------------------------------------------------------------------------
1 | angular.module('hack.tabs', [])
2 |
3 | .controller('TabsController', function ($scope, $location, $window, Links, Followers) {
4 | // If a user refreshes when the location is '/personal',
5 | // it will stay on '/personal'.
6 | var hash = $window.location.hash.split('/')[1];
7 | hash = !hash ? 'all' : hash;
8 | $scope.currentTab = hash;
9 |
10 | // What is angle? Don't worry. This just makes the
11 | // refresh button do a cool spin animation. We splurged.
12 | $scope.angle = 360;
13 |
14 | $scope.changeTab = function(newTab){
15 | $scope.currentTab = newTab;
16 | $location.path(newTab);
17 | };
18 |
19 | $scope.refresh = function(){
20 | Links.getTopStories();
21 | Links.getPersonalStories(Followers.following);
22 | Links.getBookmarks();
23 | $scope.angle += 360;
24 | };
25 | });
26 |
--------------------------------------------------------------------------------
/server/cache/cacheController.js:
--------------------------------------------------------------------------------
1 | var Cache = require('./cacheModel.js');
2 |
3 | module.exports = {
4 | topStories: function(request, response) {
5 | Cache.getTopStories(function(err,results){
6 | if(!err){
7 | response.status(200).json(results);
8 | }else{
9 | response.status(500).send(err);
10 | }
11 | });
12 | },
13 |
14 | topStoriesWithKeyword: function(request, response){
15 | console.log("THADDEUS IS A NAVY SEAL " + request.query.keyword)
16 | Cache.getTopStoriesWithKeyword(request.query.keyword, function(err,results){
17 | if(!err){
18 | response.status(200).json(results);
19 | }else{
20 | response.status(500).send(err);
21 | }
22 | });
23 | }
24 | };
25 |
26 | // Initialize and refresh the top story data every two minutes
27 | Cache.updateTopStories();
28 | setInterval(Cache.updateTopStories, 120000);
--------------------------------------------------------------------------------
/public/app/services/auth.js:
--------------------------------------------------------------------------------
1 | angular.module('hack.authService', [])
2 |
3 | .factory('Auth', function ($http, $location, $window) {
4 | var signin = function (user) {
5 | return $http({
6 | method: 'POST',
7 | url: '/api/users/signin',
8 | data: user
9 | })
10 | .then(function (resp) {
11 | return resp.data;
12 | });
13 | };
14 |
15 | var signup = function (user) {
16 | return $http({
17 | method: 'POST',
18 | url: '/api/users/signup',
19 | data: user
20 | })
21 | .then(function (resp) {
22 | return resp.data;
23 | });
24 | };
25 |
26 | var isAuth = function () {
27 | return !!$window.localStorage.getItem('com.hack');
28 | };
29 |
30 | var signout = function () {
31 | $window.localStorage.removeItem('com.hack');
32 | };
33 |
34 |
35 | return {
36 | signin: signin,
37 | signup: signup,
38 | isAuth: isAuth,
39 | signout: signout
40 | };
41 | });
--------------------------------------------------------------------------------
/public/app/tabs/tabs.html:
--------------------------------------------------------------------------------
1 |
9 |
10 |
11 |
12 |
13 |
2 |
3 | All
4 |
--------------------------------------------------------------------------------
/server/config/middleware.js:
--------------------------------------------------------------------------------
1 | var bodyParser = require('body-parser');
2 |
3 | module.exports = function(app, express){
4 | //Static file locations
5 | app.use(express.static(__dirname + '/../../public'));
6 | app.use(express.static(__dirname + '/../../bower_components'));
7 |
8 | //Server App middleware
9 | app.use(bodyParser.json());
10 | app.use(bodyParser.urlencoded({extended: false}));
11 |
12 | //Establish routers and inject the router into the routes file
13 | var userRouter = express.Router();
14 | require('../users/userRoutes.js')(app, userRouter);
15 |
16 | var cacheRouter = express.Router();
17 | require('../cache/cacheRoutes.js')(app, cacheRouter);
18 |
19 | var bookmarksRouter = express.Router();
20 | require('../bookmarks/bookmarksRoutes.js')(app, bookmarksRouter);
21 |
22 | //Establish routes
23 | app.use('/api/users', userRouter);
24 | app.use('/api/cache', cacheRouter);
25 | app.use('/api/bookmarks', bookmarksRouter);
26 | };
27 |
28 |
29 |
--------------------------------------------------------------------------------
/public/app/personal/personal.js:
--------------------------------------------------------------------------------
1 | angular.module('hack.personal', [])
2 |
3 | .controller('PersonalController', function ($scope, $window, Links, Followers, Auth, Bookmarks) {
4 | $scope.stories = Links.personalStories;
5 | $scope.users = Followers.following;
6 | $scope.perPage = 30;
7 | $scope.index = $scope.perPage;
8 | $scope.loggedIn = Auth.isAuth();
9 |
10 | $scope.isBookmark = function(story) {
11 | if (Bookmarks.bookmarks.indexOf(story.objectID) === -1) {
12 | return false;
13 | } else {
14 | return true;
15 | }
16 | };
17 |
18 | $scope.addBookmark = function(story) {
19 | Bookmarks.addBookmark(story);
20 | };
21 |
22 | $scope.removeBookmark = function(story) {
23 | Bookmarks.removeBookmark(story);
24 | };
25 |
26 | var init = function(){
27 | fetchUsers();
28 | };
29 |
30 | var fetchUsers = function(){
31 | Links.getPersonalStories($scope.users);
32 | Links.getBookmarks();
33 | };
34 |
35 | init();
36 | });
37 |
38 |
--------------------------------------------------------------------------------
/public/app/bookmarks/bookmarks.js:
--------------------------------------------------------------------------------
1 | angular.module('hack.bookmarks', [])
2 |
3 | .controller('BookmarksController', function ($scope, $window, Links, Followers, Bookmarks, Auth) {
4 | $scope.currentBookmarks = Bookmarks.bookmarks;
5 | $scope.loggedIn = Auth.isAuth();
6 | $scope.stories = Links.bookmarkStories;
7 | $scope.perPage = 30;
8 | $scope.index = $scope.perPage;
9 | $scope.currentlyFollowing = Followers.following;
10 |
11 | $scope.addUser = function(username) {
12 | Followers.addFollower(username);
13 | };
14 |
15 | $scope.isBookmark = function(story) {
16 | if (Bookmarks.bookmarks.indexOf(story.objectID) === -1) {
17 | return false;
18 | } else {
19 | return true;
20 | }
21 | };
22 | $scope.addBookmark = function(story) {
23 | Bookmarks.addBookmark(story);
24 | };
25 | $scope.removeBookmark = function(story) {
26 | Bookmarks.removeBookmark(story);
27 | };
28 |
29 | var init = function () {
30 | Links.getBookmarks();
31 | };
32 | init();
33 | });
--------------------------------------------------------------------------------
/public/app/personal/personal.html:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 | Personal
10 |
11 |
12 |
13 |
14 |
15 | Bookmarks
16 |
17 |
18 |
19 |
20 |
2 |
21 |
22 |
23 |
--------------------------------------------------------------------------------
/public/app/topStories/topStories.js:
--------------------------------------------------------------------------------
1 | angular.module('hack.topStories', [])
2 |
3 | .controller('TopStoriesController', function ($scope, $window, Links, Followers, Bookmarks, Auth) {
4 | angular.extend($scope, Links);
5 | $scope.stories = Links.topStories;
6 | $scope.perPage = 30;
7 | $scope.index = $scope.perPage;
8 | $scope.loggedIn = Auth.isAuth();
9 | $scope.currentlyFollowing = Followers.following;
10 |
11 | $scope.getData = function() {
12 | Links.getTopStories();
13 | };
14 |
15 | $scope.addUser = function(username) {
16 | Followers.addFollower(username);
17 | };
18 |
19 | $scope.isBookmark = function(story) {
20 | if (Bookmarks.bookmarks.indexOf(story.objectID) === -1) {
21 | return false;
22 | } else {
23 | return true;
24 | }
25 | };
26 |
27 | $scope.addBookmark = function(story) {
28 | Bookmarks.addBookmark(story);
29 | };
30 |
31 | $scope.removeBookmark = function(story) {
32 | Bookmarks.removeBookmark(story);
33 | };
34 |
35 | $scope.getData();
36 | Links.getBookmarks();
37 | });
38 |
39 |
--------------------------------------------------------------------------------
/public/app/auth/auth.js:
--------------------------------------------------------------------------------
1 | angular.module('hack.auth', [])
2 |
3 | .controller('AuthController', ["$scope", "$window", "$location", "Auth", "Followers", "Bookmarks",
4 | function ($scope, $window, $location, Auth, Followers, Bookmarks) {
5 |
6 | $scope.user = {};
7 | $scope.newUser = {};
8 | $scope.loggedIn = Auth.isAuth();
9 |
10 | $scope.signin = function () {
11 | Auth.signin($scope.user)
12 | .then(function (followers, bookmarks) {
13 | $window.localStorage.setItem('com.hack', $scope.user.username);
14 | $window.localStorage.setItem('hfUsers', followers);
15 |
16 | Followers.localToArr();
17 |
18 | $scope.loggedIn = true;
19 | $scope.user = {};
20 | })
21 | .catch(function (error) {
22 | console.error(error);
23 | });
24 | };
25 |
26 | $scope.signup = function () {
27 | $scope.newUser.following = Followers.following.join(',');
28 |
29 | Auth.signup($scope.newUser)
30 | .then(function (data) {
31 | $window.localStorage.setItem('com.hack', $scope.newUser.username);
32 |
33 | $scope.loggedIn = true;
34 | $scope.newUser = {};
35 | })
36 | .catch(function (error) {
37 | console.error(error);
38 | });
39 | };
40 |
41 | $scope.logout = function () {
42 | Auth.signout();
43 | $scope.loggedIn = false;
44 | }
45 | }]);
46 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | [](https://waffle.io/goose-windmill/goose-windmill)
2 | # Goose-Windmill
3 |
4 | > A fresh, responsive and fully featured UI for Hacker News
5 |
6 | 
7 |
8 | See the UI in action on our [Heroku deployment](http://hackfeed.herokuapp.com/#/)
9 |
10 | ## Team
11 |
12 | - __Product Owner__: Kenny Tran
13 | - __Scrum Master__: Matthew Rourke
14 | - __Development Team Members__: Jennifer Bland, Siddharth Sukumar, Lindsay Pond, Cooper Buckingham, William Kilmer, Angela Wang, Vincent Nocera
15 |
16 | ## Table of Contents
17 |
18 | 1. [Usage](#Usage)
19 | 1. [Requirements](#requirements)
20 | 1. [Development](#development)
21 | 1. [Installing Dependencies](#installing-dependencies)
22 | 1. [Tasks](#tasks)
23 | 1. [Team](#team)
24 | 1. [Contributing](#contributing)
25 |
26 | ## Usage
27 |
28 | > Some usage instructions
29 |
30 | ## Requirements
31 |
32 | - Node
33 | - Angular
34 | - Express
35 | - MongoDB
36 |
37 | ## Development
38 |
39 | ### Installing Dependencies
40 |
41 | From within the root directory:
42 |
43 | ```sh
44 | sudo npm install -g bower
45 | npm install
46 | bower install
47 | ```
48 |
49 | ### Roadmap
50 |
51 | View the project roadmap [here](LINK_TO_PROJECT_ISSUES)
52 |
53 |
54 | ## Contributing
55 |
56 | See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines.
57 |
--------------------------------------------------------------------------------
/public/app/partials/story.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
3 |
4 |
5 |
20 |
6 |
7 |
8 |
9 |
10 |
19 |
11 | {{story.author}}
12 | {{story.created_at | fromNow}} |
13 | parent |
14 | on: {{story.story_title}}
15 |
16 |
17 |
18 |
4 |
--------------------------------------------------------------------------------
/server/bookmarks/bookmarksController.js:
--------------------------------------------------------------------------------
1 | var Bookmark = require('./bookmarksModel.js');
2 |
3 | module.exports = {
4 | addBookmark: function(request, response, next) {
5 | // console.log('in server!!!', request.body);
6 | var username = request.body.username;
7 | var bookmark = request.body.bookmark;
8 |
9 | Bookmark.prototype.addBookmark(bookmark, username, function(err, results){
10 | if(!err){
11 | console.log('Bookmark data added');
12 | response.status(200).end();
13 | } else {
14 | console.log('Bookmark data add ERROR');
15 | response.status(400).send(err);
16 | }
17 | });
18 | },
19 | removeBookmark: function(request, response, next) {
20 | var username = request.body.username;
21 | var bookmark = request.body.bookmark;
22 |
23 | Bookmark.prototype.removeBookmark(bookmark, username, function(err, results){
24 | if(!err){
25 | console.log('Bookmark data removed');
26 | response.status(200).end();
27 | } else {
28 | console.log('Bookmark data remove ERROR');
29 | response.status(400).send(err);
30 | }
31 | });
32 | },
33 | getBookmarks: function(request, response, next) {
34 | var username = request.body.username;
35 | Bookmark.prototype.getBookmarks(username, function(err,results){
36 | if(!err){
37 | response.status(200).json(results);
38 | } else {
39 | response.status(500).send(err);
40 | }
41 | });
42 | }
43 | };
--------------------------------------------------------------------------------
/public/app/topStoriesWithKeyword/topStoriesWithKeyword.js:
--------------------------------------------------------------------------------
1 |
2 | angular.module('hack.topStoriesWithKeyword', [])
3 |
4 | .controller('TopStoriesWithKeywordController', function ($scope, $window, Links, Followers, Bookmarks, Auth) {
5 | angular.extend($scope, Links);
6 | $scope.stories = Links.topStoriesWithKeyword;
7 | $scope.perPage = 30;
8 | $scope.index = $scope.perPage;
9 | $scope.loggedIn = Auth.isAuth();
10 | $scope.keyword;
11 | $scope.checked = 'start';
12 |
13 | // now i want to add a scope variable that is equal to the value of an input box
14 | // this might need to be a global variable so that its value can be set in the topStories page and still exist here
15 | // an alternative would be to click a link that takes us to the keyword page with the keyword initially set to ''
16 |
17 | $scope.currentlyFollowing = Followers.following;
18 |
19 | $scope.getData = function() {
20 | Links.getTopStoriesWithKeyword($scope.keyword);
21 | // $scope.checked = $scope.keyword;
22 | };
23 |
24 | $scope.addUser = function(username) {
25 | Followers.addFollower(username);
26 | };
27 |
28 | $scope.isBookmark = function(story) {
29 | if (Bookmarks.bookmarks.indexOf(story.objectID) === -1) {
30 | return false;
31 | } else {
32 | return true;
33 | }
34 | };
35 |
36 | $scope.addBookmark = function(story) {
37 | Bookmarks.addBookmark(story);
38 | };
39 |
40 | $scope.removeBookmark = function(story) {
41 | Bookmarks.removeBookmark(story);
42 | };
43 |
44 | $scope.getData(''); // the argument here will eventually be set by the input box
45 | });
46 |
47 |
--------------------------------------------------------------------------------
/specs/client/routingSpecs.js:
--------------------------------------------------------------------------------
1 | describe('Routing', function () {
2 | // var $route;
3 | // beforeEach(module('shortly'));
4 |
5 | // beforeEach(inject(function($injector){
6 | // $route = $injector.get('$route');
7 | // }));
8 |
9 | it('Should say that true is true', function () {
10 | expect(true).to.eql(true);
11 | });
12 |
13 | // it('Should have /signup route, template, and controller', function () {
14 | // expect($route.routes['/signup']).to.be.ok();
15 | // expect($route.routes['/signup'].controller).to.be('AuthController');
16 | // expect($route.routes['/signup'].templateUrl).to.be('app/auth/signup.html');
17 | // });
18 |
19 | // it('Should have /signin route, template, and controller', function () {
20 | // expect($route.routes['/signin']).to.be.ok();
21 | // expect($route.routes['/signin'].controller).to.be('AuthController');
22 | // expect($route.routes['/signin'].templateUrl).to.be('app/auth/signin.html');
23 | // });
24 |
25 | // it('Should have /links route, template, and controller', function () {
26 | // expect($route.routes['/links']).to.be.ok();
27 | // expect($route.routes['/links'].controller).to.be('LinksController');
28 | // expect($route.routes['/links'].templateUrl).to.be('app/links/links.html');
29 | // });
30 |
31 | // it('Should have /shorten route, template, and controller', function () {
32 | // expect($route.routes['/shorten']).to.be.ok();
33 | // expect($route.routes['/shorten'].controller).to.be('ShortenController');
34 | // expect($route.routes['/shorten'].templateUrl).to.be('app/shorten/shorten.html');
35 | // });
36 | });
37 |
--------------------------------------------------------------------------------
/public/app/auth/auth.html:
--------------------------------------------------------------------------------
1 |
5 |
6 |
7 |
8 |
9 | {{story.title}}
10 |
11 | {{story.url.split('/')[2]}}
12 |
26 |
13 |
14 | 
15 | 
16 |
17 | {{story.points}} points |
18 |
19 | {{ story.author}} |
20 | {{story.created_at | fromNow}} |
21 |
22 | {{story.num_comments ? story.num_comments + ' comments' : 'discuss'}}
23 |
24 |
25 |
15 |
16 |
17 | {{story.points}} points |
18 |
19 | {{ story.author}} |
20 | {{story.created_at | fromNow}} |
21 |
22 | {{story.num_comments ? story.num_comments + ' comments' : 'discuss'}}
23 |
24 |
2 |
--------------------------------------------------------------------------------
/public/app/services/bookmarks.js:
--------------------------------------------------------------------------------
1 | // HOW OUR FOLLOWING SYSTEM WORKS:
2 | // We want users to be able to follow people before they even
3 | // log in, because who actually has time to decide on a story/password?
4 |
5 | // So, we do this by saving the users that they follow into localStorage.
6 | // On signup, we'll send the users string in localStorage to our server
7 | // which wil save them to a database.
8 |
9 | angular.module('hack.bookmarkService', [])
10 |
11 | .factory('Bookmarks', function($http, $window) {
12 | var bookmarks = [];
13 | var user = $window.localStorage.getItem('com.hack');
14 |
15 | var addBookmark = function(story){
16 |
17 | var article = {
18 | points: story.points,
19 | url: story.url,
20 | title: story.title,
21 | author: story.author,
22 | created_at: story.created_at,
23 | objectID: story.objectID,
24 | num_comments: story.num_comments
25 | };
26 | var data = {
27 | username: user,
28 | bookmark: article
29 | };
30 |
31 | $http({
32 | method: 'POST',
33 | url: '/api/bookmarks/addBookmark',
34 | data: data
35 | });
36 |
37 | if (bookmarks.indexOf(article.objectID) === -1) {
38 | bookmarks.push(article.objectID);
39 | }
40 | };
41 |
42 | var removeBookmark = function(story){
43 | var article = {
44 | objectID: story.objectID
45 | };
46 |
47 | var data = {
48 | username: user,
49 | bookmark: article
50 | };
51 |
52 | $http({
53 | method: 'POST',
54 | url: '/api/bookmarks/removeBookmark',
55 | data: data
56 | });
57 |
58 | var splicePoint = bookmarks.indexOf(article.objectID);
59 | bookmarks.splice(splicePoint, 1);
60 | };
61 |
62 | return {
63 | bookmarks: bookmarks,
64 | addBookmark: addBookmark,
65 | removeBookmark: removeBookmark
66 | }
67 | });
68 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "Goose-Windmill",
3 | "version": "1.0.0",
4 | "description": "Hacker News follower functionality",
5 | "main": "index.js",
6 | "scripts": {
7 | "test": "echo \"Error: no test specified\" && exit 1"
8 | },
9 | "repository": {
10 | "type": "git",
11 | "url": "https://github.com/Goose-Windmill/Goose-Windmill"
12 | },
13 | "keywords": [
14 | "hacker",
15 | "news",
16 | "feed"
17 | ],
18 | "author": "Goose Windmil",
19 | "license": "ISC",
20 | "bugs": {
21 | "url": "https://github.com/Goose-Windmill/Goose-Windmill"
22 | },
23 | "homepage": "https://github.com/Goose-Windmill/Goose-Windmill",
24 | "dependencies": {
25 | "bcrypt": "^0.8.2",
26 | "bcrypt-nodejs": "0.0.3",
27 | "bluebird": "^2.9.25",
28 | "body-parser": "^1.12.3",
29 | "expect": "^1.6.0",
30 | "express": "^4.12.3",
31 | "grunt-contrib-concat": "^0.5.1",
32 | "grunt-contrib-cssmin": "^0.12.3",
33 | "grunt-contrib-jshint": "^0.11.2",
34 | "grunt-contrib-uglify": "^0.9.1",
35 | "grunt-contrib-watch": "^0.6.1",
36 | "grunt-karma": "^0.10.1",
37 | "grunt-ng-annotate": "^0.10.0",
38 | "grunt-nodemon": "^0.4.0",
39 | "grunt-shell": "^1.1.2",
40 | "jasmine-core": "^2.3.3",
41 | "karma": "^0.12.31",
42 | "karma-chrome-launcher": "^0.1.11",
43 | "karma-jasmine": "^0.3.5",
44 | "karma-nyan-reporter": "0.0.60",
45 | "karma-unicorn-reporter": "^0.1.4",
46 | "mongodb": "^2.0.28",
47 | "mongoose": "^4.0.2",
48 | "q": "^1.3.0",
49 | "request": "^2.55.0",
50 | "util": "^0.10.3"
51 | },
52 | "devDependencies": {
53 | "expect.js": "^0.3.1",
54 | "grunt-concurrent": "^1.0.0",
55 | "grunt-open": "^0.2.3",
56 | "grunt-run": "^0.3.0",
57 | "grunt-services": "^0.1.0",
58 | "grunt-shell-spawn": "^0.3.8",
59 | "karma-chrome-launcher": "^0.1.11",
60 | "require": "^2.4.18"
61 | }
62 | }
63 |
--------------------------------------------------------------------------------
/public/app/app.js:
--------------------------------------------------------------------------------
1 | angular.module('hack', [
2 | 'hack.topStories',
3 | 'hack.topStoriesWithKeyword',
4 | 'hack.personal',
5 | 'hack.bookmarks',
6 | 'hack.bookmarkService',
7 | 'hack.currentlyFollowing',
8 | 'hack.linkService',
9 | 'hack.authService',
10 | 'hack.followService',
11 | 'hack.tabs',
12 | 'hack.auth',
13 | 'ngRoute'
14 | ])
15 |
16 | .config(function($routeProvider, $httpProvider) {
17 | $routeProvider
18 | .when('/', {
19 | templateUrl: 'app/topStories/topStories.html',
20 | controller: 'TopStoriesController'
21 | })
22 | .when('/personal', {
23 | templateUrl: 'app/personal/personal.html',
24 | controller: 'PersonalController'
25 | })
26 | .when('/bookmarks', {
27 | templateUrl: 'app/bookmarks/bookmarks.html',
28 | controller: 'BookmarksController'
29 | })
30 | .when('/keyword', {
31 | templateUrl: 'app/topStoriesWithKeyword/topStoriesWithKeyword.html',
32 | controller: 'TopStoriesWithKeywordController'
33 | })
34 | .otherwise({
35 | redirectTo: '/'
36 | });
37 | })
38 |
39 | .filter('fromNow', function(){
40 | return function(date){
41 | var foo = 3;
42 | return humanized_time_span(new Date(date));
43 | }
44 | })
45 |
46 | .filter('htmlsafe', ['$sce', function ($sce) {
47 | return function (text) {
48 | return $sce.trustAsHtml(text);
49 | };
50 | }])
51 |
52 | .directive('rotate', function () {
53 | return {
54 | restrict: 'A',
55 | link: function (scope, element, attrs) {
56 | scope.$watch(attrs.degrees, function (rotateDegrees) {
57 | var r = 'rotate(' + rotateDegrees + 'deg)';
58 | // console.log(r);
59 | element.css({
60 | '-moz-transform': r,
61 | '-webkit-transform': r,
62 | '-o-transform': r,
63 | '-ms-transform': r,
64 | 'transform': r
65 | });
66 | });
67 | }
68 | }
69 | });
70 |
71 |
--------------------------------------------------------------------------------
/karma.conf.js:
--------------------------------------------------------------------------------
1 | // Karma configuration
2 | // Generated on Mon Jun 30 2014 19:35:20 GMT-0700 (PDT)
3 |
4 | module.exports = function(config) {
5 | config.set({
6 |
7 | // base path that will be used to resolve all patterns (eg. files, exclude)
8 | basePath: '',
9 |
10 |
11 | // frameworks to use
12 | // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
13 | frameworks: ['jasmine'],
14 |
15 |
16 | // list of files / patterns to load in the browser
17 | files: [
18 | // angular source
19 | 'public/lib/angular.js',
20 | 'bower_components/angular-route/angular-route.js',
21 | 'public/lib/angular-mocks.js',
22 |
23 | // our app code
24 | 'public/app/**/*.js',
25 |
26 | // our spec files
27 | 'node_modules/expect.js/index.js',
28 | 'specs/client/**/*.js'
29 | ],
30 |
31 |
32 | // list of files to exclude
33 | exclude: [
34 | 'karma.conf.js'
35 | ],
36 |
37 |
38 | // preprocess matching files before serving them to the browser
39 | // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
40 | preprocessors: {
41 |
42 | },
43 |
44 |
45 | // test results reporter to use
46 | // possible values: 'dots', 'progress'
47 | // available reporters: https://npmjs.org/browse/keyword/karma-reporter
48 | reporters: ['nyan','unicorn'],
49 |
50 |
51 | // web server port
52 | port: 9876,
53 |
54 |
55 | // enable / disable colors in the output (reporters and logs)
56 | colors: true,
57 |
58 |
59 | // level of logging
60 | // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
61 | logLevel: config.LOG_INFO,
62 |
63 |
64 | // enable / disable watching file and executing tests whenever any file changes
65 | autoWatch: false,
66 |
67 |
68 | // start these browsers
69 | // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
70 | browsers: ['Chrome'],
71 |
72 | // Continuous Integration mode
73 | // if true, Karma captures browsers, runs the tests and exits
74 | singleRun: true
75 | });
76 | };
77 |
--------------------------------------------------------------------------------
/server/users/userController.js:
--------------------------------------------------------------------------------
1 | var User = require('./userModel.js');
2 |
3 | module.exports = {
4 | //Handles new user account generation
5 | signup: function(request, response, next) {
6 |
7 | var username = request.body.username;
8 | var password = request.body.password;
9 | var following = request.body.following;
10 |
11 | var params = {
12 | username: username,
13 | password: password,
14 | following: following
15 | };
16 |
17 | //First, determine if the username is available
18 | User.findOne({username: username}, function(err, user) {
19 | //User already exists, try again!
20 | if(user) {
21 | //Figure out a way for the client to redirect to the signup page
22 | //and inform the user that this username is already in use.
23 | response.status(400).send('Figure this out Kenny');
24 | } else {
25 | //If it is not in use, create the user in the database
26 | User.prototype.createUser(params, function(err){
27 | if(!err){
28 | response.status(200).send("Signed up");
29 | } else {
30 | response.status(400).send("Bad data");
31 | }
32 | });
33 | }
34 | });
35 | },
36 |
37 | //Interact with the database to validate username/password combination
38 | signin: function(request, response, next) {
39 | var username = request.body.username;
40 | var password = request.body.password;
41 |
42 | User.prototype.signin(username, password, function(err, results){
43 | if(!err){
44 | console.log('Signed in');
45 | response.status(200).send(results);
46 | } else {
47 | console.log('Sign In error');
48 | response.status(400).send(err);
49 | }
50 | })
51 | },
52 |
53 | //Controller tells the model to update the database when the user adds or
54 | //removes users from their following list
55 | updateFollowing: function(request, response, next) {
56 | var username = request.body.username;
57 | var following = request.body.following;
58 |
59 | User.prototype.updateFollowing(username, following, function(err, results){
60 | if(!err){
61 | console.log('User following data updated');
62 | response.status(200).end();
63 | } else {
64 | console.log('User following data update ERROR');
65 | response.status(400).send(err);
66 | }
67 | });
68 | }
69 | };
--------------------------------------------------------------------------------
/server/bookmarks/bookmarksModel.js:
--------------------------------------------------------------------------------
1 | var mongoose = require('mongoose');
2 | var Promise = require('bluebird');
3 |
4 | var BookmarksSchema = mongoose.Schema({
5 | title: {
6 | type: String,
7 | required: true
8 | },
9 | url: {
10 | type: String,
11 | required: true
12 | },
13 | author: {
14 | type: String,
15 | required: true
16 | },
17 | created_at: {
18 | type: String,
19 | required: true
20 | },
21 | objectID: {
22 | type: String,
23 | required: true
24 | },
25 | usernames: {
26 | type: [String],
27 | required: true
28 | },
29 | points: {
30 | type: String,
31 | required: true
32 | },
33 | num_comments: {
34 | type: String,
35 | required: true
36 | }
37 | });
38 |
39 | var Bookmark = mongoose.model('bookmarks', BookmarksSchema);
40 |
41 |
42 | Bookmark.prototype.addBookmark = function (bookmark, username, callback){
43 | //try to find the most recently clicked article in db by its ID
44 | Bookmark.findOne({objectID: bookmark.objectID}, 'usernames', function (err, result) {
45 | var allUsernames;
46 | if (err) console.log(err);
47 | //if article is not in db
48 | if (!result) {
49 | allUsernames = [];
50 | } else {
51 | //if article in db, then allUsernames is the result.usernames array
52 | //console.log('THIS IS THE RESULT OF FINDONE', result.usernames);
53 | allUsernames = result.usernames;
54 | }
55 | //regardless, add username to array, and upsert the article
56 | if (allUsernames.indexOf(username) === -1) {
57 | allUsernames.push(username);
58 | }
59 | Bookmark.update({objectID: bookmark.objectID},
60 | {
61 | points: bookmark.points,
62 | title: bookmark.title,
63 | url: bookmark.url,
64 | author: bookmark.author,
65 | created_at: bookmark.created_at,
66 | objectID: bookmark.objectID,
67 | num_comments: bookmark.num_comments,
68 | usernames: allUsernames}, {upsert: true}, function(err, result) {
69 | if (err) console.log(err);
70 | });
71 | })
72 | };
73 |
74 | Bookmark.prototype.removeBookmark = function (bookmark, username, callback) {
75 | Bookmark.findOne({objectID: bookmark.objectID}, 'usernames', function (err, result) {
76 | if (err) console.log(err);
77 | var allUsernames = result.usernames;
78 | var splicePoint = allUsernames.indexOf(username);
79 | allUsernames.splice(splicePoint, 1);
80 | Bookmark.update({objectID: bookmark.objectID},
81 | {
82 | usernames: allUsernames
83 | }, {upsert: true}, function(err, result) {
84 | if (err) console.log(err);
85 | });
86 | })
87 | };
88 |
89 | Bookmark.prototype.getBookmarks = function (username, callback) {
90 | Bookmark.find({usernames: username}, function (err, result) {
91 | if (err) console.log(err);
92 | callback(err, result);
93 | })
94 | }
95 |
96 | module.exports = Bookmark;
97 |
98 |
--------------------------------------------------------------------------------
/server/users/userModel.js:
--------------------------------------------------------------------------------
1 | var mongoose = require('mongoose');
2 | var Promise = require('bluebird');
3 | var bcrypt = require('bcrypt-nodejs');
4 |
5 | //Simple database of user data. Password is stored as a hash/salt combination.
6 | //The following value is a comma separated value of posters that the user is following.
7 | var UserSchema = mongoose.Schema({
8 | username: {
9 | type: String,
10 | required: true,
11 | unique: true
12 | },
13 | hashword: {
14 | type: String,
15 | required: true
16 | },
17 | following: {
18 | type: String,
19 | required: true
20 | },
21 | });
22 |
23 | var User = mongoose.model('users', UserSchema);
24 |
25 | //Model generates new users on signup. This function is only called after the controller
26 | //determines that the username is not taken.
27 | //params: an object that contains a string of the username, plain text string of the password,
28 | // and a comma separated string of users that the user is following
29 | User.prototype.createUser = function (params, callback){
30 | //User password is stored as a hash/salt combination
31 | bcrypt.hash(params.password, null, null, function(err, hash){
32 | if(hash) {
33 | var newUser = new User({
34 | username: params.username,
35 | hashword: hash,
36 | following: params.following,
37 | });
38 | newUser.save(function(err,results){
39 | //Relay user creation success/failure back to the controller
40 | callback(err, results);
41 | });
42 | } else {
43 | //bcrypt.hash error reporting
44 | callback(err);
45 | }
46 | });
47 | };
48 |
49 | //Model handles finding the user and password comparison
50 | User.prototype.signin = function (username, password, callback){
51 | //Find if the user exists
52 | User.findOne({'username':username},function(err,user){
53 | //If the user exists, compare hashed passwords
54 | if(user){
55 | bcrypt.compare(password, user.hashword, function(err, res) {
56 | if (res) {
57 | //If correct, return the list of hacker news posters that the user is following
58 | callback(null, user.following);
59 | } else {
60 | //If not correct, handle error
61 | callback('Incorrect password', null);
62 | }
63 | });
64 | } else {
65 | //If the user doesn't exist, handle error
66 | callback('Username not found', null);
67 | }
68 | });
69 | };
70 |
71 | //Update database when the user adds or removes users from their following list
72 | //Method operates on the assumption that the .signin has validated the username.
73 | User.prototype.updateFollowing = function (username, following, callback){
74 | //Find the user in the database
75 | //Could try to refactor to .findOneAndUpdate or .findOneAndModify
76 | User.findOne({username: username}, function(err, user) {
77 | //Modify and save the database
78 | user.following = following;
79 | user.save();
80 | callback(err);
81 | });
82 | };
83 |
84 | module.exports = User;
--------------------------------------------------------------------------------
/public/app/services/followers.js:
--------------------------------------------------------------------------------
1 | // HOW OUR FOLLOWING SYSTEM WORKS:
2 | // We want users to be able to follow people before they even
3 | // log in, because who actually has time to decide on a username/password?
4 |
5 | // So, we do this by saving the users that they follow into localStorage.
6 | // On signup, we'll send the users string in localStorage to our server
7 | // which wil save them to a database.
8 |
9 | angular.module('hack.followService', [])
10 |
11 | .factory('Followers', function($http, $window) {
12 | var following = [];
13 |
14 | var updateFollowing = function(){
15 | var user = $window.localStorage.getItem('com.hack');
16 |
17 | if(!!user){
18 | var data = {
19 | username: user,
20 | following: localStorageUsers()
21 | };
22 |
23 | $http({
24 | method: 'POST',
25 | url: '/api/users/updateFollowing',
26 | data: data
27 | });
28 | }
29 | };
30 |
31 | var addFollower = function(username){
32 | var localFollowing = localStorageUsers();
33 |
34 | if (!localFollowing.includes(username) && following.indexOf(username) === -1) {
35 | localFollowing += ',' + username
36 | $window.localStorage.setItem('hfUsers', localFollowing);
37 | following.push(username);
38 | }
39 |
40 | // makes call to database to mirror our changes
41 | updateFollowing();
42 | };
43 |
44 | var removeFollower = function(username){
45 | var localFollowing = localStorageUsers();
46 |
47 | if (localFollowing.includes(username) && following.indexOf(username) > -1) {
48 | following.splice(following.indexOf(username), 1);
49 |
50 | localFollowing = localFollowing.split(',');
51 | localFollowing.splice(localFollowing.indexOf(username), 1).join(',');
52 | $window.localStorage.setItem('hfUsers', localFollowing);
53 | }
54 |
55 | // makes call to database to mirror our changes
56 | updateFollowing();
57 | };
58 |
59 | var localStorageUsers = function(){
60 | return $window.localStorage.getItem('hfUsers');
61 | }
62 |
63 |
64 | // this function takes the csv in localStorage and turns it into an array.
65 | // There are pointers pointing to the 'following' array. The 'following' array
66 | // is how our controllers listen for changes and dynamically update the DOM.
67 | // (because you can't listen to localStorage changes)
68 | var localToArr = function(){
69 | if(!localStorageUsers()){
70 | // If the person is a new visitor, set pg and sama as the default
71 | // people to follow. Kinda like Tom on MySpace. Except less creepy.
72 | $window.localStorage.setItem('hfUsers', 'pg,sama');
73 | }
74 |
75 | var users = localStorageUsers().split(',');
76 |
77 | following.splice(0, following.length);
78 | following.push.apply(following, users);
79 | };
80 |
81 |
82 |
83 | var init = function(){
84 | localToArr();
85 | };
86 |
87 | init();
88 |
89 | return {
90 | following: following,
91 | addFollower: addFollower,
92 | removeFollower: removeFollower,
93 | localToArr: localToArr
94 | }
95 | })
96 |
--------------------------------------------------------------------------------
/_PRESS-RELEASE.md:
--------------------------------------------------------------------------------
1 | # Hacker Feed #
2 |
3 |
18 |
19 | Browse Hacker News more efficiently by telling Hacker Feed what you want to follow.
20 |
21 | ## Summary ##
22 | The Hacker News interface is outdated and does not have any options for personalize filtering. Hacker Feed exists to make Hacker News users time browsing more efficient by personalizing their feed.
23 |
24 | ## Problem ##
25 | Hacker News users do not have any options for filtering their content.
26 |
27 | ## Solution ##
28 | Hacker Feed allows its users to personalize their Hacker News reading experience by allowing them to follow users and topics that they find interesting.
29 |
30 | ## Quote from You ##
31 | "Hack your Hacker News experience." - Sid
32 |
33 | ## How to Get Started ##
34 | Go to the website, sign up for an account, and start following your favorite HN users and topics.
35 |
36 | ## Customer Quote ##
37 | "I cut my time browsing Hacker News by 50% while also reading only the interesting content." - Paul Graham
38 |
39 | ## Closing and Call to Action ##
40 | Visit LINK, sign up for an account, follow your favorite users and topics, and watch Hacker Feed do all your work for you!
41 |
--------------------------------------------------------------------------------
/server/cache/cacheModel.js:
--------------------------------------------------------------------------------
1 | var request = require('request');
2 |
3 | //In server memory of Hacker News current top stories
4 | var topStories = [];
5 | var topStoriesWithKeyword = [];
6 |
7 | //Set headers
8 | var headers = {
9 | 'User-Agent': 'Hacker Feed',
10 | 'Content-Type': 'application/json'
11 | };
12 |
13 | module.exports = {
14 | //Access function for model data
15 | getTopStories: function(callback) {
16 | if (topStories.length) {
17 | callback(null, topStories);
18 | } else {
19 | callback(new Error('Top Stories not cached!'));
20 | }
21 | },
22 |
23 | getTopStoriesWithKeyword: function(keyword, callback) {
24 | topStoriesWithKeyword = [];
25 | // for (var i = 0; i < topStories.length; i++){
26 | // if (topStories[i].title.search(keyword) !== -1){
27 | // topStoriesWithKeyword.push(topStories[i]);
28 | // }
29 | // }
30 | var options = {
31 | url: 'http://hn.algolia.com/api/v1/search?query=' + keyword,
32 | method: 'GET',
33 | // params: {query: keyword}
34 | }
35 |
36 | request(options, function(error, response){
37 | if (error) {
38 | return;
39 | }
40 | var data = JSON.parse(response.body);
41 | console.log("data length" + data.hits.length);
42 | // console.log("")
43 | for (var i = 0; i < data.hits.length; i ++){
44 | topStoriesWithKeyword.push(data.hits[i]);
45 | // console.log(data.hits[i]);
46 | }
47 | console.log("ketword sotries length" + topStoriesWithKeyword.length);
48 | if (topStoriesWithKeyword.length) {
49 | callback(null, topStoriesWithKeyword);
50 | } else {
51 | callback(new Error('Top Stories with keyword not found!'));
52 | };
53 | })
54 | // console.log("what" + topStoriesWithKeyword.length);
55 |
56 | },
57 | // The top news stories data is retrieved from the Algolia API, however it does not include
58 | // Hacker News' ranking algorithm. The data retrieved from Algolia is sorted according to the
59 | // ranking on the firebase API
60 |
61 | updateTopStories: function() {
62 | var storyOrderUrl = 'https://hacker-news.firebaseio.com/v0/topstories.json';
63 |
64 | // Configure API request
65 | var options = {
66 | url: storyOrderUrl,
67 | method: 'GET',
68 | headers: headers
69 | };
70 |
71 | // Perform the firebase API request
72 | request(options, function(error, response, html){
73 | if (error) {
74 | return;
75 | }
76 | var data = JSON.parse(response.body);
77 | var storyOrder = data;
78 |
79 | // Generate algolia search API URL
80 | var storyUrl = 'http://hn.algolia.com/api/v1/search?hitsPerPage=500&tagFilters=story,(';
81 | var storyUrlIds = [];
82 | for(var i = 0; i < storyOrder.length; i++) {
83 | storyUrlIds.push('story_' + storyOrder[i]);
84 | }
85 | storyUrl += storyUrlIds.join(',') + ')';
86 | options.url = storyUrl;
87 |
88 | request(options, function(error, response, html){
89 | // Reorder the retrieved stories to match the hacker news front page
90 |
91 | var data = JSON.parse(response.body);
92 | var index;
93 | var indexMap = data.hits.map(function(obj) {
94 | return obj.objectID;
95 | });
96 |
97 | // Clear out previous top stories
98 | topStories.length = 0;
99 |
100 | //storyOrder matches hacker news front page. Find data related to the story ID
101 | //in the incoming response data
102 | for(var i = 0; i < storyOrder.length; i++) {
103 | index = indexMap.indexOf(String(storyOrder[i]));
104 | var item = data.hits[index];
105 | if(item){
106 | topStories.push(data.hits[index]);
107 | }
108 | }
109 | console.log("Top Stories Updated");
110 | console.log("# of stories " + topStories.length);
111 | });
112 | });
113 | }
114 | };
115 |
--------------------------------------------------------------------------------
/public/app/services/links.js:
--------------------------------------------------------------------------------
1 | angular.module('hack.linkService', [])
2 |
3 | .factory('Links', function($window, $http, $interval, Followers, Bookmarks) {
4 | var personalStories = [];
5 | var topStories = [];
6 | var bookmarkStories = [];
7 |
8 |
9 | var topStoriesWithKeyword = [];
10 |
11 | var getTopStories = function() {
12 | console.log('getTopStories');
13 | var url = '/api/cache/topStories'
14 |
15 | return $http({
16 | method: 'GET',
17 | url: url
18 | })
19 | .then(function(resp) {
20 |
21 | // Very important to not point topStories to a new array.
22 | // Instead, clear out the array, then push all the new
23 | // datum in place. There are pointers pointing to this array.
24 | topStories.splice(0, topStories.length);
25 | topStories.push.apply(topStories, resp.data);
26 | });
27 | };
28 |
29 | var getTopStoriesWithKeyword = function(keyword) {
30 | console.log('getTopStoriesWithKeyword');
31 | var url = '/api/cache/topStoriesWithKeyword'
32 |
33 | return $http({
34 | method: 'GET',
35 | url: url,
36 | params: {keyword: keyword}
37 | })
38 | .then(function(resp) {
39 | console.log(resp);
40 |
41 | // Very important to not point topStories to a new array.
42 | // Instead, clear out the array, then push all the new
43 | // datum in place. There are pointers pointing to this array.
44 | topStoriesWithKeyword.splice(0, topStoriesWithKeyword.length);
45 | topStoriesWithKeyword.push.apply(topStoriesWithKeyword, resp.data);
46 | console.log(topStoriesWithKeyword);
47 | });
48 | }
49 |
50 | var getPersonalStories = function(usernames){
51 | var query = 'http://hn.algolia.com/api/v1/search_by_date?hitsPerPage=500&tagFilters=(story,comment),(';
52 | var csv = arrToCSV(usernames);
53 |
54 | query += csv + ')';
55 |
56 | return $http({
57 | method: 'GET',
58 | url: query
59 | })
60 | .then(function(resp) {
61 | angular.forEach(resp.data.hits, function(item){
62 | // HN Comments don't have a title. So flag them as a comment.
63 | // This will come in handy when we decide how to render each item.
64 | if(item.title === null){
65 | item.isComment = true;
66 | }
67 | });
68 |
69 | // Very important to not point personalStories to a new array.
70 | // Instead, clear out the array, then push all the new
71 | // datum in place. There are pointers pointing to this array.
72 | personalStories.splice(0, personalStories.length);
73 | personalStories.push.apply(personalStories, resp.data.hits);
74 | });
75 | };
76 |
77 | var getBookmarks = function(){
78 | var user = $window.localStorage.getItem('com.hack');
79 |
80 | var data = {username: user};
81 | return $http({
82 | method: 'POST',
83 | url: '/api/bookmarks/getBookmarks',
84 | data: data
85 | })
86 | .then(function(resp) {
87 | bookmarkStories.splice(0, bookmarkStories.length);
88 | angular.forEach(resp.data, function (story) {
89 | bookmarkStories.push(story);
90 | if (Bookmarks.bookmarks.indexOf(story.objectID) === -1) {
91 | Bookmarks.bookmarks.push(story.objectID);
92 | }
93 | });
94 | });
95 | };
96 |
97 | var arrToCSV = function(arr){
98 | var holder = [];
99 |
100 | for(var i = 0; i < arr.length; i++){
101 | holder.push('author_' + arr[i]);
102 | }
103 |
104 | return holder.join(',');
105 | };
106 |
107 | var init = function(){
108 | getPersonalStories(Followers.following);
109 |
110 | $interval(function(){
111 | getPersonalStories(Followers.following);
112 | getTopStories();
113 | }, 300000);
114 | };
115 |
116 | init();
117 |
118 | return {
119 | getTopStories: getTopStories,
120 | getTopStoriesWithKeyword: getTopStoriesWithKeyword,
121 | getPersonalStories: getPersonalStories,
122 | personalStories: personalStories,
123 | topStories: topStories,
124 | topStoriesWithKeyword: topStoriesWithKeyword,
125 | getBookmarks: getBookmarks,
126 | bookmarkStories: bookmarkStories
127 | };
128 | });
129 |
130 |
131 |
--------------------------------------------------------------------------------
/public/lib/human-time.js:
--------------------------------------------------------------------------------
1 | // Copyright (C) 2011 by Will Tomlins
2 | //
3 | // Github profile: http://github.com/layam
4 | //
5 | // Permission is hereby granted, free of charge, to any person obtaining a copy
6 | // of this software and associated documentation files (the "Software"), to deal
7 | // in the Software without restriction, including without limitation the rights
8 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | // copies of the Software, and to permit persons to whom the Software is
10 | // furnished to do so, subject to the following conditions:
11 | //
12 | // The above copyright notice and this permission notice shall be included in
13 | // all copies or substantial portions of the Software.
14 | //
15 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | // THE SOFTWARE.
22 |
23 |
24 | function humanized_time_span(date, ref_date, date_formats, time_units) {
25 | //Date Formats must be be ordered smallest -> largest and must end in a format with ceiling of null
26 | date_formats = date_formats || {
27 | past: [
28 | { ceiling: 60, text: "$seconds seconds ago" },
29 | { ceiling: 3600, text: "$minutes minutes ago" },
30 | { ceiling: 86400, text: "$hours hours ago" },
31 | { ceiling: 2629744, text: "$days days ago" },
32 | { ceiling: 31556926, text: "$months months ago" },
33 | { ceiling: null, text: "$years years ago" }
34 | ],
35 | future: [
36 | { ceiling: 60, text: "in $seconds seconds" },
37 | { ceiling: 3600, text: "in $minutes minutes" },
38 | { ceiling: 86400, text: "in $hours hours" },
39 | { ceiling: 2629744, text: "in $days days" },
40 | { ceiling: 31556926, text: "in $months months" },
41 | { ceiling: null, text: "in $years years" }
42 | ]
43 | };
44 | //Time units must be be ordered largest -> smallest
45 | time_units = time_units || [
46 | [31556926, 'years'],
47 | [2629744, 'months'],
48 | [86400, 'days'],
49 | [3600, 'hours'],
50 | [60, 'minutes'],
51 | [1, 'seconds']
52 | ];
53 |
54 | date = new Date(date);
55 | ref_date = ref_date ? new Date(ref_date) : new Date();
56 | var seconds_difference = (ref_date - date) / 1000;
57 |
58 | var tense = 'past';
59 | if (seconds_difference < 0) {
60 | tense = 'future';
61 | seconds_difference = 0-seconds_difference;
62 | }
63 |
64 | function get_format() {
65 | for (var i=0; i
3 |
41 | HN Feed
4 |Sign up to save your followers
5 |
6 |
22 |
23 |
24 |
25 |
39 |
40 |
42 |
45 | HN Feed
43 | 44 |
13 |
14 |
15 |
105 |
106 |
16 |
17 |
18 |
20 |
21 | Select
19 |
22 |
25 |
28 |
31 |
34 |
35 |
36 |
37 |
38 |
40 |
41 | Following
39 |
42 |
51 |
43 |
44 |
45 |
46 |
49 |
50 |
52 |
53 |
104 |
54 |
56 |
57 |
58 | HN Feed
55 |
59 |
102 |
103 |
60 |
97 |
98 |
61 |
77 |
78 |
79 |
80 |
94 |
95 | Sign in to save your followers and bookmarks
96 |
99 |
100 |
101 |
107 |
108 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 |
--------------------------------------------------------------------------------
/Gruntfile.js:
--------------------------------------------------------------------------------
1 | module.exports = function(grunt) {
2 |
3 | grunt.initConfig({
4 | pkg: grunt.file.readJSON('package.json'),
5 | concat: {
6 | dist: {
7 | files: {
8 | 'public/dist/production.js':
9 | ['public/app/services/**.js',
10 | 'public/app/auth/auth.js',
11 | 'public/app/currentlyFollowing/currentlyFollowing.js',
12 | 'public/app/personal/personal.js',
13 | 'public/app/bookmarks/bookmarks.js',
14 | 'public/app/tabs/tabs.js',
15 | 'public/app/topStories/topStories.js',
16 | 'public/app/topStoriesWithKeyword/topStoriesWithKeyword.js',
17 | 'public/app/app.js'],
18 | 'public/dist/production.css': ['public/styles/*.css']
19 | },
20 | }
21 | },
22 |
23 | nodemon: {
24 | dev: {
25 | script: 'index.js'
26 | }
27 | },
28 |
29 | karma: {
30 | options: {
31 | // point all tasks to karma config file
32 | configFile: './karma.conf.js'
33 | },
34 | unit: {
35 | // run tests once instead of continuously
36 | singleRun: true
37 | },
38 | continuous: {
39 | // keep karma running in the background
40 | background: true
41 | }
42 | },
43 |
44 | uglify: {
45 | build: {
46 | src: 'public/dist/production.js',
47 | dest: 'public/dist/production.min.js'
48 | }
49 | },
50 |
51 | cssmin: {
52 | css:{
53 | src: 'public/dist/production.css',
54 | dest: 'public/dist/production.min.css'
55 | }
56 | },
57 |
58 | jshint: {
59 | files: [
60 | 'public/app/**/*.js', 'server/**/*.js',
61 | ],
62 | options: {
63 | force: 'false',
64 | jshintrc: '.jshintrc',
65 | ignores: [
66 | 'public/lib/**/*.js',
67 | 'public/dist/**/*.js'
68 | ]
69 | }
70 | },
71 |
72 | // this task needs to be run after concat (and before uglify) is called on any angular files,
73 | ngAnnotate: {
74 | options: {
75 | add:true,
76 | },
77 | dist: {
78 | files: {
79 | 'public/dist/production.js': ['public/dist/production.js'],
80 | }
81 | },
82 | },
83 |
84 | watch: {
85 | scripts: {
86 | files: [
87 | 'public/**/*.js',
88 | 'public/lib/**/*.js',
89 | ],
90 | tasks: [
91 | 'jshint',
92 | 'concat',
93 | 'ngAnnotate',
94 | 'uglify',
95 | 'cssmin'
96 | ]
97 | },
98 | css: {
99 | files: 'public/**/*.css',
100 | tasks: ['cssmin']
101 | },
102 | karma: {
103 | // run these tasks when these files change
104 | files: ['public/app/**/*.js', 'test/**/*.js'],
105 | tasks: ['karma:continuous:run'] // note the :run flag
106 | }
107 | },
108 |
109 | shell: {
110 | pull: {
111 | command: 'git pull --rebase upstream master'
112 | },
113 | runDB: {
114 | command: 'mongod',
115 | options: {
116 | async: true
117 | }
118 | },
119 | newTab:{
120 | command: 'osascript -e \'tell application \"Terminal\" to activate\' -e \'tell application \"System Events\" to tell process \"Terminal\" to keystroke \"t\" using command down\''
121 | },
122 | push: {
123 | command: function(branch) {
124 | return 'git push origin ' + branch;
125 | }
126 | },
127 | },
128 |
129 | open: {
130 | all: {
131 | path: 'http://localhost:3000/#/'
132 | }
133 | }
134 |
135 |
136 | });
137 |
138 | grunt.loadNpmTasks('grunt-contrib-concat');
139 | grunt.loadNpmTasks('grunt-nodemon');
140 | grunt.loadNpmTasks('grunt-contrib-uglify');
141 | grunt.loadNpmTasks('grunt-contrib-cssmin');
142 | grunt.loadNpmTasks('grunt-contrib-jshint');
143 | grunt.loadNpmTasks('grunt-ng-annotate');
144 | grunt.loadNpmTasks('grunt-shell');
145 | grunt.loadNpmTasks('grunt-contrib-watch');
146 | grunt.loadNpmTasks('grunt-shell-spawn');
147 | grunt.loadNpmTasks('grunt-run');
148 | grunt.loadNpmTasks('grunt-services');
149 | grunt.loadNpmTasks('grunt-open');
150 | grunt.loadNpmTasks('grunt-karma');
151 | grunt.loadNpmTasks('karma-chrome-launcher');
152 |
153 |
154 | //To run this function, call the task gitFunctions and pass in the name of the branch that
155 | // will be pushed up to github
156 | //For example, grunt gitFunctions:newFeatureBranch
157 | //if no branch name is passed in, nothing happens
158 | grunt.registerTask('gitFunctions', 'Pull and push from github', function(n) {
159 | if (n){
160 | grunt.task.run('shell:pull');
161 | grunt.task.run('shell:push:' + n);
162 | }
163 | });
164 |
165 | // this is to start and stop the Mongo server
166 | grunt.registerTask('start', 'Start all required services', ['startMongo']);
167 | grunt.registerTask('stop', 'Stop all services', ['stopMongo']);
168 |
169 | grunt.registerTask('server', function (target) {
170 | var nodemon = grunt.util.spawn({
171 | cmd: 'grunt',
172 | grunt: true,
173 | args: ['nodemon']
174 | });
175 | nodemon.stdout.pipe(process.stdout);
176 | nodemon.stderr.pipe(process.stderr);
177 |
178 | // here you can run other tasks e.g.
179 | grunt.task.run([ 'watch' ]);
180 |
181 | });
182 |
183 | //call this task to start the mongo server and the node server
184 | grunt.registerTask('startApp', [
185 | 'start',
186 | 'server',
187 | ]);
188 |
189 | //call this task to run the test suite
190 | grunt.registerTask('test', ['karma:continuous:start', 'watch:karma']);
191 |
192 | //call this task before something is pushed to github
193 | grunt.registerTask('build', [
194 | 'jshint',
195 | 'concat',
196 | 'ngAnnotate',
197 | 'uglify',
198 | 'cssmin'
199 | ]);
200 |
201 | };
--------------------------------------------------------------------------------
/_CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | # Contributing
2 |
3 | ## General Workflow
4 |
5 | 1. Fork the repo
6 | 1. Cut a namespaced feature branch from master
7 | - bug/...
8 | - feat/...
9 | - test/...
10 | - doc/...
11 | - refactor/...
12 | 1. Make commits to your feature branch. Prefix each commit like so:
13 | - (feat) Added a new feature
14 | - (fix) Fixed inconsistent tests [Fixes #0]
15 | - (refactor) ...
16 | - (cleanup) ...
17 | - (test) ...
18 | - (doc) ...
19 | 1. When you've finished with your fix or feature, Rebase upstream changes into your branch. submit a [pull request][]
20 | directly to master. Include a description of your changes.
21 | 1. Your pull request will be reviewed by another maintainer. The point of code
22 | reviews is to help keep the codebase clean and of high quality and, equally
23 | as important, to help you grow as a programmer. If your code reviewer
24 | requests you make a change you don't understand, ask them why.
25 | 1. Fix any issues raised by your code reviwer, and push your fixes as a single
26 | new commit.
27 | 1. Once the pull request has been reviewed, it will be merged by another member of the team. Do not merge your own commits.
28 |
29 | ## Detailed Workflow
30 |
31 | ### Fork the repo
32 |
33 | Use github’s interface to make a fork of the repo, then add that repo as an upstream remote:
34 |
35 | ```
36 | git remote add upstream https://github.com/hackreactor-labs/