[ New ] 10 Cách BaseServices API Đơn Giản Hóa Quy Trình [ Extends ]

class TokenService extends BaseServiceClient {
    constructor(baseURL, apiKey) {
        super(baseURL);
        this.apiKey = apiKey;
        this.token = null;
        this.tokenExpiry = null;
    }

    async refreshToken() {
        const response = await this.request('/refresh-token', {
            method: 'POST',
            headers: {
                'Authorization': `Bearer ${this.apiKey}`
            }
        });
        this.token = response.token;
        this.tokenExpiry = Date.now() + response.expires_in * 1000;
    }

    async requestWithToken(endpoint, options = {}) {
        if (!this.token || Date.now() >= this.tokenExpiry) {
            await this.refreshToken();
        }
        options.headers = {
            ...options.headers,
            'Authorization': `Bearer ${this.token}`
        };
        return this.request(endpoint, options);
    }
}

// Sử dụng lớp
const tokenService = new TokenService('https://api.example.com', 'your-api-key');
tokenService.requestWithToken('/secure-data')
    .then(data => console.log('Secure data:', data))
    .catch(error => console.error('Token error:', error));

class FileUploadService extends BaseServiceClient {
    async uploadFile(endpoint, file) {
        const formData = new FormData();
        formData.append('file', file);

        return this.request(endpoint, {
            method: 'POST',
            body: formData
        });
    }
}

// Sử dụng lớp
const fileUploadService = new FileUploadService('https://api.example.com');
const fileInput = document.querySelector('input[type="file"]');
fileInput.addEventListener('change', () => {
    const file = fileInput.files[0];
    fileUploadService.uploadFile('/upload', file)
        .then(response => console.log('File uploaded:', response))
        .catch(error => console.error('Upload error:', error));
});

class DataService extends BaseServiceClient {
    async getDataWithPagination(endpoint, page, limit) {
        return this.request(`${endpoint}?page=${page}&limit=${limit}`);
    }

    async filterData(endpoint, filters) {
        const queryString = new URLSearchParams(filters).toString();
        return this.request(`${endpoint}?${queryString}`);
    }
}

// Sử dụng lớp
const dataService = new DataService('https://api.example.com');
dataService.getDataWithPagination('/items', 1, 10)
    .then(data => console.log('Paginated data:', data))
    .catch(error => console.error('Pagination error:', error));

dataService.filterData('/items', { category: 'books', priceRange: '10-50' })
    .then(data => console.log('Filtered data:', data))
    .catch(error => console.error('Filter error:', error));

class WebhookService extends BaseServiceClient {
    async registerWebhook(endpoint, webhookUrl) {
        return this.postData(endpoint, { url: webhookUrl });
    }

    async getWebhooks(endpoint) {
        return this.request(endpoint);
    }

    async deleteWebhook(endpoint, webhookId) {
        return this.request(`${endpoint}/${webhookId}`, { method: 'DELETE' });
    }
}

// Sử dụng lớp
const webhookService = new WebhookService('https://api.example.com');
webhookService.registerWebhook('/webhooks', 'https://yourapp.com/webhook')
    .then(response => console.log('Webhook registered:', response))
    .catch(error => console.error('Webhook registration error:', error));

webhookService.getWebhooks('/webhooks')
    .then(webhooks => console.log('Webhooks:', webhooks))
    .catch(error => console.error('Get webhooks error:', error));

webhookService.deleteWebhook('/webhooks', 'webhook-id')
    .then(() => console.log('Webhook deleted'))
    .catch(error => console.error('Delete webhook error:', error));

class NotificationService extends BaseServiceClient {
    async getNotifications() {
        return this.request('/notifications');
    }

    async markAsRead(notificationId) {
        return this.request(`/notifications/${notificationId}/read`, { method: 'POST' });
    }
}

// Sử dụng lớp
const notificationService = new NotificationService('https://api.example.com');
notificationService.getNotifications()
    .then(notifications => console.log('Notifications:', notifications))
    .catch(error => console.error('Get notifications error:', error));

notificationService.markAsRead('notification-id')
    .then(() => console.log('Notification marked as read'))
    .catch(error => console.error('Mark as read error:', error));

class ScheduleService extends BaseServiceClient {
    async createSchedule(scheduleData) {
        return this.postData('/schedules', scheduleData);
    }

    async getSchedules() {
        return this.request('/schedules');
    }

    async deleteSchedule(scheduleId) {
        return this.request(`/schedules/${scheduleId}`, { method: 'DELETE' });
    }
}

// Sử dụng lớp
const scheduleService = new ScheduleService('https://api.example.com');
scheduleService.createSchedule({ task: 'Backup', time: '02:00' })
    .then(schedule => console.log('Schedule created:', schedule))
    .catch(error => console.error('Create schedule error:', error));

scheduleService.getSchedules()
    .then(schedules => console.log('Schedules:', schedules))
    .catch(error => console.error('Get schedules error:', error));

scheduleService.deleteSchedule('schedule-id')
    .then(() => console.log('Schedule deleted'))
    .catch(error => console.error('Delete schedule error:', error));

class EmailService extends BaseServiceClient {
    async sendEmail(emailData) {
        return this.postData('/send-email', emailData);
    }
}

// Sử dụng lớp
const emailService = new EmailService('https://api.example.com');
emailService.sendEmail({
    to: '[email protected]',
    subject: 'Test Email',
    body: 'This is a test email.'
})
    .then(response => console.log('Email sent:', response))
    .catch(error => console.error('Send email error:', error));

class UserGroupService extends BaseServiceClient {
    async createGroup(groupData) {
        return this.postData('/groups', groupData);
    }

    async getGroups() {
        return this.request('/groups');
    }

    async addUserToGroup(groupId, userId) {
        return this.request(`/groups/${groupId}/users`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ userId })
        });
    }

    async removeUserFromGroup(groupId, userId) {
        return this.request(`/groups/${groupId}/users/${userId}`, { method: 'DELETE' });
    }
}

// Sử dụng lớp
const userGroupService = new UserGroupService('https://api.example.com');
userGroupService.createGroup({ name: 'Admins' })
    .then(group => console.log('Group created:', group))
    .catch(error => console.error('Create group error:', error));

userGroupService.getGroups()
    .then(groups => console.log('Groups:', groups))
    .catch(error => console.error('Get groups error:', error));

userGroupService.addUserToGroup('group-id', 'user-id')
    .then(() => console.log('User added to group'))
    .catch(error => console.error('Add user to group error:', error));

userGroupService.removeUserFromGroup('group-id', 'user-id')
    .then(() => console.log('User removed from group'))
    .catch(error => console.error('Remove user from group error:', error));

class ReportingService extends BaseServiceClient {
    async generateReport(reportType, parameters) {
        return this.postData(`/reports/${reportType}`, parameters);
    }

    async getReportStatus(reportId) {
        return this.request(`/reports/status/${reportId}`);
    }
}

// Sử dụng lớp
const reportingService = new ReportingService('https://api.example.com');
reportingService.generateReport('sales', { startDate: '2023-01-01', endDate: '2023-01-31' })
    .then(report => console.log('Report generated:', report))
    .catch(error => console.error('Generate report error:', error));

reportingService.getReportStatus('report-id')
    .then(status => console.log('Report status:', status))
    .catch(error => console.error('Get report status error:', error));

class LocationService extends BaseServiceClient {
    async addLocation(locationData) {
        return this.postData('/locations', locationData);
    }

    async getLocation(locationId) {
        return this.request(`/locations/${locationId}`);
    }

    async updateLocation(locationId, locationData) {
        return this.request(`/locations/${locationId}`, {
            method: 'PUT',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(locationData)
        });
    }

    async deleteLocation(locationId) {
        return this.request(`/locations/${locationId}`, { method: 'DELETE' });
    }
}

// Sử dụng lớp
const locationService = new LocationService('https://api.example.com');
locationService.addLocation({ name: 'New York Office', address: '123 Main St, NY' })
    .then(location => console.log('Location added:', location))
    .catch(error => console.error('Add location error:', error));

locationService.getLocation('location-id')
    .then(location => console.log('Location details:', location))
    .catch(error => console.error('Get location error:', error));

locationService.updateLocation('location-id', { name: 'NY Office Updated' })
    .then(location => console.log('Location updated:', location))
    .catch(error => console.error('Update location error:', error));

locationService.deleteLocation('location-id')
    .then(() => console.log('Location deleted'))
    .catch(error => console.error('Delete location error:', error));