jira-pat 1.0.0

package/frontend/src/hooks/useIssueDrawer.js

@@ -0,0 +1,305 @@
+import { useState, useEffect, useCallback } from 'react';
+import { 
+  fetchIssueDetail, fetchComments, postComment, fetchTransitions, 
+  transitionIssue, fetchAssignableUsers, assignIssue, 
+  uploadAttachment, fetchProjectVersions, updateIssue, searchLabels 
+} from '../services/api';
+
+export function useIssueDrawer(issueKey, addToast, refetch) {
+  const [issueDetail, setIssueDetail] = useState(null);
+  const [comments, setComments] = useState([]);
+  const [transitions, setTransitions] = useState([]);
+  const [assignableUsers, setAssignableUsers] = useState([]);
+  const [drawerLoading, setDrawerLoading] = useState(false);
+  const [drawerError, setDrawerError] = useState(null);
+
+  const [newCommentText, setNewCommentText] = useState('');
+  const [isPostingComment, setIsPostingComment] = useState(false);
+  const [targetTransitionId, setTargetTransitionId] = useState('');
+  const [isTransitioning, setIsTransitioning] = useState(false);
+  const [assigneeSearch, setAssigneeSearch] = useState('');
+  const [targetAccountId, setTargetAccountId] = useState('');
+  const [isAssigning, setIsAssigning] = useState(false);
+  const [projectVersions, setProjectVersions] = useState([]);
+  const [newLabelText, setNewLabelText] = useState('');
+  const [labelSuggestions, setLabelSuggestions] = useState([]);
+  const [showLabelSuggestions, setShowLabelSuggestions] = useState(false);
+  const [isUpdatingLabels, setIsUpdatingLabels] = useState(false);
+  const [isUpdatingVersions, setIsUpdatingVersions] = useState(false);
+  const [isUploading, setIsUploading] = useState(false);
+  const [uploadMessage, setUploadMessage] = useState('');
+  const [isTransitioningOptimistic, setIsTransitioningOptimistic] = useState(false);
+  const [optimisticStatus, setOptimisticStatus] = useState(null);
+  const [isAssigningOptimistic, setIsAssigningOptimistic] = useState(false);
+  const [optimisticAssignee, setOptimisticAssignee] = useState(null);
+
+  useEffect(() => {
+    if (!issueKey) return;
+    
+    setDrawerLoading(true);
+    setDrawerError(null);
+    setIssueDetail(null);
+    setComments([]);
+    setTransitions([]);
+    setAssignableUsers([]);
+    setNewCommentText('');
+    setTargetTransitionId('');
+    setTargetAccountId('');
+    setAssigneeSearch('');
+    setUploadMessage('');
+    setNewLabelText('');
+
+    const loadIssueData = async () => {
+      try {
+        const [detailData, commentsData, transitionsData, usersData] = await Promise.all([
+          fetchIssueDetail(issueKey),
+          fetchComments(issueKey),
+          fetchTransitions(issueKey).catch(() => []),
+          fetchAssignableUsers(issueKey).catch(() => [])
+        ]);
+        setIssueDetail(detailData);
+        setComments(commentsData);
+        setTransitions(transitionsData);
+        setAssignableUsers(usersData);
+
+        if (detailData.fields.project?.key) {
+          const versions = await fetchProjectVersions(detailData.fields.project.key).catch(() => []);
+          setProjectVersions(versions);
+        }
+      } catch (err) {
+        setDrawerError(err.message || 'Failed to load issue details');
+      } finally {
+        setDrawerLoading(false);
+      }
+    };
+
+    loadIssueData();
+  }, [issueKey]);
+
+  useEffect(() => {
+    if (!newLabelText || newLabelText.length < 1) {
+      setLabelSuggestions([]);
+      setShowLabelSuggestions(false);
+      return;
+    }
+    const timer = setTimeout(async () => {
+      try {
+        const labels = await searchLabels(newLabelText);
+        const currentLabels = issueDetail?.fields?.labels || [];
+        const filtered = labels.filter(l => !currentLabels.includes(l));
+        setLabelSuggestions(filtered);
+        setShowLabelSuggestions(filtered.length > 0);
+      } catch (err) {
+        console.error('Label search error:', err);
+      }
+    }, 300);
+    return () => clearTimeout(timer);
+  }, [newLabelText, issueDetail]);
+
+  useEffect(() => {
+    if (!issueKey || !assigneeSearch || assigneeSearch.length < 1) return;
+    const timer = setTimeout(async () => {
+      try {
+        const users = await fetchAssignableUsers(issueKey, assigneeSearch);
+        setAssignableUsers(users);
+      } catch (err) {
+        console.error('Assignee search error:', err);
+      }
+    }, 500);
+    return () => clearTimeout(timer);
+  }, [assigneeSearch, issueKey]);
+
+  const handlePostComment = useCallback(async () => {
+    if (!newCommentText.trim() || !issueKey) return;
+    setIsPostingComment(true);
+    try {
+      const postedComment = await postComment(issueKey, newCommentText);
+      setComments(prev => [...prev, postedComment]);
+      setNewCommentText('');
+      addToast('Comment posted', 'success');
+    } catch (err) {
+      addToast(`Error posting comment: ${err.message}`, 'error');
+    } finally {
+      setIsPostingComment(false);
+    }
+  }, [newCommentText, issueKey, addToast]);
+
+  const handleAssignUser = useCallback(async (accountId, displayName) => {
+    if (!accountId || !issueKey) return;
+
+    const optimisticAssigneeObj = {
+      displayName,
+      accountId,
+      avatarUrls: { '48x48': '' },
+    };
+    setOptimisticAssignee(optimisticAssigneeObj);
+    setIsAssigningOptimistic(true);
+    setTargetAccountId('');
+    setAssigneeSearch('');
+    setIsAssigning(true);
+
+    try {
+      await assignIssue(issueKey, accountId);
+      fetchIssueDetail(issueKey).then(setIssueDetail).catch(() => {});
+      refetch?.();
+      addToast('Issue assigned successfully', 'success');
+    } catch (err) {
+      setOptimisticAssignee(null);
+      addToast(`Failed to assign: ${err.message}`, 'error');
+    } finally {
+      setIsAssigningOptimistic(false);
+      setIsAssigning(false);
+    }
+  }, [issueKey, addToast, refetch]);
+
+  const handleFileUpload = useCallback(async (e) => {
+    const file = e.target.files?.[0];
+    if (!file || !issueKey) return;
+
+    if (file.size > 10 * 1024 * 1024) {
+      setUploadMessage('Error: File size exceeds 10MB limit');
+      return;
+    }
+
+    const ALLOWED_TYPES = ['image/png', 'image/jpeg', 'image/gif', 'application/pdf', 'text/plain', 'application/zip'];
+    if (!ALLOWED_TYPES.includes(file.type)) {
+      addToast('File type not allowed', 'error');
+      e.target.value = '';
+      return;
+    }
+
+    setIsUploading(true);
+    setUploadMessage('');
+    try {
+      await uploadAttachment(issueKey, file);
+      setUploadMessage('File uploaded successfully');
+      addToast('File attached successfully', 'success');
+      const updatedDetail = await fetchIssueDetail(issueKey);
+      setIssueDetail(updatedDetail);
+    } catch (err) {
+      setUploadMessage(`Error uploading file: ${err.message}`);
+      addToast(`Error attaching file: ${err.message}`, 'error');
+    } finally {
+      setIsUploading(false);
+      e.target.value = '';
+    }
+  }, [issueKey, addToast]);
+
+  const handleUpdateVersion = useCallback(async (versionId) => {
+    if (!issueKey) return;
+    setIsUpdatingVersions(true);
+    try {
+      const fixVersions = versionId ? [{ id: versionId }] : [];
+      await updateIssue(issueKey, { fixVersions });
+      const updatedDetail = await fetchIssueDetail(issueKey);
+      setIssueDetail(updatedDetail);
+      addToast('Fix version updated', 'success');
+    } catch (err) {
+      addToast(`Error updating version: ${err.message}`, 'error');
+    } finally {
+      setIsUpdatingVersions(false);
+    }
+  }, [issueKey, addToast]);
+
+  const handleAddLabel = useCallback(async (labelToAdd) => {
+    const label = (typeof labelToAdd === 'string' ? labelToAdd : newLabelText).trim();
+    if (!label || !issueKey) return;
+    const currentLabels = issueDetail?.fields?.labels || [];
+    if (currentLabels.includes(label)) return;
+
+    setIsUpdatingLabels(true);
+    try {
+      const updatedLabels = [...currentLabels, label];
+      await updateIssue(issueKey, { labels: updatedLabels });
+      const updatedDetail = await fetchIssueDetail(issueKey);
+      setIssueDetail(updatedDetail);
+      setNewLabelText('');
+      setShowLabelSuggestions(false);
+      addToast('Label added', 'success');
+    } catch (err) {
+      addToast(`Error adding label: ${err.message}`, 'error');
+    } finally {
+      setIsUpdatingLabels(false);
+    }
+  }, [newLabelText, issueKey, issueDetail, addToast]);
+
+  const handleRemoveLabel = useCallback(async (labelToRemove) => {
+    if (!issueKey) return;
+    setIsUpdatingLabels(true);
+    try {
+      const updatedLabels = issueDetail?.fields?.labels?.filter(l => l !== labelToRemove) || [];
+      await updateIssue(issueKey, { labels: updatedLabels });
+      const updatedDetail = await fetchIssueDetail(issueKey);
+      setIssueDetail(updatedDetail);
+      addToast('Label removed', 'success');
+    } catch (err) {
+      addToast(`Error removing label: ${err.message}`, 'error');
+    } finally {
+      setIsUpdatingLabels(false);
+    }
+  }, [issueKey, issueDetail, addToast]);
+
+  const handleUpdateStatus = useCallback(async (transitionId, transitionName) => {
+    if (!transitionId || !issueKey) return;
+
+    setOptimisticStatus(transitionName);
+    setIsTransitioningOptimistic(true);
+    setTargetTransitionId('');
+    setIsTransitioning(true);
+
+    try {
+      await transitionIssue(issueKey, transitionId);
+      fetchIssueDetail(issueKey).then(setIssueDetail).catch(() => {});
+      fetchTransitions(issueKey).then(setTransitions).catch(() => {});
+      refetch?.();
+      addToast('Status updated successfully', 'success');
+    } catch (err) {
+      setOptimisticStatus(null);
+      addToast(`Failed to update status: ${err.message}`, 'error');
+    } finally {
+      setIsTransitioningOptimistic(false);
+      setIsTransitioning(false);
+    }
+  }, [issueKey, addToast, refetch]);
+
+  return {
+    issueDetail,
+    comments,
+    transitions,
+    assignableUsers,
+    drawerLoading,
+    drawerError,
+    newCommentText,
+    setNewCommentText,
+    isPostingComment,
+    targetTransitionId,
+    setTargetTransitionId,
+    isTransitioning,
+    isTransitioningOptimistic,
+    optimisticStatus,
+    assigneeSearch,
+    setAssigneeSearch,
+    targetAccountId,
+    setTargetAccountId,
+    isAssigning,
+    isAssigningOptimistic,
+    optimisticAssignee,
+    projectVersions,
+    isUpdatingVersions,
+    newLabelText,
+    setNewLabelText,
+    labelSuggestions,
+    showLabelSuggestions,
+    setShowLabelSuggestions,
+    isUpdatingLabels,
+    isUploading,
+    uploadMessage,
+    handlePostComment,
+    handleAssignUser,
+    handleFileUpload,
+    handleUpdateVersion,
+    handleAddLabel,
+    handleRemoveLabel,
+    handleUpdateStatus
+  };
+}

package/frontend/src/hooks/useIssuesList.js

@@ -0,0 +1,30 @@
+import { useState, useEffect } from 'react';
+import { getIssues } from '../services/api';
+
+export function useIssuesList(projectKey, statusFilter) {
+  const [issues, setIssues] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+
+  const refetch = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await getIssues({
+        project: projectKey,
+        status: statusFilter ? statusFilter : 'exclude:Done,Cancelled,Closed',
+      });
+      setIssues(data.issues || []);
+    } catch (err) {
+      setError(err.message || 'Failed to fetch issues');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    refetch();
+  }, [projectKey, statusFilter]);
+
+  return { issues, loading, error, refetch };
+}

package/frontend/src/hooks/useToasts.js

@@ -0,0 +1,19 @@
+import { useState, useCallback } from 'react';
+
+export function useToasts() {
+  const [toasts, setToasts] = useState([]);
+
+  const addToast = useCallback((message, type = 'info') => {
+    const id = Date.now();
+    setToasts(prev => [...prev, { id, message, type }]);
+    setTimeout(() => {
+      setToasts(prev => prev.filter(t => t.id !== id));
+    }, 4000);
+  }, []);
+
+  const removeToast = useCallback((id) => {
+    setToasts(prev => prev.filter(t => t.id !== id));
+  }, []);
+
+  return { toasts, addToast, removeToast };
+}