winwardo / solid-octo-disco Goto Github PK

https://github.com/usablica/intro.js

Have something along these lines in webpack.config.dev.js

module.exports = {
  devtool: 'eval',
  entry: [
    'eventsource-polyfill', //necessary evil for hot loading with IE
    'webpack-hot-middleware/client',
    './src/index.js'
  ],
  output: {
    path: path.join(__dirname, 'public'),
    filename: 'bundle.js',
    publicPath: '/public/'
  },
  plugins: [
    new webpack.HotModuleReplacementPlugin(),
    new webpack.NoErrorsPlugin()
  ],
  module: {
    loaders: [{
      test: /\.js$/,
      loaders: ['babel'],
      include: path.join(__dirname, 'src')
    }, {
      test: /\.css$/,
      loader: 'style!css',
      include: path.join(__dirname, 'css')
    }]
  }
};

and devServer.js:

var path = require('path');
var express = require('express');
var webpack = require('webpack');
var config = require('./webpack.config.dev');

var app = express();
var compiler = webpack(config);

app.use(require('webpack-dev-middleware')(compiler, {
  noInfo: true,
  publicPath: config.output.publicPath
}));

app.use(require('webpack-hot-middleware')(compiler));
app.get('*', function(req, res) {
  res.sendFile(path.join(__dirname, '/public', 'index.html'));
});

app.listen(8080, 'localhost', function(err) {
  if (err) {
    console.log(err);
    return;
  }

  console.log('Listening at http://localhost:8080');
});

To run : "node devServer.js" command

Allow access to stream from Twitter, so we can see new tweets instantly.

{'query': 'some string'}

at the minimum, although obviously there'll be a lot more depth to it.
@VasilyShelkov comment as you get a better idea of what you want to send from #4
#46 will need to keep up with the latest version of this.

Two less files and plus I can't run them in Linux :( npm universal and shouldn't have problems running it right ?

Add header follow #5

Open up a Stream, when a new tweet arrives, display on map.

http://tweetping.net an example.

Finding a public rest API for football related information such as:
-> Teams
-> Players
-> Match Data

ability to use import/export rather than let x = require('x'); and not having to put "use strict" over every file.

To do this use gulp.

Also see https://github.com/arnarthor/node-es6-boilerplate for inspiration, checked it over and it neat and understandable about how to enable this as well as some other goodies 👍

Add geo location where available to the Tweets that are stored when a search query is made

(at least) 10 most active users and the main keywords associated with them Example:

< profile picture> @WayneRooney 25 tweets - most frequent words: pal(100), mate(100), ball(11), player(8)…

@lizziecundy tweets: 12 - most frequent words: game(12), what(11), gorgeous(8) …

This is the requirement from the assignment spec

Also make it a vbit prettier :)

Right now, the Search API only considers the first term we search for.
We need to be able to search on multiple queries at once, then either intersect (for) AND or union (for OR) the results.

E.g.
football (x)
. Football (x)
. FOOTBALL (x)

For a more finegrained view of words

This is currently mitigated in #84 by wrapping in a try/catch, but it's indicative of the code below not correctly checking before trying to access [0]

Live Stream tweats based on a randomly selected team of the day

for #4

MapDispatchToProps function and pass to connect redux function from SearchTermList and pass to props of 'TermItem' for delete and edit 'paramTypes'.

Style Search 'TermItem' to have appropriate @,#,from,keyword UI feedback to user of each TermItem depending on the paramTypes of its query prop

Being able to save the queries made by a user to be either alerted or quickly be able to use that saved query in future uses

Via Twitter (maybe facebook, google+) and just standard login with email/password

Just use Google Maps probably and drop pins on, but we'll check out other potential APIs.

Especially useful to people who want to know about transfers as soon as possible

query each search term individually to our DB and check the latest result if older than X then search twitter.

Two options on how to request searches:

1. We dispatch an action every place that we add searchQueryTerms
2. We dispatch 1 action for when the SearchQueryTerms component recieves a new term. So it's decoupled from the search filters and AddSearchTerm components.

I believe option two is the better.

subcomponet of #4

Category selections include:
Team
Player
League
Match ? maybe
Sensitivity (on/off)

Decouple it enough to allow for Tweets vs other types of post, but get a basic design out. We can make it look nicer later.

ie most used word Lemon = [LeMON, lemon, LeMoN]

currently can only hide/show the variants individual which means 3 clicks for user and 3 different actions

should be able to hide/show all variants with 1 click and 1 action since only advanced users are likely to care about the variants of the mostUsedWords

In the given query, who are the users who make up the most tweets? This is based on the given search query.

Per user, find the most used words - see #6.

Adding a pie-chart for this would be neat.

Add a filewatcher such as nodemon (https://github.com/remy/nodemon) so that during development don't have to keep killing the server and restarting for every little change made.

I recommend we have a series of input boxes that add an extra one as you type, so the user doesn't have to worry about typing AND and OR etc.

Also if we can have a name -> twitter account optional substitution that'd be cool. E.g. typing in "Wayne Rooney" recommends "Did you mean @WayneRooney?"

The retrieved queries need to be stored as:
-a source of data
-cache to reduce the number of queries to Twitter

GraphQL/Relational/NoSQL?

At the moment it does a dummy search, it should be using real data.

If this isn't written with complete test coverage I will 😢

Find what public APIs are available from Twitter.

Check out any convenient npm libraries like twit: https://www.npmjs.com/package/twit

at /search/:query
POST an object of this minimum form: {'query': 'some string'}, and it will return data from OrientDB.

Before returning, it MAY search Twitter (or Flickr, etc) for extra, more updated information using some heuristic.

• Component for the most active users based on the users with the most tweets in the results feed.
• Have a search action to be able to find particular users like in most used words
• Be able to filter the results by checkbox of user tweets like filtering most used words

Promises are resolved at the wrong times

See http://stackoverflow.com/questions/17887984/is-it-possible-to-get-more-than-100-tweets

From the data retrieved from #1 and also think about relating them to Tweeters where possible

Get semantic-UI setup and working for the project

React
Express
Babel for ES6
OrientDB
Webpack
Semantic-UI

Anything else @VasilyShelkov?

If a user logs in with Twitter, we can find out who they're following. We can then find out if any of those accounts are following people we know to be footballers or big football tweeters, and can recommend them.

Use Semantic-UI with React. 👍

Only add Redux if we know there's a good use for it.

Only run development server/middleware etc.. when NODE_ENV set to development otherwise if undefined run production.

This is to make sure it works on Lewin

Soccer -> octopus -> social

The Premier Social Soccer Graph

Use the Twit package for this, need to be able to run basic searches, maybe check out streaming.

This is so social media sites that have a lower userbase aren't always at the bottom of the results

When searching, a user should be able to tick a check box which says whether or not they want their query terms to result in intersected, or unioned results - e.g. more queries = more specific vs more general.

By default we'll choose OR.
#82

For the Twitter API search