1package main
  2
  3import (
  4	"encoding/json"
  5	"fmt"
  6	"net/http"
  7	"sort"
  8	"strconv"
  9	"time"
 10
 11	"gopkg.in/mgo.v2/bson"
 12
 13	"github.com/gorilla/mux"
 14)
 15
 16type Routes []Route
 17
 18var routes = Routes{
 19	Route{
 20		"Index",
 21		"GET",
 22		"/",
 23		Index,
 24	},
 25	Route{
 26		"AllAddresses",
 27		"Get",
 28		"/alladdresses",
 29		AllAddresses,
 30	},
 31	Route{
 32		"GetLastAddr",
 33		"Get",
 34		"/lastaddr",
 35		GetLastAddr,
 36	},
 37	Route{
 38		"GetLastTx",
 39		"Get",
 40		"/lasttx",
 41		GetLastTx,
 42	},
 43	Route{
 44		"AddressNetwork",
 45		"GET",
 46		"/address/network/{address}",
 47		AddressNetwork,
 48	},
 49	Route{
 50		"AddressSankey",
 51		"GET",
 52		"/address/sankey/{address}",
 53		AddressSankey,
 54	},
 55	Route{
 56		"NetworkMap",
 57		"Get",
 58		"/map",
 59		NetworkMap,
 60	},
 61	Route{
 62		"GetTotalHourAnalysis",
 63		"Get",
 64		"/totalhouranalysis",
 65		GetTotalHourAnalysis,
 66	},
 67	Route{
 68		"GetLast24HourAnalysis",
 69		"Get",
 70		"/last24hour",
 71		GetLast24HourAnalysis,
 72	},
 73}
 74
 75//ROUTES
 76
 77func Index(w http.ResponseWriter, r *http.Request) {
 78	fmt.Fprintln(w, "ask for recommendations in /r")
 79	//http.FileServer(http.Dir("./web"))
 80}
 81
 82/*
 83func NewUser(w http.ResponseWriter, r *http.Request) {
 84	ipFilter(w, r)
 85	decoder := json.NewDecoder(r.Body)
 86	var newUser UserModel
 87	err := decoder.Decode(&newUser)
 88	check(err)
 89	defer r.Body.Close()
 90
 91	saveUser(userCollection, newUser)
 92
 93	fmt.Println(newUser)
 94	fmt.Fprintln(w, "new user added: ", newUser.ID)
 95}
 96*/
 97func AllAddresses(w http.ResponseWriter, r *http.Request) {
 98	ipFilter(w, r)
 99
100	nodes := []NodeModel{}
101	iter := nodeCollection.Find(bson.M{"type": "address"}).Limit(10000).Iter()
102	err := iter.All(&nodes)
103
104	//convert []resp struct to json
105	jsonNodes, err := json.Marshal(nodes)
106	check(err)
107
108	fmt.Fprintln(w, string(jsonNodes))
109}
110func GetLastAddr(w http.ResponseWriter, r *http.Request) {
111	ipFilter(w, r)
112
113	addresses := []AddressModel{}
114	err := addressCollection.Find(bson.M{}).Limit(10).Sort("-$natural").All(&addresses)
115	check(err)
116
117	//convert []resp struct to json
118	jsonResp, err := json.Marshal(addresses)
119	check(err)
120
121	fmt.Fprintln(w, string(jsonResp))
122}
123func GetLastTx(w http.ResponseWriter, r *http.Request) {
124	ipFilter(w, r)
125
126	txs := []TxModel{}
127	err := txCollection.Find(bson.M{}).Limit(10).Sort("-$natural").All(&txs)
128	check(err)
129
130	//convert []resp struct to json
131	jsonData, err := json.Marshal(txs)
132	check(err)
133
134	fmt.Fprintln(w, string(jsonData))
135}
136func AddressNetwork(w http.ResponseWriter, r *http.Request) {
137	ipFilter(w, r)
138
139	vars := mux.Vars(r)
140	address := vars["address"]
141	if address == "undefined" {
142		fmt.Fprintln(w, "not valid address")
143	} else {
144		network := addressTree(address)
145
146		//convert []resp struct to json
147		jNetwork, err := json.Marshal(network)
148		check(err)
149
150		fmt.Fprintln(w, string(jNetwork))
151	}
152}
153func AddressSankey(w http.ResponseWriter, r *http.Request) {
154	ipFilter(w, r)
155	vars := mux.Vars(r)
156	address := vars["address"]
157	if address == "undefined" {
158		fmt.Fprintln(w, "not valid address")
159	} else {
160		network := addressTree(address)
161		var sankey SankeyModel
162
163		fmt.Println("network generated")
164		mapNodeK := make(map[string]int)
165		for k, n := range network.Nodes {
166			var sankeyNode SankeyNodeModel
167			//sankeyNode.StringNode = n.Id
168			sankeyNode.Node = k
169			sankeyNode.Name = n.Id
170			sankey.Nodes = append(sankey.Nodes, sankeyNode)
171			mapNodeK[n.Id] = k
172		}
173		for _, e := range network.Edges {
174			var sankeyLink SankeyLinkModel
175			//sankeyLink.StringSource = e.From
176			sankeyLink.Source = mapNodeK[e.From]
177			//sankeyLink.StringTarget = e.To
178			sankeyLink.Target = mapNodeK[e.To]
179			sankeyLink.Value = e.Label
180			sankey.Links = append(sankey.Links, sankeyLink)
181		}
182		fmt.Println("Sankey generated")
183
184		//convert []resp struct to json
185		jsonSankey, err := json.Marshal(sankey)
186		check(err)
187
188		fmt.Fprintln(w, string(jsonSankey))
189	}
190}
191func NetworkMap(w http.ResponseWriter, r *http.Request) {
192	ipFilter(w, r)
193
194	nodes, err := getAllNodes()
195	check(err)
196	edges, err := getAllEdges()
197	check(err)
198
199	var network NetworkModel
200	network.Nodes = nodes
201	network.Edges = edges
202
203	//convert []resp struct to json
204	jNetwork, err := json.Marshal(network)
205	check(err)
206
207	fmt.Fprintln(w, string(jNetwork))
208}
209
210func GetTotalHourAnalysis(w http.ResponseWriter, r *http.Request) {
211	ipFilter(w, r)
212
213	hourAnalysis := []HourCountModel{}
214	iter := hourCountCollection.Find(bson.M{}).Limit(10000).Iter()
215	err := iter.All(&hourAnalysis)
216
217	//sort by hour
218	sort.Slice(hourAnalysis, func(i, j int) bool {
219		return hourAnalysis[i].Hour < hourAnalysis[j].Hour
220	})
221
222	var resp HourAnalysisResp
223	for _, d := range hourAnalysis {
224		resp.Labels = append(resp.Labels, d.Hour)
225		resp.Data = append(resp.Data, d.Count)
226	}
227
228	//convert []resp struct to json
229	jsonResp, err := json.Marshal(resp)
230	check(err)
231	fmt.Fprintln(w, string(jsonResp))
232}
233
234func GetLast24HourAnalysis(w http.ResponseWriter, r *http.Request) {
235	ipFilter(w, r)
236
237	fromDate := time.Now().AddDate(0, 0, -1)
238	toDate := time.Now()
239
240	txs := []TxModel{}
241	err := txCollection.Find(bson.M{
242		"datet": bson.M{
243			"$gt": fromDate,
244			"$lt": toDate,
245		},
246	}).Sort("-$natural").All(&txs)
247	check(err)
248
249	hourFrequencies := make(map[int]int)
250	for _, tx := range txs {
251		hourFrequencies[tx.Date.Hour]++
252	}
253	var hourCount []HourCountModel
254	for hour, frequency := range hourFrequencies {
255		hourCount = append(hourCount, HourCountModel{strconv.Itoa(hour), frequency})
256	}
257	//sort by hour
258	sort.Slice(hourCount, func(i, j int) bool {
259		return hourCount[i].Hour < hourCount[j].Hour
260	})
261
262	var resp HourAnalysisResp
263	for _, d := range hourCount {
264		resp.Labels = append(resp.Labels, d.Hour)
265		resp.Data = append(resp.Data, d.Count)
266	}
267
268	//convert []resp struct to json
269	jsonResp, err := json.Marshal(resp)
270	check(err)
271	fmt.Fprintln(w, string(jsonResp))
272}