fix data

src/app/countdown/countdown.page.ts

@@ -21,6 +21,7 @@ import {
   exitOutline,
   arrowBackOutline
 } from 'ionicons/icons';
+import { FocusRecordService } from '../services/ncloud';
 
 @Component({
   selector: 'app-countdown',
@@ -177,4 +178,21 @@ export class CountdownPage implements OnInit, OnDestroy {
       console.error('Error playing alert sound:', error);
     });
   }
+
+  async completeTimer() {
+    try {
+      await FocusRecordService.createRecord({
+        duration: this.duration,
+        category: this.activityType,
+        startTime: new Date(Date.now() - this.duration * 60 * 1000),
+        endTime: new Date(),
+        completed: true
+      });
+      
+      await this.showCompletionAlert();
+      this.playAlertSound();
+    } catch (error) {
+      console.error('保存专注记录失败:', error);
+    }
+  }
 }

src/app/models/Task.ts

@@ -78,4 +78,13 @@ export class Task extends CloudObject {
       throw error;
     }
   }
+
+  async saveTask(): Promise<void> {
+    try {
+      await this.parseObject.save();
+    } catch (error) {
+      console.error('保存任务失败:', error);
+      throw error;
+    }
+  }
 } 

src/app/services/auth.service.ts

@@ -25,6 +25,6 @@ export class AuthService {
   }
 
   isLoggedIn(): boolean {
-    return !!this.currentUser;
+    return Parse.User.current() !== null;
   }
 } 

src/app/services/ncloud.ts

@@ -46,4 +46,212 @@ export class CloudQuery {
       throw error;
     }
   }
+}
+
+export class Task extends CloudObject {
+  objectId?: string;
+  title: string = '';
+  content: string = '';
+  userId: string = '';
+  completed: boolean = false;
+  startTime?: Date;
+  endTime?: Date;
+  createdAt?: Date;
+  updatedAt?: Date;
+
+  constructor() {
+    super();
+    this.parseObject = new Parse.Object('Task');
+  }
+
+  static fromParseObject(parseObject: Parse.Object): Task {
+    const task = new Task();
+    task.setParseObject(parseObject);
+    task.objectId = parseObject.id;
+    task.title = parseObject.get('title');
+    task.content = parseObject.get('content');
+    task.userId = parseObject.get('userId');
+    task.completed = parseObject.get('completed');
+    task.startTime = parseObject.get('startTime');
+    task.endTime = parseObject.get('endTime');
+    task.createdAt = parseObject.get('createdAt');
+    task.updatedAt = parseObject.get('updatedAt');
+    return task;
+  }
+
+  override async save(): Promise<void> {
+    const currentUser = Parse.User.current();
+    if (!currentUser) {
+      throw new Error('User not logged in');
+    }
+
+    this.parseObject.set('title', this.title);
+    this.parseObject.set('content', this.content);
+    this.parseObject.set('userId', currentUser.id);
+    this.parseObject.set('completed', this.completed);
+    this.parseObject.set('startTime', this.startTime);
+    this.parseObject.set('endTime', this.endTime);
+
+    // 设置 ACL
+    const acl = new Parse.ACL(currentUser);
+    acl.setPublicReadAccess(false);
+    acl.setPublicWriteAccess(false);
+    this.parseObject.setACL(acl);
+
+    await super.save();
+  }
+
+  async destroy(): Promise<void> {
+    await this.parseObject.destroy();
+  }
+}
+
+export class FocusRecord extends CloudObject {
+  objectId?: string;
+  userId: string = '';
+  duration: number = 0;
+  category: string = '';
+  startTime?: Date;
+  endTime?: Date;
+  completed: boolean = false;
+  createdAt?: Date;
+  updatedAt?: Date;
+
+  constructor() {
+    super();
+    this.parseObject = new Parse.Object('FocusRecord');
+  }
+
+  static fromParseObject(parseObject: Parse.Object): FocusRecord {
+    const record = new FocusRecord();
+    record.setParseObject(parseObject);
+    record.objectId = parseObject.id;
+    record.userId = parseObject.get('userId');
+    record.duration = parseObject.get('duration');
+    record.category = parseObject.get('category');
+    record.startTime = parseObject.get('startTime');
+    record.endTime = parseObject.get('endTime');
+    record.completed = parseObject.get('completed');
+    record.createdAt = parseObject.get('createdAt');
+    record.updatedAt = parseObject.get('updatedAt');
+    return record;
+  }
+
+  override async save(): Promise<void> {
+    const currentUser = Parse.User.current();
+    if (!currentUser) {
+      throw new Error('User not logged in');
+    }
+
+    this.parseObject.set('userId', currentUser.id);
+    this.parseObject.set('duration', this.duration);
+    this.parseObject.set('category', this.category);
+    this.parseObject.set('startTime', this.startTime);
+    this.parseObject.set('endTime', this.endTime);
+    this.parseObject.set('completed', this.completed);
+
+    // 设置 ACL
+    const acl = new Parse.ACL(currentUser);
+    acl.setPublicReadAccess(false);
+    acl.setPublicWriteAccess(false);
+    this.parseObject.setACL(acl);
+
+    await super.save();
+  }
+}
+
+export class FocusRecordService {
+  static async createRecord(data: {
+    duration: number;
+    category: string;
+    startTime: Date;
+    endTime: Date;
+    completed: boolean;
+  }): Promise<FocusRecord> {
+    try {
+      const record = new FocusRecord();
+      Object.assign(record, data);
+      await record.save();
+      return record;
+    } catch (error) {
+      console.error('创建专注记录失败:', error);
+      throw error;
+    }
+  }
+
+  static async getRecords(): Promise<FocusRecord[]> {
+    try {
+      const query = new CloudQuery('FocusRecord');
+      query.equalTo('userId', Parse.User.current()?.id);
+      const results = await query.find();
+      return results.map(result => {
+        if (result instanceof Parse.Object) {
+          return FocusRecord.fromParseObject(result);
+        }
+        return result as FocusRecord;
+      });
+    } catch (error) {
+      console.error('获取专注记录失败:', error);
+      throw error;
+    }
+  }
+}
+
+export class TaskService {
+  static async getTasks(): Promise<Task[]> {
+    try {
+      const query = new CloudQuery('Task');
+      query.equalTo('user', Parse.User.current());
+      const results = await query.find();
+      return results.map(result => {
+        if (result instanceof Parse.Object) {
+          return Task.fromParseObject(result);
+        }
+        return result as Task;
+      });
+    } catch (error) {
+      console.error('获取任务失败:', error);
+      throw error;
+    }
+  }
+
+  static async createTask(taskData: { 
+    title: string; 
+    content: string; 
+    completed: boolean; 
+    startTime?: Date; 
+    endTime?: Date; 
+  }): Promise<Task> {
+    try {
+      const task = new Task();
+      task.title = taskData.title;
+      task.content = taskData.content;
+      task.completed = taskData.completed;
+      task.startTime = taskData.startTime;
+      task.endTime = taskData.endTime;
+      await task.save();
+      return task;
+    } catch (error) {
+      console.error('创建任务失败:', error);
+      throw error;
+    }
+  }
+
+  static async updateTask(task: Task): Promise<void> {
+    try {
+      await task.save();
+    } catch (error) {
+      console.error('更新任务失败:', error);
+      throw error;
+    }
+  }
+
+  static async deleteTask(task: Task): Promise<void> {
+    try {
+      await task.destroy();
+    } catch (error) {
+      console.error('删除任务失败:', error);
+      throw error;
+    }
+  }
 } 

src/app/tab1/tab1.page.ts

@@ -1,10 +1,10 @@
 import { Component, OnInit } from '@angular/core';
-import { Router } from '@angular/router';
-import { Task } from '../../models/Task';
-import { AuthService } from '../services/auth.service';
+import { IonicModule, AlertController } from '@ionic/angular';
 import { CommonModule } from '@angular/common';
 import { FormsModule } from '@angular/forms';
-import { IonicModule } from '@ionic/angular';
+import { addIcons } from 'ionicons';
+import { addOutline } from 'ionicons/icons';
+import { Task } from '../models/Task';
 import * as Parse from 'parse';
 
 @Component({
@@ -12,74 +12,98 @@ import * as Parse from 'parse';
   templateUrl: 'tab1.page.html',
   styleUrls: ['tab1.page.scss'],
   standalone: true,
-  imports: [
-    CommonModule,
-    FormsModule,
-    IonicModule
-  ]
+  imports: [IonicModule, CommonModule, FormsModule]
 })
 export class Tab1Page implements OnInit {
   tasks: Task[] = [];
-  newTask: Task = new Task();
   isModalOpen = false;
+  newTask: Task = new Task();
 
   constructor(
-    private router: Router,
-    private auth: AuthService
-  ) {}
+    private alertController: AlertController
+  ) {
+    addIcons({ addOutline });
+  }
 
-  async ngOnInit() {
-    await this.loadTasks();
+  ngOnInit() {
+    this.checkLoginAndLoadTasks();
   }
 
-  async loadTasks() {
+  ionViewWillEnter() {
+    this.checkLoginAndLoadTasks();
+  }
+
+  private async checkLoginAndLoadTasks() {
+    const currentUser = Parse.User.current();
+    console.log('Current User:', currentUser);
+    if (currentUser) {
+      await this.loadTasks();
+    }
+  }
+
+  private async loadTasks() {
     try {
-      const currentUser = Parse.User.current();
-      if (currentUser) {
-        this.tasks = await Task.getUserTasks(currentUser.id);
-      }
-    } catch (error: any) {
-      console.error('Error loading tasks:', error);
+      this.tasks = await Task.getUserTasks(Parse.User.current()?.id || '');
+    } catch (error) {
+      console.error('加载任务失败:', error);
     }
   }
 
   async addTask() {
     const currentUser = Parse.User.current();
     if (!currentUser) {
-      alert('请先登录后再添加任务');
+      const alert = await this.alertController.create({
+        header: '提示',
+        message: '请先登录后再创建任务',
+        buttons: ['确定']
+      });
+      await alert.present();
       return;
     }
 
     try {
-      await Task.create({
+      if (!this.newTask.title) {
+        throw new Error('标题不能为空');
+      }
+
+      const newTaskData = {
         title: this.newTask.title,
-        content: this.newTask.content,
-        startTime: this.newTask.startTime,
-        endTime: this.newTask.endTime,
+        content: this.newTask.content || '',
         completed: false,
+        startTime: new Date().toISOString(),
+        endTime: new Date().toISOString(),
         userId: currentUser.id
-      });
-      
-      await this.loadTasks();
-      this.isModalOpen = false;
+      };
+
+      const task = await Task.create(newTaskData);
+      console.log('Task created:', task);
+      this.tasks.push(task);
+      this.setOpen(false);
       this.newTask = new Task();
-    } catch (error: any) {
-      console.error('Failed to create task:', error);
+    } catch (error) {
+      console.error('创建任务失败:', error);
+      const errorAlert = await this.alertController.create({
+        header: '错误',
+        message: error instanceof Error ? error.message : '创建任务失败，请重试',
+        buttons: ['确定']
+      });
+      await errorAlert.present();
     }
   }
 
   setOpen(isOpen: boolean) {
     this.isModalOpen = isOpen;
+    if (!isOpen) {
+      this.newTask = new Task();
+    }
   }
 
   async toggleComplete(task: Task) {
+    task.completed = !task.completed;
     try {
-      if (!task.id) return;
-      task.completed = !task.completed;
-      await task.save();
-      await this.loadTasks();
-    } catch (error: any) {
-      console.error('Error toggling task completion:', error);
+      await task.saveTask();
+    } catch (error) {
+      console.error('更新任务失败:', error);
     }
   }
 }