from django.utils.translation import gettext
import graphene
from utils.graphene.mutation import generate_input_type_for_serializer
from utils.graphene.error_types import mutation_is_not_valid, CustomErrorType
from .serializers import NotificationGqSerializer
from .schema import NotificationType
from .models import Notification
NotificationStatusInputType = generate_input_type_for_serializer(
'NotificationStatusInputType', serializer_class=NotificationGqSerializer)
class NotificationStatusUpdate(graphene.Mutation):
class Arguments:
data = NotificationStatusInputType(required=True)
errors = graphene.List(graphene.NonNull(CustomErrorType))
ok = graphene.Boolean()
result = graphene.Field(NotificationType)
@staticmethod
def mutate(root, info, data):
try:
instance = Notification.objects.get(
id=data['id'], receiver=info.context.request.user)
except Notification.DoesNotExist:
return NotificationStatusUpdate(errors=[
from .models import (
AnalysisFramework,
AnalysisFrameworkMembership,
)
from .serializers import (
AnalysisFrameworkGqlSerializer as AnalysisFrameworkSerializer,
AnalysisFrameworkMembershipGqlSerializer as
AnalysisFrameworkMembershipSerializer,
)
from .schema import (
AnalysisFrameworkDetailType,
AnalysisFrameworkMembershipType,
)
AnalysisFrameworkInputType = generate_input_type_for_serializer(
'AnalysisFrameworkInputType',
serializer_class=AnalysisFrameworkSerializer,
)
AnalysisFrameworkMembershipInputType = generate_input_type_for_serializer(
'AnalysisFrameworkMembershipInputType',
serializer_class=AnalysisFrameworkMembershipSerializer,
)
class CreateAnalysisFramework(GrapheneMutation):
class Arguments:
data = AnalysisFrameworkInputType(required=True)
# output fields
result = graphene.Field(AnalysisFrameworkDetailType)
# class vars
UnifiedConnector,
ConnectorSourceLead,
)
from .schema import (
UnifiedConnectorType,
ConnectorSourceLeadType,
)
from .serializers import (
UnifiedConnectorGqSerializer,
UnifiedConnectorWithSourceGqSerializer,
ConnectorSourceLeadGqSerializer,
)
from .tasks import process_unified_connector
UnifiedConnectorInputType = generate_input_type_for_serializer(
'UnifiedConnectorInputType',
serializer_class=UnifiedConnectorGqSerializer,
)
UnifiedConnectorWithSourceInputType = generate_input_type_for_serializer(
'UnifiedConnectorWithSourceInputType',
serializer_class=UnifiedConnectorWithSourceGqSerializer,
)
ConnectorSourceLeadInputType = generate_input_type_for_serializer(
'ConnectorSourceLeadInputType',
serializer_class=ConnectorSourceLeadGqSerializer,
)
class UnifiedConnectorMixin():
@classmethod
def filter_queryset(cls, qs, info):
return qs.filter(project=info.context.active_project)
ProjectAcceptRejectSerializer,
ProjectMembershipGqlSerializer as ProjectMembershipSerializer,
ProjectUserGroupMembershipGqlSerializer as ProjectUserGroupMembershipSerializer,
ProjectVizConfigurationSerializer,
)
from .schema import (
ProjectDetailType,
ProjectJoinRequestType,
ProjectMembershipType,
ProjectUserGroupMembershipType,
ProjectVizDataType,
)
ProjectCreateInputType = generate_input_type_for_serializer(
'ProjectCreateInputType',
serializer_class=ProjectGqSerializer,
)
ProjectUpdateInputType = generate_input_type_for_serializer(
'ProjectUpdateInputType',
serializer_class=ProjectGqSerializer,
partial=True,
)
ProjectJoinRequestInputType = generate_input_type_for_serializer(
'ProjectJoinRequestInputType',
serializer_class=ProjectJoinGqSerializer,
)
ProjectAcceptRejectInputType = generate_input_type_for_serializer(
'ProjectAcceptRejectInputType',
MissingPredictionReview,
WrongPredictionReview,
)
from .schema import (
DraftEntryType,
MissingPredictionReviewType,
WrongPredictionReviewType,
)
from .serializers import (
DraftEntryGqlSerializer,
WrongPredictionReviewGqlSerializer,
MissingPredictionReviewGqlSerializer,
)
DraftEntryInputType = generate_input_type_for_serializer(
'DraftEntryInputType',
serializer_class=DraftEntryGqlSerializer,
)
WrongPredictionReviewInputType = generate_input_type_for_serializer(
'WrongPredictionReviewInputType',
serializer_class=WrongPredictionReviewGqlSerializer,
)
MissingPredictionReviewInputType = generate_input_type_for_serializer(
'MissingPredictionReviewInputType',
serializer_class=MissingPredictionReviewGqlSerializer,
)
class CreateDraftEntry(PsGrapheneMutation):
class Arguments:
PsGrapheneMutation,
PsBulkGrapheneMutation,
PsDeleteMutation,
)
from utils.graphene.error_types import (mutation_is_not_valid, CustomErrorType)
from deep.permissions import ProjectPermissions as PP
from .models import Lead, LeadGroup
from .schema import LeadType, LeadGroupType
from .serializers import (
LeadGqSerializer as LeadSerializer,
LeadCopyGqSerializer,
)
LeadInputType = generate_input_type_for_serializer(
'LeadInputType',
serializer_class=LeadSerializer,
)
LeadCopyInputType = generate_input_type_for_serializer(
'LeadCopyInputType',
serializer_class=LeadCopyGqSerializer,
)
class LeadMutationMixin():
@classmethod
def filter_queryset(cls, qs, info):
return qs.filter(project=info.context.active_project)
class LeadGroupMutationMixin():
GrapheneMutation,
UserGroupDeleteMutation,
UserGroupGrapheneMutation,
UserGroupBulkGrapheneMutation,
)
from .models import UserGroup, GroupMembership
from .schema import UserGroupType, GroupMembershipType
from .serializers import (
UserGroupGqSerializer,
UserGroupMembershipGqlSerializer,
)
UserGroupInputType = generate_input_type_for_serializer(
'UserGroupInputType',
serializer_class=UserGroupGqSerializer,
)
UserGroupMembershipInputType = generate_input_type_for_serializer(
'UserGroupMembershipInputType',
serializer_class=UserGroupMembershipGqlSerializer,
)
class CreateUserGroup(GrapheneMutation):
class Arguments:
data = UserGroupInputType(required=True)
model = UserGroup
serializer_class = UserGroupGqSerializer
result = graphene.Field(UserGroupType)
import graphene
from utils.graphene.mutation import (
generate_input_type_for_serializer,
PsGrapheneMutation,
PsDeleteMutation,
)
from deep.permissions import ProjectPermissions as PP
from .models import EntryReviewComment
from .schema import EntryReviewCommentDetailType
from .serializers import (
EntryReviewCommentGqlSerializer as EntryReviewCommentSerializer, )
EntryReviewCommentInputType = generate_input_type_for_serializer(
'EntryReviewCommentInputType',
serializer_class=EntryReviewCommentSerializer,
)
class EntryReviewCommentMutationMixin():
@classmethod
def filter_queryset(cls, qs, info):
return qs.filter(created_by=info.context.user)
class CreateEntryReviewComment(EntryReviewCommentMutationMixin,
PsGrapheneMutation):
class Arguments:
data = EntryReviewCommentInputType(required=True)
model = EntryReviewComment
from utils.graphene.error_types import mutation_is_not_valid, CustomErrorType
from utils.graphene.mutation import generate_input_type_for_serializer
from .serializers import (
LoginSerializer,
RegisterSerializer,
GqPasswordResetSerializer as ResetPasswordSerializer,
PasswordChangeSerializer,
UserMeSerializer,
HIDLoginSerializer
)
from .schema import UserMeType
LoginInputType = generate_input_type_for_serializer('LoginInputType', LoginSerializer)
HIDLoginInputType = generate_input_type_for_serializer('HIDLoginInputType', HIDLoginSerializer)
RegisterInputType = generate_input_type_for_serializer('RegisterInputType', RegisterSerializer)
ResetPasswordInputType = generate_input_type_for_serializer('ResetPasswordInputType', ResetPasswordSerializer)
PasswordChangeInputType = generate_input_type_for_serializer('PasswordChangeInputType', PasswordChangeSerializer)
UserMeInputType = generate_input_type_for_serializer('UserMeInputType', UserMeSerializer)
class Login(graphene.Mutation):
class Arguments:
data = LoginInputType(required=True)
result = graphene.Field(UserMeType)
errors = graphene.List(graphene.NonNull(CustomErrorType))
ok = graphene.Boolean(required=True)
captcha_required = graphene.Boolean(required=True, default_value=False)
from utils.graphene.mutation import (
generate_input_type_for_serializer,
PsGrapheneMutation,
PsBulkGrapheneMutation,
PsDeleteMutation,
)
from deep.permissions import ProjectPermissions as PP
from .models import Entry
from .schema import EntryType
from .serializers import (
EntryGqSerializer as EntrySerializer, )
EntryInputType = generate_input_type_for_serializer(
'EntryInputType',
serializer_class=EntrySerializer,
)
class EntryMutationMixin():
@classmethod
def filter_queryset(cls, qs, info):
return qs.filter(
# Filter by project
project=info.context.active_project,
# Filter by project's active analysis_framework (Only show active AF's entries)
analysis_framework=info.context.active_project.
analysis_framework_id,
)
import graphene
from utils.graphene.mutation import (
generate_input_type_for_serializer,
PsGrapheneMutation,
)
from deep.permissions import ProjectPermissions as PP
from deep.celery import app as celery_app
from .models import Export
from .schema import UserExportType, get_export_qs
from .serializers import ExportCreateGqlSerializer as ExportCreateSerializer
ExportCreateInputType = generate_input_type_for_serializer(
'ExportCreateInputType',
serializer_class=ExportCreateSerializer,
)
class UserExportMutationMixin():
@classmethod
def filter_queryset(cls, _, info):
return get_export_qs(info)
class CreateUserExport(PsGrapheneMutation):
class Arguments:
data = ExportCreateInputType(required=True)
model = Export
serializer_class = ExportCreateSerializer
