markers = accidents.all()

if not is_thin:

markers += discussions.all()

yield '{"markers": ['

is_first = True

for marker in markers:

if is_first:

is_first = False

prefix = ''

else:

prefix = ','

yield prefix + json.dumps(marker.serialize(is_thin))

output_file = StringIO()

yield output_file.getvalue()

output_file.truncate(0)

output = None

for marker in results.all():

serialized = marker.serialize()

if not output:

output = csv.DictWriter(output_file, serialized.keys())

output.writeheader()

row = {k: v.encode('utf8')

if type(v) is unicode else v

for k, v in serialized.iteritems()}

output.writerow(row)

yield output_file.getvalue()

logging.debug('getting markers')

ne_lat = float(request.values['ne_lat'])

ne_lng = float(request.values['ne_lng'])

sw_lat = float(request.values['sw_lat'])

sw_lng = float(request.values['sw_lng'])

zoom = int(request.values['zoom'])

start_date = datetime.date.fromtimestamp(int(request.values['start_date']))

end_date = datetime.date.fromtimestamp(int(request.values['end_date']))

fatal = int(request.values['show_fatal'])

severe = int(request.values['show_severe'])

light = int(request.values['show_light'])

inaccurate = int(request.values['show_inaccurate'])

show_markers = bool(request.values['show_markers'])

show_discussions = bool(request.values['show_discussions'])

logging.debug('querying markers in bounding box')

is_thin = (zoom < MINIMAL_ZOOM)

accidents = Marker.bounding_box_query(ne_lat, ne_lng, sw_lat, sw_lng,

start_date, end_date,

fatal, severe, light, inaccurate,

show_markers, is_thin, yield_per=50)

discussions = DiscussionMarker.bounding_box_query(ne_lat, ne_lng,

sw_lat, sw_lng, show_discussions)

if request.values.get('format') == 'csv':

return Response(generate_csv(accidents), headers={

"Content-Type": "text/csv",

"Content-Disposition": 'attachment; filename="data.csv"'

})

else: # defaults to json

return Response(generate_json(accidents, discussions,

is_thin),

involved = db_session.query(Involved).filter(Involved.accident_id == marker_id)

vehicles = db_session.query(Vehicle).filter(Vehicle.accident_id == marker_id)

list_to_return = list()

for inv in involved:

obj = inv.serialize()

obj["age_group"] = lms_dictionary.get((92, obj["age_group"]))

obj["population_type"] = lms_dictionary.get((66, obj["population_type"]))

obj["home_district"] = lms_dictionary.get((77, obj["home_district"]))

obj["home_nafa"] = lms_dictionary.get((79, obj["home_nafa"]))

obj["home_area"] = lms_dictionary.get((80, obj["home_area"]))

obj["home_municipal_status"] = lms_dictionary.get((78, obj["home_municipal_status"]))

obj["home_residence_type"] = lms_dictionary.get((81, obj["home_residence_type"]))

list_to_return.append(obj)

for veh in vehicles:

obj = veh.serialize()

obj["engine_volume"] = lms_dictionary.get((111, obj["engine_volume"]))

obj["total_weight"] = lms_dictionary.get((112, obj["total_weight"]))

obj["driving_directions"] = lms_dictionary.get((28, obj["driving_directions"]))

list_to_return.append(obj)

if request.method == "GET":

try:

marker = db_session.query(DiscussionMarker)\

.filter(DiscussionMarker.identifier == \

request.values['identifier']).first()

context = {'identifier': marker.identifier, 'title': marker.title}

return render_template('disqus.html', **context)

except AttributeError:

return index(message=u"הדיון לא נמצא: " + request.values['identifier'])

except KeyError:

return index(message=u"דיון לא חוקי")

else:

marker = parse_data(DiscussionMarker, get_json_object(request))

if marker is None:

log_bad_request(request)

return make_response("")

marker = Marker.get_by_key_name(key_name)

follower = Follower.all().filter("marker", marker).filter("user", self.user).get()

if not follower:

marker = Marker.get_by_key_name(key_name)

follower = Follower.all().filter("marker", marker).filter("user", self.user).get()

if follower:

start_time = time.time()

if request.method == "GET":

ne_lat = float(request.values['ne_lat'])

ne_lng = float(request.values['ne_lng'])

sw_lat = float(request.values['sw_lat'])

sw_lng = float(request.values['sw_lng'])

start_date = datetime.date.fromtimestamp(int(request.values['start_date']))

end_date = datetime.date.fromtimestamp(int(request.values['end_date']))

fatal = int(request.values['show_fatal'])

severe = int(request.values['show_severe'])

light = int(request.values['show_light'])

inaccurate = int(request.values['show_inaccurate'])

zoom = int(request.values['zoom'])

results = retrieve_clusters(ne_lat, ne_lng, sw_lat, sw_lng,

start_date, end_date,

fatal, severe, light, inaccurate, zoom)

logging.debug('calculating clusters took ' + str(time.time() - start_time))

# at this point the marker id is just a running number, and the

# LMS is in the description and needs to be promoted to a DB

# field so we can query it. We also need to add a provider id.

context = {'minimal_zoom': MINIMAL_ZOOM}

highlight = parse_data(HighlightPoint, get_json_object(request))

if highlight is None:

log_bad_request(request)

return make_response("")

# if it's a user gps type (user location), only handle a single post request per session

if int(highlight.type) == HighlightPoint.HIGHLIGHT_TYPE_USER_GPS:

if not SESSION_HIGHLIGHTPOINT_KEY in session:

session[SESSION_HIGHLIGHTPOINT_KEY] = "saved"

else:

return make_response("")

try:

db_session.add(obj)

db_session.commit()

return jsonify(obj.serialize())

except Exception as e:

logging.debug("could not handle a post for object:{0}, error:{1}".format(obj, e.message))

try:

return cls.parse(data) if data is not None else None

except Exception as e:

logging.debug("Could not parse the requested data, for class:{0}, data:{1}. Error:{2}".format(cls, data, e.message))

try:

return request.get_json(force=True)

except Exception as e:

logging.debug("Could not get json from a request. request:{0}. Error:{1}".format(request, e.message))

try:

logging.debug("Bad {0} Request over {1}. Values: {2} {3}".format(request.method, request.url, request.form, request.args))

except AttributeError:

context = {'minimal_zoom': MINIMAL_ZOOM, 'url': request.base_url}

if 'marker' in request.values:

markers = Marker.get_marker(request.values['marker'])

if markers.count() == 1:

marker = markers[0]

context['coordinates'] = (marker.latitude, marker.longitude)

context['marker'] = marker.id

if 'start_date' in request.values:

context['start_date'] = string2timestamp(request.values['start_date'])

elif marker:

context['start_date'] = year2timestamp(marker.created.year)

if 'end_date' in request.values:

context['end_date'] = string2timestamp(request.values['end_date'])

elif marker:

context['end_date'] = year2timestamp(marker.created.year + 1)

for attr in 'show_fatal', 'show_severe', 'show_light', 'show_inaccurate', \

'zoom':

if attr in request.values:

context[attr] = request.values[attr]

if 'map_only' in request.values:

if request.values['map_only'] in ('1', 'true'):

context['map_only'] = 1

if 'lat' in request.values and 'lon' in request.values:

context['coordinates'] = (request.values['lat'], request.values['lon'])

if message:

context['message'] = message

jsonData = request.get_json(force=True)

emailaddress = str(jsonData['address'])

fname = (jsonData['fname']).encode("utf8")

lname = (jsonData['lname']).encode("utf8")

if len(fname)>40:

return jsonify(respo='First name to long')

if len(lname)>40:

return jsonify(respo='Last name to long')

if len(emailaddress)>40:

return jsonify(respo='Email too long', emailaddress = emailaddress)

user_exists = db_session.query(User).filter(User.email == emailaddress)

if user_exists.count()==0:

user = User(email = emailaddress, first_name = fname.decode("utf8"), last_name = lname.decode("utf8"), new_features_subscription=True)

db_session.add(user)

db_session.commit()

return jsonify(respo='Subscription saved', )

else:

user_exists = user_exists.first()

if user_exists.new_features_subscription==False:

user_exists.new_features_subscription = True

db_session.add(user_exists)

db_session.commit()

return jsonify(respo='Subscription saved', )

else:

username = fields.StringField(validators=[validators.required()])

password = fields.PasswordField(validators=[validators.required()])

def validate_login(self, field):

user = self.get_user()

if user is None:

raise validators.ValidationError('Invalid user')

if not check_password_hash(user.password.encode("utf8"), self.password.data.encode("utf8")):

raise validators.ValidationError('Invalid password')

def get_user(self):

username = fields.StringField(validators=[validators.required()])

email = fields.StringField()

password = fields.PasswordField(validators=[validators.required()])

def validate_login(self, field):

if db_session.query(User).filter_by(username=self.username.data).count() > 0:

login_manager = login.LoginManager()

login_manager.init_app(app)

# Create user loader function

@login_manager.user_loader

def load_user(user_id):

@expose('/')

def index(self):

if login.current_user.is_authenticated():

if current_user.has_role('admin'):

return super(AdminIndexView, self).index()

else:

return make_response("Unauthorized User")

else:

return redirect(url_for('.login_view'))

@expose('/login/', methods=('GET', 'POST'))

def login_view(self):

# handle user login

form = LoginFormAdmin(request.form)

if helpers.validate_form_on_submit(form):

user = form.get_user()

login.login_user(user)

if login.current_user.is_authenticated():

return redirect(url_for('.index'))

#link = '<p>Don\'t have an account? <a href="' + url_for('.register_view') + '">Click here to register.</a></p>'

self._template_args['form'] = form

#self._template_args['link'] = link

return super(AdminIndexView, self).index()

# @expose('/register/', methods=('GET', 'POST'))

# def register_view(self):

# form = RegistrationForm(request.form)

# if helpers.validate_form_on_submit(form):

# user = User()

#

# form.populate_obj(user)

# # we hash the users password to avoid saving it as plaintext in the db,

# # remove to use plain text:

# user.password = generate_password_hash(form.password.data)

# user.is_admin = True

#

# db_session.add(user)

# db_session.commit()

#

# login.login_user(user)

# return redirect(url_for('.index'))

# link = '<p>Already have an account? <a href="' + url_for('.login_view') + '">Click here to log in.</a></p>'

# self._template_args['form'] = form

# self._template_args['link'] = link

# return super(AdminIndexView, self).index()

@expose('/logout/')

def logout_view(self):

login.logout_user()

@roles_required('admin')

@expose('/', methods=('GET', 'POST'))

def index(self):

if request.method=='GET':

user_emails = db_session.query(User).filter(User.new_features_subscription == True)

email_list = []

for user in user_emails:

email_list.append(user.email)

email_list.append(';')

context = {'user_emails': email_list}

return self.render('sendemail.html', **context)

else:

jsondata = request.get_json(force=True)

users_send_email_to = db_session.query(User).filter(User.new_features_subscription == True)

message = Mail()

message.set_subject(jsondata['subject'].encode("utf8"))

message.set_text(jsondata['message'].encode("utf8"))

message.set_from('ANYWAY Team <feedback@anyway.co.il>')

for user in users_send_email_to:

message.add_bcc(user.email)

try:

status, msg = sg.send(message)

except SendGridClientError:

return "Error occurred while trying to send the emails"

except SendGridServerError:

return "Error occurred while trying to send the emails"

return "Email/s Sent"

def is_visible(self):

@roles_required('admin')

@expose('/')

def index(self):

highlightedpoints = db_session.query(HighlightPoint).options(load_only("id", "latitude", "longitude", "type"))

points = []

point_id_list = []

for point in highlightedpoints:

p = HighlightPoint()

p.id = point.id

p.latitude = point.latitude

p.longitude = point.longitude

p.created = point.created

p.type = point.type

points.append(p)

context = {'points': points}

return self.render('viewhighlighted.html', **context)

def is_visible(self):

username = StringField('Username', validators=[validators.DataRequired()])

password = PasswordField('Password', validators=[validators.DataRequired()])

def validate_on_submit(self):

if self.username.data == '':

return False

if self.password.data == '':

return False

@roles_required('admin')

@expose('/', methods=('GET', 'POST'))

def index(self):

formAccount = OpenAccountForm(request.form)

if request.method == "POST" and formAccount.validate_on_submit():

user = User(username = formAccount.username.data, password = formAccount.password.data)

role = db_session.query(Role).filter(Role.id==2).first()

user.roles.append(role)

db_session.add(user)

db_session.commit()

flash('The user was created successfully')

return self.render('open_account.html', form=formAccount)

def is_visible(self):

global lms_dictionary

for directory in glob.glob("{0}/{1}/*/*".format(app.static_folder, 'data/lms')):

main_dict = dict(get_dict_file(directory))

if len(main_dict) == 0:

return

if len(main_dict) == 1:

for dic in main_dict['Dictionary']:

if type(dic[DICTCOLUMN3]) is str:

lms_dictionary[(int(dic[DICTCOLUMN1]),int(dic[DICTCOLUMN2]))] = dic[DICTCOLUMN3].decode(content_encoding)

else:

lms_dictionary[(int(dic[DICTCOLUMN1]),int(dic[DICTCOLUMN2]))] = int(dic[DICTCOLUMN3])

for name, filename in lms_dict_files.iteritems():

files = filter(lambda path: filename.lower() in path.lower(), os.listdir(directory))

amount = len(files)

if amount == 0:

raise ValueError("file not found in directory: " + filename)

if amount > 1:

raise ValueError("there are too many matches: " + filename)

csv = CsvReader(os.path.join(directory, files[0]))

username = StringField('User Name', [validators.DataRequired()])

def validate(self):

if not super(LoginForm, self).validate():

return False

if self.username.data.strip() == '':

return False

self.user = db_session.query(User).filter(User.username==self.username.data).first()

if self.user is None:

return False

if self.password.data == self.user.password:

return True

if current_user.is_authenticated():

if current_user.has_role('privileged_user'):

context = {'user_name': get_current_user_first_name()}

return render_template('testroles.html', **context)

else:

return make_response("Unauthorized User")

else:

cur_id = current_user.get_id()

cur_user = db_session.query(User).filter(User.id == cur_id).first()

if cur_user is not None:

return cur_user.first_name

"""

Edits 'years.js', a years structure ready to be presented in app.js

as user's last-4-years filter choices.

"""

year_col = db.session.query(distinct(func.extract("year", Marker.created)))

years = OrderedDict([("שנת" + " %d" % year, year_range(year))

for year in sorted(year_col, reverse=True)[:4]])

years_file = os.path.join(app.static_folder, 'js/years.js')

with open(years_file, 'w') as outfile:

outfile.write("var ACCYEARS = ")

json.dump(years, outfile, encoding='utf-8')

outfile.write(";\n")

logging.debug("wrote '%s'" % years_file)