def ready(self):
# Register signals.
from . import signals
# When registering by decorator, the last app in INSTALLED_APPS gets
# called first. But in order to override cartridge templates, we need to
# be before cartridge in INSTALLED_APPS. Therefore we register here
# after all apps have been init'd.
from mezzanine.forms.models import Form
from mezzanine.pages.page_processors import processor_for
from .page_processors import override_mezzanine_form_processor
processor_for(Form)(override_mezzanine_form_processor)
if not settings.SESSION_COOKIE_SECURE:
logger = logging.getLogger(__name__)
logger.warning(
'SESSION_COOKIE_SECURE is not set! Cartridge-Downloads stores '
'client credentials in session cookies.')
def can_change(self, request):
return AbstractResource.can_change(self, request)
def can_delete(self, request):
return AbstractResource.can_delete(self, request)
def can_view(self, request):
return AbstractResource.can_view(self, request)
@classmethod
def get_supported_upload_file_types(cls):
# all file types are supported
return ('.*')
processor_for(ModelInstanceResource)(resource_processor)
# metadata container class
class ModelInstanceMetaData(CoreMetaData):
_model_output = generic.GenericRelation(ModelOutput)
_executed_by = generic.GenericRelation(ExecutedBy)
@property
def model_output(self):
return self._model_output.all().first()
@property
def executed_by(self):
return self._executed_by.all().first()
@classmethod
return
nc_res_file = get_resource_files_by_extension(self, ".nc")
txt_res_file = get_resource_files_by_extension(self, ".txt")
from hs_file_types.models.netcdf import netcdf_file_update # avoid recursive import
if nc_res_file and txt_res_file:
netcdf_file_update(self, nc_res_file[0], txt_res_file[0], user)
discovery_content_type = 'Multidimensional (NetCDF)' # used during discovery
class Meta:
verbose_name = 'Multidimensional (NetCDF)'
proxy = True
processor_for(NetcdfResource)(resource_processor)
class NetCDFMetaDataMixin(models.Model):
"""This class must be the first class in the multi-inheritance list of classes"""
variables = GenericRelation(Variable)
ori_coverage = GenericRelation(OriginalCoverage)
class Meta:
abstract = True
@property
def originalCoverage(self):
return self.ori_coverage.all().first()
def has_all_required_elements(self):
@classmethod
def can_have_multiple_files(cls):
# resource can't have any files
return False
@classmethod
def get_metadata_class(cls):
return ToolMetaData
@property
def can_be_published(self):
return False
processor_for(ToolResource)(resource_processor)
class SupportedFileExtensions(AbstractMetaDataElement):
term = 'SupportedFileExtensions'
value = models.CharField(max_length=1024, blank=True, default="")
class Meta:
# SupportedFileExtensions element is not repeatable
unique_together = ("content_type", "object_id")
class AppHomePageUrl(AbstractMetaDataElement):
term = 'AppHomePageUrl'
value = models.CharField(max_length=1024, blank=True, default="")
def has_resources(self):
return self.resources.count() > 0
@property
def are_all_contained_resources_published(self):
if not self.has_resources:
return False
return not self.resources.all().filter(raccess__published=False).exists()
@property
def can_be_published(self):
return self.can_be_public_or_discoverable and \
self.are_all_contained_resources_published
@property
def update_text_file(self):
return self.extra_data.get('update_text_file', 'True')
processor_for(CollectionResource)(resource_processor)
class CollectionDeletedResource(models.Model):
resource_title = models.TextField(null=False, blank=False)
deleted_by = models.ForeignKey(User)
date_deleted = models.DateTimeField(auto_now_add=True)
collection = models.ForeignKey(BaseResource)
resource_id = models.CharField(max_length=32)
resource_type = models.CharField(max_length=50)
resource_owners = models.ManyToManyField(User, related_name='collectionDeleted')
return AbstractResource.can_add(self, request)
def can_change(self, request):
return AbstractResource.can_change(self, request)
def can_delete(self, request):
return AbstractResource.can_delete(self, request)
def can_view(self, request):
return AbstractResource.can_view(self, request)
class Meta:
verbose_name = 'Multidimensional (NetCDF)'
processor_for(NetcdfResource)(resource_processor)
# define the netcdf metadata
class NetcdfMetaData(CoreMetaData):
variables = generic.GenericRelation(Variable)
ori_coverage = generic.GenericRelation(OriginalCoverage)
@classmethod
def get_supported_element_names(cls):
# get the names of all core metadata elements
elements = super(NetcdfMetaData, cls).get_supported_element_names()
# add the name of any additional element to the list
elements.append('Variable')
elements.append('OriginalCoverage')
return elements
# Model Instance Resource type
class ModelInstanceResource(BaseResource):
objects = ResourceManager("ModelInstanceResource")
discovery_content_type = 'Model Instance' # used during discovery
class Meta:
verbose_name = 'Model Instance Resource'
proxy = True
@classmethod
def get_metadata_class(cls):
return ModelInstanceMetaData
processor_for(ModelInstanceResource)(resource_processor)
# metadata container class
class ModelInstanceMetaData(CoreMetaData):
_model_output = GenericRelation(ModelOutput)
_executed_by = GenericRelation(ExecutedBy)
@property
def resource(self):
return ModelInstanceResource.objects.filter(object_id=self.id).first()
@property
def model_output(self):
return self._model_output.all().first()
geometryinformation = self.metadata.geometryinformation
if geometryinformation is not None:
hs_term_dict[
"HS_GFR_FEATURE_COUNT"] = geometryinformation.featureCount
else:
hs_term_dict["HS_GFR_FEATURE_COUNT"] = 0
return hs_term_dict
discovery_content_type = 'Geographic Feature (ESRI Shapefiles)' # used during discovery
class Meta:
verbose_name = 'Geographic Feature (ESRI Shapefiles)'
proxy = True
processor_for(GeographicFeatureResource)(resource_processor)
class GeographicFeatureMetaDataMixin(models.Model):
"""This class must be the first class in the multi-inheritance list of classes"""
geometryinformations = GenericRelation(GeometryInformation)
fieldinformations = GenericRelation(FieldInformation)
originalcoverages = GenericRelation(OriginalCoverage)
class Meta:
abstract = True
@property
def geometryinformation(self):
return self.geometryinformations.all().first()
discovery_content_type = 'Model Program' # used during discovery
class Meta:
verbose_name = 'Model Program Resource'
proxy = True
@classmethod
def get_metadata_class(cls):
return ModelProgramMetaData
@classmethod
def get_supported_upload_file_types(cls):
# all file types are supported
return ('.*')
processor_for(ModelProgramResource)(resource_processor)
class ModelProgramMetaData(CoreMetaData):
_mpmetadata = GenericRelation(MpMetadata)
@property
def resource(self):
return ModelProgramResource.objects.filter(object_id=self.id).first()
@property
def serializer(self):
"""Return an instance of rest_framework Serializer for self """
from serializers import ModelProgramMetaDataSerializer
return ModelProgramMetaDataSerializer(self)
if date_data[key] is None:
date_data[key] = coverage_element.value[key]
else:
if comparison_operator(
parser.parse(date_data[key]),
parser.parse(coverage_element.value[key])):
date_data[key] = coverage_element.value[key]
for temp_cov in temporal_coverages:
start_date = parser.parse(temp_cov.value['start'])
end_date = parser.parse(temp_cov.value['end'])
temp_cov.value['start'] = start_date.strftime('%m/%d/%Y')
temp_cov.value['end'] = end_date.strftime('%m/%d/%Y')
set_date_value(date_data, temp_cov, 'start')
set_date_value(date_data, temp_cov, 'end')
temp_cov = self.metadata.temporal_coverage
if date_data['start'] is not None and date_data['end'] is not None:
if temp_cov:
temp_cov._value = json.dumps(date_data)
temp_cov.save()
else:
self.metadata.create_element("coverage",
type='period',
value=date_data)
# this would allow us to pick up additional form elements for the template before the template
# is displayed
processor_for(CompositeResource)(resource_processor)
md = ConfigParser.ConfigParser()
md.readfp(StringIO.StringIO(metadata))
resource.project_name = root
resource.model_desc = md.get('rhessys', 'model_description')
resource.git_repo = md.get('rhessys', 'rhessys_src')
resource.commit_id = md.get('rhessys', 'rhessys_sha')
resource.study_area_bbox = md.get('study_area', 'bbox_wgs84')
resource.save()
zfile.close()
processor_for(InstResource)(resource_processor)
@processor_for(InstResource)
def main_page(request, page):
if(request.method == 'POST'):
form = InputForm(request.POST)
if(form.is_valid()):
content_model = page.get_content_model()
content_model.name=form.cleaned_data['name']
content_model.git_username = form.cleaned_data['git_username']
content_model.git_password = form.cleaned_data['git_password']
content_model.git_branch = form.cleaned_data['git_branch']
content_model.model_command_line_parameters = form.cleaned_data['model_command_line_parameters']
#content_model.project_name = form.cleaned_data['project_name']
#content_model.model_desc = form.cleaned_data['model_desc']
#content_model.study_area_bbox = form.cleaned_data['study_area_bbox']
# modified
# #######################
# # TEMPORAL DEFINITION #
# #######################
# # Only for Instance Types
# hm_begin = models.DateTimeField(verbose_name='Simulation Begin',
# help_text='The start date of the model simulation (mm/dd/yyyy hh:mm)')
# hm_end = models.DateTimeField(verbose_name='Simulation End',
# help_text='The end date of the model simulation (mm/dd/yyyy hh:mm)')
# hm_timestep = models.FloatField(verbose_name='Simulation Time Interval',
# help_text='The timestep interval that is used for calculations (in seconds)')
class Meta:
verbose_name = 'HydroProgram'
processor_for(HydroProgramResource)(resource_processor)
from django.contrib.contenttypes import generic
from django.contrib.auth.models import User, Group
from django.db import models
from mezzanine.pages.models import Page, RichText
from mezzanine.core.models import Ownable
from hs_core.models import AbstractResource
from hs_core.models import resource_processor
from mezzanine.pages.page_processors import processor_for
class TimeSeries(Page, RichText, AbstractResource):
resource_description = models.TextField(null=False, blank=True, default='',
help_text='I.E. Upper Provo River Flow',
)
resource_url=models.TextField(max_length=100,null=False, blank=True, default='',
help_text="The WSDL Url for your web services- I.E. 'http://worldwater.byu.edu/interactive/dr/services/index.php/services/cuahsi_1_1.asmx?WSDL'"
)
resource_namespace=models.TextField(max_length=100,null=False, blank=True, default='',
help_text='The namespace is probably {http://www.cuahsi.org/waterML/1.1/}'
)
resource_file=models.FileField(upload_to="timeseries",null=True,blank=True)
class Meta:
verbose_name = "Time Series"
processor_for(TimeSeries)(resource_processor)
class Meta:
proxy = True
verbose_name = 'Script Resource'
@classmethod
def get_supported_upload_file_types(cls):
# one file type is supported
return ".r", ".py", ".m"
@classmethod
def get_metadata_class(cls):
return ScriptMetaData
processor_for(ScriptResource)(resource_processor)
class ScriptSpecificMetadata(AbstractMetaDataElement):
term = "ScriptSpecificMetadata"
# program language
scriptLanguage = models.CharField(verbose_name='Programming Language', blank=True, max_length=100, default='R',
help_text='The programming language that the script is written in')
# language version
languageVersion = models.CharField(verbose_name='Programming Language Version', blank=True, max_length=255,
help_text='The software version of the script')
# script version
scriptVersion = models.CharField(verbose_name='Script Version', max_length=255, blank=True, default='1.0',
@property
def are_all_contained_resources_published(self):
if not self.has_resources:
return False
return not self.resources.all().filter(
raccess__published=False).exists()
@property
def can_be_published(self):
return self.can_be_public_or_discoverable and \
self.are_all_contained_resources_published
@property
def update_text_file(self):
return self.extra_data.get('update_text_file', 'True')
processor_for(CollectionResource)(resource_processor)
class CollectionDeletedResource(models.Model):
resource_title = models.TextField(null=False, blank=False)
deleted_by = models.ForeignKey(User)
date_deleted = models.DateTimeField(auto_now_add=True)
collection = models.ForeignKey(BaseResource)
resource_id = models.CharField(max_length=32)
resource_type = models.CharField(max_length=50)
resource_owners = models.ManyToManyField(User,
related_name='collectionDeleted')
@classmethod
def can_have_multiple_files(cls):
# resource can't have any files
return False
@classmethod
def get_metadata_class(cls):
return ToolMetaData
@property
def can_be_published(self):
return False
processor_for(ToolResource)(resource_processor)
class SupportedFileExtensions(AbstractMetaDataElement):
term = 'SupportedFileExtensions'
value = models.CharField(max_length=1024, blank=True, default="")
class Meta:
# SupportedFileExtensions element is not repeatable
unique_together = ("content_type", "object_id")
class AppHomePageUrl(AbstractMetaDataElement):
term = 'AppHomePageUrl'
value = models.CharField(max_length=1024, blank=True, default="")
# get existing hs_term_dict from base class
hs_term_dict = super(RasterResource, self).get_hs_term_dict()
# add new terms for Raster res
hs_term_dict["HS_FILE_NAME"] = ""
for res_file in self.files.all():
_, f_fullname, f_ext = get_resource_file_name_and_extension(
res_file)
if f_ext.lower() == '.vrt':
hs_term_dict["HS_FILE_NAME"] = f_fullname
break
return hs_term_dict
# this would allow us to pick up additional form elements for the template
# before the template is displayed via Mezzanine page processor
processor_for(RasterResource)(resource_processor)
class GeoRasterMetaDataMixin(models.Model):
"""This class must be the first class in the multi-inheritance list of classes"""
# required non-repeatable cell information metadata elements
_cell_information = GenericRelation(CellInformation)
_band_information = GenericRelation(BandInformation)
_ori_coverage = GenericRelation(OriginalCoverage)
class Meta:
abstract = True
@property
def cellInformation(self):
class Meta:
verbose_name = 'Generic Hydroshare Resource'
def can_add(self, request):
return AbstractResource.can_add(self, request)
def can_change(self, request):
return AbstractResource.can_change(self, request)
def can_delete(self, request):
return AbstractResource.can_delete(self, request)
def can_view(self, request):
return AbstractResource.can_view(self, request)
def resource_processor(request, page):
extra = page_permissions_page_processor(request, page)
extra['res'] = page.get_content_model()
extra['dc'] = { m.term_name : m.content for m in extra['res'].dublin_metadata.all() }
return extra
processor_for(GenericResource)(resource_processor)
@processor_for('resources')
def resource_listing_processor(request, page):
owned_resources = list(GenericResource.objects.filter(owners__pk=request.user.pk))
editable_resources = list(GenericResource.objects.filter(owners__pk=request.user.pk))
viewable_resources = list(GenericResource.objects.filter(public=True))
return locals()
verbose_name = 'Model Program Resource'
proxy = True
@property
def metadata(self):
md = ModelProgramMetaData()
meta = self._get_metadata(md)
return meta
@classmethod
def get_supported_upload_file_types(cls):
# all file types are supported
return ('.*')
processor_for(ModelProgramResource)(resource_processor)
class ModelProgramMetaData(CoreMetaData):
_mpmetadata = GenericRelation(MpMetadata)
@property
def resource(self):
return ModelProgramResource.objects.filter(object_id=self.id).first()
@property
def program(self):
return self._mpmetadata.all().first()
@classmethod
def get_supported_element_names(cls):
from mezzanine.pages.page_processors import processor_for
from django.db import models
from django.contrib.contenttypes.models import ContentType
class ResourceAggregation(Page, AbstractResource, RichText):
resources = generic.GenericRelation('resource_aggregation.Resource')
def can_add(self, request):
return AbstractResource.can_add(self, request)
def can_change(self, request):
return AbstractResource.can_change(self, request)
def can_delete(self, request):
return AbstractResource.can_delete(self, request)
def can_view(self, request):
return AbstractResource.can_view(self, request)
processor_for(ResourceAggregation)(resource_processor)
class Resource(models.Model):
object_id = models.PositiveIntegerField()
content_type = models.ForeignKey(ContentType)
content_object = generic.GenericForeignKey('content_type', 'object_id')
resource_short_id = models.CharField(max_length=32, db_index=True) # the short_id of the resource
resource_description = models.CharField(max_length=5000, blank=True, default='')
def get_supported_upload_file_types(cls):
# no file types are supported
return ()
@classmethod
def allow_multiple_file_upload(cls):
# no file can be uploaded
return False
@classmethod
def can_have_multiple_files(cls):
# resource can't have any files
return False
processor_for(RefTimeSeriesResource)(resource_processor)
class ReferenceURL(AbstractMetaDataElement):
term = 'ReferenceURL'
value = models.CharField(max_length=500)
type = models.CharField(max_length=4)
class Method(AbstractMetaDataElement):
term = 'Method'
code = models.CharField(max_length=500, default="", blank=True)
description = models.TextField(default="", blank=True)
class QualityControlLevel(AbstractMetaDataElement):
term = 'QualityControlLevel'
code = models.CharField(max_length=500, default="", blank=True)
definition = models.CharField(max_length=500, default="", blank=True)
return False
def can_add(self, request):
return AbstractResource.can_add(self, request)
def can_change(self, request):
return AbstractResource.can_change(self, request)
def can_delete(self, request):
return AbstractResource.can_delete(self, request)
def can_view(self, request):
return AbstractResource.can_view(self, request)
# this would allow us to pick up additional form elements for the template before the template is displayed via Mezzanine page processor
processor_for(RasterResource)(resource_processor)
class RasterMetaData(CoreMetaData):
# required non-repeatable cell information metadata elements
_cell_information = generic.GenericRelation(CellInformation)
_band_information = generic.GenericRelation(BandInformation)
_ori_coverage = generic.GenericRelation(OriginalCoverage)
@property
def cellInformation(self):
return self._cell_information.all().first()
@property
def bandInformation(self):
return self._band_information.all()
class Meta:
proxy = True
verbose_name = 'Script Resource'
@classmethod
def get_supported_upload_file_types(cls):
# one file type is supported
return ".r", ".py", ".m"
@property
def metadata(self):
md = ScriptMetaData()
return self._get_metadata(md)
processor_for(ScriptResource)(resource_processor)
class ScriptSpecificMetadata(AbstractMetaDataElement):
term = "ScriptSpecificMetadata"
# program language
scriptLanguage = models.CharField(
verbose_name='Programming Language',
blank=True,
max_length=100,
default='R',
help_text='The programming language that the script is written in')
# language version
languageVersion = models.CharField(
hs_term_dict = super(GeographicFeatureResource, self).get_hs_term_dict()
geometryinformation = self.metadata.geometryinformation
if geometryinformation is not None:
hs_term_dict["HS_GFR_FEATURE_COUNT"] = geometryinformation.featureCount
else:
hs_term_dict["HS_GFR_FEATURE_COUNT"] = 0
return hs_term_dict
discovery_content_type = 'Geographic Feature (ESRI Shapefiles)' # used during discovery
class Meta:
verbose_name = 'Geographic Feature (ESRI Shapefiles)'
proxy = True
processor_for(GeographicFeatureResource)(resource_processor)
class GeographicFeatureMetaDataMixin(models.Model):
"""This class must be the first class in the multi-inheritance list of classes"""
geometryinformations = GenericRelation(GeometryInformation)
fieldinformations = GenericRelation(FieldInformation)
originalcoverages = GenericRelation(OriginalCoverage)
class Meta:
abstract = True
@property
def geometryinformation(self):
return self.geometryinformations.all().first()