001/*
002 *    Copyright 2024-2025, Warm-Flow (290631660@qq.com).
003 *
004 *    Licensed under the Apache License, Version 2.0 (the "License");
005 *    you may not use this file except in compliance with the License.
006 *    You may obtain a copy of the License at
007 *
008 *       https://www.apache.org/licenses/LICENSE-2.0
009 *
010 *    Unless required by applicable law or agreed to in writing, software
011 *    distributed under the License is distributed on an "AS IS" BASIS,
012 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 *    See the License for the specific language governing permissions and
014 *    limitations under the License.
015 */
016package org.dromara.warm.flow.core.orm.service.impl;
017
018
019import org.dromara.warm.flow.core.FlowFactory;
020import org.dromara.warm.flow.core.dao.WarmDao;
021import org.dromara.warm.flow.core.handler.DataFillHandler;
022import org.dromara.warm.flow.core.orm.agent.WarmQuery;
023import org.dromara.warm.flow.core.orm.service.IWarmService;
024import org.dromara.warm.flow.core.utils.CollUtil;
025import org.dromara.warm.flow.core.utils.ObjectUtil;
026import org.dromara.warm.flow.core.utils.SqlHelper;
027import org.dromara.warm.flow.core.utils.page.Page;
028
029import java.io.Serializable;
030import java.util.Collection;
031import java.util.List;
032
033/**
034 * BaseService层处理
035 *
036 * @author warm
037 * @since 2023-03-17
038 */
039public abstract class WarmServiceImpl<M extends WarmDao<T>, T> implements IWarmService<T> {
040
041    protected M warmDao;
042
043    public M getDao() {
044        return warmDao;
045    }
046
047    protected abstract IWarmService<T> setDao(M warmDao);
048
049    @Override
050    public T getById(Serializable id) {
051        return getDao().selectById(id);
052    }
053
054    @Override
055    public List<T> getByIds(Collection<? extends Serializable> ids) {
056        return getDao().selectByIds(ids);
057    }
058
059    @Override
060    public Page<T> page(T entity, Page<T> page) {
061        return getDao().selectPage(entity, page);
062    }
063
064    @Override
065    public List<T> list(T entity) {
066        return getDao().selectList(entity, null);
067    }
068
069    @Override
070    public List<T> list(T entity, WarmQuery<T> query) {
071        return getDao().selectList(entity, query);
072    }
073
074    @Override
075    public T getOne(T entity) {
076        List<T> list = getDao().selectList(entity, null);
077        return CollUtil.getOne(list);
078    }
079
080    @Override
081    public long selectCount(T entity) {
082        return getDao().selectCount(entity);
083    }
084
085    @Override
086    public Boolean exists(T entity) {
087        long count = selectCount(entity);
088        return count > 0;
089    }
090
091    @Override
092    public boolean save(T entity) {
093        insertFill(entity);
094        return SqlHelper.retBool(getDao().save(entity));
095    }
096
097    @Override
098    public boolean updateById(T entity) {
099        updateFill(entity);
100        return SqlHelper.retBool(getDao().updateById(entity));
101    }
102
103    @Override
104    public boolean removeById(Serializable id) {
105        return SqlHelper.retBool(getDao().deleteById(id));
106    }
107
108    @Override
109    public boolean remove(T entity) {
110        return SqlHelper.retBool(getDao().delete(entity));
111    }
112
113    @Override
114    public boolean removeByIds(Collection<? extends Serializable> ids) {
115        return SqlHelper.retBool(getDao().deleteByIds(ids));
116    }
117
118    @Override
119    public void saveBatch(List<T> list) {
120        if (CollUtil.isEmpty(list)) {
121            return;
122        }
123        this.saveBatch(list, 100);
124    }
125
126    @Override
127    public void saveBatch(List<T> list, int batchSize) {
128        if (CollUtil.isEmpty(list)) {
129            return;
130        }
131
132        List<List<T>> split = CollUtil.split(list, batchSize > 0 ? batchSize : 100);
133
134        for (List<T> ts : split) {
135            ts.forEach(this::insertFill);
136            getDao().saveBatch(ts);
137        }
138    }
139
140    @Override
141    public void updateBatch(List<T> list) {
142        if (CollUtil.isEmpty(list)) {
143            return;
144        }
145        list.forEach(this::updateFill);
146        getDao().updateBatch(list);
147    }
148
149    @Override
150    public WarmQuery<T> orderById() {
151        return new WarmQuery<>(this).orderById();
152    }
153
154    @Override
155    public WarmQuery<T> orderByCreateTime() {
156        return new WarmQuery<>(this).orderByCreateTime();
157    }
158
159    @Override
160    public WarmQuery<T> orderByUpdateTime() {
161        return new WarmQuery<>(this).orderByUpdateTime();
162    }
163
164    @Override
165    public WarmQuery<T> orderByAsc(String orderByField) {
166        return new WarmQuery<>(this).orderByAsc(orderByField);
167    }
168
169    @Override
170    public WarmQuery<T> orderByDesc(String orderByField) {
171        return new WarmQuery<>(this).orderByDesc(orderByField);
172    }
173
174    @Override
175    public WarmQuery<T> orderBy(String orderByField) {
176        return new WarmQuery<>(this).orderBy(orderByField);
177    }
178
179
180    public void insertFill(T entity) {
181        DataFillHandler dataFillHandler = FlowFactory.dataFillHandler();
182        if (ObjectUtil.isNotNull(dataFillHandler)) {
183            dataFillHandler.idFill(entity);
184            dataFillHandler.insertFill(entity);
185        }
186    }
187
188    public void updateFill(T entity) {
189        DataFillHandler dataFillHandler = FlowFactory.dataFillHandler();
190        if (ObjectUtil.isNotNull(dataFillHandler)) {
191            dataFillHandler.updateFill(entity);
192        }
193    }
194}