def test_scoreboard_api(self, client, admin_user):
event_data = {
"start_date": datetime.datetime.now() -
datetime.timedelta(
days=1,
hours=3),
"end_date": datetime.datetime.now() +
datetime.timedelta(
days=3,
hours=3),
"organizer": "some organizer",
"creator": admin_user,
"title": "Event in SI",
"pub_date": datetime.datetime.now(),
"country": "SI",
"geoposition": Geoposition(
46.05528,
14.51444),
"location": "Ljubljana",
"audience": [1],
"theme": [1],
"tags": [
"tag1",
"tag2"],
}
event = create_or_update_event(**event_data)
event.status = 'APPROVED'
event.save()
event_data = {
"start_date": datetime.datetime.now() - datetime.timedelta(days=1, hours=3),
"end_date": datetime.datetime.now() + datetime.timedelta(days=3, hours=3),
"organizer": "other organizer",
"creator": admin_user,
"title": "Event in IS",
"pub_date": datetime.datetime.now(),
"country": "IS",
"geoposition": Geoposition(64.13244, -21.85690),
"location": "Reykjavík",
"audience": [1],
"theme": [1],
"tags": ["tag1", "tag2"],
}
event = create_or_update_event(**event_data)
event.status = 'APPROVED'
event.save()
response_json = client.get('/api/scoreboard/?format=json')
response_data = json.loads(response_json.content)
assert isinstance(response_data, list)
assert len(response_data) > 1
assert response_data[0]["country_name"] == "Iceland"
assert response_data[1]["country_name"] == "Slovenia"
def test_area_bottom_right(self):
# create booking
booking = Booking()
booking.client = self.client
booking.passengers = 1
booking.luggage_number = 2
booking.flight = "18070-12324"
booking.departure = Geoposition(49.010247, 2.547678)
booking.destination = Geoposition(48.792502, 2.386336)
booking.distance = math.hypot(48.792502 - 49.010247,
2.386336 - 2.547678)
# booking.destination = "Place de la Libération, 94400 Vitry-sur-Seine"
self.assertFalse(booking is None)
self.assertEqual(get_area(booking), self.bottom_right)
def setUp(self):
self.VRM = VRM_Account.objects.create(vrm_user_id='*****@*****.**',vrm_password="******")
self.location = Geoposition(52.5,24.3)
self.organisation = Sesh_Organisation.objects.create(name='test_organisation')
self.site = Sesh_Site.objects.create(site_name=u"Test site",
comission_date=timezone.datetime(2015, 12, 11, 22, 0),
location_city=u"kigali",
location_country=u"rwanda",
installed_kw=123.0,
position=self.location,
system_voltage=24,
number_of_panels=12,
battery_bank_capacity=12321,
has_genset=True,
has_grid=True,
organisation=self.organisation)
#create test user
self.test_sesh_user = Sesh_User.objects.create_user(username='******',
email='*****@*****.**',
password='******',
phone_number='250786688713',
organisation=self.organisation)
def test_event_list_all(self, client, admin_user):
event_data = {
"start_date":
datetime.datetime.now() - datetime.timedelta(days=1, hours=3),
"end_date":
datetime.datetime.now() + datetime.timedelta(days=3, hours=3),
"organizer":
"some organizer",
"creator":
admin_user,
"title":
"Unique REST API Event",
"pub_date":
datetime.datetime.now(),
"country":
"SI",
"geoposition":
Geoposition(46.05528, 14.51444),
"location":
"Ljubljana",
"audience": [1],
"theme": [1],
"tags": ["tag1", "tag2"],
}
event = create_or_update_event(**event_data)
event.status = 'APPROVED'
event.save()
response_json = client.get('/api/event/list/?format=json')
response_data = json.loads(response_json.content)
assert isinstance(response_data, list)
assert event_data['title'] in response_json.content
class VenueFactory(factory.DjangoModelFactory):
class Meta:
model = Venue
quadra = factory.LazyAttribute(lambda o: faker.company())
address = factory.LazyAttribute(lambda o: faker.address())
location = Geoposition(52.522906, 13.41156)
def test_create_event_from_dict_with_all_fields(self):
with open(local(__file__).dirname +
'/../../static/img/team/alja.jpg') as fp:
io = StringIO.StringIO()
io.write(fp.read())
uploaded_picture = InMemoryUploadedFile(io, None, "alja.jpg",
"jpeg", io.len, None)
uploaded_picture.seek(0)
event_data = {
"end_date": datetime.datetime.now(),
"start_date": datetime.datetime.now(),
"organizer": "some organizer",
"creator": User.objects.filter(pk=1)[0],
"title": "event title",
"pub_date": datetime.datetime.now(),
"country": "SI",
"geoposition": Geoposition(46.05528, 14.51444),
"location": "Ljubljana",
"audience": [1],
"theme": [1],
"tags": ["tag1", "tag2"],
"picture": uploaded_picture
}
test_event = create_or_update_event(**event_data)
self.assertEqual(2, test_event.pk)
self.assertEqual("Ljubljana", test_event.location)
self.assertEqual("46.05528", str(test_event.geoposition.latitude))
self.assertIn("tag1", test_event.tags.names())
self.assertIn("tag2", test_event.tags.names())
assert 'event_picture/alja' in test_event.picture.path
def setUp(self): # flake8: noqa
super(NetworkGroupPluginTest, self).setUp()
self.britain = NetworkGroup.objects.create(
name='Open Knowledge Foundation Britain',
group_type=0, # local group
description='Bisquits, tea, and open data',
country='GB',
mailinglist_url='http://lists.okfn.org/okfn-britain',
homepage_url='http://gb.okfn.org/',
twitter='OKFNgb')
self.buckingham = NetworkGroup.objects.create(
name='Open Knowledge Buckingham',
group_type=0, # local group
description='We run the Open Palace project',
country='GB',
region=u'Buckingham',
position=Geoposition(51.501364, -0.141890),
homepage_url='http://queen.okfn.org/',
twitter='buckingham',
facebook_url='http://facebook.com/queenthepersonnottheband',
youtube='Queenovision')
self.germany = NetworkGroup.objects.create(
name='Open Knowledge Foundation Germany',
group_type=1, # chapter
description='Haben Sie ein Kugelschreiber bitte?',
country='DE',
mailinglist_url='http://lists.okfn.org/okfn-de',
homepage_url='http://de.okfn.org/',
twitter='OKFNde')
self.localgroups = NetworkGroupList(group_type=0)
self.chapters = NetworkGroupList(group_type=1)
def post(self, request, *args, **kwargs):
"""
POST USER LOCATION AS CHECK-IN
:param request: POST
:param args: Member, Geolocation, Time, Radius
"""
member = request.user
time = timezone.now()
lat = request.POST['lat']
lng = request.POST['lng']
radius_meters = request.POST['radius']
pos = Geoposition(lat, lng)
location = Location(position=pos, created_time=time)
location.save()
zone = Zone(location=location, radius_meters=radius_meters)
zone.save()
check_in = CheckIn(member=member,
time=time,
zone=zone,
location=location)
check_in.save()
serializer = CheckInSerializer(check_in, many=False)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def setUp(self):
"""
Initializing the db
"""
self.user = Sesh_User.objects.create_superuser(username='******',
email="*****@*****.**",
password='******')
self.client = Client()
self.site = Sesh_Site.objects.create(
site_name='test',
comission_date=timezone.now(),
location_city='Kigali',
location_country='Rwanda',
position=Geoposition(12, 1),
installed_kw=25,
system_voltage=45,
number_of_panels=45,
battery_bank_capacity=450,
)
self.rmc_account = Sesh_RMC_Account.objects.create(
site=self.site,
api_key='testing',
api_key_numeric='123456789987654321',
)
self.sensor_node = Sensor_Node.objects.create(site=self.site,
node_id=5)
def query_zip_code(zip_code):
if not zip_code.isdigit():
return
r = requests.get('http://api.zippopotam.us/de/%s' % zip_code)
if r.status_code == 200:
result = r.json()['places'][0]
return Geoposition(result['latitude'], result['longitude'])
def test_edit_event_with_all_fields(self):
# First create a new event
with open(local(__file__).dirname +
'/../../static/img/team/alja.jpg') as fp:
io = StringIO.StringIO()
io.write(fp.read())
uploaded_picture = InMemoryUploadedFile(io, None, "alja.jpg",
"jpeg", io.len, None)
uploaded_picture.seek(0)
event_data = {
"end_date": datetime.datetime.now(),
"start_date": datetime.datetime.now(),
"organizer": "some organizer",
"creator": User.objects.filter(pk=1)[0],
"title": "event title",
"pub_date": datetime.datetime.now(),
"country": "SI",
"geoposition": Geoposition(46.05528, 14.51444),
"location": "Ljubljana",
"audience": [1],
"theme": [1],
"tags": ["tag1", "tag2"],
"picture": uploaded_picture
}
test_event = create_or_update_event(**event_data)
# Then edit it
with open(
local(__file__).dirname +
'/../../static/img/team/ercchy.jpg') as fp:
io = StringIO.StringIO()
io.write(fp.read())
uploaded_picture = InMemoryUploadedFile(io, None, "ercchy.jpg",
"jpeg", io.len, None)
uploaded_picture.seek(0)
event_data = {
"end_date": datetime.datetime.now(),
"start_date": datetime.datetime.now(),
"organizer": "another organiser",
"creator": User.objects.filter(pk=1)[0],
"title": "event title - edited",
"pub_date": datetime.datetime.now(),
"country": "SI",
# "geoposition": Geoposition(46.05528,14.51444),
"location": "Ljubljana",
"audience": [1],
"theme": [1],
"tags": ["tag3", "tag4"],
"picture": uploaded_picture
}
test_event = create_or_update_event(event_id=test_event.id,
**event_data)
assert "tag1" not in test_event.tags.names()
assert 'event_picture/alja' not in test_event.picture
assert 'event_picture/ercchy' in test_event.picture.path
class LocationFactory(factory.DjangoModelFactory):
class Meta(object):
model = Location
name = factory.Sequence(lambda n: 'Location_{0}'.format(n))
position = Geoposition(52.5, 13.4)
country = factory.SubFactory(CountryFactory)
group = factory.SubFactory(LocationGroupFactory)
def test_area_high_right(self):
# create booking
booking = Booking()
booking.client = self.client
booking.passengers = 1
booking.luggage_number = 2
booking.flight = "18070-12324"
# booking.departure = "Aéroport Charles de Gaulle (T3-Roissypole), Tremblay-en-France"
# booking.destination = "23 Rue Madeleine Vionnet, 93300 Aubervilliers"
booking.departure = Geoposition(49.010247, 2.547678)
booking.destination = Geoposition(48.903194, 2.374365)
booking.distance = math.hypot(48.903194 - 49.010247,
2.374365 - 2.547678)
self.assertFalse(booking is None)
self.assertEqual(get_area(booking), self.high_right)
def test_area_high_left(self):
# create booking
booking = Booking()
booking.client = self.client
booking.passengers = 1
booking.luggage_number = 2
booking.flight = "18070-12324"
# booking.departure = "Aéroport Charles de Gaulle (T3-Roissypole), Tremblay-en-France"
# booking.destination = "Place Charles de Gaulle, 75008 Paris"
booking.departure = Geoposition(49.010247, 2.547678)
booking.destination = Geoposition(48.873959, 2.295825)
booking.distance = math.hypot(48.873959 - 49.010247,
2.295825 - 2.547678)
self.assertFalse(booking is None)
self.assertEqual(get_area(booking), self.high_left)
def test_area_bottom_left(self):
# create booking
booking = Booking()
booking.client = self.client
booking.passengers = 1
booking.luggage_number = 2
booking.flight = "18070-12324"
# booking.departure = "Aéroport Charles de Gaulle (T3-Roissypole), Tremblay-en-France"
# booking.destination = "Champ de Mars, 5 Avenue Anatole France, 75007 Paris""
booking.departure = Geoposition(49.010247, 2.547678)
booking.destination = Geoposition(48.858956, 2.294512)
booking.distance = math.hypot(48.858956 - 49.010247,
2.294512 - 2.547678)
self.assertFalse(booking is None)
self.assertEqual(get_area(booking), self.bottom_left)
def test_db_value_to_python_object(self):
obj = PointOfInterest.objects.create(name='Foo',
address='some where',
city='city',
zipcode='12345',
position=Geoposition(52.5, 13.4))
poi = PointOfInterest.objects.get(id=obj.id)
self.assertIsInstance(poi.position, Geoposition)
def setUp(self):
"""
Initializing
"""
self.location = Geoposition(1.7, 1.8)
self.organisation = Sesh_Organisation.objects.create(name='test_org',
slack_token='testing_token')
self.test_user = Sesh_User.objects.create_user(username='******',
email='*****@*****.**',
password='******',
organisation=self.organisation,
is_org_admin=True,
department='test',
send_mail=True)
self.site = Sesh_Site.objects.create(site_name='test_site',
organisation=self.organisation,
comission_date=timezone.now(),
location_city='kigali',
location_country='Rwanda',
installed_kw=123.0,
position = self.location,
system_voltage = 12,
number_of_panels = 12,
battery_bank_capacity = 1000)
self.attributes_data = [
{"table":"Daily_Data_Point",
"column":"daily_no_of_alerts",
"operation":"average",
"user_friendly_name":"Daily no of alerts average"},
{"table":"Daily_Data_Point",
"column":"daily_power_consumption_total",
"operation":"sum",
"user_friendly_name":"Daily power consumption total sum"
},
]
self.daily_data_point_one = Daily_Data_Point.objects.create(
site = self.site,
date = timezone.now(),
daily_pv_yield = 10,
daily_power_consumption_total = 10,
)
self.daily_data_point_two = Daily_Data_Point.objects.create(
site = self.site,
date = timezone.now(),
daily_pv_yield = 10,
daily_power_consumption_total = 10,
)
self.report = Report_Job.objects.create(site=self.site,
duration="daily",
day_to_report=datetime.now().today().weekday(),
attributes=self.attributes_data)
def compress(self, data_list):
if data_list:
# set maximum geohash precision by default
precision = data_list[2]
if precision is None:
precision = GEOHASH_PRECISION
position = Geoposition(data_list[0], data_list[1])
return position.geohash[0:precision]
return None
def create_place(user):
i = user.id
place = Place(name="Place Test",
position=Geoposition(float(i * 78.2357), float(i * 15.4913)),
desc="I'm just a place in location " + str(i),
userId=user)
place.save()
return place
def add_place(puserId, plat, plong, pdesc, pname, ppic):
p = Place.objects.get_or_create(name=pname,
userId=UserProfile.objects.get(pk=puserId),
position=Geoposition(
float(plat), float(plong)),
desc=pdesc,
picLink=ppic,
slug=slugify(pname))[0]
return p
def mapdisplay(request):
context = {}
try:
context['center'] = Area.objects.get(name='UQ').address.position
except Area.DoesNotExist:
context['center'] = Geoposition(-27.4702785, 153.0055264)
context['carparks'] = Carpark.objects.filter(verified=True)
return render(request, 'map.html', context)
def __init__(self, *args, **kwargs):
self.widget = GeopositionWidget()
fields = (
forms.DecimalField(label=_('latitude')),
forms.DecimalField(label=_('longitude')),
)
if 'initial' in kwargs:
kwargs['initial'] = Geoposition(*kwargs['initial'].split(','))
super(GeopositionField, self).__init__(fields, **kwargs)
def modify(request):
if request.method == 'GET':
if 'lat' and 'lng' and 'uid' not in request.GET:
return HttpResponse("fail no position in get")
lat = request.GET['lat']
lng = request.GET['lng']
uid = request.GET['uid']
try:
p = Geoposition(lat, lng)
obj = crime.objects.get(position=p, personne=User.objects.get(id=uid))
obj_id = obj.id
gouv = obj.gouvernorat
desc = obj.description
sx = obj.sexe
temp = str(obj.time)[:-6]
cat = obj.crimetype
lat = str(obj.position.latitude)
lon = str(obj.position.longitude)
dictionnaire = {'id': obj_id,
'gouv': gouv,
'temp': temp,
'desc': desc,
'lat': lat,
'lon': lon,
'sx': sx,
'cat': cat}
return HttpResponse(json.dumps(dictionnaire),
content_type='application/json')
except crime.DoesNotExist:
return HttpResponse("fail no crime in get")
elif request.method == 'POST':
if 'id' not in request.POST:
return HttpResponse("fail no id")
the_id = request.POST['id']
try:
obj = crime.objects.get(id=the_id)
except crime.DoesNotExist:
return HttpResponse("fail no crime")
if request.user == obj.personne:
if "gouvernorat" in request.POST:
obj.gouvernorat = request.POST["gouvernorat"]
if "description" in request.POST:
obj.description = request.POST["description"]
if "sexe" in request.POST:
obj.sexe = request.POST["sexe"]
if "crimetype" in request.POST:
obj.crimetype = request.POST["crimetype"]
if "position" in request.POST:
position = request.POST["position"]
if "time" in request.POST:
obj.time = request.POST["time"]
obj.save()
return HttpResponseRedirect('/crime/mod/')
else:
return HttpResponse("fail all")
def setUp(self):
# Need this to create a Site
self.VRM = VRM_Account.objects.create(vrm_user_id='*****@*****.**',
vrm_password="******")
# Setup Influx
self._influx_db_name = 'test_db'
self.i = Influx(database=self._influx_db_name)
try:
self.i.create_database(self._influx_db_name)
#Generate random data points for 24h
except:
self.i.delete_database(self._influx_db_name)
sleep(1)
self.i.create_database(self._influx_db_name)
pass
# Setup Kapacitor
self.kap = Kapacitor()
self.template_id = 'test_template'
self.task_id = 'test_task'
self.dj_template_name = 'alert_template'
self.dbrps = [{'db': self._influx_db_name, 'rp': 'autogen'}]
self.location = Geoposition(52.5, 24.3)
dt = timezone.make_aware(timezone.datetime(2015, 12, 11, 22, 0))
self.site = Sesh_Site.objects.create(site_name=u"Test_aggregate",
comission_date=dt,
location_city=u"kigali",
location_country=u"rwanda",
vrm_account=self.VRM,
installed_kw=123.0,
position=self.location,
system_voltage=12,
number_of_panels=12,
vrm_site_id=213,
battery_bank_capacity=12321,
has_genset=True,
has_grid=True)
#self.no_points = create_test_data(self.site,
# start = self.site.comission_date,
# end = dt + timedelta( hours = 48),
# interval = 30,
# random = False)
#create test user
self.test_user = Sesh_User.objects.create_user("john doe",
"*****@*****.**",
"asdasd12345")
#assign a user to the sites
assign_perm("view_Sesh_Site", self.test_user, self.site)
def add_geoposition(countries):
geo = Geoposition()
for country in countries:
if not country.get('cities') is None:
for city in country['cities']:
if city_dict.get(city['city']) is None:
city_location = geo.get_geoposition(
city['city'], country['country'])
city_dict[city['city']] = city_location
else:
city_location = city_dict[city['city']]
city['location'] = city_location
if country_dict.get(country['country']) is None:
country_location = geo.get_geoposition(country=country['country'])
country_dict[country['country']] = country_location
else:
country_location = country_dict[country['country']]
country['location'] = country_location
return countries
def run():
a = Location.objects.all()
for item in a:
if item.gps_latitude and item.gps_longitude:
item.geo_location = Geoposition(latitude=item.gps_latitude,
longitude=item.gps_longitude)
item.save()
else:
pass
def seguimiento_gps(request):
data = []
p = Position(user=User.objects.get(id=int(request.POST.get('user', ''))),
position=Geoposition(request.POST.get('latitude', ''),
request.POST.get('longitude', '')),
fecha=request.POST.get('fecha', None))
p.save()
data.append({'mensaje': "posicion registrada con exito"})
data = json.dumps(data)
return HttpResponse(data, content_type="application/json")
def event_create(request):
if request.method == 'POST': #If form was sent via POST method:
context = {}
form1 = EventForm(request.POST, prefix="form1")
form2 = LocationForm(request.POST, prefix="form2")
pos = form2['position'].value() #get list of coordinates
lat = pos[0] #get latitude from the list
lng = pos[1] #get longitude from the list
geo = Geoposition(
lat, lng
) #Create a Geoposition object from the coordinates that are passed as arguments to constructor
location = Location.objects.create(name="test", position=geo)
name = form1['name'].value()
cat = form1['category'].value(
) #category is given as an integer i.e: 1,2,3....
category = Category.objects.get(
pk=cat) #get Category by pk and not by name
d_start = form1['date_start'].value(
) #get Date string in format 2016-12-24
date_start = datetime.strptime(
d_start, '%Y/%m/%d %H:%M') #create a datetime object
d_end = form1['date_end'].value()
date_end = datetime.strptime(
d_end, '%Y/%m/%d %H:%M') #create a datetime object
description = form1['description'].value()
person_limit = form1['person_limit'].value()
fee = form1['fee'].value()
public = form1['public'].value()
participant = request.user.profile #reference to Logged Profile object
#Create an Event object
newly_created_event = Event.objects.create(name=name,
category=category,
date_start=date_start,
date_end=date_end,
description=description,
person_limit=person_limit,
fee=fee,
public=public,
host=participant,
where=location)
newly_created_event.add_participant(
participant
) #Adds profile to profiles list in Event model and saves changes to database.
return redirect(
reverse('Event:event_detail',
kwargs={'event_pk': newly_created_event.pk
})) #redirect to event detail page
else: #If entered to this URL by GET request:
#Create a context dictionary and pass both forms with different prefixes
context = {
'event_form': EventForm(prefix='form1'),
'location_form': LocationForm(prefix='form2'),
}
template = 'Event/event_create.html' #Destination template browswer will redirect to.
return render(request, template, context)
class PlaceFactory(factory.DjangoModelFactory):
class Meta(object):
model = Place
exclude = ['content_object']
position = Geoposition(52.5, 13.4)
country = factory.SubFactory(CountryFactory)
object_id = factory.SelfAttribute('content_object.id')
content_type = factory.LazyAttribute(
lambda o: ContentType.objects.get_for_model(o.content_object))
def to_python(self, value):
if not value or value == 'None':
return None
if isinstance(value, Geoposition):
return value
if isinstance(value, list):
return Geoposition(value[0], value[1])
# default case is string
value_parts = value.rsplit(',')
try:
latitude = value_parts[0]
except IndexError:
latitude = '0.0'
try:
longitude = value_parts[1]
except IndexError:
longitude = '0.0'
return Geoposition(latitude, longitude)
