djangoldp/management/commands/generate_static_content.py

+import os
+import json
+import requests
+from django.core.management.base import BaseCommand
+from django.conf import settings
+from django.apps import apps
+from urllib.parse import urlparse, urljoin
+
+class StaticContentGenerator:
+    def __init__(self, stdout, style):
+        self.stdout = stdout
+        self.style = style
+        self.base_uri = getattr(settings, 'BASE_URL', '')
+        self.max_depth = getattr(settings, 'MAX_RECURSION_DEPTH', 5)
+        self.request_timeout = getattr(settings, 'SSR_REQUEST_TIMEOUT', 10)
+        self.regenerated_urls = set()
+        self.failed_urls = set()
+        self.output_dir = 'ssr'
+        self.output_dir_filtered = 'ssr_filtered'
+
+    def generate_content(self):
+        self._create_output_directory()
+        for model in self._get_static_models():
+            self._process_model(model)
+
+    def _create_output_directory(self):
+        os.makedirs(self.output_dir, exist_ok=True)
+        os.makedirs(self.output_dir_filtered, exist_ok=True)
+
+    def _get_static_models(self):
+        return [model for model in apps.get_models() if hasattr(model._meta, 'static_version')]
+
+    def _process_model(self, model):
+        self.stdout.write(f"Generating content for model: {model}")
+        url = self._build_url(model)
+        if url not in self.regenerated_urls and url not in self.failed_urls:
+            self._fetch_and_save_content(model, url, self.output_dir)
+        else:
+            self.stdout.write(self.style.WARNING(f'Skipping {url} as it has already been fetched'))
+        if hasattr(model._meta, 'static_params'):
+            url = self._build_url(model, True)
+            if url not in self.regenerated_urls and url not in self.failed_urls:
+                self._fetch_and_save_content(model, url, self.output_dir_filtered)
+            else:
+                self.stdout.write(self.style.WARNING(f'Skipping {url} as it has already been fetched'))
+
+    def _build_url(self, model, use_static_params=False):
+        container_path = model.get_container_path()
+        url = urljoin(self.base_uri, container_path)
+        if hasattr(model._meta, 'static_params') and use_static_params:
+            url += '?' + '&'.join(f'{k}={v}' for k, v in model._meta.static_params.items())
+        return url
+
+    def _fetch_and_save_content(self, model, url, output_dir):
+        try:
+            response = requests.get(url, timeout=self.request_timeout)
+            if response.status_code == 200:
+                content = self._update_ids_and_fetch_associated(response.text)
+                self._save_content(model, url, content, output_dir)
+            else:
+                self.stdout.write(self.style.ERROR(f'Failed to fetch content from {url}: HTTP {response.status_code}'))
+        except requests.exceptions.RequestException as e:
+            self.stdout.write(self.style.ERROR(f'Error fetching content from {url}: {str(e)}'))
+
+    def _save_content(self, model, url, content, output_dir):
+        relative_path = urlparse(url).path.strip('/')
+        file_path = os.path.join(output_dir, relative_path)
+        if file_path.endswith('/'):
+            file_path = file_path[:-1]
+        if not file_path.endswith('.jsonld'):
+            file_path += '.jsonld'
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        try:
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            self.stdout.write(self.style.SUCCESS(f'Successfully saved content for {model._meta.model_name} from {url} to {file_path}'))
+        except IOError as e:
+            self.stdout.write(self.style.ERROR(f'Error saving content for {model._meta.model_name}: {str(e)}'))
+
+    def _update_ids_and_fetch_associated(self, content, depth=0):
+        if depth > self.max_depth:
+            return content
+
+        try:
+            data = json.loads(content)
+            self._process_data(data, depth)
+            return json.dumps(data)
+        except json.JSONDecodeError as e:
+            self.stdout.write(self.style.ERROR(f'Failed to decode JSON: {e}'))
+            return content
+
+    def _process_data(self, data, depth):
+        if isinstance(data, dict):
+            self._process_item(data, depth)
+        elif isinstance(data, list):
+            for item in data:
+                if isinstance(item, dict):
+                    self._process_item(item, depth)
+
+    def _process_item(self, item, depth):
+        if '@id' in item:
+            self._update_and_fetch_content(item, depth)
+
+        for value in item.values():
+            if isinstance(value, (dict, list)):
+                self._process_data(value, depth)
+
+    def _update_and_fetch_content(self, item, depth):
+        original_id = item['@id']
+        parsed_url = urlparse(original_id)
+
+        if not parsed_url.netloc:
+            original_id = urljoin(self.base_uri, original_id)
+            parsed_url = urlparse(original_id)
+
+        path = parsed_url.path
+        if path.startswith(urlparse(self.base_uri).path):
+            path = path[len(urlparse(self.base_uri).path):]
+
+        new_id = f'/ssr{path}'
+        item['@id'] = urljoin(self.base_uri, new_id)
+
+        self._fetch_and_save_associated_content(original_id, path, depth)
+
+    def _rewrite_ids_before_saving(self, data):
+        if isinstance(data, dict):
+            if '@id' in data:
+                original_id = data['@id']
+                parsed_url = urlparse(data['@id'])
+                if not parsed_url.netloc:
+                    content_id = urljoin(self.base_uri, original_id)
+                    parsed_url = urlparse(content_id)
+
+                if 'ssr/' not in data['@id']:
+                    path = parsed_url.path
+                    if path.startswith(urlparse(self.base_uri).path):
+                        path = path[len(urlparse(self.base_uri).path):]
+
+                    new_id = f'/ssr{path}'
+                    data['@id'] = urljoin(self.base_uri, new_id)
+            for value in data.values():
+                if isinstance(value, (dict, list)):
+                    self._rewrite_ids_before_saving(value)
+        elif isinstance(data, list):
+            for item in data:
+                self._rewrite_ids_before_saving(item)
+        return data
+
+    def _fetch_and_save_associated_content(self, url, new_path, depth):
+        if url in self.regenerated_urls:
+            self.stdout.write(self.style.WARNING(f'Skipping {url} as it has already been fetched'))
+            return
+        if url in self.failed_urls:
+            self.stdout.write(self.style.WARNING(f'Skipping {url} as it has already been tried and failed'))
+            return
+
+        file_path = os.path.join(self.output_dir, new_path.strip('/'))
+        if file_path.endswith('/'):
+            file_path = file_path[:-1]
+        if not file_path.endswith('.jsonld'):
+            file_path += '.jsonld'
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+        try:
+            response = requests.get(url, timeout=self.request_timeout)
+            if response.status_code == 200:
+                updated_content = json.loads(self._update_ids_and_fetch_associated(response.text, depth + 1))
+                updated_content = self._rewrite_ids_before_saving(updated_content)
+
+                with open(file_path, 'w', encoding='utf-8') as f:
+                    f.write(json.dumps(updated_content))
+                self.regenerated_urls.add(url)
+                self.stdout.write(self.style.SUCCESS(f'Successfully fetched and saved associated content from {url} to {file_path}'))
+            else:
+                self.failed_urls.add(url)
+                self.stdout.write(self.style.ERROR(f'Failed to fetch associated content from {url}: HTTP {response.status_code}'))
+        except requests.exceptions.RequestException as e:
+            self.stdout.write(self.style.ERROR(f'Error fetching associated content from {url}: {str(e)}'))
+        except IOError as e:
+            self.stdout.write(self.style.ERROR(f'Error saving associated content from {url}: {str(e)}'))
+
+class Command(BaseCommand):
+    help = 'Generate static content for models having the static_version meta attribute set to 1/true'
+
+    def handle(self, *args, **options):
+        generator = StaticContentGenerator(self.stdout, self.style)
+        generator.generate_content()
\ No newline at end of file

djangoldp/middleware.py

 from django.conf import settings
-from django.utils.http import is_safe_url
+from django.utils.http import url_has_allowed_host_and_scheme
 from django.shortcuts import redirect
-
+from djangoldp.models import Model
+from django.http import HttpResponse
 
 class AllowOnlySiteUrl:
     def __init__(self, get_response):
@@ -9,7 +10,55 @@ class AllowOnlySiteUrl:
 
     def __call__(self, request):
         response = self.get_response(request)
-        if(is_safe_url(request.get_raw_uri(), allowed_hosts=settings.SITE_URL) or response.status_code != 200):
+        if(url_has_allowed_host_and_scheme(request.get_raw_uri(), allowed_hosts=settings.SITE_URL) or response.status_code != 200):
             return response
         else:
             return redirect('{}{}'.format(settings.SITE_URL, request.path), permanent=True)
+
+
+class AllowRequestedCORSMiddleware:
+    '''A CORS Middleware which allows the domains requested by the request'''
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        if request.method == 'OPTIONS':
+            # Return an empty 200 response for OPTIONS requests
+            # The CORS headers will be added by AllowRequestedCORSMiddleware later
+            response = HttpResponse(status=200)
+        else:
+            response = self.get_response(request)
+
+        response["Access-Control-Allow-Origin"] = request.headers.get('origin')
+        response["Access-Control-Allow-Methods"] = "GET,POST,PUT,PATCH,DELETE,OPTIONS,HEAD"
+        response["Access-Control-Allow-Headers"] = \
+            getattr(settings, 'OIDC_ACCESS_CONTROL_ALLOW_HEADERS',
+                    "authorization, Content-Type, if-match, accept, DPoP, cache-control, prefer")
+        response["Access-Control-Expose-Headers"] = "Location, User"
+        response["Access-Control-Allow-Credentials"] = 'true'
+
+        return response
+
+
+class OptionsResponseMiddleware:
+    """Middleware that returns a 200 response for OPTIONS requests.
+    
+    This should be placed BEFORE the AllowRequestedCORSMiddleware in the stack
+    to ensure OPTIONS requests receive proper CORS headers.
+    
+    This middleware is not enabled by default. To use it, add
+    'djangoldp.middleware.OptionsResponseMiddleware' to your MIDDLEWARE setting
+    before 'djangoldp.middleware.AllowRequestedCORSMiddleware'.
+    """
+    
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        if request.method == 'OPTIONS':
+            # Return an empty 200 response for OPTIONS requests
+            # The CORS headers will be added by AllowRequestedCORSMiddleware later
+            return HttpResponse(status=200)
+        
+        # For all other requests, proceed as normal
+        return self.get_response(request)
\ No newline at end of file

djangoldp/migrations/0006_activity.py

+# -*- coding: utf-8 -*-
+# Generated by Django 1.11 on 2020-04-21 19:43
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import djangoldp.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0005_auto_20200221_1127'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Activity',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('urlid', djangoldp.fields.LDPUrlField(blank=True, null=True, unique=True)),
+                ('aid', djangoldp.fields.LDPUrlField(null=True)),
+                ('local_id', djangoldp.fields.LDPUrlField()),
+                ('payload', models.BinaryField()),
+                ('created_at', models.DateField(auto_now_add=True)),
+            ],
+            options={
+                'abstract': False,
+                'default_permissions': ('add', 'change', 'delete', 'view', 'control'),
+            },
+        ),
+    ]

djangoldp/migrations/0007_auto_20200429_1346.py

+# -*- coding: utf-8 -*-
+# Generated by Django 1.11 on 2020-04-29 13:46
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0006_activity'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='activity',
+            name='allow_create_backlink',
+            field=models.BooleanField(default=True, help_text='set to False to disable backlink creation after Model save'),
+        ),
+        migrations.AddField(
+            model_name='ldpsource',
+            name='allow_create_backlink',
+            field=models.BooleanField(default=True, help_text='set to False to disable backlink creation after Model save'),
+        ),
+    ]

djangoldp/migrations/0008_auto_20200501_1207.py

+# -*- coding: utf-8 -*-
+# Generated by Django 1.11 on 2020-05-01 12:07
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0007_auto_20200429_1346'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='activity',
+            name='backlink_created',
+            field=models.BooleanField(default=False, help_text='set automatically to indicate the Model is a backlink'),
+        ),
+        migrations.AddField(
+            model_name='ldpsource',
+            name='backlink_created',
+            field=models.BooleanField(default=False, help_text='set automatically to indicate the Model is a backlink'),
+        ),
+    ]

djangoldp/migrations/0009_auto_20200505_1733.py

+# -*- coding: utf-8 -*-
+# Generated by Django 1.11 on 2020-05-05 17:33
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0008_auto_20200501_1207'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='activity',
+            old_name='backlink_created',
+            new_name='is_backlink',
+        ),
+        migrations.RenameField(
+            model_name='ldpsource',
+            old_name='backlink_created',
+            new_name='is_backlink',
+        ),
+    ]

djangoldp/migrations/0010_follower.py

+# -*- coding: utf-8 -*-
+# Generated by Django 1.11 on 2020-05-19 10:37
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import djangoldp.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0009_auto_20200505_1733'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Follower',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('urlid', djangoldp.fields.LDPUrlField(blank=True, null=True, unique=True)),
+                ('is_backlink', models.BooleanField(default=False, help_text='set automatically to indicate the Model is a backlink')),
+                ('allow_create_backlink', models.BooleanField(default=True, help_text='set to False to disable backlink creation after Model save')),
+                ('object', models.URLField()),
+                ('inbox', models.URLField()),
+            ],
+            options={
+                'abstract': False,
+                'default_permissions': ('add', 'change', 'delete', 'view', 'control'),
+            },
+        ),
+    ]

djangoldp/migrations/0011_auto_20200610_1323.py

+# -*- coding: utf-8 -*-
+# Generated by Django 1.11.29 on 2020-06-10 13:23
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0010_follower'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='activity',
+            name='is_backlink',
+            field=models.BooleanField(default=False, help_text='(DEPRECIATED) set automatically to indicate the Model is a backlink'),
+        ),
+        migrations.AlterField(
+            model_name='follower',
+            name='is_backlink',
+            field=models.BooleanField(default=False, help_text='(DEPRECIATED) set automatically to indicate the Model is a backlink'),
+        ),
+        migrations.AlterField(
+            model_name='ldpsource',
+            name='is_backlink',
+            field=models.BooleanField(default=False, help_text='(DEPRECIATED) set automatically to indicate the Model is a backlink'),
+        ),
+    ]

djangoldp/migrations/0012_auto_20200617_1817.py

+# -*- coding: utf-8 -*-
+# Generated by Django 1.11.29 on 2020-06-17 18:17
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0011_auto_20200610_1323'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='activity',
+            name='is_backlink',
+            field=models.BooleanField(default=False, help_text='set automatically to indicate the Model is a backlink'),
+        ),
+        migrations.AlterField(
+            model_name='follower',
+            name='is_backlink',
+            field=models.BooleanField(default=False, help_text='set automatically to indicate the Model is a backlink'),
+        ),
+        migrations.AlterField(
+            model_name='ldpsource',
+            name='is_backlink',
+            field=models.BooleanField(default=False, help_text='set automatically to indicate the Model is a backlink'),
+        ),
+    ]

djangoldp/migrations/0013_auto_20200624_1709.py

+# -*- coding: utf-8 -*-
+# Generated by Django 1.11.29 on 2020-06-24 17:09
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0012_auto_20200617_1817'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='follower',
+            name='follower',
+            field=models.URLField(blank=True, help_text='(optional) the resource/actor following the object'),
+        ),
+        migrations.AlterField(
+            model_name='follower',
+            name='inbox',
+            field=models.URLField(help_text='the inbox recipient of updates'),
+        ),
+        migrations.AlterField(
+            model_name='follower',
+            name='object',
+            field=models.URLField(help_text='the object being followed'),
+        ),
+    ]

djangoldp/migrations/0014_auto_20200909_2206.py

+# Generated by Django 2.2 on 2020-09-09 22:06
+
+from django.db import migrations, models
+import django.db.models.deletion
+import djangoldp.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0013_auto_20200624_1709'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ScheduledActivity',
+            fields=[
+                ('activity_ptr', models.OneToOneField(auto_created=True, on_delete=django.db.models.deletion.CASCADE, parent_link=True, primary_key=True, serialize=False, to='djangoldp.Activity')),
+                ('failed_attempts', models.PositiveIntegerField(default=0, help_text='a log of how many failed retries have been made sending the activity')),
+            ],
+            options={
+                'abstract': False,
+                'default_permissions': ('add', 'change', 'delete', 'view', 'control'),
+            },
+            bases=('djangoldp.activity',),
+        ),
+        migrations.AlterField(
+            model_name='activity',
+            name='created_at',
+            field=models.DateTimeField(auto_now_add=True),
+        ),
+        migrations.AlterField(
+            model_name='activity',
+            name='local_id',
+            field=djangoldp.fields.LDPUrlField(help_text='/inbox or /outbox url (local - this server)'),
+        ),
+        migrations.AlterField(
+            model_name='activity',
+            name='payload',
+            field=models.BinaryField(),
+        ),
+        migrations.AddField(
+            model_name='activity',
+            name='success',
+            field=models.BooleanField(default=False,
+                                      help_text='set to True when an Activity is successfully delivered'),
+        ),
+        migrations.AddField(
+            model_name='activity',
+            name='type',
+            field=models.CharField(blank=True, help_text='the ActivityStreams type of the Activity', max_length=64,
+                                   null=True),
+        ),
+        migrations.AddField(
+            model_name='activity',
+            name='is_finished',
+            field=models.BooleanField(default=True),
+        ),
+        migrations.AddField(
+            model_name='activity',
+            name='response_code',
+            field=models.CharField(blank=True, help_text='Response code sent by receiver', max_length=8, null=True),
+        ),
+        migrations.AddField(
+            model_name='activity',
+            name='response_location',
+            field=djangoldp.fields.LDPUrlField(blank=True, help_text='Location saved activity can be found', null=True),
+        ),
+        migrations.AddField(
+            model_name='activity',
+            name='response_body',
+            field=models.BinaryField(null=True),
+        ),
+        migrations.AddField(
+            model_name='activity',
+            name='external_id',
+            field=djangoldp.fields.LDPUrlField(help_text='the /inbox or /outbox url (from the sender or receiver)',
+                                               null=True),
+        ),
+        migrations.RemoveField(
+            model_name='activity',
+            name='aid',
+        ),
+    ]

djangoldp/migrations/0015_auto_20210125_1847.py

+# Generated by Django 2.2.17 on 2021-01-25 18:47
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0014_auto_20200909_2206'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='activity',
+            options={'default_permissions': ['add', 'change', 'delete', 'view', 'control']},
+        ),
+        migrations.AlterModelOptions(
+            name='follower',
+            options={'default_permissions': ['add', 'change', 'delete', 'view', 'control']},
+        ),
+        migrations.AlterModelOptions(
+            name='ldpsource',
+            options={'default_permissions': ['add', 'change', 'delete', 'view', 'control'], 'ordering': ('federation',)},
+        ),
+        migrations.AlterModelOptions(
+            name='scheduledactivity',
+            options={'default_permissions': ['add', 'change', 'delete', 'view', 'control']},
+        ),
+    ]

djangoldp/migrations/0016_alter_activity_options_alter_follower_options_and_more.py

+# Generated by Django 4.2.3 on 2023-08-31 15:27
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0015_auto_20210125_1847'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='activity',
+            options={'default_permissions': {'delete', 'change', 'view', 'add', 'control'}},
+        ),
+        migrations.AlterModelOptions(
+            name='follower',
+            options={'default_permissions': {'delete', 'change', 'view', 'add', 'control'}},
+        ),
+        migrations.AlterModelOptions(
+            name='ldpsource',
+            options={'default_permissions': {'delete', 'change', 'view', 'add', 'control'}, 'ordering': ('federation',)},
+        ),
+        migrations.AlterModelOptions(
+            name='scheduledactivity',
+            options={'default_permissions': {'delete', 'change', 'view', 'add', 'control'}},
+        ),
+    ]

djangoldp/migrations/0017_alter_activity_urlid_alter_follower_urlid_and_more.py

+# Generated by Django 4.2.3 on 2023-09-03 20:26
+
+from django.db import migrations
+import djangoldp.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0016_alter_activity_options_alter_follower_options_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='activity',
+            name='urlid',
+            field=djangoldp.fields.LDPUrlField(blank=True, db_index=True, null=True, unique=True),
+        ),
+        migrations.AlterField(
+            model_name='follower',
+            name='urlid',
+            field=djangoldp.fields.LDPUrlField(blank=True, db_index=True, null=True, unique=True),
+        ),
+        migrations.AlterField(
+            model_name='ldpsource',
+            name='urlid',
+            field=djangoldp.fields.LDPUrlField(blank=True, db_index=True, null=True, unique=True),
+        ),
+    ]

djangoldp/migrations/0018_alter_activity_payload_alter_activity_response_body.py

+# Generated by Django 4.2.3 on 2023-10-17 19:25
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0017_alter_activity_urlid_alter_follower_urlid_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='activity',
+            name='payload',
+            field=models.TextField(),
+        ),
+        migrations.AlterField(
+            model_name='activity',
+            name='response_body',
+            field=models.TextField(null=True),
+        ),
+    ]

djangoldp/migrations/0019_sitesettings.py

+# Generated by Django 4.2 on 2025-06-17 14:10
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0018_alter_activity_payload_alter_activity_response_body'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='SiteSettings',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('title', models.CharField(default='My App', max_length=200)),
+                ('description', models.TextField(blank=True)),
+                ('terms_url', models.URLField(blank=True)),
+            ],
+        ),
+    ]

djangoldp/migrations/0020_rename_sitesettings_sitesetting.py

+# Generated by Django 4.2 on 2025-06-17 14:33
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('djangoldp', '0019_sitesettings'),
+    ]
+
+    operations = [
+        migrations.RenameModel(
+            old_name='SiteSettings',
+            new_name='SiteSetting',
+        ),
+    ]

djangoldp/models/__init__.py

+from .site_setting import SiteSetting
+from .models import Model, LDPModelManager, LDPSource, Activity, ScheduledActivity, Follower, DynamicNestedField
\ No newline at end of file

djangoldp/models.py → djangoldp/models/models.py

-from urllib.parse import urlparse
+import json
+import logging
+import uuid
+
 from django.conf import settings
 from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Group
+from django.core.exceptions import ObjectDoesNotExist, ValidationError, FieldDoesNotExist
 from django.db import models
 from django.db.models.base import ModelBase
-from django.db.models.signals import post_save
+from django.db.models.signals import post_save, pre_save, pre_delete, m2m_changed
 from django.dispatch import receiver
-from django.urls import reverse_lazy, get_resolver
+from django.urls import get_resolver
 from django.utils.datastructures import MultiValueDictKeyError
 from django.utils.decorators import classonlymethod
-
+from guardian.shortcuts import assign_perm
+from rest_framework.utils import model_meta
 from djangoldp.fields import LDPUrlField
-from djangoldp.permissions import LDPPermissions
+from djangoldp.permissions import DEFAULT_DJANGOLDP_PERMISSIONS, OwnerPermissions, InheritPermissions, ReadOnly
+
+logger = logging.getLogger('djangoldp')
 
+Group._meta.serializer_fields = ['name', 'user_set']
+Group._meta.rdf_type = 'foaf:Group'
+# Group._meta.rdf_context = {'user_set': 'foaf:member'}
+Group._meta.permission_classes = [(OwnerPermissions&ReadOnly)|InheritPermissions]
+Group._meta.owner_field = 'user'
+Group._meta.inherit_permissions = []
 
 class LDPModelManager(models.Manager):
-    # an alternative to all() which exlcudes external resources
     def local(self):
+        '''an alternative to all() which exlcudes external resources'''
         queryset = super(LDPModelManager, self).all()
         internal_ids = [x.pk for x in queryset if not Model.is_external(x)]
         return queryset.filter(pk__in=internal_ids)
 
-
 class Model(models.Model):
-    urlid = LDPUrlField(blank=True, null=True, unique=True)
+    urlid = LDPUrlField(blank=True, null=True, unique=True, db_index=True)
+    is_backlink = models.BooleanField(default=False, help_text='set automatically to indicate the Model is a backlink')
+    allow_create_backlink = models.BooleanField(default=True,
+                                                help_text='set to False to disable backlink creation after Model save')
     objects = LDPModelManager()
 
+    class Meta:
+        default_permissions = DEFAULT_DJANGOLDP_PERMISSIONS
+        abstract = True
+        depth = 0
+
     def __init__(self, *args, **kwargs):
         super(Model, self).__init__(*args, **kwargs)
 
-    @classmethod
-    def get_view_set(cls):
-        '''returns the view_set defined in the model Meta or the LDPViewSet class'''
-        view_set = getattr(cls._meta, 'view_set', getattr(cls.Meta, 'view_set', None))
-        if view_set is None:
-            from djangoldp.views import LDPViewSet
-            view_set = LDPViewSet
-        return view_set
-
     @classmethod
     def get_container_path(cls):
         '''returns the url path which is used to access actions on this model (e.g. /users/)'''
@@ -51,7 +63,7 @@ class Model(models.Model):
 
     @classonlymethod
     def absolute_url(cls, instance_or_model):
-        if isinstance(instance_or_model, ModelBase) or instance_or_model.urlid is None or instance_or_model.urlid == '':
+        if isinstance(instance_or_model, ModelBase) or not instance_or_model.urlid:
             return '{}{}'.format(settings.SITE_URL, Model.resource(instance_or_model))
         else:
             return instance_or_model.urlid
@@ -74,16 +86,24 @@ class Model(models.Model):
     @classonlymethod
     def slug_field(cls, instance_or_model):
         if isinstance(instance_or_model, ModelBase):
-            object_name = instance_or_model.__name__.lower()
+            model = instance_or_model
         else:
-            object_name = instance_or_model._meta.object_name.lower()
+            model = type(instance_or_model)
+        
+        # Use cached value if present
+        if hasattr(model, "_slug_field"):
+            return model._slug_field
+        object_name = model.__name__.lower()
         view_name = '{}-detail'.format(object_name)
+
         try:
             slug_field = '/{}'.format(get_resolver().reverse_dict[view_name][0][0][1][0])
         except MultiValueDictKeyError:
-            slug_field = Model.get_meta(instance_or_model, 'lookup_field', 'pk')
+            slug_field = getattr(model._meta, 'lookup_field', 'pk')
         if slug_field.startswith('/'):
             slug_field = slug_field[1:]
+        
+        model._slug_field = slug_field
         return slug_field
 
     @classonlymethod
@@ -98,33 +118,44 @@ class Model(models.Model):
 
         return path
 
-    class Meta:
-        default_permissions = ('add', 'change', 'delete', 'view', 'control')
-        abstract = True
-        depth = 0
-
     @classonlymethod
     def resolve_id(cls, id):
+        '''
+        Resolves the id of a given path (e.g. /container/1/)
+        Raises Resolver404 if the path cannot be found, ValidationError if the path is for a model base
+        and an ObjectDoesNotExist exception if the resource does not exist
+        '''
         id = cls.__clean_path(id)
-        view, args, kwargs = get_resolver().resolve(id)
+        match = get_resolver().resolve(id)
+        kwargs = match.kwargs
+        view = match.func
+
+        if match.url_name.endswith('-list') or len(match.kwargs.keys()) == 0:
+            raise ValidationError('resolve_id received a path for a container or nested container')
         return view.initkwargs['model'].objects.get(**kwargs)
 
     @classonlymethod
     def resolve_parent(cls, path):
         split = path.strip('/').split('/')
-        parent_path = "/".join(split[0:len(split) - 1])
+        parent_path = "/".join(split[:-1])
         return Model.resolve_id(parent_path)
 
     @classonlymethod
     def resolve_container(cls, path):
+        '''retruns the model container of passed URL path'''
         path = cls.__clean_path(path)
         view, args, kwargs = get_resolver().resolve(path)
         return view.initkwargs['model']
 
     @classonlymethod
     def resolve(cls, path):
-        if settings.BASE_URL in path:
-            path = path[len(settings.BASE_URL):]
+        '''
+        resolves the containing model and associated id in the path. If there is no id in the path returns None
+        :param path: a URL path to check
+        :return: the container model and resolved id in a tuple
+        '''
+        if path.startswith(settings.BASE_URL):
+            path = path.replace(settings.BASE_URL, '')
         container = cls.resolve_container(path)
         try:
             resolve_id = cls.resolve_id(path)
@@ -142,40 +173,85 @@ class Model(models.Model):
         return path
 
     @classonlymethod
-    def get_permission_classes(cls, related_model, default_permissions_classes):
-        '''returns the permission_classes set in the models Meta class'''
-        return cls.get_meta(related_model, 'permission_classes', default_permissions_classes)
+    def get_or_create(cls, model, urlid, update=False, **field_tuples):
+        '''
+        gets an object with the passed urlid if it exists, creates it if not
+        :param model: the model class which the object belongs to
+        :param update: if set to True the object will be updated with the passed field_tuples
+        :param field_tuples: kwargs for the model creation/updating
+        :return: the object, fetched or created
+        :raises Exception: if the object does not exist, but the data passed is invalid
+        '''
+        try:
+            rval = model.objects.get(urlid=urlid)
+            if update:
+                for field in field_tuples.keys():
+                    setattr(rval, field, field_tuples[field])
+                rval.save()
+            return rval
+        except ObjectDoesNotExist:
+            if model is get_user_model():
+                field_tuples['username'] = str(uuid.uuid4())
+            return model.objects.create(urlid=urlid, is_backlink=True, **field_tuples)
 
     @classonlymethod
-    def get_meta(cls, model_class, meta_name, default=None):
-        '''returns the models Meta class'''
-        if hasattr(model_class, 'Meta'):
-            meta = getattr(model_class.Meta, meta_name, default)
-        else:
-            meta = default
-        return getattr(model_class._meta, meta_name, meta)
+    def get_or_create_external(cls, model, urlid, **kwargs):
+        '''
+        checks that the parameterised urlid is external and then returns the result of Model.get_or_create
+        :raises ObjectDoesNotExist: if the urlid is not external and the object doesn't exist
+        '''
+        if not Model.is_external(urlid) and not model.objects.filter(urlid=urlid).exists():
+            raise ObjectDoesNotExist
+        return Model.get_or_create(model, urlid, **kwargs)
 
-    @staticmethod
-    def get_permissions(obj_or_model, user_or_group, filter):
-        permissions = filter
-        for permission_class in Model.get_permission_classes(obj_or_model, [LDPPermissions]):
-            permissions = permission_class().filter_user_perms(user_or_group, obj_or_model, permissions)
-        return [{'mode': {'@type': name.split('_')[0]}} for name in permissions]
+    @classonlymethod
+    def get_subclass_with_rdf_type(cls, type):
+        #TODO: deprecate
+        '''returns Model subclass with Meta.rdf_type matching parameterised type, or None'''
+        if type == 'foaf:user':
+            return get_user_model()
+
+        def find_subclass_with_rdf_type(cls):
+            if getattr(cls._meta, "rdf_type", None) == type:
+                return cls
+            for subcls in cls.__subclasses__():
+                result = find_subclass_with_rdf_type(subcls)
+                if result:
+                    return result
+            return None
+
+        for subcls in Model.__subclasses__():
+            result = find_subclass_with_rdf_type(subcls)
+            if result:
+                return result
+
+        return None
 
     @classmethod
     def is_external(cls, value):
-        '''returns True if the urlid of the value passed is from an external source'''
+        '''
+        :param value: string urlid or an instance with urlid field
+        :return: True if the urlid is external to the server, False otherwise
+        '''
         try:
-            return value.urlid is not None and not value.urlid.startswith(settings.SITE_URL)
+            if not value:
+                return False
+            if not isinstance(value, str):
+                value = value.urlid
+
+            # This expects all @ids to start with http which mlight not be universal. Maybe needs a fix.
+            return value.startswith('http') and not value.startswith(settings.SITE_URL)
         except:
             return False
 
+#TODO: this breaks the serializer, which probably assumes that traditional models don't have a urlid.
+# models.Model.urlid = property(lambda self: '{}{}'.format(settings.SITE_URL, Model.resource(self)))
 
 class LDPSource(Model):
     federation = models.CharField(max_length=255)
 
     class Meta(Model.Meta):
-        rdf_type = 'ldp:Container'
+        rdf_type = 'sib:federatedContainer'
         ordering = ('federation',)
         container_path = 'sources'
         lookup_field = 'federation'
@@ -184,26 +260,122 @@ class LDPSource(Model):
         return "{}: {}".format(self.federation, self.urlid)
 
 
+class Activity(Model):
+    '''Models an ActivityStreams Activity'''
+    local_id = LDPUrlField(help_text='/inbox or /outbox url (local - this server)')  # /inbox or /outbox full url
+    external_id = LDPUrlField(null=True, help_text='the /inbox or /outbox url (from the sender or receiver)')
+    payload = models.TextField()
+    response_location = LDPUrlField(null=True, blank=True, help_text='Location saved activity can be found')
+    response_code = models.CharField(null=True, blank=True, help_text='Response code sent by receiver', max_length=8)
+    response_body = models.TextField(null=True)
+    type = models.CharField(null=True, blank=True, help_text='the ActivityStreams type of the Activity',
+                            max_length=64)
+    is_finished = models.BooleanField(default=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    success = models.BooleanField(default=False, help_text='set to True when an Activity is successfully delivered')
+
+    class Meta(Model.Meta):
+        container_path = "activities"
+        rdf_type = 'as:Activity'
+        disable_url = True
+
+    def to_activitystream(self):
+        return json.loads(self.payload)
+
+    def response_to_json(self):
+        return self.to_activitystream()
+
+
+# temporary database-side storage used for scheduled tasks in the ActivityQueue
+class ScheduledActivity(Activity):
+    failed_attempts = models.PositiveIntegerField(default=0,
+                                                  help_text='a log of how many failed retries have been made sending the activity')
+
+    def save(self, *args, **kwargs):
+        self.is_finished = False
+        super(ScheduledActivity, self).save(*args, **kwargs)
+
+    class Meta(Model.Meta):
+        disable_url = True
+
+
+class Follower(Model):
+    '''Models a subscription on a model. When the model is saved, an Update activity will be sent to the inbox'''
+    object = models.URLField(help_text='the object being followed')
+    inbox = models.URLField(help_text='the inbox recipient of updates')
+    follower = models.URLField(help_text='(optional) the resource/actor following the object', blank=True)
+
+    def __str__(self):
+        return 'Inbox ' + str(self.inbox) + ' on ' + str(self.object)
+
+    class Meta(Model.Meta):
+        disable_url = True
+
+class DynamicNestedField:
+    '''
+    Used to define a method as a nested_field.
+    Usage:
+        LDPUser.circles = lambda self: Circle.objects.filter(members__user=self)
+        LDPUser.circles.field = DynamicNestedField(Circle, 'circles')
+    '''
+    related_query_name = None
+    one_to_many = False
+    many_to_many = True
+    many_to_one = False
+    one_to_one = False
+    read_only = True
+    name = ''
+    def __init__(self, model:models.Model|None, remote_name:str, name:str='', remote:object|None=None) -> None:
+        self.model = model
+        self.name = name
+        if remote:
+            self.remote_field = remote
+        else:
+            self.remote_field = DynamicNestedField(None, '', remote_name, self)
+
 @receiver([post_save])
 def auto_urlid(sender, instance, **kwargs):
     if isinstance(instance, Model):
+        changed = False
         if getattr(instance, Model.slug_field(instance), None) is None:
             setattr(instance, Model.slug_field(instance), instance.pk)
-            instance.save()
-        if (instance.urlid is None or instance.urlid == '' or 'None' in instance.urlid):
+            changed = True
+        if (not instance.urlid or 'None' in instance.urlid):
             instance.urlid = instance.get_absolute_url()
+            changed = True
+        if changed:
             instance.save()
 
+@receiver(post_save)
+def create_role_groups(sender, instance, created, **kwargs):
+    if created:
+        for name, params in getattr(instance._meta, 'permission_roles', {}).items():
+            group, x = Group.objects.get_or_create(name=f'LDP_{instance._meta.model_name}_{name}_{instance.id}')
+            setattr(instance, name, group)
+            instance.save()
+            if params.get('add_author'):
+                assert hasattr(instance._meta, 'auto_author'), "add_author requires to also define auto_author"
+                author = getattr(instance, instance._meta.auto_author)
+                if author:
+                    group.user_set.add(author)
+            for permission in params.get('perms', []):
+                assign_perm(f'{permission}_{instance._meta.model_name}', group, instance)
 
-if 'djangoldp_account' not in settings.DJANGOLDP_PACKAGES:
-    def webid(self):
-        # an external user should have urlid set
-        webid = getattr(self, 'urlid', None)
-        if webid is not None and urlparse(settings.BASE_URL).netloc != urlparse(webid).netloc:
-            webid = self.urlid
-        # local user use user-detail URL with primary key
-        else:
-            webid = '{0}{1}'.format(settings.BASE_URL, reverse_lazy('user-detail', kwargs={'pk': self.pk}))
-        return webid
 
-    get_user_model().webid = webid
+def invalidate_cache_if_has_entry(entry):
+    from djangoldp.serializers import GLOBAL_SERIALIZER_CACHE
+
+    if GLOBAL_SERIALIZER_CACHE.has(entry):
+        GLOBAL_SERIALIZER_CACHE.invalidate(entry)
+
+def invalidate_model_cache_if_has_entry(model):
+    entry = getattr(model._meta, 'label', None)
+    invalidate_cache_if_has_entry(entry)
+
+@receiver([pre_save, pre_delete])
+def invalidate_caches(sender, instance, **kwargs):
+    invalidate_model_cache_if_has_entry(sender)
+
+@receiver([m2m_changed])
+def invalidate_caches_m2m(sender, instance, action, *args, **kwargs):
+    invalidate_model_cache_if_has_entry(kwargs['model'])
\ No newline at end of file

djangoldp/models/site_setting.py

+# models.py
+from django.db import models
+
+class SiteSetting(models.Model):
+    title = models.CharField(max_length=200, default="My App")
+    description = models.TextField(blank=True)
+    terms_url = models.URLField(blank=True)
+
+    def save(self, *args, **kwargs):
+        self.pk = 1  # enforce singleton
+        super().save(*args, **kwargs)
+
+    @classmethod
+    def get_solo(cls):
+        return cls.objects.get_or_create(pk=1)[0]
\ No newline at end of file