A PREFERENTIAL VOTING SYSTEM AS A COLLABORATION SOFTWARE SOLUTION. A Thesis. Presented to the. Faculty of. San Diego State University

Transcription

1 A PREFERENTIAL VOTING SYSTEM AS A COLLABORATION SOFTWARE SOLUTION A Thesis Presented to the Faculty of San Diego State University In Partial Fulfillment of the Requirements for the Degree Master of Science in Computer Science by Abhiraj Shekhar Pande Spring 2014

2

3 iii Copyright 2014 by Abhiraj Shekhar Pande All Rights Reserved

4 iv DEDICATION I wish to dedicate the work of my Master s Thesis to my parents, brother, and sister for being supportive all through my life. I express my gratitude to them..

5 v ABSTRACT OF THE THESIS A Preferential Voting System as a Collaboration Software Solution by Abhiraj Shekhar Pande Master of Science in Computer Science San Diego State University, 2014 This Thesis project is targeted at providing software solutions to Collaboration issues. The server side of a Preferential Voting System is implemented in order to help achieve a common objective amongst people of different geographical regions, and people of different skill set. A database running on a server needs to communicate with the client in order to achieve the desired results. The back end of the project requires a comprehensive understanding of what the user intends to do. The commands retrieved through a User Interface is captured and interfaced to the web server with the help of the middleware. In this project, Flask microarchitecture which uses Python is made use of to process the job of the middleware.

6 vi TABLE OF CONTENTS PAGE ABSTRACT...v LIST OF TABLES... viii LIST OF FIGURES... ix ACKNOWLEDGMENTS...x CHAPTER 1 INTRODUCTION DESIGN AND METHODOLOGIES Overview Requirements Technology Development Environment IMPLEMENTATION ElasticSearch Sharding in ElasticSearch JSon Performance Gain Middleware Flask Register Log-in/Log-out Vote Results APP.PY CONCLUSION Conclusion Obstacles Faced FUTURE EVOLUTION...18

7 vii REFERENCES...19 APPENDIX SERVER SIDE SOURCE CODE OF PREFERENTIAL VOTING TOOL... 20

8 viii LIST OF TABLES PAGE Table 3.1. Schema for the Tool...7

9 ix LIST OF FIGURES PAGE Figure 2.1. Technology stack....4 Figure 3.1. ElasticSearch node structure as part of a cluster....7 Figure 3.2. CPU usage comparison of Solr and ElasticSearch Figure 3.3. Response times of Solr and ElasticSearch Figure 3.4. Typical web development structure Figure 3.5. Voting Tool structure Figure 3.6. Hello World in FLASK Figure 3.7. Registration feed to database Figure 3.8. Login and logout functionality in middleware Figure 3.9. Interaction with ElasticSearch for voting feature Figure Routing example....16

10 x ACKNOWLEDGMENTS I thank Dr. Carl Eckberg from the Computer Science department for serving as the Chair in my Thesis Committee. I thank Dr. Robert Briggs from the MIS department for giving me the opportunity to work with him. Last but not the least, I d like to thank Dr. William Root from the Computer Science department for serving as the third member in my committee. Thank you all for your guidance.

11 1 CHAPTER 1 INTRODUCTION Collaboration has always been practiced by groups in the field of research. Although it has been around for a long time, the methods of collaboration constantly keep changing. It used to be a case where inter-departments within universities collaborated to achieve a common task, but in the current day where innovation takes a higher precedence and the scope for the brightest minds getting together is greater than ever, the means of collaborating have evolved. A step to get the bright minds from all across the globe together is being taken here by implementing a Preferential Voting System as part of a Collaboration Software Solution. A massive advantage of collaborating is that a common goal can be achieved in a much shorter time span with its values being much higher than attained otherwise [1]. There are however its own disadvantages to collaboration. Often, group members are unable to comprehend the thinking of another team member while members are in different geographical locations. This indicates that in order for all members of a task team to understand what a particular member states or suggest, one needs to give an elaborate description behind the idea suggested. This generates a more structured approach indirectly without it actually being the intent. This way, member joining the task team later can go through previous records to get up to speed. This approach, although slightly time consuming, is more beneficial in the long run, and can be portrayed as an advantage of collaboration indeed. The Preferential Voting System implemented is a voting tool which will base a user s vote upon their preference. It could so happen that there are multiple right choices to a solution, but there could still be one way which is better than the other while not ruling out other options. In such a scenario, the Preferential Voting System comes in handy and it is this system that has been concentrated on in this report. The Preferential Voting System is targeted at a San Diego State University faculty member whose primary focus over several years has been in the domain of Collaboration.

12 The following is a quick summary of the sections covered in this Thesis report: Chapter 1: Talks about the pros and cons of collaboration, and the need for a voting tool. Chapter 2: Brief discussion of some of the methods involved in the implementation of the voting system. Chapter 3: Goes in depth about the back end of the tool Chapter 4: Conclusion along with obstacles experienced during the course of this project is mentioned Chapter 5: Refers to some additions to the tool that could take place 2

13 3 CHAPTER 2 DESIGN AND METHODOLOGIES 2.1 OVERVIEW The Preferential Voting System gets commands from the user through a GUI and the data is processed and maintained at the back end through an interface or a middleware. The middleware makes use of a Flask microarchitecture which uses Python language to communicate with the database on server. The idea of the project is to enable users vote on Ballot items. Features such as notification pop up along with comments for each ballot is implemented. 2.2 REQUIREMENTS The following are needed for the tool to run: 1 machine which runs the Python server 2 or more machines to run the ElasticSearch database A domain name 2.3 TECHNOLOGY Python o Using the ESClient library, it interacts with the ElasticSearch library o Provides interfacing between the front and the back-end ElasticSearch o Used to maintain and retrieve information in the server o Its features are made available via JSON 2.4 DEVELOPMENT ENVIRONMENT Python ElasticSearch Figure 2.1 shows the technology stack.

14 Figure 2.1. Technology stack. 4

15 5 CHAPTER 3 IMPLEMENTATION A database server is required to store and manipulate any kind of data that a web application deals with and to store the data in an organized fashion. Choosing the right kind of database is crucial to the tool s performance. It can also determine the complexity of the project and determine how scalable it could be. There are multiple databases available. For instance, MySQL, MSSQL, SAP, Oracle [2] are some of the most popular databases used in the industry. Choosing a database depends on the requirement as each and every database has its own advantages along with disadvantages. In our project, ElasticSearch database is being used. Keeping in mind future enhancements, performance, and speed, ElasticSearch database seemed ideal for our use. This is a relatively new technology compared to all of the databases mentioned earlier. Newer technology need not necessarily mean better technology. However, in this case, some of the features, which are mentioned as we go along in the report; that ElasticSearch possesses proves to be a strong enough reason for one to tilt towards using it. 3.1 ELASTICSEARCH ElasticSearch is a distributed search engine that is based on Apache Lucene [2]. Lucene is a search engine software library which has features such as ranked indexing, and rapid indexing. ElasticSearch divides the database into Shards Sharding in ElasticSearch A Shard is a horizontal division in a database or a search engine [3]. This is in contrast to vertical partitioning which is a database design principle where database is partitioned into columns. Each partition is a part of a Shard which in turn may be located on a separate server or a physical location [3]. In this approach, since the partitions are divided and segregated amongst multiple servers, the number of rows in an individual server is lesser. This in turn means there is lesser number of indexes, thereby making searches much quicker. Since the load is distributed amongst multiple machines, the performance is enhanced.

16 6 In ElasticSearch, while creating an index, multiple shards are asked to be created in a single machine. When another machine is started, ElasticSearch automatically moves those shards for us into the new machine. This concept basically is an overallocation of nodes. It is a common strategy and some architectures call it Virtual Nodes. Due to moving of shards, reindexing of data is not required and therefore performance is enhanced. Often, in databases like MYSQL, when the need is to add some more nodes to the cluster once 80-85% of the cluster space has been used, re-indexing for each of those extra nodes need to be done and this would eventually mean 120% or so of the cluster space is being used. This will make the entire cluster fall down. Such issues are negated with ElasticSearch. Replicas can be created on the fly. With every additional machine that is being started, shards are moved around in an appropriate fashion and the number of replicas can be increased as per implementation requirements. The size limit of a shard is not fixed. To arrive at an answer, multiple factors such as hardware the nodes are running on, memory allocated to the virtual machine, size of the documents, the type of the documents and the search implementation need to be taken into account. Unfortunately, it is not easy to compute this value. One possibility could be to implement one shard, and then load this shard with documents till its limit is reached. By default, ElasticSearch creates 5 shards for an index. With ElasticSearch shards, a small single user is relatively expensive on the resource to maintain since a single shard can hold a lot of documents or data. One way to solve this is to just have more nodes be part of the cluster. This therefore, is very scalable. Another approach would be to allocate the same index to multiple users across the cluster. A single index is created per user and this way, searching becomes more feasible as users would want to search for their data and not all data in the server. An example of this is Google Mail. This gives rise to the Filtering feature offered in ElasticSearch. A user is given an alias name, which is effectively the user id, and this is associated with a user index. A filter is associated with this and just the data that is relevant to that particular user is retrieved. With a particular alias name, relevant routing and filtering is automatically taken care of by ElasticSearch. If multiple aliases are present, then the filtering is applied and just the shards that are relevant is looked at as part of a search.

17 7 The database schema looks more or less like the following (see Table 3.1). Table 3.1. Schema for the Tool User userid First Name Last Name password_encrypted Metadata ballots createdby ballotid ballot_options userid voted_ballots vote_information Polldata ballotid options createdby Below shown in Figure 3.1 [4] is the structure of the database node. Figure 3.1. ElasticSearch node structure as part of a cluster. Source: Twan Wolthof. Extended Abstract. Xeago.nl, n.d. accessed Nov

18 JSon JSon is native to JavaScript, however, it is also language independent. XML is often used to communicate between web servers and the client side. JSon is an alternate to it. With our implementation, it is a massive performance gain by using JSon since we have a lot of JavaScript involved. This makes the application lightweight by using JSon. An object can have infinite depth to the data it stores and JSon categorizes this in a comfortable fashion for us. The data from the server is served back to the client side in JSon format. To get a better understanding of JSon, here are certain comparisons between JSon and XML. With support to different types, JSon can add just traditional data types whereas XML supports any format such as audio, video, and many more. When it comes to security however, JSon is more secure since XML may contain an executable file. As of data storage, XML stores data as a tree format and JSon stores it as arrays and records. Data transfers are much easier to languages that support object oriented programming like Python and that is another reason why JSon has been the way we import data Performance Gain Solr is a search engine that is popular. Therefore, a comparison between Solr and ElasticSearch would depict the superiority of one over the other. Solr is based on the Apache Lucene project too. Similar to ElasticSearch, Solr supports both XML and JSon, and is written in Java. Speed tests made are shown below indicating that ElasticSearch seems to query data in much quicker time than Solr. Another comparison between the two is when it comes to CPU usage. Due to ElasticSearch s lightweight capabilities, it does not occupy or need as much CPU attention as Solr. Figure 3.2 [5] shows CPU usage of databases. Figure 3.3 [5] clearly shows that ElasticSearch s response times are quicker. 3.2 MIDDLEWARE The middleware links the front end of the tool to the back end. The middleware typically has a server of its own. Front end servers act as the middleware on most systems. This is a server that is dedicated to the technologies used in the middleware. They communicate with the back end server. The front end servers query the back-end servers directly. The problem with such a structure is that they have many drawbacks. Mentioning some of them will give the reader a

19 9 Figure 3.2. CPU usage comparison of Solr and ElasticSearch. Source: Jack Chen. Moving the Market Places to ElasticSearch, Envato, accessed Dec Figure 3.3. Response times of Solr and ElasticSearch. Source: Jack Chen. Moving the Market Places to ElasticSearch, Envato, accessed Dec

20 10 better picture of the reason behind the structure chosen behind the current voting tool. Firstly, the system is hard to be completely distributed since multiple servers lie across multiple layers. Scalability is an issue when there is more than the required number of layers in the system along with more resources being required too. The programming code itself tends to get a little more convoluted than needed and this will certainly not help the scalability issue or any bug fix. Figure 3.4 shows the typical database structures and the used one. Figure 3.4. Typical web development structure. How this system has changed is mentioned in Figure 3.5. The job that I had to focus on is to make the middleware as light and thin as possible Flask Flask is the micro-framework that is used in the middle of this system. Unlike typical frameworks where multiple features are bundled into the same system, thereby making it a heavy framework to work with, Flask on the other hand has enough number of features to make a quality tool by having a light middleware. It makes use of RESTful url mapping. Log-in and log-out capabilities are simpler to use. Also, it inhibits the quality of

21 11 Figure 3.5. Voting Tool structure. session based cookies. By session based cookies, it means that the cookies are erased when the browser is closed by the user [6]. There exists a buffer in the system whose purpose is to store cookies of browsing sessions. The framework is written in Python programming language. It imports libraries such as Werkzeug WSGI and Jinja2. Below is a Hello World program that is written in Python with the Flask api (see Figure 3.6) Register Registration is required before the tool can be accessed by the user. The user sees four fields that need to be filled. Once the values have been entered, the following code executes (see Figure 3.7). The return value, resp is a response object which happens to be an instance of response_class is obtained from a view function [7]. The make_response method can take one of the four possible parameters. It can be either a string as the body, or a Unicode, or a method of WSGI, or a tuple that is of the order (response, status, headers) [7]. Here, we make use of a WSGI function redirect.

22 12 Figure 3.6. Hello World in FLASK. def register1234(): print "svs" resp = make_response(redirect('/dashboard')) return resp Figure 3.7. Registration feed to database Log-in/Log-out Both the log-in and the log-in functionality are taken care in the home.py file. Once the user enters the credential information, the html code interacts with the middleware, which is here the Python code, makes use of the routing file, and lands in the home.py file. Middleware functionality of login and logout methods are shown in Figure 3.8. The user id is chosen by the user and this is stored as username. This username is requested for with the help pf the request.form.get method. The http code that this python file deals has a form implementation. Therefore a form request is sent out. Similar to the username, the password is also obtained. Cookies store the information about the log-in session and not the information about the user itself. Therefore, personal data is not compromised. It is merely an

23 13 def login(): username = request.form.get("username") password = request.form.get("password") resp = make_response(redirect('/dashboard')) resp.set_cookie('username', username) return resp def logout(): resp = make_response(redirect('/dashboard')) resp.delete_cookie('username') return resp Figure 3.8. Login and logout functionality in middleware. addition to browsers so they can pull up session much quick in case of abnormal termination or accidental termination of the session. The cookie is set for the user that has logged in making use of the username. Once the user id and password has been retrieved, the make_redirect method routes the user to the home page of the tool. During log-out, the complete opposite of the log-in occurs. Since Flask makes use of session based cookies, the cookie that is stored is deleted once the user logs out. The cookie however remains if the user has not logged out or if the browser closes without the user logging out Vote The feature of voting in this tool is one of its primary features. Before a ballot can be voted on, a list of ballot names is retrieved from the database. It is possible that multiple users do not want to vote on each and every ballot that exists. Rather, they might want to vote on just a few ballots or also in a case where priorities for voting have been set, this method of yielding the entire list of ballot not voted upon makes sense. All of the ballots that have already been voted on will directly go into the Results page. The getballotlist method takes care of retrieving the ballot list. This method will in turn call the getballotcompletelist method which does the job of interacting with the server.

24 14 In the getballotcompletelist method, the votedids will hold the id s of ballots that have been voted on. The user name associated is obtained too. If the id is not part of the votedids, then that id needs to be part of polldata which effectively stores all ballots that the user needs to vote on. The ballots in the ballot list are sorted alphabetically to help users find the ballot they are looking for more easily. Each ballot in the ballot list has a corresponding id. This id is obtained by using the request method. The id is obtained from an array. If the id does not exist, then the voting home page is displayed. The ballot for a particular user is obtained. The user name of the user needs to be obtained for this purpose with the help of another request method. Having the user name and the id to be retrieved, we now know what ballot items to get and display out for voting. All ballot items are stored as an array and these array indices are accessed to get the ballot for voting to the user. An instruction that only unique values need to be given to each ballot item is displayed to negate any ambiguity that might exist. Once the ballot information is obtained, then the user will vote on it. For the vote to be stored in the database, another method called the postvote method is called. Variables take in all the values entered by the user in the voting page after going inside a particular ballot. ESClient is used to know the IP address of the machine where the database resides in. If there is no url, then it is the IP address of the server that all the users need to use in order to access the web application. The users would then have to be hooked on to the same network as well have the same IP address. This means that it is possible for multiple users to access the tool without having to go to a website name. Voting code is shown in Figure 3.9. ESClient is a Python library which is totally lightweight and it makes use of the RESTful approach. This is a library that interacts with the ElasticSearch database making it ideal for use in our case. It comes with a couple of scripts along with the ESClient package. They are esdump and esimport [8]. The ESClient library needs to be installed too as part of the middleware server. While storing the user entered preferences in the database, the result for each of the option will be a cumulative sum of all the preferences also entered by other users. The current user value would add on to this value and is then stored with the updated value. The following is a code snippet of the previous elaboration. value1 += int(options.get(option1))

25 15 def getballot(): id = request.args.keys()[0] if not id: return render_template ( "pages/vote/vote.html", ballot=none, username = request.cookies.get('username') ) ballot = getballotfromid(id) if (ballot is not None): print "SVS*****######" print request.args.keys()[0] print ballot return render_template( "pages/vote/vote.html", ballot=ballot, username = request.cookies.get('username') ) else: return render_template( "pages/vote/vote.html", ballot=none, username = request.cookies.get('username') ) Figure 3.9. Interaction with ElasticSearch for voting feature. The same happens for every ballot item. The id will specify which ballot to go post all of these values against. The JSON structure is used in the database to store all these for individual id s Results The results are viewed as a bar chart with the help of Google libraries. A list of every ballot that has been created by every user of the tool is displayed in alphabetical order. The user selects the ballot for which the user needs to see the results. The getresultlist method which in turn calls the getresultsobject method takes care of this feature of retrieving the ballot list. Regardless of whether the ballot has been voted upon or not, the ballot is visible in the Results tab as long as a user has created it. Every id that is associated with a ballot is obtained with the help of the following code. ids = result['hits']['hits'][0]['fields'].get("ids") The sorting of the retrieved ballots is done with the help of the following line of code.

26 16 sorteddata = sorted(polldata, key=lambda k: ( k['name'] ) ) Now, for viewing the specific result for a particular ballot, the job is to retrieve the cumulated ranks of every option from the ballot and displays it as a chart. getresults and getresutsobjectfromkey methods exist for the same purpose. If the id has not been voted on, then just the result page with a chart is displayed without any ranks being retrieved since there are no ranks assigned. Therefore, no reading of ranks is required. An empty graph with options written on the sides indicating that the ballot has not been voted on is seen. The rank for every ballot that has been voted on is retrieved. Each rank is given a particular value on graph. The lower the rank number, the higher the graph value. Therefore, rank 1 would have the highest value on graph, implying the bar on chart is the longest APP.PY The most important functionality of the Flask API is providing independent routing. The freedom to route the html code to the back end as per the programmers will is a major bonus and that has been exploited to the fullest here. There have been multiple routes that have been created in this tool. They are for the landing page, login page, register page, logout page, results page, create ballot page, ballot list page, vote page, submit vote page, and submit ballot page. The routing files specifically says which python code is to be implemented by mentioning the file name and also the function name for any particular html code. Below is a code snippet for the results page routing (see Figure 3.10). ## Results app.add_url_rule('/results', view_func=results.getresults) app.add_url_rule('/resultslist', view_func=results.getresultslist) Figure Routing example.

27 17 CHAPTER 4 CONCLUSION 4.1 CONCLUSION The Preferential Voting ballot tool is a collaboration software tool. It makes use of some of the most up to date technologies in the market such as the database being used in ElasticSearch or be it the middleware which makes use of the Flask micro-framework that has a RESTful approach in its core. It makes use of the ESClient to make sure the middleware is made light while interacting with the backend. JSon on the other hand helps reduce the amount of code required to be written since there are no queries that are required. The tool in itself does the job of voting in a preferential order and gives the user enough power to choose on items that are related to his or her interests. The tool has been developed in a manner that future enhancements can be done with the minimal of effort and it has been made sure that compatibility with various machines is not a problem. The simplicity of the coding makes debugging easier and the coding standards have in our opinion been exceptional. The Appendix has the server side source code of the tool. 4.2 OBSTACLES FACED There have been multiple obstacles that had to be successfully encountered. Here are some of the most important of them. The ability to program thinking on the lines of scalability was hard. Technology compatibility and feasibility was another issue faced. It had to be made sure that all technologies we used was available and at the same time, the complexity to use each of them needed to be at its bare minimum to help development and also tweaking. Remotely working on joint projects is a little more time consuming when compared to working in tandem from the same location. Synchronization plays a vital factor and sticking to schedules is ever more crucial than ever before.

28 18 CHAPTER 5 FUTURE EVOLUTION A collaboration tool can have multiple features within it. Enhancements can be made fairly easily as the base has been set up well enough. A comment bar so users can express their opinions on a particular issue about a ballot or a ballot item Uploading of files to help improve understandability of the concerns of a user to the administrator or to other members of the tool To make usability at it s easiest, an application for smartphones can be created where upon any activity related to a users ballot, a notification can be made to pop up. Although fairly ambitious given the scope of the project, the capability for enhancement is immense.

29 19 REFERENCES [1] Robert O. Briggs. Facilitator-in-a-Box: Process support applications to help practitioners realize the potential of collaboration technology. Journal of Management Information Systems, 20: 4, [2] Wikipedia. Database, accessed Dec [3] Wikipedia. Shard (database architecture), accessed Nov [4] Twan Wolthof. Extended Abstract. Xeago.nl, n.d. accessed Nov [5] Jack Chen. Moving the Market Places to ElasticSearch, Envato, accessed Dec [6] Quinstreet. Session Cookie, Webopedia, n.d. accessed Dec [7] Armin Ronacher. API, Flask, n.d. accessed Nov [8] Github. ESClient, n.d. accessed Dec

30 20 APPENDIX SERVER SIDE SOURCE CODE OF PREFERENTIAL VOTING TOOL

31 21 from flask import Flask from flask import request from.routes import * from. import settings locale.setlocale(locale.lc_all, '') # empty string for platform's default setting app = Flask( import_name= name, template_folder=settings.template_folder, static_folder=settings.static_folder, static_url_path=settings.static_url_path) # Routes app.debug = True ## Landing page. app.add_url_rule('/', view_func=home.landingpage) ## Login app.add_url_rule('/login', view_func=home.login, methods=['post']) ## Register app.add_url_rule('/registrationpage', view_func=home.registerpage ) app.add_url_rule('/register1234', view_func=home.register1234, methods=['post']) ## Logout app.add_url_rule('/logout', view_func=home.logout ) ## Dashboard app.add_url_rule('/dashboard', view_func=dashboard.initialize) ## Results app.add_url_rule('/results', view_func=results.getresults) app.add_url_rule('/resultslist', view_func=results.getresultslist) ## create ballot app.add_url_rule( '/createballot', view_func=ballot.getballotpage ) ## ballot list app.add_url_rule( '/ballotlist', view_func= vote.getballotlist ) ## vote app.add_url_rule( '/vote', view_func=vote.getballot ) # submit vote app.add_url_rule('/vote/postvote', view_func=vote.postvote, methods=['post'])

32 22 # submit ballot app.add_url_rule('/createballot/postballot', view_func=ballot.postballot, methods=['post']) # Main app.secret_key = settings.secret_key def landingpage(): """Homepage for the tool. Shows a list collections and build summary page.""" if 'username' in request.cookies: ##return render_template("pages/results/stats.html", username = request.cookies.get('username')) resp = make_response(redirect('/ballotlist')) return resp return render_template("pages/home/login.html") def registerpage(): return render_template("pages/home/register.html") def login(): username = request.form.get("username") password = request.form.get("password") esclient = ESClient("localhost:9200") query_string_args = { "q": "_id:{}".format( "1" ), "fields" : "{}".format( username ), "timeout":10 } print query_string_args result = esclient.search(query_string_args=query_string_args, indexes=['manhattan'], doctypes=['polldata']) print "##########SVS############********" try: password_original = result['hits']['hits'][0]['fields'][username]['password'] except KeyError: print "oops wrong id" return render_template("pages/home/login.html") if ( password_original!= password ): return render_template("pages/home/login.html") resp = make_response(redirect('/ballotlist')) resp.set_cookie('username', username) return resp def register1234():

33 23 print "svs" esclient = ESClient("localhost:9200") username = request.form.get("username") password = request.form.get("password") userparams = { username : { "votedids" : [], "password" : password } } print userparams esclient.index('manhattan','polldata',body=userparams,docid="1", op_type="update") print "Sri Venkatesh Stotram" return render_template("pages/home/login.html") def register(): print "svs" esclient = ESClient("localhost:9200") username = request.form.get("username") password = request.form.get("password") userparams = { username : { "votedids" : [] } } esclient.index('manhattan','polldate',body=userparams,docid="1", op_type="update") print "Sri Venkatesh Stotram" resp = make_response(redirect('/login')) return resp def logout(): resp = make_response(redirect('/dashboard')) resp.delete_cookie('username') return resp def register(): username = request.form.get("username") password = request.form.get("password") resp = make_response(redirect('/login')) return resp def _issuehttprequest( requesttype, uri, body=none, validresponses=[] ): headers = {"Content-type" : "application/json", "Accept" : "*/*" }

34 24 connection = httplib.httpconnection( "localhost:5001" ) try: INFO( "{} {}:{}/{}".format( requesttype, connection.host, connection.port, uri ) ) connection.request( requesttype, uri, body, headers ) response = connection.getresponse() responsetext = response.read() if response.status not in [httplib.ok] + validresponses: errmsg = "Failed: {} {} ({}:{})\nmessage:{}".format( requesttype, uri, connection.host, connection.port, responsetext ) raise Error.HttpError( response.status, response.reason, errmsg ) return responsetext finally: connection.close() from flask import render_template from flask import request from flask import redirect import json import time import httplib from..models.esclient import ESClient from flask import make_response def getballotlist(): ballotlist = getballotcompletelist() if (ballotlist is not None): print "SVS*****######" print ballotlist return render_template( "pages/vote/ballotlist.html", ballotlist=ballotlist, username = request.cookies.get('username') ) else: return render_template( "pages/vote/ballotlist.html", ballotlist=none, username = request.cookies.get('username') ) def getballot(): id = request.args.keys()[0] if not id: return render_template( "pages/vote/vote.html", ballot=none, username = request.cookies.get('username') ) ballot = getballotfromid(id) if (ballot is not None): print "SVS*****######" print request.args.keys()[0]

35 25 print ballot return render_template( "pages/vote/vote.html", ballot=ballot, username = request.cookies.get('username') ) else: return render_template( "pages/vote/vote.html", ballot=none, username = request.cookies.get('username') ) def getballotfromid( id ): esclient = ESClient("localhost:9200") query_string_args = { "q": "_id:{}".format( id ), "fields" : "name,createdby,options,_id", "timeout":10 } result = esclient.search(query_string_args=query_string_args, indexes=['manhattan'], doctypes=['polldata']) print id if ( int(result['hits']['total']) < 1): return None print "**********SVS************" print result poll = result['hits']['hits'][0]['fields'] poll['_id'] = id return poll def getballotobject(): username = request.cookies.get('username') esclient = ESClient("localhost:9200") query_string_args = { "q": "_id:{}".format( "1" ), "fields" : "ids,{}".format( username ), "timeout":10 } print query_string_args result = esclient.search(query_string_args=query_string_args, indexes=['manhattan'], doctypes=['polldata']) ids = result['hits']['hits'][0]['fields'].get("ids") votedids = result['hits']['hits'][0]['fields'].get(username).get("votedids") print votedids for id in ids: print id if ( votedids is None ): continue if ( id in votedids ): continue query_string_args = {

36 26 "q": "_id:{}".format( id ), "fields" : "name,createdby,options,_id", "timeout":10 } result = esclient.search(query_string_args=query_string_args, indexes=['manhattan'], doctypes=['polldata']) print id if ( int(result['hits']['total']) < 1): continue print "**********SVS************" print result poll = result['hits']['hits'][0]['fields'] poll['_id'] = id return poll break return None def getballotcompletelist(): polldata = [] username = request.cookies.get('username') esclient = ESClient("localhost:9200") query_string_args = { "q": "_id:{}".format( "1" ), "fields" : "ids,{}".format( username ), "timeout":10 } print query_string_args result = esclient.search(query_string_args=query_string_args, indexes=['manhattan'], doctypes=['polldata']) ids = result['hits']['hits'][0]['fields'].get("ids") votedids = result['hits']['hits'][0]['fields'].get(username).get("votedids") print votedids for id in ids: print id if ( votedids is None ): continue if ( id in votedids ): continue query_string_args = { "q": "_id:{}".format( id ), "fields" : "name,createdby,options,_id", "timeout":10 } result = esclient.search(query_string_args=query_string_args, indexes=['manhattan'], doctypes=['polldata']) print id

37 27 if ( int(result['hits']['total']) < 1): continue print "**********SVS************" print result poll = result['hits']['hits'][0]['fields'] poll['_id'] = id polldata.append( poll ) sorteddata = sorted(polldata, key=lambda k: ( k['name'] ) ) ##sorteddata = sorted(polldata, key=lambda k: ( len ( k['name'] ) ) ) return sorteddata def postvote(): print "**********svs**********" username = request.cookies.get('username') ballotid = request.form.get('ballotid') option1 = request.form.get("option1") option2 = request.form.get("option2") option3 = request.form.get("option3") option4 = request.form.get("option4") value1 = 5-int(request.form.get("value1")) value2 = 5-int(request.form.get("value2")) value3 = 5-int(request.form.get("value3")) value4 = 5-int(request.form.get("value4")) esclient = ESClient("localhost:9200") query_string_args = { "q": "_id:{}".format( ballotid ), "fields" : "options", "timeout":10 } result = esclient.search(query_string_args=query_string_args, indexes=['manhattan'], doctypes=['polldata']) options = result['hits']['hits'][0]['fields'].get("options") print str(option1) print "****############ SVS" print ballotid value1 += int(options.get(option1)) print value1 value2 += int(options.get(option2)) print value2 value3 += int(options.get(option3)) print value3 value4 += int(options.get(option4)) print value4 ballotparams = {

38 28 "options" : { option1 : value1, option2 : value2, option3 : value3, option4 : value4 } } esclient.index('manhattan','polldata',body=ballotparams,docid=ballotid, op_type="update") print "Elastic return value:"+ esclient.last_response.text listparams = { "script" : "ctx._source.{}.votedids += id".format(username), "params" : { "id" : ballotid } } _issuehttprequest( "POST", "/manhattan/polldata/{}/_update".format( 1 ), body=json.dumps(listparams), validresponses=[httplib.no_content] ) resp = make_response(redirect('/results?{}'.format(ballotid))) return resp ## return redirect ('/results?{}'.format(ballotid)) def _issuehttprequest( requesttype, uri, body=none, validresponses=[] ): headers = {"Content-type" : "application/json", "Accept" : "*/*" } connection = httplib.httpconnection( "localhost:9200" ) try: connection.request( requesttype, uri, body, headers ) response = connection.getresponse() responsetext = response.read() if response.status not in [httplib.ok] + validresponses: errmsg = "Failed: {} {} ({}:{})\nmessage:{}".format( requesttype, uri, connection.host, connection.port, responsetext ) ##raise Error.HttpError( response.status, response.reason, errmsg ) return responsetext finally: connection.close() def getresults(): ##return render_template( "pages/results/view_results.html" ) id = request.args.keys()[0]

39 29 if not id: return render_template( "pages/results/resultslist.html", ballot=none, username = request.cookies.get('username') ) polldata = getresultsobjectfromkey(id) print polldata return render_template( "pages/results/stats.html", polldata = polldata, username = request.cookies.get('username') ) def getresultslist(): ##return render_template( "pages/results/view_results.html" ) polldata = getresultsobject() print polldata return render_template( "pages/results/resultslist.html", polldata = polldata, username = request.cookies.get('username') ) def getresultsobject(): esclient = ESClient("localhost:9200") query_string_args = { "q": "_id:{}".format( "1" ), "fields" : "ids", "timeout":10 } result = esclient.search(query_string_args=query_string_args, indexes=['manhattan'], doctypes=['polldata']) ids = result['hits']['hits'][0]['fields'].get("ids") print result polldata = [] for id in reversed(ids): query_string_args = { "q": "_id:{}".format( id ), "fields" : "name,createdby,options,_id", "timeout":10 } result = esclient.search(query_string_args=query_string_args, indexes=['manhattan'], doctypes=['polldata']) print id if ( int(result['hits']['total']) < 1): continue print "**********SVS************" print result poll = result['hits']['hits'][0]['fields'] poll['_id'] = id polldata.append(poll) print polldata sorteddata = sorted(polldata, key=lambda k: ( k['name'] ) )

40 30 print "****svs*******" return sorteddata def getresultsobjectfromkey(id_url): esclient = ESClient("localhost:9200") query_string_args = { "q": "_id:{}".format( "1" ), "fields" : "ids", "timeout":10 } result = esclient.search(query_string_args=query_string_args, indexes=['manhattan'], doctypes=['polldata']) ids = result['hits']['hits'][0]['fields'].get("ids") print result polldata = [] for id in [id_url]: query_string_args = { "q": "_id:{}".format( id ), "fields" : "name,createdby,options,_id", "timeout":10 } result = esclient.search(query_string_args=query_string_args, indexes=['manhattan'], doctypes=['polldata']) print id if ( int(result['hits']['total']) < 1): continue print "**********SVS************" print result poll = result['hits']['hits'][0]['fields'] poll['_id'] = id polldata.append(poll) print polldata sorteddata = sorted(polldata, key=lambda k: ( k['name'] ) ) print "****svs*******" return sorteddata