psat-server-web 0.6.7__tar.gz → 0.6.9__tar.gz

{psat_server_web-0.6.7/psat_server_web.egg-info → psat_server_web-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: psat-server-web
-Version: 0.6.7
+Version: 0.6.9
 Summary: Pan-STARRS and ATLAS web interface.
 Home-page: https://github.com/genghisken/psat-server-web
 Author: genghisken
@@ -28,6 +28,8 @@ Requires-Dist: gkutils>=0.3.10
 Requires-Dist: requests
 Requires-Dist: lasair
 Requires-Dist: dustmaps
+Requires-Dist: django-debug-toolbar
+Requires-Dist: pillow
 
 # psat-server-web
 Python 3 web interface for the Pan-STARRS and ATLAS surveys.

psat_server_web-0.6.9/psat_server_web/__version__.py

@@ -0,0 +1 @@
+__version__ = '0.6.9'

psat_server_web-0.6.9/psat_server_web/atlas/accounts/forms.py

@@ -0,0 +1,115 @@
+"""
+Forms for user account management.
+"""
+from django import forms
+from django.contrib.auth.models import User, Group
+from django.core.exceptions import ValidationError
+
+
+class CreateUserForm(forms.Form):
+    """
+    Form for creating new users with profile settings.
+    Only accessible by admin users.
+    """
+    # User basic information
+    username = forms.CharField(
+        max_length=150,
+        widget=forms.TextInput(attrs={
+            'class': 'form-control',
+            'placeholder': 'Enter username'
+        }),
+        help_text='Required. Letters, digits and @/./+/-/_ only.'
+    )
+    
+    email = forms.EmailField(
+        widget=forms.EmailInput(attrs={
+            'class': 'form-control',
+            'placeholder': 'Enter email address'
+        }),
+        help_text='Required. Valid email address.'
+    )
+    
+    first_name = forms.CharField(
+        max_length=30,
+        widget=forms.TextInput(attrs={
+            'class': 'form-control',
+            'placeholder': 'Enter first name'
+        }),
+        help_text='Required. First name of the user.'
+    )
+    
+    last_name = forms.CharField(
+        max_length=150,
+        widget=forms.TextInput(attrs={
+            'class': 'form-control',
+            'placeholder': 'Enter last name'
+        }),
+        help_text='Required. Last name of the user.'
+    )
+
+    image = forms.ImageField(
+        required=False,
+        widget=forms.ClearableFileInput(attrs={
+            'class': 'form-control-file'
+        }),
+        help_text='Optional. Upload a profile image (.gif, .png, .jpg).'
+    )
+    
+    # Group selection for token expiration and write access
+    group = forms.ModelChoiceField(
+        queryset=Group.objects.all(),
+        empty_label="Select a group",
+        widget=forms.Select(attrs={
+            'class': 'form-control'
+        }),
+        help_text=(
+            'Select group to determine API token expiration time and '
+            'write access permissions.'
+        )
+    )
+
+    has_write_access = forms.BooleanField(
+        required=False,
+        label='Can edit observations',
+        widget=forms.CheckboxInput(),
+        help_text='Grant the user permission to edit observations.'
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        for field_name, field in self.fields.items():
+            auto_id = self.auto_id % field_name
+            id_for_error = f"{auto_id}_errorlist"
+            id_for_help = f"{auto_id}_helptext"
+            field.widget.attrs.update(
+                {
+                    "aria-describedby": f"{id_for_error} {id_for_help}",
+                }
+            )
+
+    def clean_username(self):
+        """Validate that username is unique."""
+        username = self.cleaned_data['username']
+        if User.objects.filter(username=username).exists():
+            raise ValidationError('A user with this username already exists.')
+        return username
+    
+    def clean_email(self):
+        """Validate that email is unique."""
+        email = self.cleaned_data['email']
+        if User.objects.filter(email=email).exists():
+            raise ValidationError('A user with this email already exists.')
+        return email
+
+
+class ChangeProfileImageForm(forms.Form):
+    """
+    Form for changing the user's profile image.
+    """
+    image = forms.ImageField(
+        required=False,
+        widget=forms.ClearableFileInput(attrs={
+            'class': 'form-control-file'
+        }),
+        help_text='Optional. Upload a new profile image (.gif, .png, .jpg).'
+    )

psat_server_web-0.6.9/psat_server_web/atlas/accounts/migrations/0005_userprofile_image_userprofile_image_b64.py

@@ -0,0 +1,24 @@
+# Generated by Django 5.2.1 on 2025-08-08 22:55
+
+import django.core.validators
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('accounts', '0004_userprofile'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='image',
+            field=models.ImageField(blank=True, help_text='Optional. Upload a profile image (.gif, .png, .jpg).', null=True, upload_to='profile_pics/', validators=[django.core.validators.FileExtensionValidator(allowed_extensions=['gif', 'jpeg', 'jpg', 'png'])]),
+        ),
+        migrations.AddField(
+            model_name='userprofile',
+            name='image_b64',
+            field=models.TextField(blank=True, null=True),
+        ),
+    ]

psat_server_web-0.6.9/psat_server_web/atlas/accounts/migrations/0006_alter_userprofile_image.py

@@ -0,0 +1,20 @@
+# Generated by Django 5.2.1 on 2025-08-27 11:30
+
+import accounts.models
+import django.core.validators
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('accounts', '0005_userprofile_image_userprofile_image_b64'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='userprofile',
+            name='image',
+            field=models.ImageField(blank=True, help_text='Optional. Upload a profile image (.gif, .png, .jpg).', null=True, upload_to=accounts.models.user_directory_path, validators=[django.core.validators.FileExtensionValidator(allowed_extensions=['gif', 'jpeg', 'jpg', 'png'])]),
+        ),
+    ]

psat_server_web-0.6.9/psat_server_web/atlas/accounts/models.py

@@ -0,0 +1,121 @@
+
+from PIL import Image
+from django.utils.timezone import timedelta
+from django.contrib.auth.models import Group
+from django.db import models
+from django.core.validators import FileExtensionValidator
+from django.conf import settings
+import io
+import os
+import re
+
+from .utils import bytes2string
+
+
+def user_directory_path(instance, filename):
+    # file will be uploaded to MEDIA_ROOT/profile_pics/<username>/<filename>
+    # Securely extract the base filename and validate it
+    base_filename = os.path.basename(filename)
+    # Allow only alphanumerics, underscores, hyphens, and dots in filenames
+    if not re.fullmatch(r'[\w.\-]+', base_filename):
+        raise ValueError("Invalid profile image filename.")
+    return f'profile_pics/{instance.user.username}/{base_filename}'
+
+
+class UserProfile(models.Model):
+    """UserProfile.
+    
+    Extension of the User model to store additional information, such as token 
+    expiration time and avatar image.
+    """
+
+    if settings.DEBUG:
+        staticRoot = settings.STATICFILES_DIRS[0]
+    else:
+        staticRoot = settings.STATIC_ROOT
+    
+    id = models.AutoField(primary_key=True)
+    user = models.OneToOneField(
+        'auth.User', 
+        on_delete=models.CASCADE, 
+        related_name='profile'
+    )
+    password_unuseable_fl = models.BooleanField(
+        default=False,
+        help_text='If true, password requires changing before login'
+    )
+
+    image = models.ImageField(
+        upload_to=user_directory_path,
+        validators=[FileExtensionValidator(
+            allowed_extensions=['gif', 'jpeg', 'jpg', 'png']
+        )],
+        blank=True,
+        null=True,
+        help_text='Optional. Upload a profile image (.gif, .png, .jpg).'
+    )
+    image_b64 = models.TextField(
+        blank=True,
+        null=True,
+    )
+
+    def __str__(self):
+        return f'{self.user.username} Profile'
+
+    def save(self, *args, **kwargs):
+        super(UserProfile, self).save(*args, **kwargs)
+        if self.image:
+            img = Image.open(self.image.path)
+            if img.height > 300 or img.width > 300:
+                output_size = (300, 300)
+                img.thumbnail(output_size)
+                img.save(self.image.path)
+            imgByteArr = io.BytesIO()
+            img.save(imgByteArr, format=img.format)
+            self.image_b64 = bytes2string(imgByteArr.getvalue())
+            super(UserProfile, self).save(*args, **kwargs)
+  
+    class Meta:
+        """Meta.
+        """
+        app_label = 'accounts'
+        managed = True
+        verbose_name = 'User Profile'
+        verbose_name_plural = 'User Profiles'
+        db_table = 'auth_user_profile'
+
+
+class GroupProfile(models.Model):
+    """GroupProfile.
+    
+    Extension of the Group model to store additional information, such as token 
+    expiration time.
+    """
+    id = models.AutoField(primary_key=True)
+    group = models.OneToOneField(
+        Group, 
+        on_delete=models.CASCADE, 
+        related_name='profile'
+    )
+    api_write_access = models.BooleanField(
+        default=False,
+        help_text='Does the group have write access to the API?'
+    )
+    token_expiration_time = models.DurationField(
+        help_text='in days, default 1 day (24*60*60 seconds)',
+        default=timedelta(days=1)
+    )
+    description = models.TextField(
+        blank=True,
+        help_text='What is the group for?'
+    )
+    
+    class Meta:
+        """Meta.
+        """
+        app_label = 'accounts'
+        managed = True
+        verbose_name = 'Group Profile'
+        verbose_name_plural = 'Group Profiles'
+        db_table = 'auth_group_profile'
+

psat_server_web-0.6.9/psat_server_web/atlas/accounts/urls.py

@@ -0,0 +1,32 @@
+from django.urls import include, path, re_path
+from django.contrib.auth import views as auth_views
+
+from accounts import views
+
+urlpatterns = [
+    re_path(r'^login/', views.loginView, name="login"),
+    re_path(r'^register/', views.register_user, name="register"),
+    re_path(r'^logout/', views.logoutView, name="logout"),
+    re_path(r'^auth/', views.authView, name="auth"),
+    re_path(r'^loggedin/', views.loggedin, name="loggedin"),
+    re_path(r'^invalid/', views.invalidLogin, name="invalid"),
+    re_path(
+        r'^change_password/$',
+        views.AtlasPasswordChangeView.as_view(),
+        name="change_password"
+    ),
+    re_path(
+        r'^password_change_done/$',
+        auth_views.PasswordChangeDoneView.as_view(
+            template_name="password_change_done.html"
+        ),
+        name="password_change_done"
+    ),
+    re_path(r'^create_user/$', views.create_user, name="create_user"),
+    re_path(
+        r'^change_profile_image/$',
+        views.change_profile_image,
+        name="change_profile_image"
+    ),
+    path("", include("django_registration.backends.activation.urls")),
+]

psat_server_web-0.6.9/psat_server_web/atlas/accounts/utils.py

@@ -0,0 +1,42 @@
+import logging
+import base64
+
+logger = logging.getLogger(__name__)
+
+
+def needs_to_change_password(user):
+    """
+    Custom test to check if the user is logged in and has a specific attribute.
+    """
+    try:
+        logger.debug(
+            f"Checking if user {user.username} needs to change password."
+        )
+        logger.debug(f"User profile: {user.profile}")
+        return user.profile.password_unuseable_fl
+    except AttributeError:
+        return False
+
+
+def bytes2string(bytes):
+    """*convert byte to string and return*
+
+    **Key Arguments:**
+
+    - `bytes` -- the byte string to convert
+    """
+    base64_bytes = base64.b64encode(bytes)
+    str = base64_bytes.decode('utf-8')
+    return str
+
+
+def string2bytes(str):
+    """*convert string to bytes and return*
+
+    **Key Arguments:**
+
+    - `str` -- the str string to convert to string
+    """
+    base64_bytes = str.encode('utf-8')
+    bytes = base64.decodebytes(base64_bytes)
+    return bytes

psat_server_web-0.6.9/psat_server_web/atlas/accounts/views.py

@@ -0,0 +1,303 @@
+from django.shortcuts import render, redirect
+from django.contrib.auth import views as auth_views
+from django.contrib import auth, messages
+from django import forms
+from django.contrib.auth.forms import UserCreationForm, PasswordChangeForm
+from django.contrib.auth.models import Group, Permission
+from django.contrib.auth.decorators import login_required, user_passes_test
+import logging
+
+from accounts.models import UserProfile
+from accounts.utils import needs_to_change_password
+
+logger = logging.getLogger(__name__)
+
+
+class LoginForm(forms.Form):
+    """LoginForm.
+    """
+
+    username = forms.CharField(
+        required=False,
+        widget=forms.TextInput(
+            attrs={'size': '50', 'class': 'form-control'}
+        )
+    )
+    password = forms.CharField(
+        required=False,
+        widget=forms.PasswordInput(
+            attrs={'size': '50', 'class': 'form-control'}
+        )
+    )
+
+
+def loginView(request):
+    """login.
+
+    Args:
+        request:
+    """
+    auth.logout(request)
+    form = LoginForm()
+    return render(request, 'login.html', {'form': form})
+
+
+def authView(request):
+    """authView.
+
+    Args:
+        request:
+    """
+    # Although we picked up the "next" parameter via GET in our template,
+    # we submitted it via POST.
+    next = request.POST.get('next', '')
+
+    username = request.POST.get('username', '')
+    password = request.POST.get('password', '')
+    user = auth.authenticate(username=username, password=password)
+
+    if user is not None:
+        # Expire the login session after 1 day.
+        # 2017-11-28 KWS Changed expiry to 30 days.
+        # 1 day expiry too irritating.
+        request.session.set_expiry(30 * 86400)
+        auth.login(request, user)
+        try:
+            if user.profile.password_unuseable_fl:
+                return redirect('change_password')
+        except AttributeError:
+            logger.warning(f'User {user} has no profile.')
+        
+        if next == '':
+            return redirect('home')
+        else:
+            return redirect(next)
+
+    else:
+        return redirect('invalid')
+
+
+def loggedin(request):
+    """loggedin.
+
+    Args:
+        request:
+    """
+    return render(request, 'loggedin.html',
+                  {'full_name': request.user.username})
+
+
+def invalidLogin(request):
+    """invalidLogin.
+
+    Args:
+        request:
+    """
+    return render(request, 'invalid_login.html')
+
+
+def logoutView(request):
+    """logout.
+
+    Args:
+        request:
+    """
+    auth.logout(request)
+    return render(request, 'logout.html')
+
+
+def register_user(request):
+    if request.method == 'POST':
+        form = UserCreationForm(request.POST)
+        if form.is_valid():
+            form.save()
+            return redirect('login')
+    else:
+        form = UserCreationForm()
+    return render(request, 'register.html', {'form': form})
+
+
+class AtlasPasswordChangeForm(PasswordChangeForm):
+    """AtlasPasswordChangeForm.
+    """
+    error_messages = {
+        **PasswordChangeForm.error_messages,
+        'password_old_same_new': (
+            "The new password cannot be the same as the old password."
+        ),
+        'old_password_incorrect': "The old password is not correct.",
+    }
+
+    def clean_new_password1(self):
+        """ 
+        Further checking on old password to ensure it is not the same as the 
+        new password.
+        """
+        new_password1 = self.cleaned_data['new_password1']
+        try:
+            old_password = self.cleaned_data['old_password']
+        except KeyError:
+            # This is a new password change form, so we don't have an old
+            # password to check against.
+            raise forms.ValidationError(
+                self.error_messages['old_password_incorrect'],
+                code='old_password_incorrect',
+            )
+        
+        if old_password == new_password1:
+            raise forms.ValidationError(
+                self.error_messages['password_old_same_new'],
+                code='password_old_same_new',
+            )
+        return new_password1
+
+
+class AtlasPasswordChangeView(auth_views.PasswordChangeView):
+    """AtlasPasswordChangeView.
+    """
+    form_class = AtlasPasswordChangeForm
+    template_name = 'change_password.html'
+    
+    def form_valid(self, form):
+        # Unset the password_unuseable flag in the user profile
+        try:
+            form.user.profile.password_unuseable_fl = False
+            form.user.profile.save()
+        except AttributeError:
+            logger.warning(f'User {form.user} has no profile.')
+        
+        return super().form_valid(form)
+
+    def get_context_data(self, **kwargs):
+        context_data = super().get_context_data(**kwargs)
+        try:
+            context_data['password_unuseable_fl'] = (
+                self.request.user.profile.password_unuseable_fl
+            )
+        except AttributeError:
+            logger.warning(f'User {self.request.user} has no profile.')
+            context_data['password_unuseable_fl'] = False
+        return context_data
+
+
+@login_required
+@user_passes_test(lambda u: u.is_staff, login_url='invalid')
+def create_user(request):
+    """
+    Create a new user with profile settings.
+    Only accessible by admin users.
+    """
+    from accounts.forms import CreateUserForm
+    from accounts.models import UserProfile, GroupProfile
+    from django.contrib.auth.models import User
+    from django.contrib import messages
+    
+    if request.method == 'POST':
+        form = CreateUserForm(request.POST, request.FILES)
+        if form.is_valid():
+            try:
+                # Create the user
+                user = User.objects.create_user(
+                    username=form.cleaned_data['username'],
+                    email=form.cleaned_data['email'],
+                    first_name=form.cleaned_data['first_name'],
+                    last_name=form.cleaned_data['last_name'],
+                    password='atlas'
+                )
+                
+                user.save()
+
+                if form.cleaned_data.get('has_write_access'):
+                    # Grant write access if the checkbox is checked
+                    permission = Permission.objects.get(
+                        codename='has_write_access'
+                    )
+                    user.user_permissions.add(
+                        permission
+                    )
+                
+                # Add user to selected group
+                group = form.cleaned_data['group']
+                user.groups.add(group)
+                
+                # Create or update user profile
+                profile, created = UserProfile.objects.get_or_create(user=user)
+                # Temp password must be changed by user
+                profile.password_unuseable_fl = True 
+                profile.save()
+                image = form.cleaned_data.get('image')
+                if image:
+                    profile.image = image
+                    profile.save()
+                
+                messages.success(
+                    request,
+                    f'User {user.username} created successfully!'
+                )
+                
+                # Clear form for next user creation
+                form = CreateUserForm()
+                
+            except Exception as e:
+                messages.error(request, f'Error creating user: {str(e)}')
+                
+    else:
+        form = CreateUserForm()
+    
+    # Get group information for display
+    groups_info = []
+    for group in Group.objects.all():
+        try:
+            group_profile = GroupProfile.objects.get(group=group)
+            groups_info.append({
+                'group': group,
+                'token_expiration': group_profile.token_expiration_time,
+                'api_write_access': group_profile.api_write_access,
+                'description': group_profile.description
+            })
+        except GroupProfile.DoesNotExist:
+            groups_info.append({
+                'group': group,
+                'token_expiration': 'Not set',
+                'api_write_access': False,
+                'description': 'No profile configured'
+            })
+    
+    context = {
+        'form': form,
+        'groups_info': groups_info,
+        'title': 'Create New User'
+    }
+    
+    return render(request, 'create_user.html', context)
+
+
+@user_passes_test(
+    lambda u: not needs_to_change_password(u),
+    login_url='change_password'
+)
+@login_required
+def change_profile_image(request):
+    """Change the user's profile image.
+    
+    Args:
+        request: The HTTP request object.
+    """
+    from accounts.forms import ChangeProfileImageForm
+    
+    if request.method == 'POST':
+        form = ChangeProfileImageForm(request.POST, request.FILES)
+        if form.is_valid():
+            profile, created = UserProfile.objects.get_or_create(
+                user=request.user
+            )
+            image = form.cleaned_data.get('image')
+            if image:
+                profile.image = image
+                profile.save()
+            messages.success(request, 'Profile image updated successfully!')
+            return redirect('home')
+    else:
+        form = ChangeProfileImageForm()
+    
+    return render(request, 'change_profile_image.html', {'form': form})