Python Species.save_with_user方法代码示例

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
    def test_like_filter(self):
        species = Species(
            instance=self.instance,
            common_name='this is a test species',
            genus='Genus-1',
            otm_code='S1')
        species.save_with_user(self.commander)

        p, t = self.create_tree_and_plot()

        t.species = species
        t.save_with_user(self.commander)

        species_like_filter = json.dumps({
            'species.common_name':
            {'LIKE': 's a tes'}})

        result = [o.pk for o in
                  _execute_filter(
                      self.instance, species_like_filter)]

        self.assertEqual(result, [p.pk])

        species.common_name = 'no match'
        species.save_with_user(self.commander)

        result = _execute_filter(
            self.instance, species_like_filter)

        self.assertEqual(len(result), 0)

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
    def test_like_filter(self):
        species = Species(
            instance=self.instance,
            common_name='this is a test species',
            genus='Genus-1',
            otm_code='S1')
        species.save_with_user(self.commander)

        p, t = self.create_tree_and_plot()

        t.species = species
        t.save_with_user(self.commander)

        species_like_filter = json.dumps({
            'species.common_name':
            {'LIKE': 's a tes'}})

        plots = search.Filter(species_like_filter, '', self.instance)\
                      .get_objects(Plot)

        result = [o.pk for o in plots]

        self.assertEqual(result, [p.pk])

        species.common_name = 'no match'
        species.save_with_user(self.commander)

        plots = search.Filter(species_like_filter, '', self.instance)\
                      .get_objects(Plot)

        self.assertEqual(len(plots), 0)

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
 def test_update_species(self):
     with self._assert_updates_eco_rev(True):
         tree = Tree(instance=self.instance, plot=self.plot)
         tree.save_with_user(self.user)
         species = Species(common_name='foo', instance=self.instance)
         species.save_with_user(self.user)
         request_dict = {'tree.species': species.pk}
         update_map_feature(request_dict, self.user, self.plot)

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
    def setUp(self):
        instance = make_instance()
        user = make_admin_user(instance)

        species = Species(instance=instance, genus="g1", species="", cultivar="", max_diameter=50.0, max_height=100.0)
        species.save_with_user(User.system_user())

        login(self.client, user.username)

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
 def test_height_too_large_for_species_fails_validation(self):
     max_height = 1
     s = Species(genus='Ulmus', species='rubra', cultivar='Columella',
                 instance=self.instance, max_height=max_height)
     s.save_with_user(self.user)
     self.tree.species = s
     self.tree.height = str(max_height + 1)
     with self.assertRaises(ValidationError) as cm:
         self.tree.save_with_user(self.user)
     self.assertValidationErrorDictContainsKey(cm.exception, 'height')

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
    def test_species_id_search(self):
        species1 = Species(
            common_name='Species-1',
            genus='Genus-1',
            otm_code='S1',
            instance=self.instance)
        species1.save_with_user(self.commander)

        species2 = Species(
            common_name='Species-2',
            genus='Genus-2',
            otm_code='S1',
            instance=self.instance)
        species2.save_with_user(self.commander)

        p1, t1 = self.create_tree_and_plot()
        p2, t2 = self.create_tree_and_plot()
        p3, t3 = self.create_tree_and_plot()

        t1.species = species1
        t1.save_with_user(self.commander)

        t2.species = species2
        t2.save_with_user(self.commander)

        species1_filter = json.dumps({'species.id': species1.pk})
        species2_filter = json.dumps({'species.id': species2.pk})
        species3_filter = json.dumps({'species.id': -1})

        plots =\
            search.Filter(species1_filter, '', self.instance).get_objects(Plot)

        self.assertEqual(
            {p1.pk},
            {p.pk
             for p in plots})

        plots =\
            search.Filter(species2_filter, '', self.instance).get_objects(Plot)

        self.assertEqual(
            {p2.pk},
            {p.pk
             for p in plots})

        plots =\
            search.Filter(species3_filter, '', self.instance).get_objects(Plot)

        self.assertEqual(
            0, len(plots))

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
def setupTreemapEnv():
    def local_render_to_response(*args, **kwargs):
        from django.template import loader
        from django.http import HttpResponse

        httpresponse_kwargs = {'mimetype': kwargs.pop('mimetype', None)}
        hr = HttpResponse(
            loader.render_to_string(*args, **kwargs), **httpresponse_kwargs)

        if hasattr(args[1], 'dicts'):
            hr.request_context = args[1].dicts

        return hr

    django.shortcuts.render_to_response = local_render_to_response

    instance = make_instance(is_public=True)
    create_stewardship_udfs(instance)

    make_user_with_default_role(instance, 'jim')
    commander = make_commander_user(instance, 'commander')
    make_apprentice_user(instance, 'apprentice')

    n1geom = MultiPolygon(Polygon(
        ((0, 0), (100, 0), (100, 100), (0, 100), (0, 0))))

    n2geom = MultiPolygon(
        Polygon(((0, 101), (101, 101), (101, 200), (0, 200), (0, 101))))

    n1 = Boundary(name="n1", category='blah', sort_order=4, geom=n1geom)
    n2 = Boundary(name="n2", category='blah', sort_order=4, geom=n2geom)

    n1.save()
    n2.save()

    s1 = Species(otm_code="s1", genus="testus1", species="specieius1",
                 cultivar='', instance=instance)
    s2 = Species(otm_code="s2", genus="testus2", species="specieius2",
                 cultivar='', instance=instance)
    s3 = Species(otm_code="s3", genus="testus2", species="specieius3",
                 cultivar='', instance=instance)

    s1.is_native = True
    s1.fall_conspicuous = True
    s1.flower_conspicuous = True
    s1.palatable_human = True

    s2.is_native = True
    s2.fall_conspicuous = False
    s2.flower_conspicuous = True
    s2.palatable_human = False
    s2.has_wildlife_value = True

    s3.has_wildlife_value = True

    s1.save_with_user(commander)
    s2.save_with_user(commander)
    s3.save_with_user(commander)

    return instance

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
    def test_tree_hash_to_model(self):
        test_plot = Plot(geom=Point(0, 0), instance=self.instance)
        test_plot.id = 95
        test_plot.save_with_user(self.commander)

        test_species = Species(instance=self.instance, otm_code="1",
                               common_name="asdfa", genus="sdfs")
        test_species.id = 85
        test_species.save_with_user(self.commander)

        tree_dict = json.loads(self.tree_blob)
        tree = hash_to_model(MIGRATION_RULES,
                             'tree', tree_dict, self.instance)
        tree.save_with_user(self.commander)
        tree = Tree.objects.get(pk=tree.pk)
        self.assertEqual(tree.plot, test_plot)
        self.assertEqual(tree.species, test_species)
        self.assertEqual(tree.readonly, True)
        self.assertEqual(tree.diameter, 0.2900001566)
        self.assertEqual(tree.canopy_height, None)
        self.assertEqual(tree.date_planted, None)
        self.assertEqual(tree.date_removed, None)

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
    def setUp(self):
        super(ExportSpeciesTaskTest, self).setUp()

        species = Species(common_name='foo', instance=self.instance)
        species.save_with_user(self.user)

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
class EcoTest(UrlTestCase):
    def setUp(self):
        # Example url for
        # CEAT, 1630 dbh, NoEastXXX
        # eco.json?otmcode=CEAT&diameter=1630&region=NoEastXXX
        def mockbenefits(*args, **kwargs):
            benefits = {
                "Benefits": {
                    "aq_nox_avoided": 0.6792,
                    "aq_nox_dep": 0.371,
                    "aq_ozone_dep": 0.775,
                    "aq_pm10_avoided": 0.0436,
                    "aq_pm10_dep": 0.491,
                    "aq_sox_avoided": 0.372,
                    "aq_sox_dep": 0.21,
                    "aq_voc_avoided": 0.0254,
                    "bvoc": -0.077,
                    "co2_avoided": 255.5,
                    "co2_sequestered": 0,
                    "co2_storage": 6575,
                    "electricity": 187,
                    "hydro_interception": 12.06,
                    "natural_gas": 5834.1
                }
            }
            return (benefits, None)

        region = ITreeRegion.objects.get(code='NoEastXXX')
        p = region.geometry.point_on_surface

        self.instance = make_instance(is_public=True, point=p)
        self.user = make_commander_user(self.instance)

        self.species = Species(otm_code='CEAT',
                               genus='cedrus',
                               species='atlantica',
                               max_dbh=2000,
                               max_height=100,
                               instance=self.instance)

        self.species.save_with_user(self.user)

        self.plot = Plot(geom=p, instance=self.instance)

        self.plot.save_with_user(self.user)

        self.tree = Tree(plot=self.plot,
                         instance=self.instance,
                         readonly=False,
                         species=self.species,
                         diameter=1630)

        self.tree.save_with_user(self.user)

        self.origBenefitFn = ecobackend.json_benefits_call
        ecobackend.json_benefits_call = mockbenefits

    def tearDown(self):
        ecobackend.json_benefits_call = self.origBenefitFn

    def assert_benefit_value(self, bens, benefit, unit, value):
        self.assertEqual(bens[benefit]['unit'], unit)
        self.assertEqual(int(float(bens[benefit]['value'])), value)

    def test_eco_benefit_sanity(self):
        rslt, basis, error = TreeBenefitsCalculator()\
            .benefits_for_object(self.instance, self.tree.plot)

        bens = rslt['plot']

        self.assert_benefit_value(bens, 'energy', 'kwh', 1896)
        self.assert_benefit_value(bens, 'airquality', 'lbs/year', 6)
        self.assert_benefit_value(bens, 'stormwater', 'gal', 3185)
        self.assert_benefit_value(bens, 'co2', 'lbs/year', 563)

    def testSearchBenefits(self):
        request = make_request(
            {'q': json.dumps({'tree.readonly': {'IS': False}})})  # all trees
        request.instance_supports_ecobenefits = self.instance\
                                                    .has_itree_region()
        result = search_tree_benefits(request, self.instance)

        benefits = result['benefits']

        self.assertTrue(len(benefits) > 0)

    def test_group_basis_empty(self):
        basis = {}
        example = {
            'group1': {
                'n_objects_used': 5,
                'n_objects_discarded': 8
            },
            'group2': {
                'n_objects_used': 10,
                'n_objects_discarded': 12
            }
        }

        _combine_benefit_basis(basis, example)
#.........这里部分代码省略.........

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
 def setUp(self):
     self.instance = make_instance()
     user = make_commander_user(instance=self.instance)
     species = Species(instance=self.instance, otm_code='',
                       common_name='', genus='')
     species.save_with_user(user)

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
class EcoTest(UrlTestCase):
    def setUp(self):
        # Example url for
        # CEAT, 1630 dbh, NoEastXXX
        # eco.json?otmcode=CEAT&diameter=1630&region=NoEastXXX
        def mockbenefits(*args, **kwargs):
            benefits = {
                "Benefits": {
                    "aq_nox_avoided": 0.6792,
                    "aq_nox_dep": 0.371,
                    "aq_ozone_dep": 0.775,
                    "aq_pm10_avoided": 0.0436,
                    "aq_pm10_dep": 0.491,
                    "aq_sox_avoided": 0.372,
                    "aq_sox_dep": 0.21,
                    "aq_voc_avoided": 0.0254,
                    "bvoc": -0.077,
                    "co2_avoided": 255.5,
                    "co2_sequestered": 0,
                    "co2_storage": 6575,
                    "electricity": 187,
                    "hydro_interception": 12.06,
                    "natural_gas": 5834.1
                }
            }
            return (benefits, None)

        region = ITreeRegion.objects.get(code='NoEastXXX')
        p = region.geometry.point_on_surface

        self.instance = make_instance(is_public=True, point=p)
        self.user = make_commander_user(self.instance)

        self.species = Species(otm_code='CEAT',
                               genus='cedrus',
                               species='atlantica',
                               max_dbh=2000,
                               max_height=100,
                               instance=self.instance)

        self.species.save_with_user(self.user)

        self.plot = Plot(geom=p, instance=self.instance)

        self.plot.save_with_user(self.user)

        self.tree = Tree(plot=self.plot,
                         instance=self.instance,
                         readonly=False,
                         species=self.species,
                         diameter=1630)

        self.tree.save_with_user(self.user)

        self.origBenefitFn = ecobackend.json_benefits_call
        ecobackend.json_benefits_call = mockbenefits

    def tearDown(self):
        ecobackend.json_benefits_call = self.origBenefitFn

    def assert_benefit_value(self, bens, benefit, unit, value):
        self.assertEqual(bens[benefit]['unit'], unit)
        self.assertEqual(int(float(bens[benefit]['value'])), value)

    def test_eco_benefit_sanity(self):
        rslt = tree_benefits(instance=self.instance,
                             tree_or_tree_id=self.tree)

        bens = rslt['tree_benefits']

        self.assert_benefit_value(bens, 'energy', 'kwh', 1896)
        self.assert_benefit_value(bens, 'airquality', 'lbs/year', 6)
        self.assert_benefit_value(bens, 'stormwater', 'gal', 3185)
        self.assert_benefit_value(bens, 'co2', 'lbs/year', 563)

    def testSearchBenefits(self):
        request = make_request(
            {'q': json.dumps({'tree.readonly': {'IS': False}})})  # all trees
        request.instance_supports_ecobenefits = self.instance\
                                                    .has_itree_region()
        result = search_tree_benefits(request, self.instance)

        benefits = result['tree_benefits']

        self.assertTrue(len(benefits) > 0)

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
class EcoTest(UrlTestCase):
    def setUp(self):
        region = ITreeRegion.objects.get(code='NoEastXXX')
        p = region.geometry.point_on_surface

        self.instance = make_instance(is_public=True, point=p)

        self.user = make_commander_user(self.instance)

        self.species = Species(otm_code='CEAT',
                               genus='cedrus',
                               species='atlantica',
                               max_dbh=2000,
                               max_height=100,
                               instance=self.instance)
        self.species.save_with_user(self.user)

        self.plot = Plot(geom=p, instance=self.instance)

        self.plot.save_with_user(self.user)

        self.tree = Tree(plot=self.plot,
                         instance=self.instance,
                         readonly=False,
                         species=self.species,
                         diameter=1630)

        self.tree.save_with_user(self.user)

    def test_group_eco(self):
        pass  # TODO: Once filtering has been enabled

    def assert_benefit_value(self, bens, benefit, unit, value):
            self.assertEqual(bens[benefit]['unit'], unit)
            self.assertEqual(int(float(bens[benefit]['value'])), value)

    def test_eco_benefit_sanity(self):
        rslt = tree_benefits(instance=self.instance,
                             tree_id=self.tree.pk)

        bens = rslt['benefits'][0]

        self.assert_benefit_value(bens, 'energy', 'kwh', 1896)
        self.assert_benefit_value(bens, 'airquality', 'lbs/year', 6)
        self.assert_benefit_value(bens, 'stormwater', 'gal', 3185)
        self.assert_benefit_value(bens, 'co2', 'lbs/year', 563)

    def test_species_for_none_region_lookup(self):
        self.assertIsNone(species_codes_for_regions(None))

    def test_species_for_region_lookup(self):
        northeast = species_codes_for_regions(['NoEastXXX'])
        self.assertEqual(258, len(northeast))

        south = species_codes_for_regions(['PiedmtCLT'])
        self.assertEqual(244, len(south))

        combined = species_codes_for_regions(['NoEastXXX', 'PiedmtCLT'])
        self.assertEqual(338, len(combined))

        combined_set = set(combined)
        self.assertEqual(len(combined), len(combined_set),
                         "Getting the species for more than one region "
                         "should result in a unique set of otm_codes")

    def test_default_region(self):
        # move the point outside the eco region
        self.plot.geom = Point(0, 0)
        self.plot.save_with_user(self.user)

        result = tree_benefits(instance=self.instance,
                               tree_id=self.tree.pk)
        bens_wo_default = result['benefits'][0]
        self.assert_benefit_value(bens_wo_default, 'energy', 'kwh', 0)
        self.assert_benefit_value(bens_wo_default, 'airquality', 'lbs/year', 0)
        self.assert_benefit_value(bens_wo_default, 'stormwater', 'gal', 0)
        self.assert_benefit_value(bens_wo_default, 'co2', 'lbs/year', 0)

        self.instance.itree_region_default = 'NoEastXXX'
        self.instance.save()
        result = tree_benefits(instance=self.instance,
                               tree_id=self.tree.pk)
        bens_with_default = result['benefits'][0]
        self.assert_benefit_value(bens_with_default,
                                  'energy', 'kwh', 1896)
        self.assert_benefit_value(bens_with_default,
                                  'airquality', 'lbs/year', 6)
        self.assert_benefit_value(bens_with_default,
                                  'stormwater', 'gal', 3185)
        self.assert_benefit_value(bens_with_default,
                                  'co2', 'lbs/year', 563)

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
 def make_species(self, otm_code):
     species = Species(instance=self.instance, otm_code=otm_code)
     species.save_with_user(self.commander)
     return species

# 需要导入模块: from treemap.models import Species [as 别名]
# 或者: from treemap.models.Species import save_with_user [as 别名]
class EcoTest(UrlTestCase):
    def setUp(self):

        self.instance = make_instance(is_public=True)

        self.user = make_commander_user(self.instance)

        self.species = Species(otm_code='CEAT',
                               genus='cedrus',
                               species='atlantica',
                               max_dbh=2000,
                               max_height=100,
                               instance=self.instance)
        self.species.save_with_user(self.user)

        ITreeRegion.objects.all().delete()

        p1 = Point(-8515941.0, 4953519.0)

        self.region_buffer_in_meters = 1000

        ITreeRegion.objects.create(
            code='NoEastXXX',
            geometry=MultiPolygon([p1.buffer(1000)]))

        self.plot = Plot(geom=p1,
                         instance=self.instance)

        self.plot.save_with_user(self.user)

        self.tree = Tree(plot=self.plot,
                         instance=self.instance,
                         readonly=False,
                         species=self.species,
                         diameter=1630)

        self.tree.save_with_user(self.user)

    def test_tree_benefits_url(self):
        self.assert_200(
            '/%s/eco/benefit/tree/%s/' % (self.instance.url_name,
                                          self.tree.id))

    def test_tree_benefit_url_invalid(self):
        self.assert_404(
            '/%s/eco/benefit/tree/999/' % self.instance.url_name)

    def test_group_eco(self):
        pass  # TODO: Once filtering has been enabled

    def assert_benefit_value(self, bens, benefit, unit, value):
            self.assertEqual(bens[benefit]['unit'], unit)
            self.assertEqual(int(float(bens[benefit]['value'])), value)

    def test_eco_benefit_sanity(self):
        rslt = tree_benefits(instance=self.instance,
                             tree_id=self.tree.pk)

        bens = rslt['benefits'][0]

        self.assert_benefit_value(bens, 'energy', 'kwh', 1896)
        self.assert_benefit_value(bens, 'airquality', 'lbs/year', 6)
        self.assert_benefit_value(bens, 'stormwater', 'gal', 3185)
        self.assert_benefit_value(bens, 'co2', 'lbs/year', 563)

    def test_species_for_none_region_lookup(self):
        self.assertIsNone(species_codes_for_regions(None))

    def test_species_for_region_lookup(self):
        northeast = species_codes_for_regions(['NoEastXXX'])
        self.assertEqual(258, len(northeast))

        south = species_codes_for_regions(['PiedmtCLT'])
        self.assertEqual(244, len(south))

        combined = species_codes_for_regions(['NoEastXXX', 'PiedmtCLT'])
        self.assertEqual(338, len(combined))

        combined_set = set(combined)
        self.assertEqual(len(combined), len(combined_set),
                         "Getting the species for more than one region "
                         "should result in a unique set of otm_codes")

    def test_default_region(self):
        # move the point outside the eco region
        self.plot.geom.x += self.region_buffer_in_meters * 2
        self.plot.save_with_user(self.user)

        result = tree_benefits(instance=self.instance,
                               tree_id=self.tree.pk)
        bens_wo_default = result['benefits'][0]
        self.assert_benefit_value(bens_wo_default, 'energy', 'kwh', 0)
        self.assert_benefit_value(bens_wo_default, 'airquality', 'lbs/year', 0)
        self.assert_benefit_value(bens_wo_default, 'stormwater', 'gal', 0)
        self.assert_benefit_value(bens_wo_default, 'co2', 'lbs/year', 0)

        self.instance.itree_region_default = 'NoEastXXX'
        self.instance.save()
        result = tree_benefits(instance=self.instance,
                               tree_id=self.tree.pk)
#.........这里部分代码省略.........