Example #1
0
 def check_permissions(self, request):
     """ checks permissions """
     if request is not None and self.manifest is not False:
         # check to make sure edit permissions OK
         pp = ProjectPermissions(self.manifest.project_uuid)
         self.edit_permitted = pp.edit_allowed(request)
         self.view_permitted = pp.view_allowed(request)
Example #2
0
 def __init__(self,
              uuid,
              request=False):
     self.uuid = uuid
     self.request = request
     self.errors = {'uuid': False,
                    'html': False}
     self.response = {}
     self.edit_status = 0
     self.manifest = False
     if uuid is not False:
         try:
             self.manifest = Manifest.objects.get(uuid=uuid)
         except Manifest.DoesNotExist:
             self.manifest = False
             self.errors['uuid'] = 'Item ' + uuid + ' not in manifest'
         if request is not False and self.manifest is not False:
             # check to make sure edit permissions OK
             pp = ProjectPermissions(self.manifest.project_uuid)
             self.edit_permitted = pp.edit_allowed(request)
         else:
             # default to no editting permissions
             self.edit_permitted = False
     if self.manifest is not False:
         try:
             proj = Project.objects.get(uuid=self.manifest.project_uuid)
             self.edit_status = proj.edit_status
         except Project.DoesNotExist:
             proj = False
             self.edit_status = 0
 def check_permissions(self, request):
     """ checks permissions """
     if request is not None and self.manifest is not False:
         # check to make sure edit permissions OK
         pp = ProjectPermissions(self.manifest.project_uuid)
         self.edit_permitted = pp.edit_allowed(request)
         self.view_permitted = pp.view_allowed(request)
Example #4
0
 def __init__(self,
              project_uuid,
              request=False):
     self.project_uuid = project_uuid
     self.oc_root_project = False
     self.request = request
     self.errors = {'params': False}
     self.response = {}
     try:
         self.project = Project.objects.get(uuid=project_uuid)
     except Project.DoesNotExist:
         self.project = False
     try:
         self.proj_manifest_obj = Manifest.objects.get(uuid=project_uuid)
     except Manifest.DoesNotExist:
         self.proj_manifest_obj = False
     if request is not False and self.project is not False:
         # check to make sure edit permissions OK
         pp = ProjectPermissions(project_uuid)
         self.edit_permitted = pp.edit_allowed(request)
     else:
         # default to no editting permissions
         self.edit_permitted = False
     if project_uuid == '0' \
        or project_uuid == ''  \
        or project_uuid == 'oc':
         self.oc_root_project = True
     else:
         self.oc_root_project = False
Example #5
0
def project_annotations_ttl(request, identifier):
    """ Returns RDF open annotation assertions conforming to
        Pelagios specifications that link
        Open Context resources with place entities in
        gazetteers, in the turtle format
    """
    ent = Entity()
    found = ent.dereference(identifier)
    if found:
        if ent.item_type == 'projects':
            pp = ProjectPermissions(ent.uuid)
            permitted = pp.view_allowed(request)
            if permitted:
                pelagios = PelagiosGraph()
                pelagios.project_uuids = [ent.uuid]
                pelagios.test_limit = None
                pelagios.make_graph()
                # default to outputting in turtle
                output = pelagios.g.serialize(format='turtle')
                return HttpResponse(output,
                                    content_type='text/turtle; charset=utf8')
            else:
                return HttpResponse('Not authorized to get this resource',
                                    content_type='text/html; charset=utf8',
                                    status=401)
        else:
            found = False
    if found is False:
        raise Http404
Example #6
0
 def __init__(self, project_uuid, request=False):
     self.project_uuid = project_uuid
     self.oc_root_project = False
     self.request = request
     self.errors = {'params': False}
     self.response = {}
     try:
         self.project = Project.objects.get(uuid=project_uuid)
     except Project.DoesNotExist:
         self.project = False
     try:
         self.proj_manifest_obj = Manifest.objects.get(uuid=project_uuid)
     except Manifest.DoesNotExist:
         self.proj_manifest_obj = False
     if request is not False and self.project is not False:
         # check to make sure edit permissions OK
         pp = ProjectPermissions(project_uuid)
         self.edit_permitted = pp.edit_allowed(request)
     else:
         # default to no editting permissions
         self.edit_permitted = False
     if project_uuid == '0' \
        or project_uuid == ''  \
        or project_uuid == 'oc':
         self.oc_root_project = True
     else:
         self.oc_root_project = False
Example #7
0
 def check_view_permission(self, project_uuid):
     """ Checkes to see if viewing the item is permitted
     """
     permitted = True # default
     if self.request is not False:
         pp = ProjectPermissions(project_uuid)
         permitted = pp.view_allowed(self.request)
     return permitted
Example #8
0
def project_annotations(request, identifier):
    """ Returns RDF open annotation assertions conforming to
        Pelagios specifications that link
        Open Context resources with place entities in
        gazetteers
    """
    ent = Entity()
    found = ent.dereference(identifier)
    if found or identifier == 'web':
        if ent.item_type == 'projects' or identifier == 'web':
            pelagios = PelagiosGraph()
            pelagios.test_limit = None
            if 'refresh' in request.GET:
                # we're going to refresh the cache
                pelagios.refresh_cache = True
            if identifier != 'web':
                pp = ProjectPermissions(ent.uuid)
                permitted = pp.view_allowed(request)
                pelagios.project_uuids = [ent.uuid]
            else:
                # we're doing web annotations
                pelagios.do_web_annotations = True
                permitted = True
            if permitted:
                pelagios.get_graph()
                req_neg = RequestNegotiation('text/turtle')
                req_neg.supported_types = [
                    'application/rdf+xml', 'text/n3', 'application/n-triples'
                ]
                if 'HTTP_ACCEPT' in request.META:
                    req_neg.check_request_support(request.META['HTTP_ACCEPT'])
                    if req_neg.supported:
                        content_type = req_neg.use_response_type + '; charset=utf8'
                        output = pelagios.g.serialize(
                            format=req_neg.use_response_type)
                        return HttpResponse(output, content_type=content_type)
                    else:
                        # client wanted a mimetype we don't support
                        return HttpResponse(
                            req_neg.error_message,
                            content_type="text/plain; charset=utf8",
                            status=415)
                else:
                    # default to outputting in turtle
                    output = pelagios.g.serialize(format='turtle')
                    return HttpResponse(
                        output, content_type='text/turtle; charset=utf8')
            else:
                return HttpResponse('Not authorized to get this resource',
                                    content_type='text/html; charset=utf8',
                                    status=401)
        else:
            found = False
    if found is False:
        raise Http404
Example #9
0
def project_annotations(request, identifier):
    """ Returns RDF open annotation assertions conforming to
        Pelagios specifications that link
        Open Context resources with place entities in
        gazetteers
    """
    ent = Entity()
    found = ent.dereference(identifier)
    if found or identifier == 'web':
        if ent.item_type == 'projects' or identifier == 'web':
            pelagios = PelagiosGraph()
            pelagios.test_limit = None
            if 'refresh' in request.GET:
                # we're going to refresh the cache
                pelagios.refresh_cache = True
            if identifier != 'web':
                pp = ProjectPermissions(ent.uuid)
                permitted = pp.view_allowed(request)
                pelagios.project_uuids = [ent.uuid]
            else:
                # we're doing web annotations
                pelagios.do_web_annotations = True
                permitted = True
            if permitted:
                pelagios.get_graph()
                req_neg = RequestNegotiation('text/turtle')
                req_neg.supported_types = ['application/rdf+xml',
                                           'text/n3',
                                           'application/n-triples']
                if 'HTTP_ACCEPT' in request.META:
                    req_neg.check_request_support(request.META['HTTP_ACCEPT'])
                    if req_neg.supported:
                        content_type = req_neg.use_response_type + '; charset=utf8'
                        output = pelagios.g.serialize(format=req_neg.use_response_type)
                        return HttpResponse(output,
                                            content_type=content_type)
                    else:
                        # client wanted a mimetype we don't support
                        return HttpResponse(req_neg.error_message,
                                            content_type="text/plain; charset=utf8",
                                            status=415)
                else:
                    # default to outputting in turtle
                    output = pelagios.g.serialize(format='turtle')
                    return HttpResponse(output,
                                        content_type='text/turtle; charset=utf8')
            else:
                return HttpResponse('Not authorized to get this resource',
                                    content_type='text/html; charset=utf8',
                                    status=401)
        else:
            found = False
    if found is False:
        raise Http404
Example #10
0
 def __init__(self, project_uuid, request):
     self.errors = {}
     self.project_uuid = project_uuid
     try:
         self.manifest = Manifest.objects.get(uuid=project_uuid,
                                              item_type='projects')
     except Manifest.DoesNotExist:
         self.manifest = False
         self.errors[
             'uuid'] = 'No project ' + project_uuid + ' not in manifest'
     if self.manifest is not False:
         pp = ProjectPermissions(project_uuid)
         self.edit_permitted = pp.edit_allowed(request)
     else:
         self.edit_permitted = False
     self.creator_uuid = False
Example #11
0
 def __init__(self,
              project_uuid,
              request):
     self.errors = {}
     self.project_uuid = project_uuid
     try:
         self.manifest = Manifest.objects.get(uuid=project_uuid,
                                              item_type='projects')
     except Manifest.DoesNotExist:
         self.manifest = False
         self.errors['uuid'] = 'No project ' + project_uuid + ' not in manifest'
     if self.manifest is not False:
         pp = ProjectPermissions(project_uuid)
         self.edit_permitted = pp.edit_allowed(request)
     else:
         self.edit_permitted = False
     self.creator_uuid = False
Example #12
0
 def check_string_edit(self, string_uuid, request=False):
     """ checks to see if a string exists, also determines
         if the user has permissions to edit
     """
     ok = False
     try:
         str_obj = OCstring.objects.get(uuid=string_uuid)
     except OCstring.DoesNotExist:
         str_obj = False
     if str_obj is not False:
         ok = True
         if request is not False:
             # check to make sure edit permissions OK
             pp = ProjectPermissions(str_obj.project_uuid)
             self.edit_permitted = pp.edit_allowed(request)
         else:
             # default to no editting permissions
             self.edit_permitted = False
     return ok
Example #13
0
 def __init__(self, uuid, request=False):
     self.uuid = uuid
     self.creator_uuid = False
     self.request = request
     self.errors = {'uuid': False, 'html': False}
     self.response = {}
     if uuid is not False:
         try:
             self.manifest = Manifest.objects.get(uuid=uuid)
         except Manifest.DoesNotExist:
             self.manifest = False
             self.errors['uuid'] = 'Item ' + uuid + ' not in manifest'
         if request is not False and self.manifest is not False:
             # check to make sure edit permissions OK
             pp = ProjectPermissions(self.manifest.project_uuid)
             self.edit_permitted = pp.edit_allowed(request)
         else:
             # default to no editting permissions
             self.edit_permitted = False
 def __init__(self,
              uuid,
              request=False):
     self.creator_uuid = False
     self.super_user = False
     self.uuid = uuid
     self.request = request
     self.errors = {'uuid': False,
                    'params': False}
     self.response = {}
     self.orcid_ok = None
     try:
         self.manifest = Manifest.objects.get(uuid=uuid)
     except Manifest.DoesNotExist:
         self.manifest = False
         self.errors['uuid'] = 'Item ' + uuid + ' not in manifest'
     if request is not False and self.manifest is not False:
         # check to make sure edit permissions OK
         pp = ProjectPermissions(self.manifest.project_uuid)
         self.edit_permitted = pp.edit_allowed(request)
     else:
         # default to no editting permissions
         self.edit_permitted = False
Example #15
0
def project_annotations_ttl(request, identifier):
    """ Returns RDF open annotation assertions conforming to
        Pelagios specifications that link
        Open Context resources with place entities in
        gazetteers, in the turtle format
    """
    ent = Entity()
    found = ent.dereference(identifier)
    if found or identifier == 'web':
        if ent.item_type == 'projects' or identifier == 'web':
            pelagios = PelagiosGraph()
            pelagios.test_limit = None
            if 'refresh' in request.GET:
                # we're going to refresh the cache
                pelagios.refresh_cache = True
            if identifier != 'web':
                pp = ProjectPermissions(ent.uuid)
                permitted = pp.view_allowed(request)
                pelagios.project_uuids = [ent.uuid]
            else:
                # we're doing web annotations
                pelagios.do_web_annotations = True
                permitted = True
            if permitted:
                pelagios.get_graph()
                # default to outputting in turtle
                output = pelagios.g.serialize(format='turtle')
                return HttpResponse(output,
                                    content_type='text/turtle; charset=utf8')
            else:
                return HttpResponse('Not authorized to get this resource',
                                    content_type='text/html; charset=utf8',
                                    status=401)
        else:
            found = False
    if found is False:
        raise Http404