def __init__(self, user_search_string, search_by):
super().__init__(user_search_string, search_by)
self.FREEIPA_SERVER = import_from_settings('FREEIPA_SERVER')
self.FREEIPA_USER_SEARCH_BASE = import_from_settings(
'FREEIPA_USER_SEARCH_BASE', 'cn=users,cn=accounts')
self.FREEIPA_KTNAME = import_from_settings('FREEIPA_KTNAME', '')
self.server = Server('ldap://{}'.format(self.FREEIPA_SERVER),
use_ssl=True,
connect_timeout=1)
if len(self.FREEIPA_KTNAME) > 0:
logger.info('Kerberos bind enabled: %s', self.FREEIPA_KTNAME)
# kerberos SASL/GSSAPI bind
os.environ["KRB5_CLIENT_KTNAME"] = self.FREEIPA_KTNAME
self.conn = Connection(self.server,
authentication=SASL,
sasl_mechanism=KERBEROS,
auto_bind=True)
else:
# anonomous bind
self.conn = Connection(self.server, auto_bind=True)
if not self.conn.bind():
raise ImproperlyConfigured(
'Failed to bind to LDAP server: {}'.format(self.conn.result))
else:
logger.info('LDAP bind successful: %s',
self.conn.extend.standard.who_am_i())
def __init__(self, username, groups):
"""Initialize settings."""
self.IQUOTA_API_HOST = import_from_settings('IQUOTA_API_HOST')
self.IQUOTA_API_PORT = import_from_settings('IQUOTA_API_PORT')
self.IQUOTA_CA_CERT = import_from_settings('IQUOTA_CA_CERT')
self.IQUOTA_KEYTAB = import_from_settings('IQUOTA_KEYTAB')
self.username = username
self.groups = groups
def __init__(self):
self.SYSTEM_MONITOR_ENDPOINT = import_from_settings(
'SYSTEM_MONITOR_ENDPOINT')
self.SYSTEM_MONITOR_PANEL_TITLE = import_from_settings(
'SYSTEM_MONITOR_PANEL_TITLE')
self.response = None
self.data = {}
self.parse_function = getattr(self, self.RESPONSE_PARSER_FUNCTION)
self.fetch_data()
def __init__(self, user_search_string, search_by):
super().__init__(user_search_string, search_by)
self.LDAP_SERVER_URI = import_from_settings('AUTH_LDAP_SERVER_URI')
self.LDAP_USER_SEARCH_BASE = import_from_settings(
'AUTH_LDAP_USER_SEARCH_BASE')
self.LDAP_BIND_DN = import_from_settings('AUTH_LDAP_BIND_DN', None)
self.LDAP_BIND_PASSWORD = import_from_settings(
'AUTH_LDAP_BIND_PASSWORD', None)
self.conn = ldap.initialize(self.LDAP_SERVER_URI)
# Required for our LDAP
self.conn.start_tls_s()
self.conn.simple_bind_s(self.LDAP_BIND_DN, self.LDAP_BIND_PASSWORD)
def __init__(self, user_search_string, search_by):
super().__init__(user_search_string, search_by)
self.LDAP_SERVER_URI = import_from_settings('LDAP_SERVER_URI')
self.LDAP_USER_SEARCH_BASE = import_from_settings(
'LDAP_USER_SEARCH_BASE')
self.LDAP_BIND_DN = import_from_settings('LDAP_BIND_DN', None)
self.LDAP_BIND_PASSWORD = import_from_settings('LDAP_BIND_PASSWORD',
None)
self.server = Server(self.LDAP_SERVER_URI,
use_ssl=True,
connect_timeout=1)
self.conn = Connection(self.server,
self.LDAP_BIND_DN,
self.LDAP_BIND_PASSWORD,
auto_bind=True)
def get_system_monitor_context():
context = {}
system_monitor = SystemMonitor()
system_monitor_data = system_monitor.get_data()
system_monitor_panel_title = system_monitor.get_panel_title()
context['last_updated'] = system_monitor_data.get('last_updated')
context['utilization_data'] = system_monitor_data.get('utilization_data')
context['jobs_data'] = system_monitor_data.get('jobs_data')
context['system_monitor_panel_title'] = system_monitor_panel_title
context['SYSTEM_MONITOR_DISPLAY_XDMOD_LINK'] = import_from_settings(
'SYSTEM_MONITOR_DISPLAY_XDMOD_LINK', None)
context[
'SYSTEM_MONITOR_DISPLAY_MORE_STATUS_INFO_LINK'] = import_from_settings(
'SYSTEM_MONITOR_DISPLAY_MORE_STATUS_INFO_LINK', None)
return context
def __init__(self,
user_search_string,
search_by,
usernames_names_to_exclude=[]):
self.USER_SEARCH_CLASSES = import_from_settings(
'ADDITIONAL_USER_SEARCH_CLASSES', [])
self.USER_SEARCH_CLASSES.insert(
0, 'coldfront.core.user.utils.LocalUserSearch')
self.user_search_string = user_search_string
self.search_by = search_by
self.usernames_names_to_exclude = usernames_names_to_exclude
import logging
from django.contrib.auth.models import Group
from coldfront.core.utils.common import import_from_settings
from mozilla_django_oidc.auth import OIDCAuthenticationBackend
logger = logging.getLogger(__name__)
PI_GROUP = import_from_settings('MOKEY_OIDC_PI_GROUP', 'pi')
ALLOWED_GROUPS = import_from_settings('MOKEY_OIDC_ALLOWED_GROUPS', [])
DENY_GROUPS = import_from_settings('MOKEY_OIDC_DENY_GROUPS', [])
class OIDCMokeyAuthenticationBackend(OIDCAuthenticationBackend):
def _sync_groups(self, user, groups):
is_pi = False
user.groups.clear()
for group_name in groups:
group, created = Group.objects.get_or_create(name=group_name)
user.groups.add(group)
if group_name == PI_GROUP:
is_pi = True
user.userprofile.is_pi = is_pi
def _parse_groups_from_claims(self, claims):
groups = claims.get('groups', []) or []
if isinstance(groups, str):
groups = groups.split(';')
from django.contrib.auth.decorators import login_required
from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.http import HttpResponseRedirect
from django.shortcuts import render
from django.urls import reverse
from django.utils.decorators import method_decorator
from django.views import View
from django.views.generic import TemplateView
from coldfront.core.user.forms import UserSearchForm
from coldfront.core.user.utils import CombinedUserSearch
from coldfront.core.utils.mail import send_email_template
from coldfront.core.utils.common import import_from_settings
logger = logging.getLogger(__name__)
EMAIL_ENABLED = import_from_settings('EMAIL_ENABLED', False)
if EMAIL_ENABLED:
EMAIL_TICKET_SYSTEM_ADDRESS = import_from_settings(
'EMAIL_TICKET_SYSTEM_ADDRESS')
@method_decorator(login_required, name='dispatch')
class UserProfile(TemplateView):
template_name = 'user/user_profile.html'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
group_list = ', '.join(
[group.name for group in self.request.user.groups.all()])
context['group_list'] = group_list
return context
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from django.db import models
from django.utils.html import mark_safe
from django.utils.module_loading import import_string
from model_utils.models import TimeStampedModel
from simple_history.models import HistoricalRecords
from coldfront.core.project.models import Project
from coldfront.core.resource.models import Resource
from coldfront.core.utils.common import import_from_settings
import coldfront.core.attribute_expansion as attribute_expansion
logger = logging.getLogger(__name__)
ALLOCATION_ATTRIBUTE_VIEW_LIST = import_from_settings(
'ALLOCATION_ATTRIBUTE_VIEW_LIST', [])
ALLOCATION_FUNCS_ON_EXPIRE = import_from_settings('ALLOCATION_FUNCS_ON_EXPIRE',
[])
ALLOCATION_RESOURCE_ORDERING = import_from_settings(
'ALLOCATION_RESOURCE_ORDERING', ['-is_allocatable', 'name'])
class AllocationStatusChoice(TimeStampedModel):
name = models.CharField(max_length=64)
def __str__(self):
return self.name
class Meta:
ordering = [
'name',
import os
import sys
import tempfile
from django.core.management.base import BaseCommand, CommandError
from django.conf import settings
from coldfront.core.utils.common import import_from_settings
from coldfront.core.resource.models import ResourceAttribute
from coldfront.plugins.slurm.associations import SlurmCluster
from coldfront.plugins.slurm.utils import SlurmError, slurm_remove_account, slurm_remove_assoc, \
slurm_add_assoc, slurm_add_account, slurm_dump_cluster, SLURM_CLUSTER_ATTRIBUTE_NAME, \
SLURM_ACCOUNT_ATTRIBUTE_NAME, SLURM_USER_SPECS_ATTRIBUTE_NAME
SLURM_IGNORE_USERS = import_from_settings('SLURM_IGNORE_USERS', [])
SLURM_IGNORE_ACCOUNTS = import_from_settings('SLURM_IGNORE_ACCOUNTS', [])
SLURM_IGNORE_CLUSTERS = import_from_settings('SLURM_IGNORE_CLUSTERS', [])
SLURM_NOOP = import_from_settings('SLURM_NOOP', False)
logger = logging.getLogger(__name__)
class Command(BaseCommand):
help = 'Check consistency between Slurm associations and Coldfront subscriptions'
def add_arguments(self, parser):
parser.add_argument("-i", "--input", help="Path to sacctmgr dump flat file as input. Defaults to stdin")
parser.add_argument("-c", "--cluster", help="Run sacctmgr dump [cluster] as input")
parser.add_argument("-s", "--sync", help="Remove associations in Slurm that no longer exist in Coldfront", action="store_true")
parser.add_argument("-n", "--noop", help="Print commands only. Do not run any commands.", action="store_true")
parser.add_argument("-u", "--username", help="Check specific username")
from django import forms
from django.shortcuts import get_object_or_404
from coldfront.core.project.models import Project
from coldfront.core.resource.models import Resource, ResourceType
from coldfront.core.subscription.models import (Subscription,
SubscriptionAccount,
SubscriptionStatusChoice)
from coldfront.core.subscription.utils import get_user_resources
from coldfront.core.utils.common import import_from_settings
SUBSCRIPTION_ACCOUNT_ENABLED = import_from_settings(
'SUBSCRIPTION_ACCOUNT_ENABLED', False)
class SubscriptionForm(forms.Form):
resource = forms.ModelChoiceField(queryset=None, empty_label=None)
justification = forms.CharField(widget=forms.Textarea)
quantity = forms.IntegerField(required=True)
users = forms.MultipleChoiceField(widget=forms.CheckboxSelectMultiple,
required=False)
subscription_account = forms.ChoiceField(required=False)
def __init__(self, request_user, project_pk, *args, **kwargs):
super().__init__(*args, **kwargs)
project_obj = get_object_or_404(Project, pk=project_pk)
self.fields['resource'].queryset = get_user_resources(request_user)
self.fields['quantity'].initial = 1
user_query_set = project_obj.projectuser_set.select_related(
'user').filter(status__name__in=[
'Active',
from django.apps import AppConfig
from coldfront.core.utils.common import import_from_settings
FREEIPA_ENABLE_SIGNALS = import_from_settings('FREEIPA_ENABLE_SIGNALS', False)
class IPAConfig(AppConfig):
name = 'coldfront.plugins.freeipa'
def ready(self):
if FREEIPA_ENABLE_SIGNALS:
import coldfront.plugins.freeipa.signals
from django import forms
from django.shortcuts import get_object_or_404
from coldfront.core.allocation.models import (Allocation, AllocationAccount,
AllocationAttributeType,
AllocationAttribute,
AllocationStatusChoice)
from coldfront.core.allocation.utils import get_user_resources
from coldfront.core.project.models import Project
from coldfront.core.resource.models import Resource, ResourceType
from coldfront.core.utils.common import import_from_settings
ALLOCATION_ACCOUNT_ENABLED = import_from_settings(
'ALLOCATION_ACCOUNT_ENABLED', False)
ALLOCATION_CHANGE_REQUEST_EXTENSION_DAYS = import_from_settings(
'ALLOCATION_CHANGE_REQUEST_EXTENSION_DAYS', [])
class AllocationForm(forms.Form):
resource = forms.ModelChoiceField(queryset=None, empty_label=None)
justification = forms.CharField(widget=forms.Textarea)
quantity = forms.IntegerField(required=True)
users = forms.MultipleChoiceField(
widget=forms.CheckboxSelectMultiple, required=False)
allocation_account = forms.ChoiceField(required=False)
def __init__(self, request_user, project_pk, *args, **kwargs):
super().__init__(*args, **kwargs)
project_obj = get_object_or_404(Project, pk=project_pk)
self.fields['resource'].queryset = get_user_resources(request_user)
self.fields['quantity'].initial = 1
import logging
from smtplib import SMTPException
from django.conf import settings
from django.core.mail import EmailMessage, send_mail
from django.template.loader import render_to_string
from coldfront.core.utils.common import import_from_settings
logger = logging.getLogger(__name__)
EMAIL_ENABLED = import_from_settings('EMAIL_ENABLED', False)
if EMAIL_ENABLED:
EMAIL_SUBJECT_PREFIX = import_from_settings('EMAIL_SUBJECT_PREFIX')
EMAIL_DEVELOPMENT_EMAIL_LIST = import_from_settings(
'EMAIL_DEVELOPMENT_EMAIL_LIST')
def send_email(subject, body, sender, receiver_list, cc=[]):
"""Helper function for sending emails
"""
if not EMAIL_ENABLED:
return
if len(receiver_list) == 0:
logger.error('Failed to send email missing receiver_list')
return
if len(sender) == 0:
logger.error('Failed to send email missing sender address')
return
import datetime
import textwrap
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from django.core.validators import MinLengthValidator
from django.db import models
from model_utils.models import TimeStampedModel
from simple_history.models import HistoricalRecords
from coldfront.core.field_of_science.models import FieldOfScience
from coldfront.core.utils.common import import_from_settings
PROJECT_ENABLE_PROJECT_REVIEW = import_from_settings(
'PROJECT_ENABLE_PROJECT_REVIEW', False)
class ProjectStatusChoice(TimeStampedModel):
name = models.CharField(max_length=64)
def __str__(self):
return self.name
class Meta:
ordering = ('name', )
class Project(TimeStampedModel):
DEFAULT_DESCRIPTION = '''
We do not have information about your research. Please provide a detailed description of your work and update your field of science. Thank you!
import logging
import os
from django.core.exceptions import ImproperlyConfigured
from coldfront.core.utils.common import import_from_settings
from ipalib import api
CLIENT_KTNAME = import_from_settings('FREEIPA_KTNAME')
UNIX_GROUP_ATTRIBUTE_NAME = import_from_settings('FREEIPA_GROUP_ATTRIBUTE_NAME', 'freeipa_group')
FREEIPA_NOOP = import_from_settings('FREEIPA_NOOP', False)
logger = logging.getLogger(__name__)
class ApiError(Exception):
pass
class AlreadyMemberError(ApiError):
pass
class NotMemberError(ApiError):
pass
try:
os.environ["KRB5_CLIENT_KTNAME"] = CLIENT_KTNAME
api.bootstrap()
api.finalize()
api.Backend.rpcclient.connect()
except Exception as e:
logger.error("Failed to initialze FreeIPA lib: %s", e)
raise ImproperlyConfigured('Failed to initialze FreeIPA: {0}'.format(e))
import datetime
from django import forms
from django.shortcuts import get_object_or_404
from coldfront.core.project.models import (Project, ProjectReview,
ProjectUserRoleChoice)
from coldfront.core.utils.common import import_from_settings
EMAIL_DIRECTOR_PENDING_PROJECT_REVIEW_EMAIL = import_from_settings(
'EMAIL_DIRECTOR_PENDING_PROJECT_REVIEW_EMAIL')
EMAIL_ADMIN_LIST = import_from_settings('EMAIL_ADMIN_LIST', [])
EMAIL_DIRECTOR_EMAIL_ADDRESS = import_from_settings(
'EMAIL_DIRECTOR_EMAIL_ADDRESS', '')
class ProjectSearchForm(forms.Form):
""" Search form for the Project list page.
"""
LAST_NAME = 'Last Name'
USERNAME = '******'
FIELD_OF_SCIENCE = 'Field of Science'
last_name = forms.CharField(label=LAST_NAME,
max_length=100,
required=False)
username = forms.CharField(label=USERNAME, max_length=100, required=False)
field_of_science = forms.CharField(label=FIELD_OF_SCIENCE,
max_length=100,
required=False)
show_all_projects = forms.BooleanField(initial=False, required=False)
from django import forms
from django.shortcuts import get_object_or_404
from coldfront.core.allocation.models import (Allocation, AllocationAccount,
AllocationAttributeType,
AllocationStatusChoice)
from coldfront.core.allocation.utils import get_user_resources
from coldfront.core.project.models import Project
from coldfront.core.resource.models import Resource, ResourceType
from coldfront.core.utils.common import import_from_settings
ALLOCATION_ACCOUNT_ENABLED = import_from_settings(
'ALLOCATION_ACCOUNT_ENABLED', False)
class AllocationForm(forms.Form):
resource = forms.ModelChoiceField(queryset=None, empty_label=None)
justification = forms.CharField(widget=forms.Textarea)
quantity = forms.IntegerField(required=True)
users = forms.MultipleChoiceField(
widget=forms.CheckboxSelectMultiple, required=False)
allocation_account = forms.ChoiceField(required=False)
def __init__(self, request_user, project_pk, *args, **kwargs):
super().__init__(*args, **kwargs)
project_obj = get_object_or_404(Project, pk=project_pk)
self.fields['resource'].queryset = get_user_resources(request_user)
self.fields['quantity'].initial = 1
user_query_set = project_obj.projectuser_set.select_related('user').filter(
status__name__in=['Active', ])
user_query_set = user_query_set.exclude(user=project_obj.pi)
import logging
import shlex
import subprocess
import csv
from io import StringIO
from coldfront.core.utils.common import import_from_settings
SLURM_CLUSTER_ATTRIBUTE_NAME = import_from_settings(
'SLURM_CLUSTER_ATTRIBUTE_NAME', 'slurm_cluster')
SLURM_ACCOUNT_ATTRIBUTE_NAME = import_from_settings(
'SLURM_ACCOUNT_ATTRIBUTE_NAME', 'slurm_account_name')
SLURM_SPECS_ATTRIBUTE_NAME = import_from_settings('SLURM_SPECS_ATTRIBUTE_NAME',
'slurm_specs')
SLURM_USER_SPECS_ATTRIBUTE_NAME = import_from_settings(
'SLURM_USER_SPECS_ATTRIBUTE_NAME', 'slurm_user_specs')
SLURM_SACCTMGR_PATH = import_from_settings('SLURM_SACCTMGR_PATH',
'/usr/bin/sacctmgr')
SLURM_CMD_REMOVE_USER = SLURM_SACCTMGR_PATH + ' -Q -i delete user where name={} cluster={} account={}'
SLURM_CMD_REMOVE_ACCOUNT = SLURM_SACCTMGR_PATH + ' -Q -i delete account where name={} cluster={}'
SLURM_CMD_ADD_ACCOUNT = SLURM_SACCTMGR_PATH + ' -Q -i create account name={} cluster={}'
SLURM_CMD_ADD_USER = SLURM_SACCTMGR_PATH + ' -Q -i create user name={} cluster={} account={}'
SLURM_CMD_CHECK_ASSOCIATION = SLURM_SACCTMGR_PATH + ' list associations User={} Cluster={} Account={} Format=Cluster,Account,User,QOS -P'
SLURM_CMD_BLOCK_ACCOUNT = SLURM_SACCTMGR_PATH + ' -Q -i modify account {} where Cluster={} set GrpSubmitJobs=0'
SLURM_CMD_DUMP_CLUSTER = SLURM_SACCTMGR_PATH + ' dump {} file={}'
logger = logging.getLogger(__name__)
class SlurmError(Exception):
pass
from django import forms
from django.forms import ModelForm
from django.shortcuts import get_object_or_404
from coldfront.core.grant.models import Grant
from coldfront.core.utils.common import import_from_settings
CENTER_NAME = import_from_settings('CENTER_NAME')
class GrantForm(ModelForm):
class Meta:
model = Grant
exclude = [
'project',
]
labels = {
'percent_credit': 'Percent credit to {}'.format(CENTER_NAME),
'direct_funding': 'Direct funding to {}'.format(CENTER_NAME)
}
help_texts = {
'percent_credit':
'Percent credit as entered in the sponsored projects form for grant submission as financial credit to the department/unit in the credit distribution section',
'direct_funding':
'Funds budgeted specifically for {} services, hardware, software, and/or personnel'
.format(CENTER_NAME)
}
class GrantDeleteForm(forms.Form):
title = forms.CharField(max_length=255, disabled=True)
import logging
from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
from coldfront.core.subscription.models import (Subscription,
SubscriptionAttribute,
SubscriptionStatusChoice)
from coldfront.core.utils.common import get_domain_url, import_from_settings
from coldfront.core.utils.mail import send_email_template
# Get an instance of a logger
logger = logging.getLogger(__name__)
CENTER_NAME = import_from_settings('CENTER_NAME')
CENTER_BASE_URL = import_from_settings('CENTER_BASE_URL')
CENTER_PROJECT_RENEWAL_HELP_URL = import_from_settings(
'CENTER_PROJECT_RENEWAL_HELP_URL')
EMAIL_SENDER = import_from_settings('EMAIL_SENDER')
EMAIL_OPT_OUT_INSTRUCTION_URL = import_from_settings(
'EMAIL_OPT_OUT_INSTRUCTION_URL')
EMAIL_SIGNATURE = import_from_settings('EMAIL_SIGNATURE')
EMAIL_SUBSCRIPTION_EXPIRING_NOTIFICATION_DAYS = import_from_settings(
'EMAIL_SUBSCRIPTION_EXPIRING_NOTIFICATION_DAYS', [7, ])
def update_statuses():
expired_status_choice = SubscriptionStatusChoice.objects.get(
name='Expired')
import logging
import requests
import json
import xml.etree.ElementTree as ET
from coldfront.core.utils.common import import_from_settings
XDMOD_CLOUD_PROJECT_ATTRIBUTE_NAME = import_from_settings(
'XDMOD_CLOUD_PROJECT_ATTRIBUTE_NAME', 'Cloud Account Name')
XDMOD_CLOUD_CORE_TIME_ATTRIBUTE_NAME = import_from_settings(
'XDMOD_CLOUD_CORE_TIME_ATTRIBUTE_NAME', 'Core Usage (Hours)')
XDMOD_ACCOUNT_ATTRIBUTE_NAME = import_from_settings(
'XDMOD_ACCOUNT_ATTRIBUTE_NAME', 'slurm_account_name')
XDMOD_RESOURCE_ATTRIBUTE_NAME = import_from_settings(
'XDMOD_RESOURCE_ATTRIBUTE_NAME', 'xdmod_resource')
XDMOD_CPU_HOURS_ATTRIBUTE_NAME = import_from_settings(
'XDMOD_CPU_HOURS_ATTRIBUTE_NAME', 'Core Usage (Hours)')
XDMOD_API_URL = import_from_settings('XDMOD_API_URL')
_ENDPOINT_CORE_HOURS = '/controllers/user_interface.php'
_DEFAULT_PARAMS = {
'aggregation_unit': 'Auto',
'display_type': 'bar',
'format': 'xml',
'operation': 'get_data',
'public_user': '******',
'query_group': 'tg_usage',
}
logger = logging.getLogger(__name__)
from django.conf import settings
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from django.db import models
from django.utils.html import mark_safe
from django.utils.module_loading import import_string
from coldfront.core.project.models import Project
from coldfront.core.resource.models import Resource
from coldfront.core.utils.common import import_from_settings
from model_utils.models import TimeStampedModel
from simple_history.models import HistoricalRecords
logger = logging.getLogger(__name__)
SUBSCRIPTION_FUNCS_ON_EXPIRE = import_from_settings(
'SUBSCRIPTION_FUNCS_ON_EXPIRE', [])
SLURM_ACCOUNT_ATTRIBUTE_NAME = import_from_settings(
'SLURM_ACCOUNT_ATTRIBUTE_NAME', 'slurm_account_name')
class SubscriptionStatusChoice(TimeStampedModel):
name = models.CharField(max_length=64)
def __str__(self):
return self.name
class Meta:
ordering = [
'name',
]
ProjectRemoveUserForm,
ProjectReviewEmailForm,
ProjectReviewForm, ProjectSearchForm,
ProjectUserUpdateForm)
from coldfront.core.project.models import (Project, ProjectReview,
ProjectReviewStatusChoice,
ProjectStatusChoice, ProjectUser,
ProjectUserRoleChoice,
ProjectUserStatusChoice)
from coldfront.core.publication.models import Publication
from coldfront.core.user.forms import UserSearchForm
from coldfront.core.user.utils import CombinedUserSearch
from coldfront.core.utils.common import get_domain_url, import_from_settings
from coldfront.core.utils.mail import send_email, send_email_template
EMAIL_ENABLED = import_from_settings('EMAIL_ENABLED', False)
ALLOCATION_ENABLE_ALLOCATION_RENEWAL = import_from_settings(
'ALLOCATION_ENABLE_ALLOCATION_RENEWAL', True)
ALLOCATION_DEFAULT_ALLOCATION_LENGTH = import_from_settings(
'ALLOCATION_DEFAULT_ALLOCATION_LENGTH', 365)
if EMAIL_ENABLED:
EMAIL_DIRECTOR_EMAIL_ADDRESS = import_from_settings(
'EMAIL_DIRECTOR_EMAIL_ADDRESS')
EMAIL_SENDER = import_from_settings('EMAIL_SENDER')
class ProjectDetailView(LoginRequiredMixin, UserPassesTestMixin, DetailView):
model = Project
template_name = 'project/project_detail.html'
context_object_name = 'project'
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from django.db import models
from django.utils.html import mark_safe
from django.utils.module_loading import import_string
from model_utils.models import TimeStampedModel
from simple_history.models import HistoricalRecords
from coldfront.core.project.models import Project
from coldfront.core.resource.models import Resource
from coldfront.core.utils.common import import_from_settings
import coldfront.core.attribute_expansion as attribute_expansion
logger = logging.getLogger(__name__)
ALLOCATION_ATTRIBUTE_VIEW_LIST = import_from_settings(
'ALLOCATION_ATTRIBUTE_VIEW_LIST', [])
ALLOCATION_FUNCS_ON_EXPIRE = import_from_settings('ALLOCATION_FUNCS_ON_EXPIRE',
[])
class AllocationStatusChoice(TimeStampedModel):
name = models.CharField(max_length=64)
def __str__(self):
return self.name
class Meta:
ordering = [
'name',
]
