def add_org(request):
body = json.loads(request.body)
user = User.objects.get(pk=body['user_id'])
org_name = body['organization_name']
if Organization.objects.filter(name=org_name).exists():
return {
'status': 'error',
'message': 'organization name already exists'
}
create_organization(user, org_name, org_name)
return {'status': 'success', 'message': 'organization created'}
def test_adding_buildings_with_individual_selection(self):
"""
Ensure that labels are not actually paginated.
"""
user = User.objects.create_superuser(
email='*****@*****.**',
username='******',
password='******',
)
organization, _, _ = create_organization(user, "test-organization")
project = Project.objects.create(
name='test-org-1',
super_organization=organization,
owner=user,
)
buildings = self.generate_buildings(organization, 10)
self.assertFalse(project.building_snapshots.exists())
selected_buildings = [b.pk for b in buildings if b.pk % 2 == 0]
self.assertEqual(len(selected_buildings), 5)
params = self.get_filter_params(project)
params['selected_buildings'] = selected_buildings
add_buildings(project.slug, params, user.pk)
self.assertEqual(project.building_snapshots.count(), 5)
def test_results_are_not_actually_paginated(self):
"""
Ensure that labels are not actually paginated.
"""
user = User.objects.create_superuser(
email='*****@*****.**',
username='******',
password='******',
)
organization, _, _ = create_organization(user, "test-organization")
# Create 101 labels. This should be pretty future proof against any
# reasonable default pagination settings as well as realistic number of
# labels.
for i in range(101):
Label.objects.create(
color="red",
name="test_label-{0}".format(i),
super_organization=organization,
)
client = APIClient()
client.login(username=user.username, password='******')
url = reverse('labels:label-list')
response = client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], organization.labels.count())
results = response.data['results']
self.assertEqual(len(results), organization.labels.count())
def test_add_user_existing_org(self):
"""
Test creating a new user, adding them to an existing org
in the process.
"""
org, org_user, _user_created = create_organization(
self.admin_user, name='Existing Org'
)
data = {
'organization_id': org.pk,
'first_name': 'New',
'last_name': 'User',
'email': 'new_user@testserver',
'role_level': 'ROLE_MEMBER'
}
res = self._post_json(self.add_user_url, data)
self.assertEqual(res.body['status'], 'success')
user = User.objects.get(username=data['email'])
self.assertEqual(user.email, data['email'])
# the user should be a member of the existing org
self.assertTrue(user in org.users.all())
# Since this is the only user, it's automatically the owner.
self.assertTrue(self._is_org_owner(self.admin_user, org))
self.assertEqual(Organization.objects.count(), 1)
def handle(self, *args, **options):
if User.objects.filter(username=options['username']).exists():
self.stdout.write(
'User <%s> already exists' % options['username'],
ending='\n'
)
u = User.objects.get(username=options['username'])
else:
self.stdout.write(
'Creating user <%s>, password <%s> ...' % (
options['username'], options['password']
), ending=' '
)
u = User.objects.create_superuser(
options['username'],
options['username'],
options['password']
)
self.stdout.write('Created!', ending='\n')
if Organization.objects.filter(name=options['organization']).exists():
org = Organization.objects.get(name=options['organization'])
self.stdout.write(
'Org <%s> already exists' % options['organization'], ending='\n'
)
else:
self.stdout.write(
'Creating org <%s> ...' % options['organization'],
ending=' '
)
org, _, user_added = create_organization(u, options['organization'])
self.stdout.write('Created!', ending='\n')
def test_adding_buildings_with_select_all(self):
"""
Ensure that labels are not actually paginated.
"""
user = User.objects.create_superuser(
email='*****@*****.**',
username='******',
password='******',
)
organization, _, _ = create_organization(user, "test-organization")
project = Project.objects.create(
name='test-org-1',
super_organization=organization,
owner=user,
)
self.generate_buildings(organization, 10)
self.assertFalse(project.building_snapshots.exists())
params = self.get_filter_params(project)
params['select_all_checkbox'] = True
add_buildings(project.slug, params, user.pk)
self.assertEqual(project.building_snapshots.count(), 10)
def add_org(request):
"""
Creates a new organization.
Payload::
{
'organization_name': The name of the new org,
'user_id': the user id of the owner of the new org,
}
Returns::
{
'status': 'success' or 'error',
'message': message, if any,
'organization_id': The ID of the new org, if created.
}
"""
body = json.loads(request.body)
user = User.objects.get(pk=body['user_id'])
org_name = body['organization_name']
if Organization.objects.filter(name=org_name).exists():
return {
'status': 'error',
'message': 'organization name already exists'
}
org, _, _ = create_organization(user, org_name, org_name)
return {'status': 'success',
'message': 'organization created',
'organization_id': org.pk}
def test_add_org_dupe(self):
"""
Trying to create an org with a dupe name fails.
"""
create_organization(user=self.admin_user, org_name='Orgname')
data = {
'user_id': self.user.pk,
'organization_name': 'Orgname'
}
res = self._post_json(self.add_org_url, data)
self.assertEqual(res.body['status'], 'error')
self.assertEqual(Organization.objects.count(), 1)
# and most importantly, the admin/owner of the org didn't change
org = Organization.objects.first()
self.assertTrue(self._is_org_owner(self.admin_user, org))
def test_organization_query_param_is_used(self):
"""
Ensure that when the organization_id query parameter is provided, that
the endpoint returns the appropriate labels for that organization.
"""
user = User.objects.create_superuser(
email='*****@*****.**',
username='******',
password='******',
)
organization_a, _, _ = create_organization(user, "test-organization-a")
organization_b, _, _ = create_organization(user, "test-organization-b")
# Ensures that at least a single label exists to ensure that we aren't
# relying on auto-creation of labels for this test to pass.
Label.objects.create(
color="red",
name="test_label-a",
super_organization=organization_a,
)
Label.objects.create(
color="red",
name="test_label-b",
super_organization=organization_b,
)
client = APIClient()
client.login(username=user.username, password='******')
url = reverse('labels:label-list')
response_a = client.get(url, {'organization_id': organization_a.pk})
response_b = client.get(url, {'organization_id': organization_b.pk})
self.assertEqual(response_a.status_code, status.HTTP_200_OK)
self.assertEqual(response_b.status_code, status.HTTP_200_OK)
results_a = set(result['organization_id'] for result in response_a.data['results'])
results_b = set(result['organization_id'] for result in response_b.data['results'])
assert results_a == {organization_a.pk}
assert results_b == {organization_b.pk}
def test_organization_creation_creates_default_labels(self):
"""Make sure last organization user is change to owner."""
user = User.objects.create(email='*****@*****.**')
org, org_user, user_added = create_organization(
user=user,
org_name='test-organization',
)
self.assertEqual(
org.labels.count(),
len(Label.DEFAULT_LABELS),
)
def test_get_organization_user_not_owner(self):
"""test for the case where a user does not have access"""
other_user = User.objects.create(
username='******',
email='*****@*****.**',
)
other_org, _, _ = create_organization(other_user, "not my org")
resp = self.client.get(
reverse_lazy('api:v2:organizations-detail', args=[other_org.id]),
content_type='application/json',
)
self.assertEquals(json.loads(resp.content), {
'status': 'error',
'message': 'No relationship to organization'
})
def test_api_key_endpoint_returns_true_or_false_if_org_has_api_key(self):
url = reverse("api:v3:organizations-geocode-api-key-exists", args=[self.org.pk])
post_params_false = {'organization_id': self.org.pk}
false_result = self.client.get(url, post_params_false)
self.assertEqual(b'false', false_result.content)
org_with_key, _, _ = create_organization(self.user)
org_with_key.mapquest_api_key = "somekey"
org_with_key.save()
url = reverse("api:v3:organizations-geocode-api-key-exists", args=[org_with_key.id])
post_params_true = {'organization_id': org_with_key.id}
true_result = self.client.get(url, post_params_true)
self.assertEqual(b'true', true_result.content)
def setUp(self):
self.maxDiff = None
user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(
email='*****@*****.**', **user_details)
self.org, self.org_user, _ = create_organization(self.user)
mock_request = mock.MagicMock()
mock_request.user = self.user
class OrgUpdateMixinClass(OrgUpdateMixin):
request = mock_request
self.mixin_class = OrgUpdateMixinClass()
def setUp(self):
user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.user = User.objects.create_superuser(**user_details)
self.org, _, _ = create_organization(self.user, "test-organization-a")
self.column_1 = Column.objects.get(organization=self.org,
table_name='PropertyState',
column_name='address_line_1')
self.column_2 = Column.objects.get(organization=self.org,
table_name='PropertyState',
column_name='city')
self.column_3 = Column.objects.create(organization=self.org,
table_name='PropertyState',
column_name='extra data 1',
is_extra_data=True)
self.payload_data = {
"organization_id":
self.org.id,
"name":
"Test Column List Setting",
"settings_location":
"List View Settings",
"inventory_type":
"Property",
"columns": [
{
"id": self.column_1.id,
"pinned": False,
"order": 1
},
{
"id": self.column_2.id,
"pinned": False,
"order": 2
},
{
"id": self.column_3.id,
"pinned": True,
"order": 3
},
]
}
self.client.login(**user_details)
def test_get_projects(self):
"""tests get_projects"""
self._create_project('proj1', self.org.pk)
other_org, _, _ = create_organization()
# standard case, should only see proj1, not other_proj
self._set_role_level(ROLE_VIEWER)
resp = self.client.get(
reverse_lazy('api:v2:projects-list'),
{'organization_id': self.org.id},
content_type='application/json',
)
projects = json.loads(resp.content)['projects']
std_output = {
'projects': [
self._expected_project(projects[0]['modified'],
projects[0]['id'], False),
],
'status':
'success'
}
self.assertDictEqual(json.loads(resp.content), std_output)
# test for member
self._set_role_level(ROLE_MEMBER)
resp = self.client.get(
reverse_lazy("api:v2:projects-list"),
{'organization_id': self.org.id},
content_type='application/json',
)
self.assertDictEqual(json.loads(resp.content), std_output)
# test for owner
self._set_role_level(ROLE_OWNER)
resp = self.client.get(
reverse_lazy("api:v2:projects-list"),
{'organization_id': self.org.id},
content_type='application/json',
)
self.assertDictEqual(json.loads(resp.content), std_output)
# test for an org the user does not belong
resp = self.client.get(
reverse_lazy("api:v2:projects-list"),
{'organization_id': other_org.id},
content_type='application/json',
)
self.assertDictEqual(json.loads(resp.content), {
'status': 'error',
'message': 'No relationship to organization'
})
def test_get_datasets_count(self):
"""tests get_datasets_count"""
self._set_role_level(ROLE_VIEWER)
ImportRecord.objects.create(
name="test_count",
super_organization=self.org,
owner=self.user,
)
other_user = User.objects.create(
username="******",
email="*****@*****.**",
)
other_org, _, _ = create_organization(other_user, 'not my org')
ImportRecord.objects.create(
name="test_count",
super_organization=other_org,
owner=other_user,
)
resp = self.client.get(
reverse_lazy("api:v2:datasets-count") + '?organization_id=' +
str(self.org.id),
content_type='application/json',
)
self.assertDictEqual(json.loads(resp.content), {
'status': 'success',
'datasets_count': 1
})
# test case where user is not in org
resp = self.client.get(
reverse_lazy("api:v2:datasets-count") + '?organization_id=' +
str(other_org.id),
content_type='application/json',
)
self.assertDictEqual(json.loads(resp.content), {
'status': 'error',
'message': 'No relationship to organization'
})
# test case where org does not exist
resp = self.client.get(
reverse_lazy("api:v2:datasets-count") + '?organization_id=999',
content_type='application/json',
)
self.assertDictEqual(json.loads(resp.content), {
'status': 'error',
'message': 'Organization does not exist'
})
def test_delete_project(self):
"""tests delete_project"""
project = json.loads(self._create_project(name='proj1', via_http=True).content)['project']
self._set_role_level(ROLE_MEMBER)
# standard case
self.assertEqual(Project.objects.all().count(), 1)
url = "{}?organization_id={}".format(
reverse_lazy('api:v2:projects-detail', args=[project['slug']]),
str(self.org.id)
)
resp = self.client.delete(url)
self.assertDictEqual(
json.loads(resp.content),
{'status': 'success'}
)
self.assertEqual(Project.objects.all().count(), 0)
# test viewer cannot delete
project = json.loads(
self._create_project(name='proj1', via_http=True).content
)['project']
self._set_role_level(ROLE_VIEWER)
resp = self.client.delete(url)
self.assertDictEqual(
json.loads(resp.content),
{'status': 'error', 'message': 'Permission denied'}
)
# only delete the project if you are a member of its org
other_user = User.objects.create(
username="******",
email="*****@*****.**",
)
other_org, _, _ = create_organization(other_user)
project = self._create_project('proj2', other_org.pk, other_user)
self._set_role_level(ROLE_MEMBER)
url = "{}?organization_id={}".format(
reverse_lazy('api:v2:projects-detail', args=[project.slug]),
str(self.org.id)
)
resp = self.client.delete(url)
self.assertDictEqual(
json.loads(resp.content),
{
'message': 'Could not find project with slug: proj2',
'status': 'error'
}
)
def setUp(self):
user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**',
'first_name': 'Johnny',
'last_name': 'Energy',
}
self.user = User.objects.create_user(**user_details)
self.org, _, _ = create_organization(self.user, "my org")
self.cycle = Cycle.objects.filter(organization=self.org).first()
self.client.login(**user_details)
self.fake_request = FakeRequest(user=self.user)
self.maxDiff = None
year = date.today().year - 1
self.cal_year_name = "{} Calendar Year".format(year)
def setUp(self):
user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.user = User.objects.create_superuser(**user_details)
self.org, self.org_user, _ = create_organization(self.user)
self.column_factory = FakeColumnFactory(organization=self.org)
self.cycle_factory = FakeCycleFactory(organization=self.org, user=self.user)
self.property_factory = FakePropertyFactory(organization=self.org)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
self.property_view_factory = FakePropertyViewFactory(organization=self.org)
self.taxlot_state_factory = FakeTaxLotStateFactory(organization=self.org)
self.cycle = self.cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=timezone.get_current_timezone()))
self.client.login(**user_details)
def setUp(self):
user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(email='*****@*****.**',
**user_details)
self.org, _, _ = create_organization(self.user)
self.client.login(**user_details)
self.property_state_factory = FakePropertyStateFactory(
organization=self.org)
self.taxlot_state_factory = FakeTaxLotStateFactory(
organization=self.org)
self.property_view_factory = FakePropertyViewFactory(
organization=self.org)
self.taxlot_view_factory = FakeTaxLotViewFactory(organization=self.org)
def test_is_authorized_not_in_org(self):
other_user = User.objects.create(
username='******',
email='*****@*****.**',
)
other_org, _, _ = create_organization(other_user, "not my org")
resp = self.client.post(
reverse_lazy("api:v2:users-is-authorized", args=[self.user.pk]) +
'?organization_id=' + str(other_org.id),
data=json.dumps(
{'actions': ['requires_owner', 'can_invite_member']}),
content_type='application/json',
)
self.assertDictEqual(json.loads(resp.content), {
'status': 'error',
'message': 'user does not exist'
})
def setUp(self):
self.fake_user = User.objects.create(username='******')
self.fake_org, _org_user, _user_created = create_organization(
self.fake_user, name='Existing Org'
)
column_a = seed_models.Column.objects.create(
column_name='Column A',
table_name='PropertyState',
organization=self.fake_org,
is_extra_data=True,
shared_field_type=Column.SHARED_PUBLIC,
)
# field that is in the import, but not mapped to
raw_column = seed_models.Column.objects.create(
column_name='not mapped data',
organization=self.fake_org,
)
dm = seed_models.ColumnMapping.objects.create()
dm.column_raw.add(raw_column)
dm.column_mapped.add(column_a)
dm.save()
seed_models.Column.objects.create(
column_name="Apostrophe's Field",
table_name='PropertyState',
organization=self.fake_org,
is_extra_data=True
)
seed_models.Column.objects.create(
column_name='id',
table_name='PropertyState',
organization=self.fake_org,
is_extra_data=True
)
seed_models.Column.objects.create(
column_name='tax_lot_id_not_used',
table_name='TaxLotState',
organization=self.fake_org,
is_extra_data=True
)
seed_models.Column.objects.create(
column_name='Gross Floor Area',
table_name='TaxLotState',
organization=self.fake_org,
is_extra_data=True
)
def create(self, request):
"""
Creates a new organization.
---
parameters:
- name: organization_name
description: The new organization name
type: string
required: true
- name: user_id
description: The user ID (primary key) to be used as the owner of the new organization
type: integer
required: true
type:
status:
type: string
description: success or error
required: true
message:
type: string
description: error/informational message, if any
required: false
organization:
type: dict
description: A dictionary of the organization created
required: false
"""
body = request.data
user = User.objects.get(pk=body['user_id'])
org_name = body['organization_name']
if Organization.objects.filter(name=org_name).exists():
return JsonResponse({
'status': 'error',
'message': 'organization name already exists'
}, status=status.HTTP_409_CONFLICT)
org, _, _ = create_organization(user, org_name, org_name)
return JsonResponse(
{
'status': 'success',
'message': 'organization created',
'organization': _dict_org(request, [org])[0]
}
)
def setUp(self):
self.api_view = UpdateInventoryLabelsAPIView()
# Models can't be imported directly hence self
self.PropertyViewLabels = self.api_view.models['property']
self.TaxlotViewLabels = self.api_view.models['taxlot']
self.user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.user = User.objects.create_superuser(**self.user_details)
self.org, _, _ = create_organization(self.user)
self.status_label = Label.objects.create(name='test',
super_organization=self.org)
self.status_label_2 = Label.objects.create(name='test_2',
super_organization=self.org)
self.client.login(**self.user_details)
self.label_1 = Label.objects.all()[0]
self.label_2 = Label.objects.all()[1]
self.label_3 = Label.objects.all()[2]
self.label_4 = Label.objects.all()[3]
# Create some real PropertyViews, Properties, PropertyStates, and StatusLabels since validations happen
cycle_factory = FakeCycleFactory(organization=self.org, user=self.user)
cycle = cycle_factory.get_cycle(start=datetime(
2010, 10, 10, tzinfo=timezone.get_current_timezone()))
property_state_factory = FakePropertyStateFactory(
organization=self.org)
for i in range(1, 11):
ps = property_state_factory.get_property_state()
p = Property.objects.create(organization=self.org)
PropertyView.objects.create(cycle=cycle, state=ps, property=p)
self.propertyview_ids = PropertyView.objects.all().order_by(
'id').values_list('id', flat=True)
self.mock_propertyview_label_qs = mock_queryset_factory(
self.PropertyViewLabels,
flatten=True,
propertyview_id=self.propertyview_ids,
statuslabel_id=[self.label_1.id] * 3 + [self.label_2.id] * 3 +
[self.label_3.id] * 2 + [self.label_4.id] * 2)
def setUp(self):
self.user = User.objects.create(
username='******',
first_name='t',
last_name='est'
)
self.user_2 = User.objects.create(
username='******',
first_name='t',
last_name='est'
)
self.org, user_role, _user_created = create_organization(
self.user, 'Test Organization',
)
for i in range(10):
bs = BuildingSnapshot.objects.create()
bs.super_organization = self.org
bs.save()
def setUp(self):
user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**',
'first_name': 'Johnny',
'last_name': 'Energy',
}
self.user = User.objects.create_user(**user_details)
self.org, self.org_user, _ = create_organization(self.user)
self.client.login(**user_details)
# if we get into this test, the PM_UN and PM_PW variables should be available
# we'll still check of course
self.pm_un = os.environ.get(PM_UN, False)
self.pm_pw = os.environ.get(PM_PW, False)
if not self.pm_un or not self.pm_pw:
self.fail('Somehow PM test was initiated without %s or %s in the environment' % (PM_UN, PM_PW))
def setUp(self):
self.user = User.objects.create(
username='******',
first_name='t',
last_name='est'
)
self.user_2 = User.objects.create(
username='******',
first_name='t',
last_name='est'
)
self.org, user_role, _user_created = create_organization(
self.user, 'Test Organization',
)
for i in range(10):
bs = BuildingSnapshot.objects.create()
bs.super_organization = self.org
bs.save()
def set_up(self, import_file_source_type):
"""Override the base in DataMappingBaseTestCase."""
# default_values
import_file_data_state = getattr(self, 'import_file_data_state',
DATA_STATE_IMPORT)
user = User.objects.create(username='******')
org, _, _ = create_organization(user, "test-organization-a")
cycle, _ = Cycle.objects.get_or_create(
name='Test Hack Cycle 2015',
organization=org,
start=datetime.datetime(2015,
1,
1,
tzinfo=timezone.get_current_timezone()),
end=datetime.datetime(2015,
12,
31,
tzinfo=timezone.get_current_timezone()),
)
import_record_1 = ImportRecord.objects.create(owner=user,
last_modified_by=user,
super_organization=org)
import_file_1 = ImportFile.objects.create(
import_record=import_record_1, cycle=cycle)
import_record_2 = ImportRecord.objects.create(owner=user,
last_modified_by=user,
super_organization=org)
import_file_2 = ImportFile.objects.create(
import_record=import_record_2, cycle=cycle)
import_file_1.source_type = import_file_source_type
import_file_1.data_state = import_file_data_state
import_file_1.save()
import_file_2.source_type = import_file_source_type
import_file_2.data_state = import_file_data_state
import_file_2.save()
return user, org, import_file_1, import_record_1, import_file_2, import_record_2, cycle
def setUp(self):
user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**',
'first_name': 'Johnny',
'last_name': 'Energy',
}
self.user = User.objects.create_user(**user_details)
self.org, _, _ = create_organization(self.user, 'my org')
self.client.login(**user_details)
self.fake_request = FakeRequest(user=self.user)
# create BuildingSnapshot and CanonicalBuilding
self.cb = CanonicalBuilding.objects.create(active=True)
self.bs = SEEDFactory.building_snapshot(canonical_building=self.cb,
property_name='ADMIN BUILDING',
address_line_1='100 Admin St')
self.cb.canonical_snapshot = self.bs
self.cb.save()
# create AuditLog audit
self.audit_log = AuditLog.objects.create(
user=self.user,
content_object=self.cb,
audit_type=LOG,
action='create_building',
action_response={
'status': 'success',
'building_id': self.cb.pk
},
action_note='user created a building',
organization=self.org,
)
# create AuditLog note
self.note_text = 'The building has a wonderfully low EUI'
self.note = AuditLog.objects.create(
user=self.user,
content_object=self.cb,
audit_type=NOTE,
action='create_note',
action_response={'status': 'success'},
action_note=self.note_text,
organization=self.org,
)
def setUp(self):
self.maxDiff = None
user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(email='*****@*****.**',
**user_details)
self.org, self.org_user, _ = create_organization(self.user)
mock_request = mock.MagicMock()
mock_request.user = self.user
self.org_validator = OrgValidator(key='foreign_key',
field='organization_id')
class OrgValidateMixinClass(OrgValidateMixin):
context = {'request': mock_request}
org_validators = [self.org_validator]
self.mixin_class = OrgValidateMixinClass()
def setUp(self):
self.api_view = UpdateInventoryLabelsAPIView()
# Models can't be imported directly hence self
self.PropertyViewLabels = self.api_view.models['property']
self.TaxlotViewLabels = self.api_view.models['taxlot']
self.user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.user, self.org, _import_file, _import_record, self.cycle = self.set_up(
ASSESSED_RAW)
org_2, _, _ = create_organization(self.user)
self.org_2_status_label = Label.objects.create(
name='org_2_label', super_organization=org_2)
def handle(self, *args, **options):
if User.objects.filter(username=options['username']).exists():
self.stdout.write(
'User <%s> already exists' % options['username'],
ending='\n'
)
u = User.objects.get(username=options['username'])
else:
self.stdout.write(
'Creating user <%s>, password <hidden> ...' % (options['username']), ending=' '
)
if options['usertype'] == 'superuser':
u = User.objects.create_superuser(
options['username'],
options['username'],
options['password']
)
else:
u = User.objects.create_user(
options['username'],
options['username'],
options['password']
)
self.stdout.write('Creating API Key', ending='\n')
u.generate_key()
self.stdout.write('Created!', ending='\n')
if Organization.objects.filter(name=options['organization']).exists():
org = Organization.objects.get(name=options['organization'])
self.stdout.write(
'Org <%s> already exists' % options['organization'], ending='\n'
)
else:
self.stdout.write(
'Creating org <%s> ...' % options['organization'],
ending=' '
)
org, _, user_added = create_organization(u, options['organization'])
self.stdout.write('Created!', ending='\n')
def setUp(self):
user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(
email='*****@*****.**', **user_details
)
self.org, _, _ = create_organization(self.user)
self.client.login(**user_details)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
self.tax_lot_state_factory = FakeTaxLotStateFactory(organization=self.org)
self.extra_data_column = Column.objects.create(
table_name='PropertyState',
column_name='test_column',
organization=self.org,
is_extra_data=True,
)
def setUp(self):
self.user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(
email='*****@*****.**', **self.user_details
)
self.org, _, _ = create_organization(self.user)
self.client.login(**self.user_details)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
property_details = self.property_state_factory.get_details()
property_details['organization_id'] = self.org.id
state_1 = PropertyState(**property_details)
state_1.save()
self.state_1 = PropertyState.objects.get(pk=state_1.id)
self.cycle_factory = FakeCycleFactory(organization=self.org, user=self.user)
self.cycle = self.cycle_factory.get_cycle(start=datetime(2010, 10, 10, tzinfo=get_current_timezone()))
self.property_factory = FakePropertyFactory(organization=self.org)
self.property_1 = self.property_factory.get_property()
self.property_view_1 = PropertyView.objects.create(property=self.property_1, cycle=self.cycle, state=self.state_1)
self.import_record = ImportRecord.objects.create(owner=self.user, last_modified_by=self.user, super_organization=self.org)
filename = "example-GreenButton-data.xml"
filepath = os.path.dirname(os.path.abspath(__file__)) + "/data/" + filename
self.import_file = ImportFile.objects.create(
import_record=self.import_record,
source_type="GreenButton",
uploaded_filename=filename,
file=SimpleUploadedFile(name=filename, content=open(filepath, 'rb').read()),
cycle=self.cycle,
matching_results_data={"property_id": self.property_1.id}
)
self.tz_obj = timezone(TIME_ZONE)
def create(self, request):
"""
Creates a new organization.
---
parameters:
- name: organization_name
description: The new organization name
type: string
required: true
- name: user_id
description: The user ID (primary key) to be used as the owner of the new organization
type: integer
required: true
type:
status:
type: string
description: success or error
required: true
message:
type: string
description: error/informational message, if any
required: false
organization_id:
type: string
description: The ID of the new org, if created
required: false
"""
body = request.data
user = User.objects.get(pk=body['user_id'])
org_name = body['organization_name']
if Organization.objects.filter(name=org_name).exists():
return JsonResponse({
'status': 'error',
'message': 'organization name already exists'
}, status=status.HTTP_409_CONFLICT)
org, _, _ = create_organization(user, org_name, org_name)
return JsonResponse({'status': 'success',
'message': 'organization created',
'organization_id': org.pk})
def test_basic_project_creation(self):
user = User.objects.create(username='******', first_name='t', last_name='est')
org, user_role, _user_created = create_organization(
user, 'Test Organization'
)
p = Project.objects.create(
name='Test Project',
owner=user,
super_organization=org,
description='A really great test organization.',
)
p.save()
self.assertEqual(p.name, 'Test Project')
self.assertTrue('Test Project' in str(p))
self.assertEqual(p.owner, user)
self.assertEqual(p.super_organization, org)
self.assertEqual(p.status, Project.ACTIVE_STATUS)
self.assertEqual(p.description, 'A really great test organization.')
self.assertEqual(p.slug, 'test-project')
user.delete()
org.delete()
def setUp(self):
self.maxDiff = None
user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(
email='*****@*****.**', **user_details)
self.org, self.org_user, _ = create_organization(self.user)
self.cycle_factory = FakeCycleFactory(organization=self.org, user=self.user)
self.property_factory = FakePropertyFactory(organization=self.org)
self.property_state_factory = FakePropertyStateFactory(organization=self.org)
self.column_list_factory = FakeColumnListSettingsFactory(organization=self.org)
self.cycle = self.cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=timezone.get_current_timezone())
)
class ProfileIdMixInclass(ProfileIdMixin):
pass
self.mixin_class = ProfileIdMixInclass()
def setUp(self):
self.api_view = UpdateInventoryLabelsAPIView()
# Models can't be imported directly hence self
self.PropertyLabels = self.api_view.models['property']
self.TaxlotLabels = self.api_view.models['taxlot']
self.mock_property_queryset = mock_queryset_factory(
self.PropertyLabels,
flatten=True,
property_id=range(1, 11),
statuslabel_id=[1] * 3 + [2] * 3 + [3] * 2 + [4] * 2)
self.user_details = {
'username': '******',
'password': '******',
'email': '*****@*****.**'
}
self.user = User.objects.create_superuser(**self.user_details)
self.org, _, _ = create_organization(self.user)
self.status_label = Label.objects.create(name='test',
super_organization=self.org)
self.client.login(**self.user_details)
def setUp(self):
self.properties = []
self.maxDiff = None
user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(email='*****@*****.**',
**user_details)
self.org, _, _ = create_organization(self.user)
# create a default cycle
self.cycle = Cycle.objects.filter(organization_id=self.org).first()
self.property_factory = FakePropertyFactory(organization=self.org)
self.property_state_factory = FakePropertyStateFactory(
organization=self.org)
self.property_view_factory = FakePropertyViewFactory(
organization=self.org, user=self.user)
self.label_factory = FakeStatusLabelFactory(organization=self.org)
self.property_view = self.property_view_factory.get_property_view()
self.urls = ['http://example.com', 'http://example.org']
self.client.login(**user_details)
def test_basic_project_creation(self):
user = User.objects.create(username='******', first_name='t', last_name='est')
org, user_role, _user_created = create_organization(
user, 'Test Organization'
)
p = Project.objects.create(
name='Test Project',
owner=user,
super_organization=org,
description='A really great test organization.',
)
p.save()
self.assertEqual(p.name, 'Test Project')
self.assertTrue('Test Project' in str(p))
self.assertEqual(p.owner, user)
self.assertEqual(p.super_organization, org)
self.assertEqual(p.status, Project.ACTIVE_STATUS)
self.assertEqual(p.description, 'A really great test organization.')
self.assertEqual(p.slug, 'test-project')
user.delete()
org.delete()
def setUp(self):
self.maxDiff = None
user_details = {
'username': '******',
'password': '******',
}
self.user = User.objects.create_superuser(email='*****@*****.**',
**user_details)
self.org, _, _ = create_organization(self.user)
self.ga_factory = FakeGreenAssessmentFactory(organization=self.org)
assessment_data = {
'name': 'Test',
'award_body': 'Test Inc',
'recognition_type': 'AWD',
'description': 'Test Award',
'is_numeric_score': True,
'is_integer_score': True,
'validity_duration': 365
}
self.assessment = self.ga_factory.get_green_assessment(
**assessment_data)
def test_pm_property_id_existing_across_two_different_orgs_wont_lead_to_misassociated_meters(
self):
new_org, _, _ = create_organization(self.user)
property_details = FakePropertyStateFactory(
organization=new_org).get_details()
property_details['organization_id'] = new_org.id
# new state to be associated to property of different organization but has the same pm_property_id
property_details['pm_property_id'] = self.state_1.pm_property_id
state = PropertyState(**property_details)
state.save()
new_property_state = PropertyState.objects.get(pk=state.id)
new_cycle_factory = FakeCycleFactory(organization=new_org,
user=self.user)
new_cycle = new_cycle_factory.get_cycle(
start=datetime(2010, 10, 10, tzinfo=get_current_timezone()))
new_property = self.property_factory.get_property()
PropertyView.objects.create(property=new_property,
cycle=new_cycle,
state=new_property_state)
url = reverse("api:v3:import_files-start-save-data",
args=[self.import_file.id])
url += f'?organization_id={self.org.pk}'
post_params = {
'cycle_id': self.cycle.pk,
}
self.client.post(url, post_params)
# self.property_1 is associated to self.org, so according to post request, it should have 2 meters
refreshed_property_1 = Property.objects.get(
pk=self.property_1.id, organization_id__exact=self.org.pk)
self.assertEqual(refreshed_property_1.meters.all().count(), 2)
refreshed_new_property = Property.objects.get(pk=new_property.id)
self.assertEqual(refreshed_new_property.meters.count(), 0)
def test_update_rule_status_label_validation(self):
# Start with 1 Rule
dq = DataQualityCheck.retrieve(self.org.id)
dq.remove_all_rules()
base_rule_info = {
'field': 'address_line_1',
'table_name': 'PropertyState',
'enabled': True,
'data_type': Rule.TYPE_STRING,
'rule_type': Rule.RULE_TYPE_DEFAULT,
'condition': Rule.RULE_INCLUDE,
'required': False,
'not_null': False,
'min': None,
'max': None,
'text_match': 'Test Rule 1',
'severity': Rule.SEVERITY_ERROR,
'units': "",
}
dq.add_rule(base_rule_info)
rule = dq.rules.get()
# Send invalid update request that includes a label id from another org
new_org, _, _ = create_organization(self.user, "test-organization-a")
wrong_org_label_id = new_org.labels.first().id
put_data = deepcopy(base_rule_info)
put_data['status_label'] = wrong_org_label_id
url = reverse('api:v3:data_quality_check-rules-detail',
kwargs={
'nested_organization_id': self.org.id,
'pk': rule.id
})
res = self.client.put(url,
content_type='application/json',
data=json.dumps(put_data))
self.assertEqual(res.status_code, 400)
self.assertTrue(
f'Label with ID {wrong_org_label_id} not found in organization, {self.org.name}.'
in json.loads(res.content)['status_label'])
def add_user(request):
"""
Creates a new SEED user. One of 'organization_id' or 'org_name' is needed.
Sends invitation email to the new user.
Payload::
{
'organization_id': ID of an existing org to add the new user to,
'org_name': Name of a new org to create with user as owner
'first_name': First name of new user
'last_name': Last name of new user
'role': {
'value': The permission level of new user within this org
(one of member, viewer, owner)
},
'email': Email address of new user.
}
Returns::
{
'status': 'success',
'message': email address of new user,
'org': name of the new org (or existing org),
'org_created': True if new org created,
'username': Username of new user
}
"""
body = json.loads(request.body)
org_name = body.get("org_name")
org_id = body.get("organization_id")
if (org_name and org_id) or (not org_name and not org_id):
return {"status": "error", "message": "Choose either an existing org or provide a new one"}
first_name = body["first_name"]
last_name = body["last_name"]
email = body["email"]
username = body["email"]
user, created = User.objects.get_or_create(username=username.lower())
if org_id:
org = Organization.objects.get(pk=org_id)
org_created = False
else:
org, _, _ = create_organization(user, org_name)
org_created = True
# Add the user to the org. If this is the org's first user,
# the user becomes the owner/admin automatically.
# see Organization.add_member()
if not org.is_member(user):
org.add_member(user)
if body.get("role") and body.get("role", {}).get("value"):
OrganizationUser.objects.filter(organization_id=org.pk, user_id=user.pk).update(
role_level=_get_role_from_js(body["role"]["value"])
)
if created:
user.email = email
user.first_name = first_name
user.last_name = last_name
user.save()
try:
domain = request.get_host()
except Exception:
domain = "buildingenergy.com"
invite_to_seed(domain, user.email, default_token_generator.make_token(user), user.pk, first_name)
return {
"status": "success",
"message": user.email,
"org": org.name,
"org_created": org_created,
"username": user.username,
}
def create(self, request):
"""
Creates a new SEED user. One of 'organization_id' or 'org_name' is needed.
Sends invitation email to the new user.
---
parameters:
- name: organization_id
description: Organization ID if adding user to an existing organization
required: false
type: integer
- name: org_name
description: New organization name if creating a new organization for this user
required: false
type: string
- name: first_name
description: First name of new user
required: true
type: string
- name: last_name
description: Last name of new user
required: true
type: string
- name: role
description: one of owner, member, or viewer
required: true
type: string
- name: email
description: Email address of the new user
required: true
type: string
type:
status:
description: success or error
required: true
type: string
message:
description: email address of new user
required: true
type: string
org:
description: name of the new org (or existing org)
required: true
type: string
org_created:
description: True if new org created
required: true
type: string
username:
description: Username of new user
required: true
type: string
user_id:
description: User ID (pk) of new user
required: true
type: integer
"""
body = request.data
org_name = body.get('org_name')
org_id = body.get('organization_id')
if (org_name and org_id) or (not org_name and not org_id):
return JsonResponse({
'status': 'error',
'message': 'Choose either an existing org or provide a new one'
}, status=status.HTTP_409_CONFLICT)
first_name = body['first_name']
last_name = body['last_name']
email = body['email']
username = body['email']
user, created = User.objects.get_or_create(username=username.lower())
if org_id:
org = Organization.objects.get(pk=org_id)
org_created = False
else:
org, _, _ = create_organization(user, org_name)
org_created = True
# Add the user to the org. If this is the org's first user,
# the user becomes the owner/admin automatically.
# see Organization.add_member()
if not org.is_member(user):
org.add_member(user)
if body.get('role'):
# check if this is a dict, if so, grab the value out of 'value'
role = body['role']
if isinstance(role, dict):
role = role['value']
OrganizationUser.objects.filter(
organization_id=org.pk,
user_id=user.pk
).update(role_level=_get_role_from_js(role))
if created:
user.email = email
user.first_name = first_name
user.last_name = last_name
user.save()
try:
domain = request.get_host()
except Exception:
domain = 'buildingenergy.com' # TODO: What should this value be now?
invite_to_seed(domain, user.email,
default_token_generator.make_token(user), user.pk,
first_name)
return JsonResponse({'status': 'success', 'message': user.email, 'org': org.name,
'org_created': org_created, 'username': user.username,
'user_id': user.id})
